-doxy

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.