From 212d423a7b173c8f8df8638dc73c794f2ee1ffde Mon Sep 17 00:00:00 2001 From: Martin Schanzenbach Date: Sat, 29 Sep 2012 17:38:25 +0000 Subject: [PATCH] -doxy --- src/gns/gns.conf.in | 2 +- src/gns/gns_api.c | 33 ++- src/gns/gnunet-service-gns.c | 382 +++++++++++++++----------- src/gns/gnunet-service-gns_resolver.c | 96 +++++-- 4 files changed, 312 insertions(+), 201 deletions(-) diff --git a/src/gns/gns.conf.in b/src/gns/gns.conf.in index 93e6ef3fa..91c0a4dc2 100644 --- a/src/gns/gns.conf.in +++ b/src/gns/gns.conf.in @@ -14,7 +14,7 @@ AUTO_IMPORT_PKEY = YES AUTO_IMPORT_CONFIRMATION_REQ = NO MAX_PARALLEL_BACKGROUND_QUERIES = 25 DEFAULT_LOOKUP_TIMEOUT = 10 -RECORD_PUT_INTERVAL = 4 h +ZONE_PUBLISH_TIME_WINDOW = 4 h # PREFIX = valgrind --leak-check=full --track-origins=yes [gns-proxy] diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c index 94142ea88..fef7b866d 100644 --- a/src/gns/gns_api.c +++ b/src/gns/gns_api.c @@ -88,19 +88,26 @@ struct GNUNET_GNS_ShortenRequest */ struct GNUNET_GNS_ShortenRequest *prev; - /* handle to gns */ + /** + * handle to gns + */ struct GNUNET_GNS_Handle *gns_handle; - /* processor to call on shorten result */ + /** + * processor to call on shorten result + */ GNUNET_GNS_ShortenResultProcessor shorten_proc; - /* processor closure */ + /** + * processor closure + */ void *proc_cls; - /* request id */ + /** + * request id + */ uint64_t r_id; - }; @@ -119,16 +126,24 @@ struct GNUNET_GNS_GetAuthRequest */ struct GNUNET_GNS_GetAuthRequest *prev; - /* handle to gns */ + /** + * handle to gns + */ struct GNUNET_GNS_Handle *gns_handle; - /* processor to call on authority lookup result */ + /** + * processor to call on authority lookup result + */ GNUNET_GNS_GetAuthResultProcessor auth_proc; - /* processor closure */ + /** + * processor closure + */ void *proc_cls; - /* request id */ + /** + * request id + */ uint32_t r_id; }; diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c index 5ad0bcf76..c5c5ac2bf 100644 --- a/src/gns/gnunet-service-gns.c +++ b/src/gns/gnunet-service-gns.c @@ -40,9 +40,27 @@ #include "gnunet-service-gns_interceptor.h" #include "gnunet_protocols.h" -#define INITIAL_ZONE_ITERATION_INTERVAL GNUNET_TIME_UNIT_MILLISECONDS +/** + * The initial interval in milliseconds btween puts in + * a zone iteration + */ +#define INITIAL_PUT_INTERVAL GNUNET_TIME_UNIT_MILLISECONDS + +/** + * The upper bound for the zone iteration interval in milliseconds + */ #define MINIMUM_ZONE_ITERATION_INTERVAL GNUNET_TIME_UNIT_SECONDS -#define DEFAULT_RECORD_PUT_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) + +/** + * The default put interval for the zone iteration. In case + * No option is found + */ +#define DEFAULT_ZONE_PUBLISH_TIME_WINDOW GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) + +/** + * The factor the current zone iteration interval is divided by for each + * additional new record + */ #define LATE_ITERATION_SPEEDUP_FACTOR 2 @@ -52,59 +70,85 @@ struct ClientShortenHandle { - /* DLL */ + /** + * List for all shorten requests + */ struct ClientShortenHandle *next; - - /* DLL */ + /** + * List for all shorten requests + */ struct ClientShortenHandle *prev; - /* the requesting client that */ + /** + * Handle to the requesting client + */ struct GNUNET_SERVER_Client *client; - /* request id */ - uint64_t unique_id; + /** + * The request id + */ + uint64_t request_id; - /* request type */ + /** + * request type + */ enum GNUNET_GNS_RecordType type; - /* name to shorten */ + /** + * name to shorten + */ char name[MAX_DNS_NAME_LENGTH]; - /* name of private zone (relative to root) */ + /** + * name of private zone (relative to root) + */ char private_zone_id[MAX_DNS_NAME_LENGTH]; - /* name of shorten zone (relative to root) */ + /** + * name of shorten zone (relative to root) + */ char shorten_zone_id[MAX_DNS_NAME_LENGTH]; - /* root zone */ + /** + * master zone + */ struct GNUNET_CRYPTO_ShortHashCode root_zone; - /* private zone */ + /** + * private zone + */ struct GNUNET_CRYPTO_ShortHashCode private_zone; - /* shorten zone */ + /** + * shorten zone + */ struct GNUNET_CRYPTO_ShortHashCode shorten_zone; - /* Namestore lookup task */ + /** + * Namestore lookup task + */ struct GNUNET_NAMESTORE_QueueEntry *namestore_task; - }; /** - * Handle to a get auhtority operation from api + * Handle to a get authority operation from api */ struct ClientGetAuthHandle { - /* the requesting client that */ + /** + * Handle to the requesting client */ struct GNUNET_SERVER_Client *client; - /* request id */ - uint64_t unique_id; + /** + * request id + */ + uint64_t request_id; - /* name to lookup authority */ + /** + * name to lookup authority + */ char *name; - }; @@ -114,25 +158,39 @@ struct ClientGetAuthHandle struct ClientLookupHandle { - /* the requesting client that */ + /** + * Handle to the requesting client + */ struct GNUNET_SERVER_Client *client; - /* The zone we look up in */ + /** + * The zone we look up in + */ struct GNUNET_CRYPTO_ShortHashCode zone; - /* Do we only want to lookup from local cache? */ + /** + * GNUNET_YES if we only want to lookup from local cache + */ int only_cached; - /* request id */ - uint64_t unique_id; + /** + * request id + */ + uint64_t request_id; - /* request type */ + /** + * request type + */ enum GNUNET_GNS_RecordType type; - /* optional zone private key used for shorten */ + /** + * optional zone private key used for shorten + */ struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key; - /* the name to look up */ + /** + * the name to look up + */ char *name; }; @@ -149,7 +207,6 @@ static struct GNUNET_CRYPTO_RsaPrivateKey *zone_key; /** * Our handle to the namestore service - * FIXME maybe need a second handle for iteration */ static struct GNUNET_NAMESTORE_Handle *namestore_handle; @@ -179,38 +236,59 @@ static unsigned long long num_public_records; static unsigned long long last_num_public_records; /** - * FIXME! + * Zone iteration PUT interval. */ -static struct GNUNET_TIME_Relative zone_iteration_interval; +static struct GNUNET_TIME_Relative put_interval; -/* dht update interval FIXME define? */ -static struct GNUNET_TIME_Relative record_put_interval; +/** + * Time window for zone iteration + */ +static struct GNUNET_TIME_Relative zone_publish_time_window; -/* zone update task */ -static GNUNET_SCHEDULER_TaskIdentifier zone_update_taskid; +/** + * zone publish task + */ +static GNUNET_SCHEDULER_TaskIdentifier zone_publish_task; -/* automatic pkey import for name shortening */ +/** + * GNUNET_YES if automatic pkey import for name shortening + * is enabled + */ static int auto_import_pkey; -/* first zone iteration is specia */ +/** + * GNUNET_YES if zone has never been published before + */ static int first_zone_iteration; -/* lookup timeout */ +/** + * The lookup timeout + */ static struct GNUNET_TIME_Relative default_lookup_timeout; -/* ipv6 support */ +/** + * GNUNET_YES if ipv6 is supported + */ static int v6_enabled; -/* ipv4 support */ +/** + * GNUNET_YES if ipv4 is supported + */ static int v4_enabled; -/* Shorten DLL for cancelling NS requests */ +/** + * List for shorten requests + */ static struct ClientShortenHandle *csh_head; -/* Shorten DLL for cancelling NS requests */ +/** + * List for shorten requests + */ static struct ClientShortenHandle *csh_tail; -/* Statistics handle */ +/** + * Handle to the statistics service + */ static struct GNUNET_STATISTICS_Handle *statistics; @@ -237,8 +315,8 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) gns_resolver_cleanup (); if (NULL != statistics) GNUNET_STATISTICS_destroy (statistics, GNUNET_NO); - if (zone_update_taskid != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel (zone_update_taskid); + if (zone_publish_task != GNUNET_SCHEDULER_NO_TASK) + GNUNET_SCHEDULER_cancel (zone_publish_task); if (NULL != namestore_iter) GNUNET_NAMESTORE_zone_iteration_stop (namestore_iter); GNUNET_NAMESTORE_disconnect(namestore_handle); @@ -253,33 +331,23 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * @param tc task context */ static void -update_zone_dht_next (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +publish_zone_dht_next (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - zone_update_taskid = GNUNET_SCHEDULER_NO_TASK; + zone_publish_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_NAMESTORE_zone_iterator_next (namestore_iter); } /** - * Continuation for DHT put + * Periodically iterate over our zone and store everything in dht * - * @param cls closure - * @param success GNUNET_OK if the PUT was transmitted, - * GNUNET_NO on timeout, - * GNUNET_SYSERR on disconnect from service - * after the PUT message was transmitted - * (so we don't know if it was received or not) + * @param cls NULL + * @param tc task context */ static void -record_dht_put(void *cls, int success) -{ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "put request transmitted\n"); -} - - -/* prototype */ -static void -update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); +publish_zone_dht_start (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc); /** @@ -323,7 +391,7 @@ put_gns_record(void *cls, * we can safely set the interval to the value for a single * record */ - zone_iteration_interval = GNUNET_TIME_relative_divide (record_put_interval, + put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window, 1); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, @@ -331,18 +399,18 @@ put_gns_record(void *cls, } else { - zone_iteration_interval = GNUNET_TIME_relative_divide (record_put_interval, + put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window, num_public_records); } - zone_iteration_interval = GNUNET_TIME_relative_max (MINIMUM_ZONE_ITERATION_INTERVAL, - zone_iteration_interval); + put_interval = GNUNET_TIME_relative_max (MINIMUM_ZONE_ITERATION_INTERVAL, + put_interval); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration finished. Adjusted zone iteration interval to %s\n", - GNUNET_STRINGS_relative_time_to_string (zone_iteration_interval, GNUNET_YES)); + GNUNET_STRINGS_relative_time_to_string (put_interval, GNUNET_YES)); GNUNET_STATISTICS_set (statistics, "Current zone iteration interval (in ms)", - zone_iteration_interval.rel_value, + put_interval.rel_value, GNUNET_NO); GNUNET_STATISTICS_update (statistics, "Number of zone iterations", 1, GNUNET_NO); @@ -351,11 +419,11 @@ put_gns_record(void *cls, last_num_public_records, GNUNET_NO); if (0 == num_public_records) - zone_update_taskid = GNUNET_SCHEDULER_add_delayed (zone_iteration_interval, - &update_zone_dht_start, + zone_publish_task = GNUNET_SCHEDULER_add_delayed (put_interval, + &publish_zone_dht_start, NULL); else - zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start, NULL); + zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start, NULL); return; } @@ -365,14 +433,14 @@ put_gns_record(void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No records for name `%s'! Skipping.\n", name); - zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_next, + zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_next, NULL); return; } if (NULL == signature) { GNUNET_break (0); - zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_next, + zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_next, NULL); return; } @@ -401,8 +469,8 @@ put_gns_record(void *cls, _("Records for name `%s' in zone %s too large to fit into DHT"), name, GNUNET_short_h2s (&zhash)); - GNUNET_free(nrb); - zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_next, + GNUNET_free (nrb); + zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_next, NULL); return; } @@ -428,7 +496,7 @@ put_gns_record(void *cls, (char*)nrb, expiration, DHT_OPERATION_TIMEOUT, - &record_dht_put, + NULL, NULL); GNUNET_free (nrb); @@ -438,20 +506,20 @@ put_gns_record(void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last record count was lower than current record count. Reducing interval.\n"); - zone_iteration_interval = GNUNET_TIME_relative_divide (record_put_interval, + put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window, num_public_records); - next_put_interval = GNUNET_TIME_relative_divide (zone_iteration_interval, + next_put_interval = GNUNET_TIME_relative_divide (put_interval, LATE_ITERATION_SPEEDUP_FACTOR); } else - next_put_interval = zone_iteration_interval; + next_put_interval = put_interval; GNUNET_STATISTICS_set (statistics, "Current zone iteration interval (ms)", next_put_interval.rel_value, GNUNET_NO); - zone_update_taskid = GNUNET_SCHEDULER_add_delayed (next_put_interval, - &update_zone_dht_next, + zone_publish_task = GNUNET_SCHEDULER_add_delayed (next_put_interval, + &publish_zone_dht_next, NULL); } @@ -463,9 +531,9 @@ put_gns_record(void *cls, * @param tc task context */ static void -update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +publish_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - zone_update_taskid = GNUNET_SCHEDULER_NO_TASK; + zone_publish_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling DHT zone update!\n"); /* start counting again */ @@ -507,7 +575,7 @@ send_shorten_response (void* cls, const char* name) rmsg = GNUNET_malloc (sizeof (struct GNUNET_GNS_ClientShortenResultMessage) + name_len); - rmsg->id = csh->unique_id; + rmsg->id = csh->request_id; rmsg->header.type = htons(GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT); rmsg->header.size = htons(sizeof(struct GNUNET_GNS_ClientShortenResultMessage) + @@ -733,8 +801,6 @@ handle_shorten (void *cls, struct GNUNET_SERVER_Client * client, const struct GNUNET_MessageHeader * message) { - uint16_t msg_size; - const struct GNUNET_GNS_ClientShortenMessage *sh_msg; struct ClientShortenHandle *csh; const char *utf_in; char name[MAX_DNS_NAME_LENGTH]; @@ -748,17 +814,14 @@ handle_shorten (void *cls, GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - sh_msg = (const struct GNUNET_GNS_ClientShortenMessage *) message; - utf_in = (const char *) &sh_msg[1]; - if ('\0' != utf_in[msg_size - sizeof (struct GNUNET_GNS_ClientShortenMessage) - 1]) - { - GNUNET_break (0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - return; - } - csh = GNUNET_malloc (sizeof (struct ClientShortenHandle)); + + + const struct GNUNET_GNS_ClientShortenMessage *sh_msg = + (const struct GNUNET_GNS_ClientShortenMessage *) message; + + csh = GNUNET_malloc(sizeof (struct ClientShortenHandle)); csh->client = client; - csh->unique_id = sh_msg->id; + csh->request_id = sh_msg->id; GNUNET_CONTAINER_DLL_insert (csh_head, csh_tail, csh); GNUNET_STRINGS_utf8_tolower (utf_in, &nameptr); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, @@ -833,7 +896,7 @@ send_get_auth_response(void *cls, const char* name) rmsg = GNUNET_malloc(sizeof(struct GNUNET_GNS_ClientGetAuthResultMessage) + strlen(name) + 1); - rmsg->id = cah->unique_id; + rmsg->id = cah->request_id; rmsg->header.type = htons(GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT); rmsg->header.size = htons(sizeof(struct GNUNET_GNS_ClientGetAuthResultMessage) + @@ -863,8 +926,6 @@ handle_get_authority (void *cls, struct GNUNET_SERVER_Client * client, const struct GNUNET_MessageHeader * message) { - uint16_t msg_size; - const struct GNUNET_GNS_ClientGetAuthMessage *sh_msg; struct ClientGetAuthHandle *cah; const char *utf_in; char name[MAX_DNS_NAME_LENGTH]; @@ -880,18 +941,15 @@ handle_get_authority (void *cls, } GNUNET_SERVER_notification_context_add (nc, client); - sh_msg = (const struct GNUNET_GNS_ClientGetAuthMessage *) message; - utf_in = (const char *) &sh_msg[1]; - if ('\0' != utf_in[msg_size - sizeof (struct GNUNET_GNS_ClientGetAuthMessage) - 1]) - { - GNUNET_break (0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - return; - } - GNUNET_STRINGS_utf8_tolower(utf_in, &nameptr); + struct GNUNET_GNS_ClientGetAuthMessage *sh_msg = + (struct GNUNET_GNS_ClientGetAuthMessage *) message; + + GNUNET_STRINGS_utf8_tolower((const char*)&sh_msg[1], &nameptr); + + cah = GNUNET_malloc(sizeof(struct ClientGetAuthHandle)); cah->client = client; - cah->unique_id = sh_msg->id; + cah->request_id = sh_msg->id; if (strlen (name) < strlen(GNUNET_GNS_TLD)) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -925,17 +983,16 @@ handle_get_authority (void *cls, cah->name = NULL; send_get_auth_response(cah, name); return; - } - cah->name = GNUNET_malloc(strlen (name) + } + + cah->name = GNUNET_malloc (strlen (name) - strlen (GNUNET_GNS_TLD) + 1); - memset (cah->name, 0, - strlen (name) - strlen (GNUNET_GNS_TLD) + 1); - memcpy (cah->name, name, - strlen (name) - strlen(GNUNET_GNS_TLD)); + memcpy(cah->name, name, + strlen (name) - strlen (GNUNET_GNS_TLD)); /* Start delegation resolution in our namestore */ - gns_resolver_get_authority(zone_hash, zone_hash, name, &send_get_auth_response, cah); - + gns_resolver_get_authority (zone_hash, zone_hash, name, + &send_get_auth_response, cah); GNUNET_STATISTICS_update (statistics, "Authority lookup attempts", 1, GNUNET_NO); } @@ -954,7 +1011,7 @@ send_lookup_response(void* cls, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { - struct ClientLookupHandle* clh = (struct ClientLookupHandle*)cls; + struct ClientLookupHandle* clh = cls; struct GNUNET_GNS_ClientLookupResultMessage *rmsg; size_t len; @@ -962,9 +1019,10 @@ send_lookup_response(void* cls, "LOOKUP_RESULT", rd_count); len = GNUNET_NAMESTORE_records_get_size (rd_count, rd); - rmsg = GNUNET_malloc(len+sizeof(struct GNUNET_GNS_ClientLookupResultMessage)); + rmsg = GNUNET_malloc ( + len + sizeof (struct GNUNET_GNS_ClientLookupResultMessage)); - rmsg->id = clh->unique_id; + rmsg->id = clh->request_id; rmsg->rd_count = htonl(rd_count); rmsg->header.type = htons(GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT); rmsg->header.size = @@ -982,18 +1040,13 @@ send_lookup_response(void* cls, if (NULL != clh->shorten_key) GNUNET_CRYPTO_rsa_key_free (clh->shorten_key); - GNUNET_free(clh); GNUNET_STATISTICS_update (statistics, "Completed lookups", 1, GNUNET_NO); - if (rd != NULL) - { GNUNET_STATISTICS_update (statistics, "Records resolved", rd_count, GNUNET_NO); - } - } @@ -1009,8 +1062,6 @@ handle_lookup(void *cls, struct GNUNET_SERVER_Client * client, const struct GNUNET_MessageHeader * message) { - uint16_t msg_size; - const struct GNUNET_GNS_ClientLookupMessage *sh_msg; size_t namelen; char name[MAX_DNS_NAME_LENGTH]; struct ClientLookupHandle *clh; @@ -1020,7 +1071,8 @@ handle_lookup(void *cls, struct GNUNET_CRYPTO_RsaPrivateKey *key; struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey; char* tmp_pkey; - + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "LOOKUP"); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "LOOKUP"); msg_size = ntohs(message->size); if (msg_size < sizeof (struct GNUNET_GNS_ClientLookupMessage)) @@ -1031,42 +1083,40 @@ handle_lookup(void *cls, } sh_msg = (const struct GNUNET_GNS_ClientLookupMessage *) message; GNUNET_SERVER_notification_context_add (nc, client); + + struct GNUNET_GNS_ClientLookupMessage *sh_msg = + (struct GNUNET_GNS_ClientLookupMessage *) message; + if (GNUNET_YES == ntohl (sh_msg->have_key)) { - pkey = (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *)&sh_msg[1]; - tmp_pkey = (char*)&sh_msg[1]; - key = GNUNET_CRYPTO_rsa_decode_key (tmp_pkey, ntohs(pkey->len)); - GNUNET_STRINGS_utf8_tolower(&tmp_pkey[ntohs(pkey->len)], &nameptr); + pkey = (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *) &sh_msg[1]; + tmp_pkey = (char*) &sh_msg[1]; + key = GNUNET_CRYPTO_rsa_decode_key (tmp_pkey, ntohs (pkey->len)); + GNUNET_STRINGS_utf8_tolower (&tmp_pkey[ntohs (pkey->len)], &nameptr); } else { key = NULL; - utf_in = (const char *) &sh_msg[1]; - if ('\0' != utf_in[msg_size - sizeof (struct GNUNET_GNS_ClientLookupMessage) - 1]) - { - GNUNET_break (0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - return; - } - GNUNET_STRINGS_utf8_tolower(utf_in, &nameptr); - } - namelen = strlen (name)+1; + GNUNET_STRINGS_utf8_tolower ((char*) &sh_msg[1], &nameptr); + } + + namelen = strlen(name)+1; clh = GNUNET_malloc (sizeof (struct ClientLookupHandle)); memset (clh, 0, sizeof (struct ClientLookupHandle)); clh->client = client; - clh->name = GNUNET_malloc(namelen); - strcpy(clh->name, name); - clh->unique_id = sh_msg->id; - clh->type = ntohl(sh_msg->type); + clh->name = GNUNET_malloc (namelen); + strcpy (clh->name, name); + clh->request_id = sh_msg->id; + clh->type = ntohl (sh_msg->type); clh->shorten_key = key; - only_cached = ntohl(sh_msg->only_cached); + only_cached = ntohl (sh_msg->only_cached); if (strlen (name) > MAX_DNS_NAME_LENGTH) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "LOOKUP: %s is too long", name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "LOOKUP: %s is too long", name); clh->name = NULL; - send_lookup_response(clh, 0, NULL); + send_lookup_response (clh, 0, NULL); return; } @@ -1076,21 +1126,21 @@ handle_lookup(void *cls, GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "LOOKUP: Query for A record but AF_INET not supported!"); clh->name = NULL; - send_lookup_response(clh, 0, NULL); + send_lookup_response (clh, 0, NULL); return; } if ((clh->type == GNUNET_GNS_RECORD_AAAA) && (GNUNET_OK != v6_enabled)) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "LOOKUP: Query for AAAA record but AF_INET6 not supported!"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "LOOKUP: Query for AAAA record but AF_INET6 not supported!"); clh->name = NULL; - send_lookup_response(clh, 0, NULL); + send_lookup_response (clh, 0, NULL); return; } - if (1 == ntohl(sh_msg->use_default_zone)) + if (1 == ntohl (sh_msg->use_default_zone)) clh->zone = zone_hash; //Default zone else clh->zone = sh_msg->zone; @@ -1210,18 +1260,18 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, } - zone_iteration_interval = INITIAL_ZONE_ITERATION_INTERVAL; + put_interval = INITIAL_PUT_INTERVAL; - record_put_interval = DEFAULT_RECORD_PUT_INTERVAL; + zone_publish_time_window = DEFAULT_ZONE_PUBLISH_TIME_WINDOW; if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (c, "gns", - "RECORD_PUT_INTERVAL", - &record_put_interval)) + "ZONE_PUBLISH_TIME_WINDOW", + &zone_publish_time_window)) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Record put interval: %s\n", - GNUNET_STRINGS_relative_time_to_string (record_put_interval, GNUNET_YES)); + "Time window for zone iteration: %s\n", + GNUNET_STRINGS_relative_time_to_string (zone_publish_time_window, GNUNET_YES)); } if (GNUNET_OK == @@ -1297,7 +1347,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, * We have roughly an hour for all records; */ first_zone_iteration = GNUNET_YES; - zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start, NULL); + zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start, NULL); GNUNET_SERVER_add_handlers (server, handlers); diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c index 0729d6674..ae576c908 100644 --- a/src/gns/gnunet-service-gns_resolver.c +++ b/src/gns/gnunet-service-gns_resolver.c @@ -40,8 +40,19 @@ #include "gns.h" #include "gnunet-service-gns_resolver.h" +/** + * Default DHT timeout + */ #define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT + +/** + * DHT replication level + */ #define DHT_GNS_REPLICATION_LEVEL 5 + +/** + * Maximum label length of DNS names + */ #define MAX_DNS_LABEL_LENGTH 63 @@ -137,7 +148,6 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; /** * a resolution identifier pool variable - * FIXME overflow? * This is a non critical identifier useful for debugging */ static unsigned long long rid = 0; @@ -351,6 +361,7 @@ handle_auth_discovery_timeout (void *cls, process_pseu_result (gph, NULL); } + /** * Function called when we find a PSEU entry in the DHT * @@ -437,6 +448,7 @@ process_auth_discovery_dht_result (void* cls, process_pseu_result (gph, NULL); } + /** * Process PSEU discovery for shorten via namestore * @@ -508,6 +520,7 @@ process_auth_discovery_ns_result (void* cls, process_pseu_result (gph, NULL); } + /** * Callback called by namestore for a zone to name * result @@ -571,6 +584,13 @@ shorten_authority_chain (struct GetPseuAuthorityHandle *gph) } +/** + * Start shortening algorithm using auth as + * authority chain + * + * @param auth the authorities that were resolved + * @param key the private key for PKEY import + */ static void start_shorten (struct AuthorityChain *auth, const struct GNUNET_CRYPTO_RsaPrivateKey *key) @@ -777,6 +797,8 @@ free_resolver_handle (struct ResolverHandle* rh) static void finish_shorten (struct ResolverHandle *rh, struct NameShortenHandle *nsh); + + /** * finish get auth * @@ -846,8 +868,6 @@ gns_resolver_cleanup () } - - /** * Callback when record data is put into namestore * @@ -883,6 +903,12 @@ on_namestore_record_put_result (void *cls, } +/** + * Lookup timeout task + * + * @param cls the ResolverHandle for the task that timed out + * @param tc the task context + */ static void handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { @@ -890,7 +916,6 @@ handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) if (NULL != rh->timeout_cont) rh->timeout_cont (rh->timeout_cont_cls, tc); - /* FIXME: does this leak memory? */ } @@ -912,6 +937,7 @@ background_lookup_result_processor (void *cls, rd_count); } + /** * Handle timeout for DHT requests * @@ -1122,7 +1148,6 @@ resolve_record_dht (struct ResolverHandle *rh) "GNS_PHASE_REC-%llu: starting dht lookup for %s with key: %s\n", rh->id, rh->name, GNUNET_h2s (&lookup_key)); - //rh->timeout_task = GNUNET_SCHEDULER_NO_TASK; rh->dht_heap_node = NULL; if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value) @@ -1370,8 +1395,6 @@ process_record_result_vpn (void* cls, int af, const void *address) } - - /** * Process VPN lookup result for record * @@ -1415,6 +1438,13 @@ static void send_dns_packet (struct ResolverHandle *rh); +/** + * Read DNS response + * + * @param cls the ResolverHandle for this lookup + * @param addr the sockaddr + * @param addrlen the socket address length + */ static void handle_dns_resolver (void *cls, const struct sockaddr *addr, @@ -1648,6 +1678,7 @@ read_dns_response (void *cls, return; } + /** * Sends a UDP dns query to a nameserver specified in the rh * @@ -1685,6 +1716,7 @@ send_dns_packet (struct ResolverHandle *rh) } + /** * The final phase of resoution. * We found a NS RR and want to resolve via DNS @@ -1888,9 +1920,9 @@ resolve_record_vpn (struct ResolverHandle *rh, GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME &process_record_result_vpn, rh); - } + /** * The final phase of resolution. * rh->name is a name that is canonical and we do not have a delegation. @@ -1935,7 +1967,6 @@ resolve_record_ns(struct ResolverHandle *rh) } - /** * Handle timeout for DHT requests * @@ -2003,10 +2034,21 @@ dht_authority_lookup_timeout(void *cls, rh->proc(rh->proc_cls, rh, 0, NULL); } -/* Prototype */ + +/** + * Start DHT lookup for a name -> PKEY (compare NS) record in + * rh->authority's zone + * + * @param rh the pending gns query + */ static void resolve_delegation_dht(struct ResolverHandle *rh); -/* Prototype */ + +/** + * Resolve the delegation chain for the request in our namestore + * + * @param rh the resolver handle + */ static void resolve_delegation_ns(struct ResolverHandle *rh); @@ -2136,6 +2178,7 @@ on_namestore_delegation_put_result(void *cls, "GNS_NS: Error putting records into namestore: %s\n", emsg); } + /** * Function called when we get a result from the dht * for our query. Recursively tries to resolve authorities @@ -2381,14 +2424,19 @@ process_delegation_result_dht(void* cls, #define MAX_SRV_LENGTH (sizeof(uint16_t)*3)+MAX_DNS_NAME_LENGTH +/** + * Exands a name ending in .+ with the zone of origin + * + * @param dest destination buffer + * @param sec the .+ name + * @param repl the string to replace the + with + */ static void expand_plus(char* dest, char* src, char* repl) { char* pos; unsigned int s_len = strlen(src)+1; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl); //Eh? I guess this is at least strlen ('x.+') == 3 FIXME if (3 > s_len) { @@ -2414,10 +2462,13 @@ expand_plus(char* dest, char* src, char* repl) } else { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: No postprocessing for %s\n", src); memcpy(dest, src, s_len+1); } } + /** * finish lookup */ @@ -2537,6 +2588,7 @@ finish_lookup (struct ResolverHandle *rh, free_resolver_handle (rh); } + /** * Process DHT lookup result for record. * @@ -2568,8 +2620,6 @@ handle_record_dht(void* cls, struct ResolverHandle *rh, } - - /** * Process namestore lookup result for record. * @@ -2681,6 +2731,7 @@ pop_tld(char* name, char* dest) strcpy(dest, (name+len+1)); } + /** * Checks if name is in tld * @@ -2706,6 +2757,7 @@ is_tld(const char* name, const char* tld) return GNUNET_YES; } + /** * DHT resolution for delegation finished. Processing result. * @@ -3380,10 +3432,8 @@ gns_resolver_lookup_record (struct GNUNET_CRYPTO_ShortHashCode zone, GNUNET_CONTAINER_DLL_insert (rlh_head, rlh_tail, rh); if (NULL == key) - { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No shorten key for resolution\n"); - } if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value) { @@ -3653,6 +3703,7 @@ process_zone_to_name_shorten_shorten (void *cls, rh); } + /** * Callback calles by namestore for a zone to name * result @@ -3767,6 +3818,7 @@ process_zone_to_name_shorten_private (void *cls, } } + /** * Callback calles by namestore for a zone to name * result @@ -4106,7 +4158,6 @@ gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone, } nsh = GNUNET_malloc (sizeof (struct NameShortenHandle)); - nsh->proc = proc; nsh->proc_cls = proc_cls; nsh->root_zone = zone; @@ -4116,7 +4167,6 @@ gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone, strcpy (nsh->shorten_zone_name, shorten_zone_name); strcpy (nsh->result, name); - rh = GNUNET_malloc (sizeof (struct ResolverHandle)); rh->authority = *zone; rh->id = rid++; @@ -4128,9 +4178,8 @@ gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone, rh->private_local_zone = *zone; GNUNET_CONTAINER_DLL_insert (nsh_head, nsh_tail, rh); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Checking for TLD...\n"); + "Checking for TLD...\n"); if (is_zkey_tld (name) == GNUNET_YES) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -4162,7 +4211,6 @@ gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone, proc (proc_cls, name); return; } - rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, zone, //ours &zkey, @@ -4238,11 +4286,9 @@ handle_delegation_result_ns_get_auth(void* cls, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { - struct GetNameAuthorityHandle* nah; + struct GetNameAuthorityHandle* nah = rh->proc_cls; size_t answer_len; - nah = (struct GetNameAuthorityHandle*) rh->proc_cls; - /** * At this point rh->name contains the part of the name * that we do not have a PKEY in our namestore to resolve. -- 2.25.1