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