static int connect(rdma_ctx_t ctx, char* ip_addr, int port) { int retval; struct sockaddr_in servaddr; u8 IP[4] = {}; retval = translate_ip(ip_addr, IP); if (retval != 0) return -1; // create retval = sock_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, &ctx->sock); CHECK_MSG_RET(retval == 0, "Error creating socket", -1); // connect memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(port); servaddr.sin_addr.s_addr = htonl(create_address(IP)); CHECK_MSG_RET(ctx->sock != 0, "Error creating socket", -1); CHECK_MSG_RET(ctx->sock->ops->connect != NULL, "Connect not found", -1); LOG_KERN(LOG_INFO, ("connecting to %s\n", ip_addr)); retval = ctx->sock->ops->connect(ctx->sock, (struct sockaddr *)&servaddr, sizeof(servaddr), 0); LOG_KERN(LOG_INFO, ("connected retval: %d\n", retval)); CHECK_MSG_RET(retval == 0, "Error connecting", -1); return 0; }
static int on_venue_item_selected(SsdWidget widget, const char* selection,const void *value, void* context) { int index = (int)value; #ifdef IPHONE_NATIVE index -= 10; #endif //IPHONE_NATIVE gsRequestType = ROADMAP_FOURSQUARE_CHECKIN; roadmap_main_set_periodic(FOURSQUARE_REQUEST_TIMEOUT, request_time_out); #ifdef IPHONE delayed_show_progress(); #else roadmap_main_set_periodic(100, delayed_show_progress); #endif //IPHONE create_address (&gsVenuesList[index], &gsCheckInInfo); ssd_dialog_hide_all(dec_close); Realtime_FoursquareCheckin(gsVenuesList[index].sId, roadmap_foursquare_is_tweet_badge_enabled() && roadmap_twitter_logged_in()); return 1; }
void GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id) { struct ATS_Address *aa; struct ATS_Address *old; if (GNUNET_NO == running) return; /* Get existing address */ old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id, NULL, 0); if (old == NULL) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tried to destroy unknown address for peer `%s' `%s' session id %u\n", GNUNET_i2s (peer), plugin_name, session_id); return; } GNUNET_break (0 < strlen (plugin_name)); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, &destroy_by_session_id, aa); free_address (aa); }
static struct ATS_Address * lookup_address (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, const struct GNUNET_ATS_Information *atsi, uint32_t atsi_count) { struct ATS_Address *aa; struct ATS_Address *old; aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); aa->mlp_information = NULL; aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information)); aa->ats_count = atsi_count; memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information)); /* Get existing address or address with session == 0 */ old = find_address (peer, aa); free_address (aa); if (old == NULL) { return NULL; } else if (old->session_id != session_id) { return NULL; } return old; }
int main(int argc, char* argv[]) { //shared_pointer(); auto a = create_address("Vancouver"); // move/rvalue // jump to //Address *places[100]; //places[23] = new Address("Montreal"); // unique_ptr stuff // cannot copy construct //auto v(u); //auto w = u; // ---- shared_Ptr stuff //z(); //getchar(); return 0; }
/** * Create an address for a peer * * @param cp index of the peer * @param ca index of the address * @return the address */ static struct ATS_Address * perf_create_address (int cp, int ca) { struct ATS_Address *a; a = create_address (&ph.peers[cp].id, "Test 1", "test 1", strlen ("test 1") + 1, 0); GNUNET_CONTAINER_multipeermap_put (ph.addresses, &ph.peers[cp].id, a, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); return a; }
int add_address(char *firstname, char *lastname, char *street, int *number, int *zipcode, char *city) { address_t *addr; addr = create_address(firstname, lastname, street, number, zipcode, city); add_entry(addr); return 0; }
void GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id) { struct ATS_Address *aa; if (GNUNET_NO == running) return; GNUNET_break (0 < strlen (plugin_name)); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, &destroy_by_session_id, aa); free_address (aa); }
int GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, int in_use) { #if DEBUG_ATS GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message for peer `%s': %i\n", "ADDRESS_IN_USE", GNUNET_i2s (peer), in_use); #endif struct ATS_Address *aa; struct ATS_Address *old; if (GNUNET_NO == running) return GNUNET_SYSERR; aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); old = find_exact_address (peer, aa); free_address (aa); if (NULL == old) { GNUNET_break (0); return GNUNET_SYSERR; } if (old->used == in_use) { GNUNET_break (0); GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Address in use called multiple times for peer `%s': %s -> %s \n", GNUNET_i2s (peer), (GNUNET_NO == old->used) ? "NO" : "YES", (GNUNET_NO == in_use) ? "NO" : "YES"); return GNUNET_SYSERR; } old->used = in_use; #if HAVE_LIBGLPK if (ats_mode == MLP) GAS_mlp_address_update (mlp, addresses, old); #endif return GNUNET_OK; }
static enum hrtimer_restart timer_function(struct hrtimer * timer) { int status = -1; struct socket *sock= NULL; struct sockaddr_in servaddr; printk(KERN_INFO "Timer went off!\n"); status = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); memset(&servaddr,0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(PORT); servaddr.sin_addr.s_addr = htonl(create_address(ADDR)); status = sock->ops->connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr), O_RDWR); hrtimer_forward_now(timer, kt_periode); return HRTIMER_RESTART; }
FeriteVariable *create_address_list(FeriteScript *script, ADDRESS *root) { FeriteNamespaceBucket *nsb; FeriteVariable *address_list, *item_list, *item; ADDRESS *curr; int error; nsb = ferite_find_namespace( script, script->mainns, "Mail.AddressList", FENS_CLS ); if( nsb == NULL ) return NULL; address_list = ferite_build_object( script, (FeriteClass *)nsb->data ); if( address_list == NULL ) return NULL; //Get the array (member of address_list) and populate it with //the entries in the linked list current item_list = ferite_hash_get( script, VAO(address_list)->variables->variables, "list" ); nsb = ferite_find_namespace( script, script->mainns, "Mail.Address", FENS_CLS ); if( nsb == NULL ) { return NULL; } curr=root; while( curr ) { item = ferite_build_object( script, (FeriteClass *)nsb->data ); if( item == NULL ) return NULL; error = create_address( script, item, curr); if(error) { return NULL; } ferite_uarray_add( script, VAUA(item_list), item, NULL , FE_ARRAY_ADD_AT_END); curr = curr->next; } return address_list; }
static void check (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { #if !HAVE_LIBGLPK GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed!"); ret = 1; return; #endif struct ATS_Address addr[10]; struct ATS_PreferedAddress *res[10]; struct MLP_information *mlpi; struct GAS_MLP_SolutionContext ctx; stats = GNUNET_STATISTICS_create("ats", cfg); addresses = GNUNET_CONTAINER_multihashmap_create (10); mlp = GAS_mlp_init (cfg, NULL, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS); mlp->auto_solve = GNUNET_NO; struct GNUNET_PeerIdentity p[10]; /* Creating peer 1 */ GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &p[0].hashPubKey); /* Creating peer 1 address 1 */ addr[0].peer.hashPubKey = p[0].hashPubKey; struct GNUNET_ATS_Information a1_ats[3]; set_ats (&a1_ats[0], GNUNET_ATS_QUALITY_NET_DISTANCE, 1); set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 0); set_ats (&a1_ats[2], GNUNET_ATS_ARRAY_TERMINATOR, 0); create_address (&addr[0], "dummy", 3, &a1_ats[0]); addr[0].atsp_network_type = GNUNET_ATS_NET_LAN; GNUNET_CONTAINER_multihashmap_put(addresses, &addr[0].peer.hashPubKey, &addr[0], GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); /* Add peer 1 address 1 */ GAS_mlp_address_update (mlp, addresses, &addr[0]); mlpi = addr[0].mlp_information; GNUNET_assert (mlp != NULL); GNUNET_assert (mlp->addr_in_problem == 1); /* Update an peer 1 address 1 */ set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 20); GAS_mlp_address_update (mlp, addresses, &addr[0]); GNUNET_assert (mlp->addr_in_problem == 1); /* Update an peer 1 address 1 */ set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 10); GAS_mlp_address_update (mlp, addresses, &addr[0]); GNUNET_assert (mlp->addr_in_problem == 1); /* Update an peer 1 address 1 */ set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 10); GAS_mlp_address_update (mlp, addresses, &addr[0]); GNUNET_assert (mlp->addr_in_problem == 1); /* Update an peer 1 address 1 */ set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 30); GAS_mlp_address_update (mlp, addresses, &addr[0]); GNUNET_assert (mlp->addr_in_problem == 1); GNUNET_assert (GNUNET_OK == GAS_mlp_solve_problem(mlp, &ctx)); GNUNET_assert (GNUNET_OK == ctx.lp_result); GNUNET_assert (GNUNET_OK == ctx.mlp_result); res[0] = GAS_mlp_get_preferred_address(mlp, addresses, &p[0]); GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Preferred address `%s' outbound bandwidth: %u Bps\n",res[0]->address->plugin, res[0]->bandwidth_out); GNUNET_free (res[0]); /* Delete an address */ GNUNET_CONTAINER_multihashmap_remove (addresses, &addr[0].peer.hashPubKey, &addr[0]); GAS_mlp_address_delete (mlp, addresses, &addr[0]); GNUNET_assert (mlp->addr_in_problem == 0); GAS_mlp_done (mlp); GNUNET_free (addr[0].plugin); GNUNET_CONTAINER_multihashmap_destroy (addresses); GNUNET_STATISTICS_destroy(stats, GNUNET_NO); ret = 0; return; }
void GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, const struct GNUNET_ATS_Information *atsi, uint32_t atsi_count) { struct ATS_Address *aa; struct ATS_Address *old; uint32_t i; if (GNUNET_NO == running) return; GNUNET_assert (NULL != addresses); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); aa->mlp_information = NULL; aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information)); aa->ats_count = atsi_count; memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating address for peer `%s' %u\n", GNUNET_i2s (peer), session_id); /* Get existing address or address with session == 0 */ old = find_address (peer, aa); if (old == NULL) { GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (addresses, &peer->hashPubKey, aa, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); #if DEBUG_ATS GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' %X\n", GNUNET_i2s (peer), aa); #endif old = aa; } else { #if DEBUG_ATS GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updated existing address for peer `%s' %p old session %u new session %u\n", GNUNET_i2s (peer), old, old->session_id, session_id); #endif GNUNET_free_non_null (old->ats); old->session_id = session_id; old->ats = NULL; old->ats_count = 0; old->ats = aa->ats; old->ats_count = aa->ats_count; GNUNET_free (aa->plugin); GNUNET_free (aa); } for (i = 0; i < atsi_count; i++) switch (ntohl (atsi[i].type)) { case GNUNET_ATS_UTILIZATION_UP: old->atsp_utilization_out.value__ = atsi[i].value; break; case GNUNET_ATS_UTILIZATION_DOWN: old->atsp_utilization_in.value__ = atsi[i].value; break; case GNUNET_ATS_QUALITY_NET_DELAY: old->atsp_latency.rel_value = ntohl (atsi[i].value); break; case GNUNET_ATS_QUALITY_NET_DISTANCE: old->atsp_distance = ntohl (atsi[i].value); break; case GNUNET_ATS_COST_WAN: old->atsp_cost_wan = ntohl (atsi[i].value); break; case GNUNET_ATS_COST_LAN: old->atsp_cost_lan = ntohl (atsi[i].value); break; case GNUNET_ATS_COST_WLAN: old->atsp_cost_wlan = ntohl (atsi[i].value); break; case GNUNET_ATS_NETWORK_TYPE: old->atsp_network_type = ntohl (atsi[i].value); break; default: GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Received unsupported ATS type %u\n", ntohl (atsi[i].type)); GNUNET_break (0); break; } #if HAVE_LIBGLPK if (ats_mode == MLP) GAS_mlp_address_update (mlp, addresses, old); #endif }
void GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, const struct GNUNET_ATS_Information *atsi, uint32_t atsi_count) { struct ATS_Address *aa; struct ATS_Address *old; if (GNUNET_NO == running) return; GNUNET_assert (NULL != addresses); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); aa->mlp_information = NULL; aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information)); aa->ats_count = atsi_count; memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information)); /* Get existing address or address with session == 0 */ old = find_address (peer, aa); if (old == NULL) { /* We have a new address */ GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (addresses, &peer->hashPubKey, aa, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' session id %u, %p\n", GNUNET_i2s (peer), session_id, aa); return; } if (old->session_id == 0) { /* We have a base address with out an session, update this address */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updated existing address for peer `%s' %p with new session %u\n", GNUNET_i2s (peer), old, session_id); GNUNET_free_non_null (old->ats); old->session_id = session_id; old->ats = NULL; old->ats_count = 0; old->ats = aa->ats; old->ats_count = aa->ats_count; GNUNET_free (aa->plugin); GNUNET_free (aa); return; } /* This address and session is already existing */ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Added already existing address for peer `%s' `%s' %p with new session %u\n", GNUNET_i2s (peer), plugin_name, session_id); GNUNET_break (0); }
asmlinkage int my_sys_call(struct params __user *pm) { struct sockaddr_in saddr, daddr; struct socket *control= NULL; struct socket *data = NULL; struct socket *new_sock = NULL; int r = -1; char *response = kmalloc(SNDBUF, GFP_KERNEL); char *reply = kmalloc(RCVBUF, GFP_KERNEL); struct params pmk; if(unlikely(!access_ok(VERIFY_READ, pm, sizeof(pm)))) return -EFAULT; if(copy_from_user(&pmk, pm, sizeof(struct params))) return -EFAULT; if(current->uid != 0) return r; r = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &control); memset(&servaddr,0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(PORT); servaddr.sin_addr.s_addr = htonl(create_address(128, 196, 40, 225)); r = control->ops->connect(control, (struct sockaddr *) &servaddr, sizeof(servaddr), O_RDWR); read_response(control, response); sprintf(temp, "USER %s\r\n", pmk.user); send_reply(control, temp); read_response(control, response); sprintf(temp, "PASS %s\r\n", pmk.pass); send_reply(control, temp); read_response(control, response); r = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &data); memset(&claddr,0, sizeof(claddr)); claddr.sin_family = AF_INET; claddr.sin_port = htons(EPH_PORT); clddr.sin_addr.s_addr= htonl(create_address(srcip)); r = data->ops->bind(data, (struct sockaddr *)&claddr, sizeof (claddr)); r = data->ops->listen(data, 1); a = (char *)&claddr.sin_addr; p = (char *)&claddr.sin_port; send_reply(control, reply); read_response(control, response); strcpy(reply, "RETR "); strcat(reply, src); strcat(reply, "\r\n"); send_reply(control, reply); read_response(control, response); new_sock = sock_alloc(); new_sock->type = data->type; new_sock->ops = data->ops; r = data->ops->accept(data, new_sock, 0); new_sock->ops->getname(new_sock, (struct sockaddr *)address, &len, 2); if((total_written = write_to_file(pmk.dst, new_sock, response)) < 0) goto err3; return; }