static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
ret = 1;
end ();
return;
}
/* Set up peer */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID0, &p.id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID0, GNUNET_i2s_full (&p.id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s_full(&p.id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
test_ats_info[1].value = htonl(10);
test_ats_count = 2;
/* Adding address without session */
test_session = &test_addr;
create_test_address (&test_addr, "test", &test_addr, "test", strlen ("test") + 1);
test_hello_address.peer = p.id;
test_hello_address.transport_name = test_addr.plugin;
test_hello_address.address = test_addr.addr;
test_hello_address.address_length = test_addr.addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address, test_session, test_ats_info, test_ats_count);
/* Request address */
GNUNET_ATS_suggest_address (sched_ats, &p.id);
}
static void
got_initial_value (void *cls, int success)
{
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got initial value\n");
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
GNUNET_CONFIGURATION_destroy (cfg);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
}
static void
run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
struct GNUNET_TESTING_Peer *peer)
{
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
stats = GNUNET_STATISTICS_create ("ats", mycfg);
GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
/* Set up peer */
memset (&p.id, '1', sizeof (p.id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s_full(&p.id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_count = 2;
/* Adding address without session */
test_session = NULL;
create_test_address (&test_addr, "test", test_session, "test", strlen ("test") + 1);
test_hello_address.peer = p.id;
test_hello_address.transport_name = test_addr.plugin;
test_hello_address.address = test_addr.addr;
test_hello_address.address_length = test_addr.addr_len;
/* Adding address */
GNUNET_ATS_address_add (sched_ats, &test_hello_address, NULL, test_ats_info, test_ats_count);
}
/**
* Initiate transport service.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded tmp;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY",
&keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
if (GST_my_private_key == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Transport service could not access hostkey. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_stats = GNUNET_STATISTICS_create ("transport", c);
GST_peerinfo = GNUNET_PEERINFO_connect (c);
memset (&GST_my_public_key, '\0', sizeof (GST_my_public_key));
memset (&tmp, '\0', sizeof (tmp));
GNUNET_CRYPTO_rsa_key_get_public (GST_my_private_key, &GST_my_public_key);
GNUNET_CRYPTO_hash (&GST_my_public_key, sizeof (GST_my_public_key),
&GST_my_identity.hashPubKey);
GNUNET_assert (NULL != GST_my_private_key);
GNUNET_assert (0 != memcmp (&GST_my_public_key, &tmp, sizeof (GST_my_public_key)));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
if (GST_peerinfo == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
/* start subsystems */
GST_hello_start (&process_hello_update, NULL);
GNUNET_assert (NULL != GST_hello_get());
GST_blacklist_start (server);
GST_ats =
GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
GST_plugins_load (&plugin_env_receive_callback,
&plugin_env_address_change_notification,
&plugin_env_session_end,
&plugin_env_address_to_type);
GST_neighbours_start (NULL,
&neighbours_connect_notification,
&neighbours_disconnect_notification,
&neighbours_address_notification);
GST_clients_start (server);
GST_validation_start ();
}
/**
* Initiate transport service.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
long long unsigned int max_fd_cfg;
int max_fd_rlimit;
int max_fd;
int friend_only;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c,
"PEER",
"PRIVATE_KEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c,
"transport",
"HELLO_EXPIRATION",
&hello_expiration))
{
hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
}
GST_server = server;
pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
GNUNET_assert (NULL != pk);
GST_my_private_key = pk;
GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
&GST_my_identity.public_key);
GNUNET_assert(NULL != GST_my_private_key);
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"My identity is `%4s'\n",
GNUNET_i2s_full (&GST_my_identity));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
if (NULL == GST_peerinfo)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
max_fd_rlimit = 0;
max_fd_cfg = 0;
#if HAVE_GETRLIMIT
struct rlimit r_file;
if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
{
max_fd_rlimit = r_file.rlim_cur;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Maximum number of open files was: %u/%u\n",
r_file.rlim_cur,
r_file.rlim_max);
}
max_fd_rlimit = (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
#endif
GNUNET_CONFIGURATION_get_value_number (GST_cfg,
"transport",
"MAX_FD",
&max_fd_cfg);
if (max_fd_cfg > max_fd_rlimit)
max_fd = max_fd_cfg;
else
max_fd = max_fd_rlimit;
if (max_fd < DEFAULT_MAX_FDS)
max_fd = DEFAULT_MAX_FDS;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Limiting number of sockets to %u: validation %u, neighbors: %u\n",
max_fd, (max_fd / 3), (max_fd / 3) * 2);
friend_only = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
"topology",
"FRIENDS-ONLY");
if (GNUNET_SYSERR == friend_only)
friend_only = GNUNET_NO; /* According to topology defaults */
/* start subsystems */
GST_blacklist_start (GST_server,
GST_cfg,
&GST_my_identity);
GST_is = GNUNET_ATS_scanner_init ();
GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
GST_ats = GNUNET_ATS_scheduling_init (GST_cfg,
&ats_request_address_change,
NULL);
GST_ats_init ();
GST_manipulation_init ();
GST_plugins_load (&GST_manipulation_recv,
&plugin_env_address_change_notification,
&plugin_env_session_start,
&plugin_env_session_end);
GST_hello_start (friend_only,
&process_hello_update,
NULL);
GST_neighbours_start ((max_fd / 3) * 2);
GST_clients_start (GST_server);
GST_validation_start ((max_fd / 3));
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *mycfg,
struct GNUNET_TESTING_Peer *peer)
{
ret = 1;
cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* set up peer 0 */
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
&p[0].id.hashPubKey);
p0_addresses[0].plugin = "test";
p0_addresses[0].session = NULL;
p0_addresses[0].addr = GNUNET_strdup ("test_p0_a0");
p0_addresses[0].addr_len = strlen (p0_addresses[0].addr) + 1;
p0_ha[0].address = p0_addresses[0].addr;
p0_ha[0].address_length = p0_addresses[0].addr_len;
p0_ha[0].peer = p[0].id;
p0_ha[0].transport_name = p0_addresses[0].plugin;
p0_addresses[1].plugin = "test";
p0_addresses[1].session = NULL;
p0_addresses[1].addr = GNUNET_strdup ("test_p0_a1");
p0_addresses[1].addr_len = strlen(p0_addresses[1].addr) + 1;
p0_ha[1].address = p0_addresses[1].addr;
p0_ha[1].address_length = p0_addresses[1].addr_len;
p0_ha[1].peer = p[0].id;
p0_ha[1].transport_name = p0_addresses[1].plugin;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer 0: `%s'\n",
GNUNET_i2s (&p[0].id));
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
&p[1].id.hashPubKey);
p1_addresses[0].plugin = "test";
p1_addresses[0].session = NULL;
p1_addresses[0].addr = GNUNET_strdup ("test_p1_a0");
p1_addresses[0].addr_len = strlen(p1_addresses[0].addr) + 1;
p1_ha[0].address = p1_addresses[0].addr;
p1_ha[0].address_length = p1_addresses[0].addr_len;
p1_ha[0].peer = p[1].id;
p1_ha[0].transport_name = p1_addresses[0].plugin;
p1_addresses[1].plugin = "test";
p1_addresses[1].session = NULL;
p1_addresses[1].addr = GNUNET_strdup ("test_p1_a1");
p1_addresses[1].addr_len = strlen(p1_addresses[1].addr) + 1;
p1_ha[1].address = p1_addresses[1].addr;
p1_ha[1].address_length = p1_addresses[1].addr_len;
p1_ha[1].peer = p[1].id;
p1_ha[1].transport_name = p1_addresses[1].plugin;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer 1: `%s'\n",
GNUNET_i2s (&p[1].id));
/* Add addresses */
atsh = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (atsh == NULL)
{
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_ATS_address_add (atsh, &p0_ha[0], NULL, NULL, 0);
GNUNET_ATS_address_add (atsh, &p0_ha[1], NULL, NULL, 0);
GNUNET_ATS_address_add (atsh, &p1_ha[0], NULL, NULL, 0);
GNUNET_ATS_address_add (atsh, &p1_ha[1], NULL, NULL, 0);
GNUNET_ATS_suggest_address (atsh, &p[0].id);
GNUNET_ATS_suggest_address (atsh, &p[1].id);
}
static void
run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
struct GNUNET_TESTING_Peer *peer)
{
ret = 1;
cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL );
if (NULL == (perf_ats = GNUNET_ATS_performance_init (cfg, &ats_perf_cb, NULL)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to performance API\n");
GNUNET_SCHEDULER_add_now (end_badly, NULL);
}
stats = GNUNET_STATISTICS_create ("ats", cfg);
GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
/* set up peer 0 */
memset (&p[0].id, '1', sizeof (p[0].id));
p0_addresses[0].plugin = "test";
p0_addresses[0].session = NULL;
p0_addresses[0].addr = GNUNET_strdup ("test_p0_a0");
p0_addresses[0].addr_len = strlen (p0_addresses[0].addr) + 1;
p0_ha[0].address = p0_addresses[0].addr;
p0_ha[0].address_length = p0_addresses[0].addr_len;
p0_ha[0].peer = p[0].id;
p0_ha[0].transport_name = p0_addresses[0].plugin;
p0_addresses[1].plugin = "test";
p0_addresses[1].session = NULL;
p0_addresses[1].addr = GNUNET_strdup ("test_p0_a1");
p0_addresses[1].addr_len = strlen (p0_addresses[1].addr) + 1;
p0_ha[1].address = p0_addresses[1].addr;
p0_ha[1].address_length = p0_addresses[1].addr_len;
p0_ha[1].peer = p[0].id;
p0_ha[1].transport_name = p0_addresses[1].plugin;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created peer 0: `%s'\n",
GNUNET_i2s (&p[0].id));
memset (&p[1].id, '2', sizeof (p[1].id));
p1_addresses[0].plugin = "test";
p1_addresses[0].session = NULL;
p1_addresses[0].addr = GNUNET_strdup ("test_p1_a0");
p1_addresses[0].addr_len = strlen (p1_addresses[0].addr) + 1;
p1_ha[0].address = p1_addresses[0].addr;
p1_ha[0].address_length = p1_addresses[0].addr_len;
p1_ha[0].peer = p[1].id;
p1_ha[0].transport_name = p1_addresses[0].plugin;
p1_addresses[1].plugin = "test";
p1_addresses[1].session = NULL;
p1_addresses[1].addr = GNUNET_strdup ("test_p1_a1");
p1_addresses[1].addr_len = strlen (p1_addresses[1].addr) + 1;
p1_ha[1].address = p1_addresses[1].addr;
p1_ha[1].address_length = p1_addresses[1].addr_len;
p1_ha[1].peer = p[1].id;
p1_ha[1].transport_name = p1_addresses[1].plugin;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created peer 1: `%s'\n",
GNUNET_i2s (&p[1].id));
/* Add addresses */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL );
if (sched_ats == NULL )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
GNUNET_ATS_address_add (sched_ats, &p0_ha[0], NULL, NULL, 0);
GNUNET_ATS_address_add (sched_ats, &p0_ha[1], NULL, NULL, 0);
GNUNET_ATS_address_add (sched_ats, &p1_ha[0], NULL, NULL, 0);
GNUNET_ATS_address_add (sched_ats, &p1_ha[1], NULL, NULL, 0);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
char *quota_str;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", "a_str))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_out))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
GNUNET_free (quota_str);
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", "a_str))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_in))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
GNUNET_free (quota_str);
ret = 1;
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN inbound quota: %llu\n", wan_quota_in);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN outbound quota: %llu\n", wan_quota_out);
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
ret = 1;
end ();
return;
}
perf_ats = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (perf_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS performance!\n");
ret = 1;
end ();
return;
}
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID0, &p[0].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID0, GNUNET_i2s_full (&p[0].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[0].id));
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID1, &p[1].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID1, GNUNET_i2s_full (&p[1].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[1].id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_count = 2;
/* Adding address with session */
test_session[0] = &test_addr[0];
create_test_address (&test_addr[0], "test0", test_session[0], "test0", strlen ("test0") + 1);
test_hello_address[0].peer = p[0].id;
test_hello_address[0].transport_name = test_addr[0].plugin;
test_hello_address[0].address = test_addr[0].addr;
test_hello_address[0].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[0], test_session[0], test_ats_info, test_ats_count);
/* Adding address with session */
test_session[1] = &test_addr[1];
create_test_address (&test_addr[1], "test1", test_session[1], "test1", strlen ("test1") + 1);
test_hello_address[1].peer = p[1].id;
test_hello_address[1].transport_name = test_addr[0].plugin;
test_hello_address[1].address = test_addr[0].addr;
test_hello_address[1].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[1], test_session[1], test_ats_info, test_ats_count);
/* Change bandwidth preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
/* Change latency preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 10, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 100, GNUNET_ATS_PREFERENCE_END);
GNUNET_SCHEDULER_add_delayed (SLEEP, &sleep_task, NULL);
}
