From: Martin Schanzenbach Date: Thu, 8 Mar 2012 10:00:57 +0000 (+0000) Subject: -new shorten test, fixes X-Git-Tag: initial-import-from-subversion-38251~14358 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=6609ac49019f756e09e9fbec082d1f5eacfb7c74;p=oweals%2Fgnunet.git -new shorten test, fixes --- diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am index bff08d33f..7042bdba5 100644 --- a/src/gns/Makefile.am +++ b/src/gns/Makefile.am @@ -29,7 +29,8 @@ bin_PROGRAMS = \ check_PROGRAMS = \ test_gns_simple_lookup \ test_gns_simple_delegated_lookup \ - test_gns_dht_delegated_lookup + test_gns_dht_delegated_lookup \ + test_gns_simple_shorten plugin_LTLIBRARIES = \ @@ -81,6 +82,21 @@ test_gns_dht_delegated_lookup_DEPENDENCIES = \ $(top_builddir)/src/dht/libgnunetdht.la \ $(top_builddir)/src/testing/libgnunettesting.la +test_gns_simple_shorten_SOURCES = \ + test_gns_simple_shorten.c +test_gns_simple_shorten_LDADD = \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(top_builddir)/src/namestore/libgnunetnamestore.la \ + $(top_builddir)/src/gns/libgnunetgns.la \ + $(top_builddir)/src/dht/libgnunetdht.la \ + $(top_builddir)/src/testing/libgnunettesting.la +test_gns_simple_shorten_DEPENDENCIES = \ + $(top_builddir)/src/util/libgnunetutil.la \ + $(top_builddir)/src/namestore/libgnunetnamestore.la \ + $(top_builddir)/src/gns/libgnunetgns.la \ + $(top_builddir)/src/dht/libgnunetdht.la \ + $(top_builddir)/src/testing/libgnunettesting.la + gnunet_gns_SOURCES = \ gnunet-gns.c gnunet_gns_LDADD = \ diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c index 104423c32..eaae4955f 100644 --- a/src/gns/gns_api.c +++ b/src/gns/gns_api.c @@ -508,8 +508,8 @@ process_shorten_reply (void *cls, const GNUNET_HashCode * key, void *value) } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received reply for `%s' from GNS service %p\n", - name, shorten_handle->gns_handle); + "Received reply for `%s' from GNS service\n", + name); if (gns_msg->unique_id != shorten_handle->unique_id) { @@ -780,9 +780,10 @@ GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, return NULL; } - msize = sizeof (struct GNUNET_GNS_ClientShortenMessage) + strlen(name); + msize = sizeof (struct GNUNET_GNS_ClientShortenMessage) + strlen(name) +1; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to shorten %s in GNS\n", name); pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); + memset(pending, 0, (sizeof (struct PendingMessage) + msize)); shorten_msg = (struct GNUNET_GNS_ClientShortenMessage *) &pending[1]; pending->msg = &shorten_msg->header; pending->handle = handle; diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c index 75d7e8bca..1782e7a01 100644 --- a/src/gns/gnunet-service-gns.c +++ b/src/gns/gnunet-service-gns.c @@ -1702,7 +1702,7 @@ process_shorten_pseu_lookup_ns(void *cls, rh->status |= EXPIRED; } - rh->proc(cls, rh, rd_len, rd); + rh->proc(rh->proc_cls, rh, rd_len, rd); } @@ -1767,14 +1767,21 @@ handle_shorten_zone_to_name(void *cls, struct ClientShortenHandle* csh = (struct ClientShortenHandle*) rh->proc_cls; char* result; + size_t answer_len; /* we found a match in our own zone */ if (rd_len != 0) { - result = GNUNET_malloc(strlen(rh->name) + strlen(name) + 1); - memset(result, 0, strlen(rh->name) + strlen(name) + 1); - memcpy(result, rh->name, strlen(rh->name)); - memcpy(result+strlen(rh->name)+1, name, strlen(name)); + answer_len = strlen(rh->name) + strlen(name) + strlen(gnunet_tld) + 2; + result = GNUNET_malloc(answer_len); + memset(result, 0, answer_len); + strcpy(result, rh->name); + strcpy(result+strlen(rh->name), "."); + strcpy(result+strlen(rh->name)+1, name); + strcpy(result+strlen(rh->name)+strlen(name), gnunet_tld); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending shorten result %s\n", result); send_shorten_response(result, csh); @@ -1816,6 +1823,7 @@ handle_shorten_pseu_dht_result(void* cls, char* pseu; char* result; char* new_name; + size_t answer_len; int i; /** @@ -1826,15 +1834,25 @@ handle_shorten_pseu_dht_result(void* cls, for (i=0; i < rd_len; i++) { if (rd[i].record_type == GNUNET_GNS_RECORD_PSEU) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Found PSEU %s\n", (char*) rd[i].data); break; + } } - - pseu = (char*) rd[i].data; - result = GNUNET_malloc(strlen(rh->name) + strlen(pseu) + 1); - memset(result, 0, strlen(rh->name) + strlen(pseu) + 1); - memcpy(result, rh->name, strlen(rh->name)); - memcpy(result+strlen(rh->name)+1, pseu, strlen(pseu)); + pseu = (char*) rd[i].data; + answer_len = strlen(rh->name) + strlen(pseu) + strlen(gnunet_tld) + 2; + result = GNUNET_malloc(answer_len); + memset(result, 0, answer_len); + strcpy(result, rh->name); + strcpy(result+strlen(rh->name), "."); + strcpy(result+strlen(rh->name)+1, pseu); + strcpy(result+strlen(rh->name)+strlen(pseu), gnunet_tld); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending pseudonym shorten result %s\n", result); + send_shorten_response(result, csh); GNUNET_free(result); @@ -1854,11 +1872,18 @@ handle_shorten_pseu_dht_result(void* cls, /** * Our zone is next */ - result = GNUNET_malloc(strlen(rh->name) + strlen(auth_chain->name) + 2); - memset(result, 0, strlen(rh->name) + strlen(auth_chain->name) + 2); + answer_len = strlen(rh->name) + strlen(auth_chain->name) + + strlen(gnunet_tld) + 2; + + result = GNUNET_malloc(answer_len); + memset(result, 0, answer_len); strcpy(result, rh->name); - strcpy(result+strlen(rh->name)+1, "."); - strcpy(result+strlen(rh->name)+2, auth_chain->name); + strcpy(result+strlen(rh->name), "."); + strcpy(result+strlen(rh->name)+1, auth_chain->name); + strcpy(result+strlen(rh->name)+strlen(auth_chain->name)+1, gnunet_tld); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending non pseudonym shorten result %s\n", result); + send_shorten_response(result, csh); GNUNET_free(result); return; @@ -1912,6 +1937,7 @@ handle_shorten_pseu_ns_result(void* cls, char* pseu; char* result; char* new_name; + size_t answer_len; int i; /** @@ -1922,15 +1948,25 @@ handle_shorten_pseu_ns_result(void* cls, for (i=0; i < rd_len; i++) { if (rd[i].record_type == GNUNET_GNS_RECORD_PSEU) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Found PSEU %s\n", (char*) rd[i].data); break; + } } pseu = (char*) rd[i].data; - result = GNUNET_malloc(strlen(rh->name) + strlen(pseu) + 1); - memset(result, 0, strlen(rh->name) + strlen(pseu) + 1); - memcpy(result, rh->name, strlen(rh->name)); - memcpy(result+strlen(rh->name)+1, pseu, strlen(pseu)); - + answer_len = strlen(rh->name) + strlen(pseu) + strlen(gnunet_tld) + 2; + result = GNUNET_malloc(answer_len); + memset(result, 0, answer_len); + strcpy(result, rh->name); + strcpy(result+strlen(rh->name), "."); + strcpy(result+strlen(rh->name)+1, pseu); + strcpy(result+strlen(rh->name)+strlen(pseu)+1, gnunet_tld); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending shorten result %s\n", result); + send_shorten_response(result, csh); GNUNET_free(result); @@ -1997,6 +2033,8 @@ handle_shorten_delegation_result(void* cls, { struct ClientShortenHandle* csh = (struct ClientShortenHandle*) cls; struct AuthorityChain *auth_chain; + char* result; + size_t answer_len; /** * At this point rh->name contains the part of the name @@ -2016,10 +2054,22 @@ handle_shorten_delegation_result(void* cls, * (it shouldn't be, usually FIXME what happens if we * shorten to our zone to a "" record??) **/ + + answer_len = strlen(rh->name) + strlen(gnunet_tld) + 2; + result = GNUNET_malloc(answer_len); + memset(result, 0, answer_len); + strcpy(result, rh->name); + strcpy(result+strlen(rh->name), "."); + strcpy(result+strlen(rh->name)+1, gnunet_tld); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our zone: Sending name as shorten result %s\n", rh->name); + send_shorten_response(rh->name, csh); //FIXME +.gnunet! free_resolver_handle(rh); GNUNET_free(csh->name); GNUNET_free(csh); + GNUNET_free(result); return; } @@ -2092,8 +2142,8 @@ shorten_name(char* name, struct ClientShortenHandle* csh) static void send_shorten_response(const char* name, struct ClientShortenHandle *csh) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", - "SHORTEN_RESULT"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message with %s\n", + "SHORTEN_RESULT", name); struct GNUNET_GNS_ClientShortenResultMessage *rmsg; if (name == NULL) @@ -2101,15 +2151,15 @@ send_shorten_response(const char* name, struct ClientShortenHandle *csh) name = '\0'; } - rmsg = GNUNET_malloc(sizeof(struct GNUNET_GNS_ClientShortenResultMessage *) - + strlen(name)); + rmsg = GNUNET_malloc(sizeof(struct GNUNET_GNS_ClientShortenResultMessage) + + strlen(name) + 1); rmsg->unique_id = csh->unique_id; rmsg->key = csh->key; rmsg->header.type = htons(GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT); rmsg->header.size = htons(sizeof(struct GNUNET_GNS_ClientShortenResultMessage) + - strlen(name)); + strlen(name) + 1); strcpy((char*)&rmsg[1], name); @@ -2147,7 +2197,6 @@ static void handle_shorten(void *cls, } GNUNET_SERVER_notification_context_add (nc, client); - GNUNET_SERVER_client_keep (client); struct GNUNET_GNS_ClientShortenMessage *sh_msg = (struct GNUNET_GNS_ClientShortenMessage *) message; diff --git a/src/gns/test_gns_simple_shorten.c b/src/gns/test_gns_simple_shorten.c new file mode 100644 index 000000000..c06e7f61d --- /dev/null +++ b/src/gns/test_gns_simple_shorten.c @@ -0,0 +1,384 @@ +/* + 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_simple_shorten.c + * @brief basic shorten test for gns api + * + */ +#include "platform.h" +#include "gnunet_testing_lib.h" +#include "gnunet_core_service.h" +#include "block_dns.h" +#include "gnunet_signatures.h" +#include "gnunet_namestore_service.h" +#include "../namestore/namestore.h" +#include "gnunet_dnsparser_lib.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) + +/* If number of peers not in config file, use this number */ +#define DEFAULT_NUM_PEERS 2 + +/* test records to resolve */ +#define TEST_DOMAIN "www.alice.bob.gnunet" +#define TEST_IP "127.0.0.1" +#define TEST_RECORD_NAME "www" + +#define TEST_AUTHORITY_BOB "bob" +#define TEST_AUTHORITY_ALICE "alice" +#define TEST_ALICE_PSEU "carol" +#define TEST_EXPECTED_RESULT "www.carol.gnunet" + +/* Globals */ + +/** + * Directory to store temp data in, defined in config file + */ +static char *test_directory; + +struct GNUNET_TESTING_Daemon *d1; + + +/* Task handle to use to schedule test failure */ +GNUNET_SCHEDULER_TaskIdentifier die_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; + +const struct GNUNET_CONFIGURATION_Handle *cfg; + +/** + * Check whether peers successfully shut down. + */ +void +shutdown_callback (void *cls, const char *emsg) +{ + if (emsg != NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on shutdown! ret=%d\n", ok); + if (ok == 0) + ok = 2; + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "done(ret=%d)!\n", ok); +} + +/** + * Called when gns shorten finishes + */ +static void +process_shorten_result(void* cls, const char* lname, const char* sname) +{ + GNUNET_GNS_disconnect(gns_handle); + + ok = 0; + + if (sname == NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "shorten test failed!\n"); + ok = 1; + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s shortened to %s\n", lname, sname); + if (0 != strcmp(sname, TEST_EXPECTED_RESULT)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "shorten test failed! (wanted: %s got: %s\n", + lname, sname); + ok = 1; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shorten test succeeded!\n"); + + } + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n"); + GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL, + GNUNET_YES, GNUNET_NO); +} + +/** + * Function scheduled to be run on the successful start of services + * tries to shorten the name TEST_DOMAIN using gns + */ +static void +commence_testing (void *cls, int32_t success, const char *emsg) +{ + + + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "disconnecting from namestore\n"); + GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "connecting to gns\n"); + gns_handle = GNUNET_GNS_connect(cfg); + + if (NULL == gns_handle) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "failed to connect to gns\n"); + ok = 1; + return; + } + + GNUNET_GNS_shorten(gns_handle, TEST_DOMAIN, &process_shorten_result, 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. + */ +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); + GNUNET_SCHEDULER_cancel (die_task); +} + +/** + * 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; +} + +static void +do_shorten(void *cls, const struct GNUNET_PeerIdentity *id, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Daemon *d, const char *emsg) +{ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded our_pkey; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey; + struct GNUNET_CRYPTO_RsaPrivateKey *our_key; + struct GNUNET_CRYPTO_RsaPrivateKey *alice_key; + struct GNUNET_CRYPTO_RsaPrivateKey *bob_key; + GNUNET_HashCode bob_hash; + GNUNET_HashCode alice_hash; + struct GNUNET_CRYPTO_RsaSignature *sig; + char* our_keyfile; + + GNUNET_SCHEDULER_cancel (die_task); + + /* 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; + return; + } + + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "gns", + "ZONEKEY", + &our_keyfile)) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n"); + ok = -1; + return; + } + + our_key = GNUNET_CRYPTO_rsa_key_create_from_file (our_keyfile); + GNUNET_free(our_keyfile); + + bob_key = GNUNET_CRYPTO_rsa_key_create (); + alice_key = GNUNET_CRYPTO_rsa_key_create (); + + GNUNET_CRYPTO_rsa_key_get_public (our_key, &our_pkey); + GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey); + GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey); + + struct GNUNET_NAMESTORE_RecordData rd; + char* ip = TEST_IP; + struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr)); + rd.expiration = GNUNET_TIME_absolute_get_forever (); + GNUNET_assert(1 == inet_pton (AF_INET, ip, web)); + + GNUNET_CRYPTO_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash); + + rd.data_size = sizeof(GNUNET_HashCode); + rd.data = &bob_hash; + rd.record_type = GNUNET_GNS_RECORD_PKEY; + + /* put bob into our zone */ + GNUNET_NAMESTORE_record_create (namestore_handle, + our_key, + TEST_AUTHORITY_BOB, + &rd, + NULL, + NULL); + + /* put alice into bobs zone */ + GNUNET_CRYPTO_hash(&alice_pkey, sizeof(alice_pkey), &alice_hash); + rd.data = &alice_hash; + sig = GNUNET_NAMESTORE_create_signature(bob_key, TEST_AUTHORITY_ALICE, + &rd, 1); + + GNUNET_NAMESTORE_record_put (namestore_handle, + &bob_pkey, + TEST_AUTHORITY_ALICE, + GNUNET_TIME_absolute_get_forever(), + 1, + &rd, + sig, + NULL, + NULL); + + /* put www A record and PSEU into alice's zone */ + + rd.data_size = sizeof(struct in_addr); + rd.data = web; + rd.record_type = GNUNET_DNSPARSER_TYPE_A; + sig = GNUNET_NAMESTORE_create_signature(alice_key, TEST_RECORD_NAME, + &rd, 1); + + GNUNET_NAMESTORE_record_put (namestore_handle, + &alice_pkey, + TEST_RECORD_NAME, + GNUNET_TIME_absolute_get_forever(), + 1, + &rd, + sig, + NULL, + NULL); + + rd.data_size = strlen(TEST_ALICE_PSEU); + rd.data = TEST_ALICE_PSEU; + rd.record_type = GNUNET_GNS_RECORD_PSEU; + GNUNET_free(sig); + + sig = GNUNET_NAMESTORE_create_signature(alice_key, "", + &rd, 1); + + GNUNET_NAMESTORE_record_put (namestore_handle, + &alice_pkey, + "", + GNUNET_TIME_absolute_get_forever(), + 1, + &rd, + sig, + &commence_testing, + NULL); + + GNUNET_free(sig); + +} + +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_shorten, 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; + + GNUNET_log_setup ("test-gns-simple-lookup", +#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 */