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;
}
