X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fgns%2Ftest_gns_dht_delegated_lookup.c;h=f9531751ad4e3638e0f4fae675d4350391244bb4;hb=39850a9dc3d789303b91816275314898c0ae80e2;hp=83fdf18730b0de924d32a3d11c3133a06e3430fa;hpb=3363469a42ac6f4b1245c0fe160a98f40845b748;p=oweals%2Fgnunet.git diff --git a/src/gns/test_gns_dht_delegated_lookup.c b/src/gns/test_gns_dht_delegated_lookup.c index 83fdf1873..f9531751a 100644 --- a/src/gns/test_gns_dht_delegated_lookup.c +++ b/src/gns/test_gns_dht_delegated_lookup.c @@ -18,26 +18,12 @@ Boston, MA 02111-1307, USA. */ /** - * @file gns/test_gns_twopeer.c - * @brief base testcase for testing DHT service with - * two running peers. + * @file gns/test_gns_dht_delegated_lookup.c + * @brief test for record lookup via DHT * - * 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_testing_lib-new.h" #include "gnunet_core_service.h" #include "block_gns.h" #include "gnunet_signatures.h" @@ -47,103 +33,140 @@ #include "gnunet_dht_service.h" #include "gnunet_gns_service.h" -/* DEFINES */ -#define VERBOSE GNUNET_YES - /* Timeout for entire testcase */ -#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10) +#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20) -/* If number of peers not in config file, use this number */ -#define DEFAULT_NUM_PEERS 2 +/* Timeout for entire testcase */ +#define DHT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10) /* test records to resolve */ -#define TEST_DOMAIN "www.bob.gnunet" +#define TEST_DOMAIN "www.bob.gads" #define TEST_IP "127.0.0.1" #define TEST_RECORD_NAME "www" #define TEST_AUTHORITY_NAME "bob" -#define DHT_OPERATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) - -/* Globals */ - -/** - * Directory to store temp data in, defined in config file - */ -static char *test_directory; - -struct GNUNET_TESTING_Daemon *d1; +#define DHT_OPERATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) +#define KEYFILE_BOB "../namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey" /* Task handle to use to schedule test failure */ -GNUNET_SCHEDULER_TaskIdentifier die_task; +static GNUNET_SCHEDULER_TaskIdentifier die_task; +static GNUNET_SCHEDULER_TaskIdentifier wait_task; /* Global return value (0 for success, anything else for failure) */ static int ok; static struct GNUNET_NAMESTORE_Handle *namestore_handle; +static struct GNUNET_GNS_Handle *gns_handle; + static struct GNUNET_DHT_Handle *dht_handle; -const struct GNUNET_CONFIGURATION_Handle *cfg; +static const struct GNUNET_CONFIGURATION_Handle *cfg; + +static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; +static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey; +static struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; +static struct GNUNET_CRYPTO_RsaPrivateKey *bob_key; -struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; -struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey; -struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; -struct GNUNET_CRYPTO_RsaPrivateKey *bob_key; /** - * Check whether peers successfully shut down. + * 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. */ -void -shutdown_callback (void *cls, const char *emsg) +static void +end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - if (emsg != NULL) + die_task = GNUNET_SCHEDULER_NO_TASK; + if (NULL != gns_handle) + { + GNUNET_GNS_disconnect (gns_handle); + gns_handle = NULL; + } + + if (NULL != dht_handle) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on shutdown! ret=%d\n", ok); - if (ok == 0) - ok = 2; + GNUNET_DHT_disconnect (dht_handle); + dht_handle = NULL; } - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "done(ret=%d)!\n", ok); + if (NULL != namestore_handle) + { + GNUNET_NAMESTORE_disconnect (namestore_handle); + namestore_handle = NULL; + } + GNUNET_break (0); + GNUNET_SCHEDULER_shutdown (); + ok = 1; } -/** - * Function scheduled to be run on the successful start of services - * tries to look up the dns record for TEST_DOMAIN - */ + +static void +end_badly_now () +{ + + if (GNUNET_SCHEDULER_NO_TASK != wait_task) + { + GNUNET_SCHEDULER_cancel (wait_task); + wait_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_SCHEDULER_cancel (die_task); + die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL); +} + + static void -finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +shutdown_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + GNUNET_GNS_disconnect(gns_handle); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer!\n"); + GNUNET_SCHEDULER_shutdown (); +} + + +static void +on_lookup_result(void *cls, uint32_t rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) { - struct hostent *he; struct in_addr a; + int i; char* addr; - - GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES); - GNUNET_DHT_disconnect(dht_handle); - - he = gethostbyname (TEST_DOMAIN); + + if (GNUNET_SCHEDULER_NO_TASK != die_task) + { + GNUNET_SCHEDULER_cancel (die_task); + die_task = GNUNET_SCHEDULER_NO_TASK; + } - if (!he) + GNUNET_NAMESTORE_disconnect (namestore_handle); + namestore_handle = NULL; + if (rd_count == 0) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "gethostbyname failed, rp_filtering?\n"); + "Lookup failed, rp_filtering?\n"); ok = 2; } else { ok = 1; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", he->h_name); - while (*he->h_addr_list) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls); + for (i=0; ih_addr_list++, sizeof(a)); - addr = inet_ntoa(a); - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr); - if (0 == strcmp(addr, TEST_IP)) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type); + if (rd[i].record_type == GNUNET_GNS_RECORD_A) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, + memcpy(&a, rd[i].data, sizeof(a)); + addr = inet_ntoa(a); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr); + if (0 == strcmp(addr, TEST_IP)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%s correctly resolved to %s!\n", TEST_DOMAIN, addr); - ok = 0; + ok = 0; + } } else { @@ -151,37 +174,34 @@ finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) } } } - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n"); - GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL, - GNUNET_YES, GNUNET_NO); + GNUNET_DHT_disconnect (dht_handle); + dht_handle = NULL; + + GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); } + /** - * Continuation for the GNUNET_DHT_get_stop call, so that we don't shut - * down the peers without freeing memory associated with GET request. + * Function scheduled to be run on the successful start of services + * tries to look up the dns record for TEST_DOMAIN */ static void -end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +commence_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { + gns_handle = GNUNET_GNS_connect(cfg); - if (d1 != NULL) - GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL, - GNUNET_YES, GNUNET_NO); - GNUNET_SCHEDULER_cancel (die_task); -} + if (NULL == gns_handle) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to connect to GNS!\n"); + end_badly_now(); + return; + } -/** - * 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_ERROR, "Failing test with error: `%s'!\n", - (char *) cls); - GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL); - ok = 1; + GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_A, + GNUNET_NO, + NULL, + &on_lookup_result, TEST_DOMAIN); } @@ -189,9 +209,11 @@ static void put_dht(void *cls, int32_t success, const char *emsg) { struct GNSNameRecordBlock *nrb; - GNUNET_HashCode name_hash; - GNUNET_HashCode xor_hash; - GNUNET_HashCode zone_hash; + struct GNUNET_CRYPTO_ShortHashCode name_hash; + struct GNUNET_CRYPTO_ShortHashCode zone_hash; + struct GNUNET_HashCode xor_hash; + struct GNUNET_HashCode name_hash_double; + struct GNUNET_HashCode zone_hash_double; uint32_t rd_payload_length; char* nrb_data = NULL; struct GNUNET_CRYPTO_RsaSignature *sig; @@ -199,13 +221,22 @@ put_dht(void *cls, int32_t success, const char *emsg) char* ip = TEST_IP; struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr)); - rd.expiration = GNUNET_TIME_absolute_get_forever (); + rd.expiration_time = UINT64_MAX; GNUNET_assert(1 == inet_pton (AF_INET, ip, web)); rd.data_size = sizeof(struct in_addr); rd.data = web; rd.record_type = GNUNET_DNSPARSER_TYPE_A; - sig = GNUNET_NAMESTORE_create_signature(bob_key, TEST_RECORD_NAME, + rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; + + sig = GNUNET_NAMESTORE_create_signature(bob_key, GNUNET_TIME_UNIT_FOREVER_ABS, TEST_RECORD_NAME, &rd, 1); + + GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_verify_signature (&bob_pkey, + GNUNET_TIME_UNIT_FOREVER_ABS, + TEST_RECORD_NAME, + 1, + &rd, + sig)); rd_payload_length = GNUNET_NAMESTORE_records_get_size (1, &rd); nrb = GNUNET_malloc(rd_payload_length + strlen(TEST_RECORD_NAME) + 1 + sizeof(struct GNSNameRecordBlock)); @@ -213,7 +244,7 @@ put_dht(void *cls, int32_t success, const char *emsg) nrb->public_key = bob_pkey; nrb->rd_count = htonl(1); memset(&nrb[1], 0, strlen(TEST_RECORD_NAME) + 1); - memcpy(&nrb[1], TEST_RECORD_NAME, strlen(TEST_RECORD_NAME)); + strcpy((char*)&nrb[1], TEST_RECORD_NAME); nrb_data = (char*)&nrb[1]; nrb_data += strlen(TEST_RECORD_NAME) + 1; @@ -224,48 +255,60 @@ put_dht(void *cls, int32_t success, const char *emsg) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Record serialization failed!\n"); ok = 3; + GNUNET_free (nrb); + GNUNET_free (web); + end_badly_now (); return; } - GNUNET_CRYPTO_hash(TEST_RECORD_NAME, strlen(TEST_RECORD_NAME), &name_hash); - GNUNET_CRYPTO_hash(&bob_pkey, + GNUNET_CRYPTO_short_hash(TEST_RECORD_NAME, strlen(TEST_RECORD_NAME), &name_hash); + GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone_hash); - GNUNET_CRYPTO_hash_xor(&zone_hash, &name_hash, &xor_hash); + GNUNET_CRYPTO_short_hash_double(&zone_hash, &zone_hash_double); + GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double); + GNUNET_CRYPTO_hash_xor(&zone_hash_double, &name_hash_double, &xor_hash); rd_payload_length += sizeof(struct GNSNameRecordBlock) + strlen(TEST_RECORD_NAME) + 1; GNUNET_DHT_put (dht_handle, &xor_hash, 0, - GNUNET_DHT_RO_NONE, + GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_BLOCK_TYPE_GNS_NAMERECORD, rd_payload_length, (char*)nrb, - rd.expiration, + GNUNET_TIME_UNIT_FOREVER_ABS, DHT_OPERATION_TIMEOUT, NULL, NULL); - GNUNET_SCHEDULER_add_delayed(TIMEOUT, &finish_testing, NULL); + GNUNET_free (web); + GNUNET_free (nrb); + GNUNET_free (sig); + if (GNUNET_SCHEDULER_NO_TASK != die_task) + { + GNUNET_SCHEDULER_cancel (die_task); + die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); + } + wait_task = GNUNET_SCHEDULER_add_delayed(DHT_DELAY, &commence_testing, NULL); } + static void -do_lookup(void *cls, const struct GNUNET_PeerIdentity *id, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct GNUNET_TESTING_Daemon *d, const char *emsg) +do_check (void *cls, + const struct GNUNET_CONFIGURATION_Handle *ccfg, + struct GNUNET_TESTING_Peer *peer) { - - char* alice_keyfile; - GNUNET_HashCode bob_hash; + struct GNUNET_CRYPTO_ShortHashCode bob_hash; - - GNUNET_SCHEDULER_cancel (die_task); + cfg = ccfg; + die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); /* put records into namestore */ namestore_handle = GNUNET_NAMESTORE_connect(cfg); if (NULL == namestore_handle) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n"); - ok = -1; + end_badly_now (); return; } @@ -274,31 +317,34 @@ do_lookup(void *cls, const struct GNUNET_PeerIdentity *id, if (NULL == dht_handle) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to dht\n"); - ok = -1; + end_badly_now (); return; } - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "gns", + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns", "ZONEKEY", &alice_keyfile)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n"); - ok = -1; + end_badly_now (); return; } alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile); - bob_key = GNUNET_CRYPTO_rsa_key_create (); + bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB); + + GNUNET_free(alice_keyfile); GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey); GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey); - GNUNET_CRYPTO_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash); + GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash); struct GNUNET_NAMESTORE_RecordData rd; - rd.expiration = GNUNET_TIME_absolute_get_forever (); - rd.data_size = sizeof(GNUNET_HashCode); + rd.expiration_time = UINT64_MAX; + rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode); rd.data = &bob_hash; rd.record_type = GNUNET_GNS_RECORD_PKEY; + rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY; GNUNET_NAMESTORE_record_create (namestore_handle, alice_key, @@ -306,84 +352,20 @@ do_lookup(void *cls, const struct GNUNET_PeerIdentity *id, &rd, &put_dht, NULL); - - - } -static void -run (void *cls, char *const *args, const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *c) -{ - cfg = c; - /* Get path from configuration file */ - if (GNUNET_YES != - GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome", - &test_directory)) - { - ok = 404; - return; - } - - - /* 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!!!"); - - /* Start alice */ - d1 = GNUNET_TESTING_daemon_start(cfg, TIMEOUT, GNUNET_NO, NULL, NULL, 0, - NULL, NULL, NULL, &do_lookup, NULL); -} - -static int -check () -{ - int ret; - - /* Arguments for GNUNET_PROGRAM_run */ - char *const argv[] = { "test-gns-simple-lookup", /* Name to give running binary */ - "-c", - "test_gns_simple_lookup.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-simple-lookup", "nohelp", options, &run, - &ok); - if (ret != GNUNET_OK) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "`test-gns-simple-lookup': Failed with error code %d\n", ret); - } - return ok; -} int main (int argc, char *argv[]) { - int ret; + ok = 1; - GNUNET_log_setup ("test-gns-simple-lookup", -#if VERBOSE - "DEBUG", -#else + GNUNET_log_setup ("test-gns-dht-delegated-lookup", "WARNING", -#endif NULL); - ret = check (); - /** - * Need to remove base directory, subdirectories taken care - * of by the testing framework. - */ - return ret; + GNUNET_TESTING_peer_run ("test-gns-dht-delegated-lookup", "test_gns_simple_lookup.conf", &do_check, NULL); + return ok; } -/* end of test_gns_twopeer.c */ + +/* end of test_gns_dht_delegated_lookup.c */