From fc54a89326566a3b35c0c7f6dbe2f1fb507058e3 Mon Sep 17 00:00:00 2001 From: Martin Schanzenbach Date: Mon, 27 Feb 2012 16:07:30 +0000 Subject: [PATCH] -added test, lots of bugfixes --- src/gns/Makefile.am | 10 + src/gns/gnunet-service-gns.c | 96 +++++--- src/gns/namestore_stub_api.c | 13 +- src/gns/test_gns_twopeer.c | 446 ++++++++++++++++++++++++++++++++++ src/gns/test_gns_twopeer.conf | 79 ++++++ 5 files changed, 608 insertions(+), 36 deletions(-) create mode 100644 src/gns/test_gns_twopeer.c create mode 100644 src/gns/test_gns_twopeer.conf diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am index 52776993e..03d4ecaa9 100644 --- a/src/gns/Makefile.am +++ b/src/gns/Makefile.am @@ -27,9 +27,19 @@ bin_PROGRAMS = \ check_SCRIPTS = \ test_gnunet_gns.sh +check_PROGRAMS = \ + test_gns_twopeer + + plugin_LTLIBRARIES = \ libgnunet_plugin_block_gns.la +test_gns_twopeer_SOURCES = \ + test_gns_twopeer.c +test_gns_twopeer_LDADD = \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(top_builddir)/src/testing/libgnunettesting.la + #gnunet_gns_lookup_SOURCES = \ # gnunet-gns-lookup.c #gnunet_gns_lookup_LDADD = \ diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c index 070eae4d2..5b60fd6fb 100644 --- a/src/gns/gnunet-service-gns.c +++ b/src/gns/gnunet-service-gns.c @@ -236,7 +236,7 @@ process_authority_dht_result(void* cls, rd[i].data_size = ntohl(rb->data_length); rd[i].data = &rb[1]; rd[i].expiration = GNUNET_TIME_absolute_ntoh(rb->expiration); - rd[i].flags = ntohs(rb->flags); + rd[i].flags = ntohl(rb->flags); if (strcmp(name, rh->query->name) && (rd[i].record_type == rh->query->type)) @@ -289,7 +289,7 @@ resolve_authority_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name) GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key); - timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20); + timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5); xquery = htonl(GNUNET_GNS_RECORD_PKEY); //FIXME how long to wait for results? @@ -299,7 +299,7 @@ resolve_authority_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name) 5, //Replication level FIXME GNUNET_DHT_RO_NONE, &xquery, //xquery FIXME is this bad? - sizeof(GNUNET_GNS_RECORD_PKEY), + 0, // for test bp sizeof(GNUNET_GNS_RECORD_PKEY), &process_authority_dht_result, rh); @@ -338,7 +338,7 @@ process_name_dht_result(void* cls, char* name = NULL; int i; GNUNET_HashCode zone, name_hash; - + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "got dht result\n"); if (data == NULL) return; @@ -353,7 +353,7 @@ process_name_dht_result(void* cls, struct GNUNET_NAMESTORE_RecordData rd[num_records]; name = (char*)&nrb[1]; - rb = (struct GNSRecordBlock*)(&nrb[1] + strlen(name) + 1); + rb = (struct GNSRecordBlock*)(&nrb[1] + strlen(name) + 2); for (i=0; idata_length); rd[i].data = (char*)&rb[1]; rd[i].expiration = GNUNET_TIME_absolute_ntoh(rb->expiration); - rd[i].flags = ntohs(rb->flags); + rd[i].flags = ntohl(rb->flags); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Got name: %s (wanted %s)\n", name, rh->name); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Got type: %d (wanted %d)\n", + rd[i].record_type, rh->query->type); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Got data length: %d\n", rd[i].data_size); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Got flag %d\n", rd[i].flags); //FIXME class? - if (strcmp(name, rh->query->name) && + if (strcmp(name, rh->name) && (rd[i].record_type == rh->query->type)) { rh->answered++; } + rb = &rb[1] + rd[i].data_size; + } GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); @@ -409,12 +420,16 @@ resolve_name_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name) struct GNUNET_TIME_Relative timeout; GNUNET_HashCode name_hash; GNUNET_HashCode lookup_key; + struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string; GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key); - + GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "starting dht lookup for %s with key: %s\n", + name, (char*)&lookup_key_string); - timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20); + timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5); xquery = htonl(rh->query->type); //FIXME how long to wait for results? @@ -424,7 +439,7 @@ resolve_name_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name) 5, //Replication level FIXME GNUNET_DHT_RO_NONE, &xquery, //xquery FIXME is this bad? - sizeof(rh->query->type), + 0, //for test bp sizeof(rh->query->type), &process_name_dht_result, rh); @@ -671,16 +686,18 @@ process_authoritative_result(void* cls, * if this is not our zone we cannot rely on the namestore to be * complete. -> Query DHT */ - if (!GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash)) + if (GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash)) { if (remaining_time.rel_value == 0) { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "trying dht...\n"); resolve_name_dht(rh, name); return; } else { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Record is still recent. No DHT lookup\n"); } } @@ -960,24 +977,24 @@ put_some_records(void) //GNUNET_CRYPTO_hash(bob, GNUNET_CRYPTO_RSA_KEY_LENGTH, bob_zone); struct in_addr *alice = GNUNET_malloc(sizeof(struct in_addr)); - struct in_addr *bob_web = GNUNET_malloc(sizeof(struct in_addr)); + struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr)); struct GNUNET_NAMESTORE_RecordData rda; //struct GNUNET_NAMESTORE_RecordData rdb; - //struct GNUNET_NAMESTORE_RecordData rdb_web; + struct GNUNET_NAMESTORE_RecordData rdb_web; GNUNET_assert(1 == inet_pton (AF_INET, ipA, alice)); - //GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob_web)); + GNUNET_assert(1 == inet_pton (AF_INET, ipB, web)); rda.data_size = sizeof(struct in_addr); - //rdb_web.data_size = sizeof(struct in_addr); + rdb_web.data_size = sizeof(struct in_addr); //rdb.data_size = sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded); rda.data = alice; //rdb.data = bob; - //rdb_web.data = bob_web; + rdb_web.data = web; rda.record_type = GNUNET_GNS_RECORD_TYPE_A; - //rdb_web.record_type = GNUNET_GNS_RECORD_TYPE_A; + rdb_web.record_type = GNUNET_DNSPARSER_TYPE_A; //rdb.record_type = GNUNET_GNS_RECORD_PKEY; - //rdb_web.expiration = GNUNET_TIME_absolute_get_forever (); + rdb_web.expiration = GNUNET_TIME_absolute_get_forever (); rda.expiration = GNUNET_TIME_absolute_get_forever (); //rdb.expiration = GNUNET_TIME_absolute_get_forever (); @@ -988,6 +1005,12 @@ put_some_records(void) &rda, NULL, NULL); + GNUNET_NAMESTORE_record_create (namestore_handle, + zone_key, + "www", + &rdb_web, + NULL, + NULL); /* //www.bob.gnunet A IN 5.6.7.8 GNUNET_NAMESTORE_record_create (namestore_handle, @@ -995,17 +1018,16 @@ put_some_records(void) "bob", &rdb, NULL, - NULL); - GNUNET_NAMESTORE_record_put(namestore_handle, - bob, + NULL);*/ + /*GNUNET_NAMESTORE_record_put(namestore_handle, + zone_key, "www", GNUNET_TIME_absolute_get_forever (), 1, &rdb_web, NULL, //Signature NULL, //Cont - NULL); //cls - */ + NULL); //cls*/ } void @@ -1014,6 +1036,12 @@ update_zone_dht_next(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_NAMESTORE_zone_iterator_next(namestore_iter); } +void +record_dht_put(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "put request transmitted\n"); +} + /* prototype */ static void update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); @@ -1045,6 +1073,7 @@ put_gns_record(void *cls, struct GNSRecordBlock *rb; GNUNET_HashCode name_hash; GNUNET_HashCode xor_hash; + struct GNUNET_CRYPTO_HashAsciiEncoded xor_hash_string; int i; uint32_t rd_payload_length; @@ -1082,6 +1111,8 @@ put_gns_record(void *cls, for (i=0; itype = htonl(rd[i].record_type); rb->expiration = GNUNET_TIME_absolute_hton(rd[i].expiration); rb->data_length = htonl(rd[i].data_size); @@ -1097,6 +1128,10 @@ put_gns_record(void *cls, timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20); GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); GNUNET_CRYPTO_hash_xor(&zone_hash, &name_hash, &xor_hash); + GNUNET_CRYPTO_hash_to_enc (&xor_hash, &xor_hash_string); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "putting new record %s under key: %s\n", + name, (char*)&xor_hash_string); + GNUNET_DHT_put (dht_handle, &xor_hash, 5, //replication level GNUNET_DHT_RO_NONE, @@ -1105,7 +1140,7 @@ put_gns_record(void *cls, (char*)nrb, expiration, timeout, - NULL, //FIXME continuation needed? success check? yes ofc + &record_dht_put, //FIXME continuation needed? success check? yes ofc NULL); //cls for cont num_public_records++; @@ -1224,14 +1259,15 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, GNUNET_DNS_FLAG_PRE_RESOLUTION, &handle_dns_request, /* rh */ NULL); /* Closure */ - } - - if (NULL == dns_handle) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + if (NULL == dns_handle) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to the dnsservice!\n"); + } } + + /** * handle to our local namestore */ diff --git a/src/gns/namestore_stub_api.c b/src/gns/namestore_stub_api.c index 5e2b66a9d..b1fd77683 100644 --- a/src/gns/namestore_stub_api.c +++ b/src/gns/namestore_stub_api.c @@ -178,7 +178,7 @@ GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h, { if (GNUNET_CRYPTO_hash_cmp(zone, sr->zone) == 0) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "records for %s already present ow\n", + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "authority for %s already known\n", name); sr->rd_count = rd_count; for (i=0; inext) { GNUNET_CRYPTO_hash_to_enc (sr->zone, &zone_string_ex); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Got %s in %s\n", sr->name, (char*)&zone_string_ex); if ((strcmp(sr->name, name) == 0) && (0 == (GNUNET_CRYPTO_hash_cmp(sr->zone, zone)))) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Found match for %s with %d entries\n", - sr->name, sr->rd_count); + "Found match for %s in %s with %d entries\n", + sr->name, (char*)&zone_string_ex, sr->rd_count); //Simply always return all records proc(proc_cls, sr->zone_key, GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME name, sr->rd_count, sr->rd, NULL); @@ -390,6 +389,7 @@ GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, it->zone = zone; it->no_flags = must_not_have_flags; it->flags = must_have_flags; + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Begin iteration\n"); GNUNET_NAMESTORE_zone_iterator_next(it); return it; } @@ -406,9 +406,10 @@ GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it) NULL, 0, NULL, NULL); return; } - - if (GNUNET_CRYPTO_hash_cmp(it->sr->zone, it->zone)) + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Next result\n"); + if (GNUNET_CRYPTO_hash_cmp(it->sr->zone, it->zone) == 0) { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "match\n"); //Simply always return all records //check flags it->proc(it->proc_cls, it->sr->zone_key, GNUNET_TIME_UNIT_FOREVER_ABS, diff --git a/src/gns/test_gns_twopeer.c b/src/gns/test_gns_twopeer.c new file mode 100644 index 000000000..e30092cc5 --- /dev/null +++ b/src/gns/test_gns_twopeer.c @@ -0,0 +1,446 @@ +/* + This file is part of GNUnet. + (C) 2009 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ +/** + * @file gns/test_gns_twopeer.c + * @brief base testcase for testing DHT service with + * two running peers. + * + * This testcase starts peers using the GNUNET_TESTING_daemons_start + * function call. On peer start, connects to the peers DHT service + * by calling GNUNET_DHT_connected. Once notified about all peers + * being started (by the peers_started_callback function), calls + * GNUNET_TESTING_connect_topology, which connects the peers in a + * "straight line" topology. On notification that all peers have + * been properly connected, calls the do_get function which initiates + * a GNUNET_DHT_get from the *second* peer. Once the GNUNET_DHT_get + * function starts, runs the do_put function to insert data at the first peer. + * If the GET is successful, schedules finish_testing + * to stop the test and shut down peers. If GET is unsuccessful + * after GET_TIMEOUT seconds, prints an error message and shuts down + * the peers. + */ +#include "platform.h" +#include "gnunet_testing_lib.h" +#include "gnunet_core_service.h" +#include "gnunet_dht_service.h" +#include "block_dns.h" +#include "gnunet_signatures.h" + +/* DEFINES */ +#define VERBOSE GNUNET_YES + +/* Timeout for entire testcase */ +#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 40) + +/* If number of peers not in config file, use this number */ +#define DEFAULT_NUM_PEERS 2 + +/* Globals */ + +/** + * Directory to store temp data in, defined in config file + */ +static char *test_directory; + +/** + * Variable used to store the number of connections we should wait for. + */ +static unsigned int expected_connections; + +/** + * Variable used to keep track of how many peers aren't yet started. + */ +static unsigned long long peers_left; + +struct GNUNET_TESTING_Daemon *d1; +struct GNUNET_TESTING_Daemon *d2; + + +/** + * Total number of peers to run, set based on config file. + */ +static unsigned long long num_peers; + +/** + * Global used to count how many connections we have currently + * been notified about (how many times has topology_callback been called + * with success?) + */ +static unsigned int total_connections; + +/** + * Global used to count how many failed connections we have + * been notified about (how many times has topology_callback + * been called with failure?) + */ +static unsigned int failed_connections; + +/* Task handle to use to schedule test failure */ +GNUNET_SCHEDULER_TaskIdentifier die_task; + +GNUNET_SCHEDULER_TaskIdentifier bob_task; + +/* Global return value (0 for success, anything else for failure) */ +static int ok; + +int bob_online, alice_online; + +/** + * Check whether peers successfully shut down. + */ +void +shutdown_callback (void *cls, const char *emsg) +{ + if (emsg != NULL) + { + if (ok == 0) + ok = 2; + } +} + +/** + * Function scheduled to be run on the successful completion of this + * testcase. Specifically, called when our get request completes. + */ +static void +finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + ok = 0; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n"); + GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL, + GNUNET_YES, GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer2!\n"); + GNUNET_TESTING_daemon_stop (d2, TIMEOUT, &shutdown_callback, NULL, + GNUNET_YES, GNUNET_NO); + GNUNET_SCHEDULER_cancel(bob_task); + GNUNET_SCHEDULER_cancel(die_task); +} + +/** + * Continuation for the GNUNET_DHT_get_stop call, so that we don't shut + * down the peers without freeing memory associated with GET request. + */ +static void +end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + if (d1 != NULL) + GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL, + GNUNET_YES, GNUNET_NO); + if (d2 != NULL) + GNUNET_TESTING_daemon_stop (d2, TIMEOUT, &shutdown_callback, NULL, + GNUNET_YES, GNUNET_NO); +} + +/** + * Check if the get_handle is being used, if so stop the request. Either + * way, schedule the end_badly_cont function which actually shuts down the + * test. + */ +static void +end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Failing test with error: `%s'!\n", + (char *) cls); + GNUNET_SCHEDULER_cancel(bob_task); + GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL); + ok = 1; +} + +static void +do_lookup(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + //do lookup here + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 30), + &finish_testing, NULL); +} + +static void +gns_started(void *cls, const struct GNUNET_PeerIdentity *id, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Daemon *d, const char *emsg) +{ + if (NULL != emsg) + { + if (d == d1) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS failed to start alice\n"); + else + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS failed to start bob\n"); + return; + } + if (d == d1) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS started on alice\n"); + GNUNET_TESTING_daemon_start_service (d2, "gns", TIMEOUT, &gns_started, + NULL); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS started on bob\n"); + + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), + &do_lookup, NULL); +} + +/** + * This function is called whenever a connection attempt is finished between two of + * the started peers (started with GNUNET_TESTING_daemons_start). The total + * number of times this function is called should equal the number returned + * from the GNUNET_TESTING_connect_topology call. + * + * The emsg variable is NULL on success (peers connected), and non-NULL on + * failure (peers failed to connect). + */ +void +notify_connect (void *cls, const struct GNUNET_PeerIdentity *first, + const struct GNUNET_PeerIdentity *second, uint32_t distance, + const struct GNUNET_CONFIGURATION_Handle *first_cfg, + const struct GNUNET_CONFIGURATION_Handle *second_cfg, + struct GNUNET_TESTING_Daemon *first_daemon, + struct GNUNET_TESTING_Daemon *second_daemon, + const char *emsg) +{ + if (emsg == NULL) + { + total_connections++; +#if VERBOSE + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "connected peer %s to peer %s, distance %u\n", + first_daemon->shortname, second_daemon->shortname, distance); +#endif + } +#if VERBOSE + else + { + failed_connections++; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Failed to connect peer %s to peer %s with error :\n%s\n", + first_daemon->shortname, second_daemon->shortname, emsg); + } +#endif + + if (total_connections == expected_connections) + { +#if VERBOSE + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Created %d total connections, which is our target number! Starting next phase of testing.\n", + total_connections); +#endif + GNUNET_SCHEDULER_cancel (die_task); + die_task = + GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, "from test lookup"); + GNUNET_TESTING_daemon_start_service (d1, "gns", TIMEOUT, &gns_started, NULL); + + } + else if (total_connections + failed_connections == expected_connections) + { + GNUNET_SCHEDULER_cancel (die_task); + die_task = + GNUNET_SCHEDULER_add_now (&end_badly, + "from topology_callback (too many failed connections)"); + } +} + +/** + * Set up some data, and call API PUT function + */ +static void +alice_idle (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + + if (!bob_online) + { + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 2), + &alice_idle, NULL); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting peers\n"); + GNUNET_TESTING_daemons_connect (d1, d2, TIMEOUT, 5, 1, + ¬ify_connect, NULL); +} + +static void +bob_idle (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + + bob_online = 1; + bob_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 2), + &bob_idle, NULL); +} + + + + +/** + * Callback which is called whenever a peer is started (as a result of the + * GNUNET_TESTING_daemons_start call. + * + * @param cls closure argument given to GNUNET_TESTING_daemons_start + * @param id the GNUNET_PeerIdentity of the started peer + * @param cfg the configuration for this specific peer (needed to connect + * to the DHT) + * @param d the handle to the daemon started + * @param emsg NULL if peer started, non-NULL on error + */ +static void +alice_started (void *cls, const struct GNUNET_PeerIdentity *id, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Daemon *d, const char *emsg) +{ + if (emsg != NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to start daemon with error: `%s'\n", emsg); + return; + } + GNUNET_assert (id != NULL); + + alice_online = 1; + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 2), + &alice_idle, NULL); +} + +static void +bob_started (void *cls, const struct GNUNET_PeerIdentity *id, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Daemon *d, const char *emsg) +{ + if (emsg != NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to start daemon with error: `%s'\n", emsg); + return; + } + GNUNET_assert (id != NULL); + + alice_online = 1; + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 2), + &bob_idle, NULL); +} + +static void +run (void *cls, char *const *args, const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) +{ + + /* Get path from configuration file */ + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome", + &test_directory)) + { + ok = 404; + return; + } + + /* Get number of peers to start from configuration (should be two) */ + if (GNUNET_SYSERR == + GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers", + &num_peers)) + num_peers = DEFAULT_NUM_PEERS; + + /* Set peers_left so we know when all peers started */ + peers_left = num_peers; + + /* Set up a task to end testing if peer start fails */ + die_task = + GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, + "didn't start all daemons in reasonable amount of time!!!"); + alice_online = 0; + bob_online = 0; + d1 = GNUNET_TESTING_daemon_start(cfg, TIMEOUT, GNUNET_NO, NULL, NULL, 0, + NULL, NULL, NULL, &alice_started, NULL); + uint16_t port = 6000; + expected_connections = 1; + uint32_t upnum = 23; + uint32_t fdnum = 42; + struct GNUNET_CONFIGURATION_Handle *cfg2 = GNUNET_TESTING_create_cfg(cfg, + 23, &port, &upnum, + NULL, &fdnum); + GNUNET_CONFIGURATION_set_value_string (cfg2, "paths", "servicehome", + "/tmp/peer2"); + GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "HIJACK_DNS", + "NO"); + GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "ZONEKEY", + "/tmp/bobkey"); + GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "TRUSTED", + "alice:/tmp/zonekey"); + d2 = GNUNET_TESTING_daemon_start(cfg2, TIMEOUT, GNUNET_NO, NULL, NULL, 0, + NULL, NULL, NULL, &bob_started, NULL); + + +} + +static int +check () +{ + int ret; + + /* Arguments for GNUNET_PROGRAM_run */ + char *const argv[] = { "test-gns-twopeer", /* Name to give running binary */ + "-c", + "test_gns_twopeer.conf", /* Config file to use */ +#if VERBOSE + "-L", "DEBUG", +#endif + NULL + }; + struct GNUNET_GETOPT_CommandLineOption options[] = { + GNUNET_GETOPT_OPTION_END + }; + /* Run the run function as a new program */ + ret = + GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, + "test-gns-twopeer", "nohelp", options, &run, + &ok); + if (ret != GNUNET_OK) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "`test-gns-twopeer': Failed with error code %d\n", ret); + } + return ok; +} + +int +main (int argc, char *argv[]) +{ + int ret; + + GNUNET_log_setup ("test-gns-twopeer", +#if VERBOSE + "DEBUG", +#else + "WARNING", +#endif + NULL); + ret = check (); + /** + * Need to remove base directory, subdirectories taken care + * of by the testing framework. + */ + return ret; +} + +/* end of test_gns_twopeer.c */ diff --git a/src/gns/test_gns_twopeer.conf b/src/gns/test_gns_twopeer.conf new file mode 100644 index 000000000..221aa0031 --- /dev/null +++ b/src/gns/test_gns_twopeer.conf @@ -0,0 +1,79 @@ +[fs] +AUTOSTART = NO + +[resolver] +AUTOSTART = NO + +[dht] +DEBUG = NO +AUTOSTART = YES +ACCEPT_FROM6 = ::1; +ACCEPT_FROM = 127.0.0.1; +HOSTNAME = localhost +PORT = 2100 +BINARY = gnunet-service-dht + +[block] +plugins = dht test + +[dhtcache] +QUOTA = 1 MB +DATABASE = sqlite + +[transport] +PLUGINS = tcp +DEBUG = NO +ACCEPT_FROM6 = ::1; +ACCEPT_FROM = 127.0.0.1; +NEIGHBOUR_LIMIT = 50 +PORT = 12365 + +[ats] +WAN_QUOTA_IN = 1 GB +WAN_QUOTA_OUT = 1 GB + +[core] +PORT = 12092 + +[arm] +DEFAULTSERVICES = core +PORT = 12366 +DEBUG = NO + +[transport-tcp] +TIMEOUT = 300 s +PORT = 12368 +BINDTO = 127.0.0.1 + +[TESTING] +WEAKRANDOM = YES + +[gnunetd] +HOSTKEY = $SERVICEHOME/.hostkey + +[PATHS] +DEFAULTCONFIG = gns.conf +SERVICEHOME = /tmp/test-gnunetd-gns-peer-1/ + + +[nat] +DISABLEV6 = YES +ENABLE_UPNP = NO +BEHIND_NAT = NO +ALLOW_NAT = NO +INTERNAL_ADDRESS = 127.0.0.1 +EXTERNAL_ADDRESS = 127.0.0.1 +USE_LOCALADDR = NO + +[dns] +AUTOSTART = YES + +[gns] +AUTOSTART = YES +BINARY = gnunet-service-gns + + +[nse] +AUTOSTART = NO + + -- 2.25.1