static void
do_consensus ()
{
int unique_indices[replication];
unsigned int i;
for (i = 0; i < num_values; i++)
{
unsigned int j;
struct GNUNET_HashCode val;
struct GNUNET_SET_Element element;
generate_indices (unique_indices);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val);
element.data = &val;
element.size = sizeof (val);
for (j = 0; j < replication; j++)
{
int cid;
cid = unique_indices[j];
GNUNET_CONSENSUS_insert (consensus_handles[cid],
&element,
NULL, NULL);
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"all elements inserted, calling conclude\n");
for (i = 0; i < num_peers; i++)
GNUNET_CONSENSUS_conclude (consensus_handles[i],
conclude_cb, &consensus_handles[i]);
}
static int
testArithmetic ()
{
static struct GNUNET_CRYPTO_AesSessionKey zskey;
static struct GNUNET_CRYPTO_AesInitializationVector ziv;
struct GNUNET_HashCode h1;
struct GNUNET_HashCode h2;
struct GNUNET_HashCode d;
struct GNUNET_HashCode s;
struct GNUNET_CRYPTO_AesSessionKey skey;
struct GNUNET_CRYPTO_AesInitializationVector iv;
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h1);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h2);
if (GNUNET_CRYPTO_hash_distance_u32 (&h1, &h2) !=
GNUNET_CRYPTO_hash_distance_u32 (&h2, &h1))
return 1;
GNUNET_CRYPTO_hash_difference (&h1, &h2, &d);
GNUNET_CRYPTO_hash_sum (&h1, &d, &s);
if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
return 1;
GNUNET_CRYPTO_hash_xor (&h1, &h2, &d);
GNUNET_CRYPTO_hash_xor (&h1, &d, &s);
if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
return 1;
if (0 != GNUNET_CRYPTO_hash_xorcmp (&s, &h2, &h1))
return 1;
if (-1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h1))
return 1;
if (1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h2))
return 1;
memset (&d, 0xF0, sizeof (d));
if (0 != GNUNET_CRYPTO_hash_get_bit (&d, 3))
return 1;
if (1 != GNUNET_CRYPTO_hash_get_bit (&d, 6))
return 1;
memset (&d, 0, sizeof (d));
GNUNET_CRYPTO_hash_to_aes_key (&d, &skey, &iv);
if ((0 != memcmp (&skey, &zskey, sizeof (skey) - sizeof (unsigned int))) ||
(0 != memcmp (&iv, &ziv, sizeof (iv))))
return 1;
return 0;
}
static void
generatePeerIdList ()
{
int i;
for (i = 0; i < NUMBER_OF_PEERS; i++)
{
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
&pidArr[i].hashPubKey);
#if VERBOSE
printf ("Peer %d: %s\n", i, GNUNET_i2s (&pidArr[i]));
#endif
}
}
/**
* Signature of the 'main' function for a (single-peer) testcase that
* is run using 'GNUNET_TESTING_peer_run'.
*
* @param cls closure
* @param cfg configuration of the peer that was started
* @param peer identity of the peer that was created
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
config = cfg;
GNUNET_TESTING_peer_get_identity (peer, &local_id);
if (0) test_iter ();
set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_INTERSECTION);
set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_INTERSECTION);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
/* test the real set reconciliation */
init_set1 ();
}
/**
* Signature of the 'main' function for a (single-peer) testcase that
* is run using 'GNUNET_TESTING_peer_run'.
*
* @param cls closure
* @param cfg configuration of the peer that was started
* @param peer identity of the peer that was created
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
&timeout_fail,
NULL);
config = cfg;
GNUNET_TESTING_peer_get_identity (peer,
&local_id);
test_iter ();
set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
/* test the real set reconciliation */
init_set1 ();
}
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;
}
static void
check (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
unsigned int c = 0;
unsigned int c2 = 0;
unsigned int ca = 0;
int update = GNUNET_NO;
int range = GNUNET_NO;
int res;
#if !HAVE_LIBGLPK
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed!");
ret = 1;
return;
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up %u peers with %u addresses per peer\n", peers, addresses);
mlp = GAS_mlp_init (cfg, NULL, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
if (NULL == mlp)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to init MLP\n");
ret = 1;
if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
GNUNET_SCHEDULER_cancel(shutdown_task);
shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
}
if (peers == 0)
peers = DEF_PEERS;
if (addresses == 0)
addresses = DEF_ADDRESSES_PER_PEER;
p = GNUNET_malloc (peers * sizeof (struct ATS_Peer));
a = GNUNET_malloc (peers * addresses * sizeof (struct ATS_Address));
amap = GNUNET_CONTAINER_multihashmap_create(addresses * peers, GNUNET_NO);
mlp->auto_solve = GNUNET_NO;
if (start == 0)
start = 0;
if (end == 0)
end = -1;
if ((start != -1) && (end != -1))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Solving problem starting from %u to %u\n", start , end);
range = GNUNET_YES;
}
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Solving problem for %u peers\n", peers);
if ((update_percentage >= 0) && (update_percentage <= 100))
{
update = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Benchmarking with existing presolution and %u%% updated addresses\n", update_percentage);
}
else if ((update_percentage > 100) && (update_percentage != UINT_MAX))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Invalid percentage: %u\n", update_percentage);
ret = 1;
return;
}
for (c=0; c < peers; c++)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up peer %u\n", c);
GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_NONCE, &p[c].id.hashPubKey);
for (c2=0; c2 < addresses; c2++)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up address %u for peer %u\n", c2, c);
/* Setting required information */
a[ca].mlp_information = NULL;
a[ca].prev = NULL;
a[ca].next = NULL;
/* Setting address */
a[ca].peer = p[c].id;
a[ca].plugin = GNUNET_strdup("test");
a[ca].atsp_network_type = GNUNET_ATS_NET_LOOPBACK;
a[ca].ats = GNUNET_malloc (DEF_ATS_VALUES * sizeof (struct GNUNET_ATS_Information));
a[ca].ats[0].type = GNUNET_ATS_QUALITY_NET_DELAY;
a[ca].ats[0].value = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DEF_ATS_MAX_DELAY);
a[ca].ats[1].type = GNUNET_ATS_QUALITY_NET_DISTANCE;
a[ca].ats[1].value = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DEF_ATS_MAX_DISTANCE);
a[ca].ats_count = 2;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up address %u\n", ca);
GNUNET_CONTAINER_multihashmap_put (amap, &a[ca].peer.hashPubKey, &a[ca], GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
GAS_mlp_address_update(mlp, amap, &a[ca]);
ca++;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Problem contains %u peers and %u adresses\n", mlp->c_p, mlp->addr_in_problem);
if (((GNUNET_YES == range) && (((start >= 0) && ((c+1) >= start)) && (c <= end))) || ((c+1) == peers))
{
GNUNET_assert ((c+1) == mlp->c_p);
GNUNET_assert ((c+1) * addresses == mlp->addr_in_problem);
/* Solving the problem */
struct GAS_MLP_SolutionContext ctx;
res = GAS_mlp_solve_problem(mlp, &ctx);
if (GNUNET_NO == update)
{
if (GNUNET_OK == res)
{
GNUNET_assert (GNUNET_OK == ctx.lp_result);
GNUNET_assert (GNUNET_OK == ctx.mlp_result);
if (GNUNET_YES == numeric)
printf ("%u;%u;%llu;%llu\n",mlp->c_p, mlp->addr_in_problem, (unsigned long long) ctx.lp_duration.rel_value, (unsigned long long) ctx.mlp_duration.rel_value);
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Problem solved for %u peers with %u address successfully (LP: %llu ms / MLP: %llu ms)\n",
mlp->c_p, mlp->addr_in_problem, ctx.lp_duration.rel_value, ctx.mlp_duration.rel_value);
}
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Solving problem with %u peers and %u addresses failed\n", c, c2);
}
else
{
struct GAS_MLP_SolutionContext uctx;
/* Update addresses */
update_addresses (a, (c+1) * c2, update_percentage);
/* Solve again */
res = GAS_mlp_solve_problem(mlp, &uctx);
if (GNUNET_OK == res)
{
GNUNET_assert (GNUNET_OK == uctx.lp_result);
GNUNET_assert (GNUNET_OK == uctx.mlp_result);
if (GNUNET_YES == numeric)
printf ("%u;%u;%llu;%llu;%llu;%llu\n",mlp->c_p, mlp->addr_in_problem,
(unsigned long long) ctx.lp_duration.rel_value, (unsigned long long) ctx.mlp_duration.rel_value,
(unsigned long long) uctx.lp_duration.rel_value, (unsigned long long) uctx.mlp_duration.rel_value);
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Updated problem solved for %u peers with %u address successfully (Initial: LP/MLP: %llu/%llu ms, Update: %llu/%llu ms)\n",
mlp->c_p, mlp->addr_in_problem,
(unsigned long long) ctx.lp_duration.rel_value, (unsigned long long) ctx.mlp_duration.rel_value,
(unsigned long long) uctx.lp_duration.rel_value, (unsigned long long) uctx.mlp_duration.rel_value);
}
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Solving updated problem with %u peers and %u addresses failed\n", c, c2);
}
}
}
if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
GNUNET_SCHEDULER_cancel(shutdown_task);
shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
}
/**
* Generate a random hashcode.
*/
static void
nextHC (GNUNET_HashCode * hc)
{
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, hc);
}
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_HashCode id;
struct IBF_Key ibf_key;
int i;
int side;
int res;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Relative delta_time;
set_a = GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)),
GNUNET_NO);
set_b = GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)),
GNUNET_NO);
set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize),
GNUNET_NO);
key_to_hashcode = GNUNET_CONTAINER_multihashmap_create (((asize+bsize+csize == 0) ? 1 : (asize+bsize+csize)),
GNUNET_NO);
printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
hash_num, ibf_size, asize, bsize, csize);
i = 0;
while (i < asize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_a, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
i = 0;
while (i < bsize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_b, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
i = 0;
while (i < csize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_c, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
ibf_a = ibf_create (ibf_size, hash_num);
ibf_b = ibf_create (ibf_size, hash_num);
if ( (NULL == ibf_a) ||
(NULL == ibf_b) )
{
/* insufficient memory */
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
return;
}
printf ("generated sets\n");
start_time = GNUNET_TIME_absolute_get ();
GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a);
GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b);
GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a);
GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b);
delta_time = GNUNET_TIME_absolute_get_duration (start_time);
printf ("encoded in: %s\n",
GNUNET_STRINGS_relative_time_to_string (delta_time,
GNUNET_NO));
ibf_subtract (ibf_a, ibf_b);
start_time = GNUNET_TIME_absolute_get ();
for (i = 0; i <= asize + bsize; i++)
{
res = ibf_decode (ibf_a, &side, &ibf_key);
if (GNUNET_SYSERR == res)
{
printf ("decode failed, %u/%u elements left\n",
GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
asize + bsize);
return;
}
if (GNUNET_NO == res)
{
if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) &&
(0 == GNUNET_CONTAINER_multihashmap_size (set_a)))
{
delta_time = GNUNET_TIME_absolute_get_duration (start_time);
printf ("decoded successfully in: %s\n",
GNUNET_STRINGS_relative_time_to_string (delta_time,
GNUNET_NO));
}
else
{
printf ("decode missed elements (should never happen)\n");
}
return;
}
if (side == 1)
iter_hashcodes (ibf_key, remove_iterator, set_a);
if (side == -1)
iter_hashcodes (ibf_key, remove_iterator, set_b);
}
printf("cyclic IBF, %u/%u elements left\n",
GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
asize + bsize);
}
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);
}
int
main (int argc, char *argv[])
{
int ok;
struct GNUNET_HashCode rid1;
struct GNUNET_HashCode id2;
struct GNUNET_HashCode rid2;
struct GNUNET_HashCode fid;
struct GNUNET_HashCode id3;
int old;
int newVal;
struct GNUNET_CONFIGURATION_Handle *cfg;
char *name1;
char *name2;
char *name3;
char *name1_unique;
char *name2_unique;
char *noname;
int noname_is_a_dup;
int notiCount, fakenotiCount;
int count;
static char m[1024 * 1024 * 10];
memset (m, 'b', sizeof (m));
m[sizeof (m) - 1] = '\0';
GNUNET_log_setup ("test-pseudonym", "WARNING", NULL);
ok = GNUNET_YES;
GNUNET_CRYPTO_random_disable_entropy_gathering ();
(void) GNUNET_DISK_directory_remove ("/tmp/gnunet-pseudonym-test");
cfg = GNUNET_CONFIGURATION_create ();
if (-1 == GNUNET_CONFIGURATION_parse (cfg, "test_pseudonym_data.conf"))
{
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_break (0);
return -1;
}
notiCount = 0;
fakenotiCount = 0;
count = 0;
GNUNET_PSEUDONYM_discovery_callback_register (cfg, &fake_noti_callback,
&fakenotiCount);
GNUNET_PSEUDONYM_discovery_callback_register (cfg, ¬i_callback,
¬iCount);
GNUNET_PSEUDONYM_discovery_callback_unregister (&false_callback, &count);
GNUNET_PSEUDONYM_discovery_callback_unregister (&fake_noti_callback,
&fakenotiCount);
/* ACTUAL TEST CODE */
old = GNUNET_PSEUDONYM_list_all (cfg, NULL, NULL);
meta = GNUNET_CONTAINER_meta_data_create ();
GNUNET_CONTAINER_meta_data_insert (meta, "<test>", EXTRACTOR_METATYPE_TITLE,
EXTRACTOR_METAFORMAT_UTF8, "text/plain",
"test", strlen ("test") + 1);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &id1);
GNUNET_PSEUDONYM_add (cfg, &id1, meta);
CHECK (notiCount == 1);
GNUNET_PSEUDONYM_add (cfg, &id1, meta);
CHECK (notiCount == 2);
newVal = GNUNET_PSEUDONYM_list_all (cfg, &iter, &ok);
CHECK (old < newVal);
old = newVal;
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &id2);
GNUNET_PSEUDONYM_add (cfg, &id2, meta);
CHECK (notiCount == 3);
newVal = GNUNET_PSEUDONYM_list_all (cfg, &iter, &ok);
CHECK (old < newVal);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
EXTRACTOR_METATYPE_COMMENT,
EXTRACTOR_METAFORMAT_UTF8,
"text/plain", m,
strlen (m) + 1));
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &id3);
GNUNET_PSEUDONYM_add (cfg, &id3, meta);
GNUNET_PSEUDONYM_get_info (cfg, &id3, NULL, NULL, &name3, NULL);
CHECK (name3 != NULL);
GNUNET_PSEUDONYM_get_info (cfg, &id2, NULL, NULL, &name2, NULL);
CHECK (name2 != NULL);
GNUNET_PSEUDONYM_get_info (cfg, &id1, NULL, NULL, &name1, NULL);
CHECK (name1 != NULL);
CHECK (0 == strcmp (name1, name2));
name1_unique = GNUNET_PSEUDONYM_name_uniquify (cfg, &id1, name1, NULL);
name2_unique = GNUNET_PSEUDONYM_name_uniquify (cfg, &id2, name2, NULL);
CHECK (0 != strcmp (name1_unique, name2_unique));
CHECK (GNUNET_SYSERR == GNUNET_PSEUDONYM_name_to_id (cfg, "fake", &rid2));
CHECK (GNUNET_SYSERR == GNUNET_PSEUDONYM_name_to_id (cfg, name2, &rid2));
CHECK (GNUNET_SYSERR == GNUNET_PSEUDONYM_name_to_id (cfg, name1, &rid1));
CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name2_unique, &rid2));
CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name1_unique, &rid1));
CHECK (0 == memcmp (&id1, &rid1, sizeof (struct GNUNET_HashCode)));
CHECK (0 == memcmp (&id2, &rid2, sizeof (struct GNUNET_HashCode)));
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &fid);
GNUNET_log_skip (1, GNUNET_NO);
CHECK (0 == GNUNET_PSEUDONYM_rank (cfg, &fid, 0));
GNUNET_log_skip (0, GNUNET_YES);
CHECK (GNUNET_OK == GNUNET_PSEUDONYM_get_info (cfg, &fid, NULL, NULL, &noname, &noname_is_a_dup));
CHECK (noname != NULL);
CHECK (noname_is_a_dup == GNUNET_YES);
CHECK (0 == GNUNET_PSEUDONYM_rank (cfg, &id1, 0));
CHECK (5 == GNUNET_PSEUDONYM_rank (cfg, &id1, 5));
CHECK (-5 == GNUNET_PSEUDONYM_rank (cfg, &id1, -10));
CHECK (0 == GNUNET_PSEUDONYM_rank (cfg, &id1, 5));
GNUNET_free (name1);
GNUNET_free (name2);
GNUNET_free (name1_unique);
GNUNET_free (name2_unique);
GNUNET_free (name3);
GNUNET_free (noname);
/* END OF TEST CODE */
FAILURE:
GNUNET_PSEUDONYM_discovery_callback_unregister (¬i_callback, ¬iCount);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_break (GNUNET_OK ==
GNUNET_DISK_directory_remove ("/tmp/gnunet-pseudonym-test"));
return (ok == GNUNET_YES) ? 0 : 1;
}
