changing time measurement from milliseconds to microseconds
[oweals/gnunet.git] / src / gns / gnunet-service-gns.c
index c5c5ac2bff258f4945609214a85fd75d6bf2d3ee..1bff3e51d17eac99065d512c5b9158999969f9f1 100644 (file)
@@ -17,9 +17,7 @@
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
 */
-
 /**
- *
  * @file gns/gnunet-service-gns.c
  * @brief GNUnet GNS service
  * @author Martin Schanzenbach
@@ -74,6 +72,7 @@ struct ClientShortenHandle
    * List for all shorten requests
    */
   struct ClientShortenHandle *next;
+
   /**
    * List for all shorten requests
    */
@@ -85,49 +84,50 @@ struct ClientShortenHandle
   struct GNUNET_SERVER_Client *client;
 
   /**
-   * The request id
+   * Namestore lookup task
    */
-  uint64_t request_id;
+  struct GNUNET_NAMESTORE_QueueEntry *namestore_task;
 
   /**
-   * request type
-   */
-  enum GNUNET_GNS_RecordType type;
-
-  /** 
-   * name to shorten
+   * master zone
    */
-  char name[MAX_DNS_NAME_LENGTH];
+  struct GNUNET_CRYPTO_ShortHashCode root_zone;
 
   /**
-   * name of private zone (relative to root)
+   * private zone
    */
-  char private_zone_id[MAX_DNS_NAME_LENGTH];
+  struct GNUNET_CRYPTO_ShortHashCode private_zone;
   
   /**
-   * name of shorten zone (relative to root)
+   * shorten zone
    */
-  char shorten_zone_id[MAX_DNS_NAME_LENGTH];
+  struct GNUNET_CRYPTO_ShortHashCode shorten_zone;
   
   /**
-   * master zone
+   * The request id
    */
-  struct GNUNET_CRYPTO_ShortHashCode root_zone;
+  uint32_t request_id;
 
   /**
-   * private zone
+   * request type
    */
-  struct GNUNET_CRYPTO_ShortHashCode private_zone;
-  
-  /**
-   * shorten zone
+  enum GNUNET_GNS_RecordType type;
+
+  /** 
+   * name to shorten
    */
-  struct GNUNET_CRYPTO_ShortHashCode shorten_zone;
+  char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
 
   /**
-   * Namestore lookup task
+   * name of private zone (relative to root)
    */
-  struct GNUNET_NAMESTORE_QueueEntry *namestore_task;
+  char private_zone_id[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+  
+  /**
+   * name of shorten zone (relative to root)
+   */
+  char shorten_zone_id[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+
 };
 
 
@@ -137,18 +137,20 @@ struct ClientShortenHandle
 struct ClientGetAuthHandle
 {
   /**
-   * Handle to the requesting client */
+   * Handle to the requesting client 
+   */
   struct GNUNET_SERVER_Client *client;
 
   /**
-   * request id
+   * name to lookup authority
    */
-  uint64_t request_id;
+  char *name;
 
   /**
-   * name to lookup authority
+   * request id
    */
-  char *name;
+  uint32_t request_id;
+
 };
 
 
@@ -164,34 +166,34 @@ struct ClientLookupHandle
   struct GNUNET_SERVER_Client *client;
 
   /**
-   * The zone we look up in
+   * optional zone private key used for shorten
    */
-  struct GNUNET_CRYPTO_ShortHashCode zone;
+  struct GNUNET_CRYPTO_EccPrivateKey *shorten_key;
 
   /**
-   * GNUNET_YES if we only want to lookup from local cache
+   * the name to look up
    */
-  int only_cached;
+  char *name; 
 
   /**
-   * request id 
+   * The zone we look up in
    */
-  uint64_t request_id;
+  struct GNUNET_CRYPTO_ShortHashCode zone;
 
   /**
-   * request type
+   * request id 
    */
-  enum GNUNET_GNS_RecordType type;
+  uint32_t request_id;
 
   /**
-   * optional zone private key used for shorten
+   * GNUNET_YES if we only want to lookup from local cache
    */
-  struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key;
+  int only_cached;
 
   /**
-   * the name to look up
+   * request type
    */
-  char *name; 
+  enum GNUNET_GNS_RecordType type;
 };
 
 
@@ -203,7 +205,7 @@ static struct GNUNET_DHT_Handle *dht_handle;
 /**
  * Our zone's private key
  */
-static struct GNUNET_CRYPTO_RsaPrivateKey *zone_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *zone_key;
 
 /**
  * Our handle to the namestore service
@@ -304,23 +306,40 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ClientShortenHandle *csh_tmp;
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Shutting down!");
+             "Shutting down!\n");
   while (NULL != (csh_tmp = csh_head))
   {
     GNUNET_CONTAINER_DLL_remove (csh_head, csh_tail, csh_tmp);
-    GNUNET_free(csh_tmp);
+    GNUNET_free (csh_tmp);
   }
   GNUNET_SERVER_notification_context_destroy (nc);  
   gns_interceptor_stop ();
   gns_resolver_cleanup ();
   if (NULL != statistics)
+  {
     GNUNET_STATISTICS_destroy (statistics, GNUNET_NO);
-  if (zone_publish_task != GNUNET_SCHEDULER_NO_TASK)
+    statistics = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != zone_publish_task)
+  {
     GNUNET_SCHEDULER_cancel (zone_publish_task);
+    zone_publish_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != namestore_iter)
+  {
     GNUNET_NAMESTORE_zone_iteration_stop (namestore_iter);
-  GNUNET_NAMESTORE_disconnect(namestore_handle);
-  GNUNET_DHT_disconnect(dht_handle);
+    namestore_iter = NULL;
+  }
+  if (NULL != namestore_handle)
+  {
+    GNUNET_NAMESTORE_disconnect (namestore_handle);
+    namestore_handle = NULL;
+  }
+  if (NULL != dht_handle)
+  {
+    GNUNET_DHT_disconnect (dht_handle);
+    dht_handle = NULL;
+  }
 }
 
 
@@ -347,7 +366,7 @@ publish_zone_dht_next (void *cls,
  */
 static void
 publish_zone_dht_start (void *cls, 
-                       const struct GNUNET_SCHEDULER_TaskContext *tc);
+                       const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -362,13 +381,13 @@ publish_zone_dht_start (void *cls,
  * @param signature the signature for the record data
  */
 static void
-put_gns_record(void *cls,
-                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+put_gns_record (void *cls,
+                const struct GNUNET_CRYPTO_EccPublicKey *key,
                 struct GNUNET_TIME_Absolute expiration,
                 const char *name,
                 unsigned int rd_count,
                 const struct GNUNET_NAMESTORE_RecordData *rd,
-                const struct GNUNET_CRYPTO_RsaSignature *signature)
+                const struct GNUNET_CRYPTO_EccSignature *signature)
 {  
   struct GNSNameRecordBlock *nrb;
   struct GNUNET_CRYPTO_ShortHashCode zhash;
@@ -391,26 +410,24 @@ put_gns_record(void *cls,
        * we can safely set the interval to the value for a single
        * record
        */
-      put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window,
-                                                             1);
-
+      put_interval = zone_publish_time_window;
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                  "No records in db.\n");
     }
     else
     {
       put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window,
-                                                             num_public_records);
+                                                 num_public_records);
     }
     put_interval = GNUNET_TIME_relative_max (MINIMUM_ZONE_ITERATION_INTERVAL,
-                                                        put_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 (put_interval, GNUNET_YES));
     GNUNET_STATISTICS_set (statistics,
                            "Current zone iteration interval (in ms)",
-                           put_interval.rel_value,
+                           put_interval.rel_value_us / 1000LL,
                            GNUNET_NO);
     GNUNET_STATISTICS_update (statistics,
                               "Number of zone iterations", 1, GNUNET_NO);
@@ -445,6 +462,17 @@ put_gns_record(void *cls,
     return;
   }
   
+  /* TODO 2) AB: New publishing
+   *
+   * - Use new signature S_d
+   * - Obtain new derived public key V = H(H(i,Q) * Q)
+   * - Obtain HKDF(i,Q)
+   * - Compute encrypte record block E with HKDF(i,Q) (rd, rd_count)
+   * - Create block B = |V,E,S_d|
+   * - Compute new DHT key H(V) in TODO 3)
+   *
+   * -> Put (H(V), B)
+   */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Putting records for `%s' into the DHT\n", name); 
   rd_payload_length = GNUNET_NAMESTORE_records_get_size (rd_count, rd); 
@@ -458,7 +486,7 @@ put_gns_record(void *cls,
   nrb_data += namelen;
   rd_payload_length += sizeof(struct GNSNameRecordBlock) + namelen;
   GNUNET_CRYPTO_short_hash (key,
-                           sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                           sizeof (struct GNUNET_CRYPTO_EccPublicKey),
                            &zhash);
   if (-1 == GNUNET_NAMESTORE_records_serialize (rd_count,
                                                 rd,
@@ -474,7 +502,7 @@ put_gns_record(void *cls,
                                                    NULL);
     return;
   }
-
+  /* TODO AB: Here records are put in the DHT: modify dht_key to H(key) = H(H(name,zone) * zone) */
   GNUNET_GNS_get_key_for_record (name, &zhash, &dht_key);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "putting %u records from zone %s for `%s' under key: %s with size %u and timeout %s\n",
@@ -486,7 +514,8 @@ put_gns_record(void *cls,
              GNUNET_STRINGS_relative_time_to_string (DHT_OPERATION_TIMEOUT, GNUNET_YES));
   
   GNUNET_STATISTICS_update (statistics,
-                            "Record bytes put into DHT", rd_payload_length, GNUNET_NO);
+                            "Record bytes put into DHT", 
+                           rd_payload_length, GNUNET_NO);
 
   (void) GNUNET_DHT_put (dht_handle, &dht_key,
                         DHT_GNS_REPLICATION_LEVEL,
@@ -507,7 +536,7 @@ put_gns_record(void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Last record count was lower than current record count.  Reducing interval.\n");
     put_interval = GNUNET_TIME_relative_divide (zone_publish_time_window,
-                                                           num_public_records);
+                                               num_public_records);
     next_put_interval = GNUNET_TIME_relative_divide (put_interval,
                                                     LATE_ITERATION_SPEEDUP_FACTOR);
   }
@@ -516,11 +545,11 @@ put_gns_record(void *cls,
 
   GNUNET_STATISTICS_set (statistics,
                         "Current zone iteration interval (ms)",
-                        next_put_interval.rel_value,
+                        next_put_interval.rel_value_us / 1000LL,
                         GNUNET_NO); 
   zone_publish_task = GNUNET_SCHEDULER_add_delayed (next_put_interval,
-                                                    &publish_zone_dht_next,
-                                                    NULL);
+                                                   &publish_zone_dht_next,
+                                                   NULL);
 }
 
 
@@ -531,11 +560,13 @@ put_gns_record(void *cls,
  * @param tc task context
  */
 static void
-publish_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_zone_dht_start (void *cls, 
+                       const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   zone_publish_task = GNUNET_SCHEDULER_NO_TASK;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling DHT zone update!\n");  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+             "Scheduling DHT zone update!\n");  
   /* start counting again */
   num_public_records = 0;
   namestore_iter = GNUNET_NAMESTORE_zone_iteration_start (namestore_handle,
@@ -563,7 +594,8 @@ send_shorten_response (void* cls, const char* name)
   struct GNUNET_GNS_ClientShortenResultMessage *rmsg;
   size_t name_len;
   
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message with %s\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+             "Sending `%s' message with %s\n",
               "SHORTEN_RESULT", name);
   if (NULL == name)
     name_len = 0;
@@ -605,12 +637,12 @@ send_shorten_response (void* cls, const char* name)
  */
 static void
 process_shorten_in_private_zone_lookup (void *cls,
-                                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                                       const struct GNUNET_CRYPTO_EccPublicKey *key,
                                        struct GNUNET_TIME_Absolute expiration,
                                        const char *name,
                                        unsigned int rd_count,
                                        const struct GNUNET_NAMESTORE_RecordData *rd,
-                                       const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                       const struct GNUNET_CRYPTO_EccSignature *signature)
 {
   struct ClientShortenHandle *csh = cls;
   struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
@@ -618,9 +650,8 @@ process_shorten_in_private_zone_lookup (void *cls,
 
   csh->namestore_task = NULL;
   if (0 == strcmp (csh->private_zone_id, ""))
-    pzone = NULL;
-  
-  if (rd_count == 0)
+    pzone = NULL;  
+  if (0 == rd_count)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "No shorten zone in private zone!\n");
@@ -629,17 +660,14 @@ process_shorten_in_private_zone_lookup (void *cls,
   }
   else
   {
-    GNUNET_assert (rd_count == 1);
-
+    GNUNET_break (1 == rd_count);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Shorten zone %s found in private zone %s\n",
                 name, csh->private_zone_id);
 
     sprintf (csh->shorten_zone_id, "%s.%s", name, csh->private_zone_id);
   }
-  
   GNUNET_CONTAINER_DLL_remove (csh_head, csh_tail, csh);
-
   gns_resolver_shorten_name (&csh->root_zone,
                              pzone,
                              szone,
@@ -665,12 +693,12 @@ process_shorten_in_private_zone_lookup (void *cls,
  */
 static void
 process_shorten_in_root_zone_lookup (void *cls,
-                      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
-                      struct GNUNET_TIME_Absolute expiration,
-                      const char *name,
-                      unsigned int rd_count,
-                      const struct GNUNET_NAMESTORE_RecordData *rd,
-                      const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                    const struct GNUNET_CRYPTO_EccPublicKey *key,
+                                    struct GNUNET_TIME_Absolute expiration,
+                                    const char *name,
+                                    unsigned int rd_count,
+                                    const struct GNUNET_NAMESTORE_RecordData *rd,
+                                    const struct GNUNET_CRYPTO_EccSignature *signature)
 {
   struct ClientShortenHandle *csh = cls;
   struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
@@ -679,17 +707,14 @@ process_shorten_in_root_zone_lookup (void *cls,
   csh->namestore_task = NULL;
   if (0 == strcmp (csh->private_zone_id, ""))
     pzone = NULL;
-
-  if (rd_count == 0)
+  if (0 == rd_count)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "No shorten zone in zone and no private zone!\n");
 
     strcpy (csh->shorten_zone_id, "");
-
     GNUNET_CONTAINER_DLL_remove (csh_head, csh_tail, csh);
     szone = NULL;
-
     gns_resolver_shorten_name (&csh->root_zone,
                                pzone,
                                szone,
@@ -699,19 +724,15 @@ process_shorten_in_root_zone_lookup (void *cls,
                                &send_shorten_response, csh);
     return;
   }
-
-  GNUNET_assert (rd_count == 1);
-
+  GNUNET_break (rd_count == 1);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Private zone %s found in root zone\n", name);
-
   strcpy (csh->private_zone_id, name);
-
   csh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
-                                  pzone,
-                                  szone,
-                                  &process_shorten_in_private_zone_lookup,
-                                  csh);
+                                                      pzone,
+                                                      szone,
+                                                      &process_shorten_in_private_zone_lookup,
+                                                      csh);
 }
 
 
@@ -725,67 +746,41 @@ process_shorten_in_root_zone_lookup (void *cls,
  * @param rd_count number of records found
  * @param rd record data
  * @param signature
- *
  */
 static void
 process_private_in_root_zone_lookup (void *cls,
-                      const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
-                      struct GNUNET_TIME_Absolute expiration,
-                      const char *name,
-                      unsigned int rd_count,
-                      const struct GNUNET_NAMESTORE_RecordData *rd,
-                      const struct GNUNET_CRYPTO_RsaSignature *signature)
+                                    const struct GNUNET_CRYPTO_EccPublicKey *key,
+                                    struct GNUNET_TIME_Absolute expiration,
+                                    const char *name,
+                                    unsigned int rd_count,
+                                    const struct GNUNET_NAMESTORE_RecordData *rd,
+                                    const struct GNUNET_CRYPTO_EccSignature *signature)
 {
   struct ClientShortenHandle *csh = cls;
-  csh->namestore_task = NULL;
 
-  if (rd_count == 0)
+  csh->namestore_task = NULL;
+  if (0 == rd_count)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "No private zone in root zone\n");
-
     strcpy (csh->private_zone_id, "");
-  
     csh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
-                                  &csh->root_zone,
-                                  &csh->shorten_zone,
-                                  &process_shorten_in_root_zone_lookup,
-                                  csh);
+                                                        &csh->root_zone,
+                                                        &csh->shorten_zone,
+                                                        &process_shorten_in_root_zone_lookup,
+                                                        csh);
     return;
   }
-
-  GNUNET_assert (rd_count == 1);
-
+  GNUNET_break (1 == rd_count);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Private zone %s found in root zone\n", name);
-
+              "Private zone `%s' found in root zone\n", 
+             name);
   strcpy (csh->private_zone_id, name);
-
-  csh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
-                                  &csh->private_zone,
-                                  &csh->shorten_zone,
-                                  &process_shorten_in_private_zone_lookup,
-                                  csh);
-}
-
-
-/**
- * Lookup the zone infos and shorten name
- *
- * @param csh the shorten handle
- *
- */
-static void
-start_shorten_name (struct ClientShortenHandle *csh)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Looking for private zone name in root zone\n");
-
   csh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
-                                  &csh->root_zone,
-                                  &csh->private_zone,
-                                  &process_private_in_root_zone_lookup,
-                                  csh);
+                                                      &csh->private_zone,
+                                                      &csh->shorten_zone,
+                                                      &process_shorten_in_private_zone_lookup,
+                                                      csh);
 }
 
 
@@ -803,10 +798,13 @@ handle_shorten (void *cls,
 {
   struct ClientShortenHandle *csh;
   const char *utf_in;
-  char name[MAX_DNS_NAME_LENGTH];
+  char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
   char* nameptr = name;
+  uint16_t msg_size;
+  const struct GNUNET_GNS_ClientShortenMessage *sh_msg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "SHORTEN");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+             "Received `%s' message\n", "SHORTEN");
   msg_size = ntohs (message->size);
   if (msg_size < sizeof (struct GNUNET_GNS_ClientShortenMessage))
   {
@@ -814,18 +812,21 @@ handle_shorten (void *cls,
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-
-
-  const struct GNUNET_GNS_ClientShortenMessage *sh_msg =
-    (const struct GNUNET_GNS_ClientShortenMessage *) message;
-  
+  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));
   csh->client = client;
   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,
-               "SHORTEN: Converted `%s' to `%s'\n", 
+            "SHORTEN: Converted `%s' to `%s'\n", 
             utf_in, 
             nameptr);
   GNUNET_SERVER_notification_context_add (nc, client);  
@@ -838,7 +839,7 @@ handle_shorten (void *cls,
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }
-  if (strlen (name) > MAX_DNS_NAME_LENGTH) 
+  if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) 
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                "SHORTEN: %s is too long\n", name);
@@ -847,7 +848,7 @@ handle_shorten (void *cls,
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }  
-  if ( (! is_gnunet_tld (name)) && 
+  if ( (! is_gads_tld (name)) && 
        (! is_zkey_tld (name)) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -864,7 +865,11 @@ handle_shorten (void *cls,
     csh->root_zone = zone_hash; //Default zone
   else
     csh->root_zone = sh_msg->zone;
-  start_shorten_name (csh);
+  csh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
+                                                      &csh->root_zone,
+                                                      &csh->private_zone,
+                                                      &process_private_in_root_zone_lookup,
+                                                      csh);
   GNUNET_STATISTICS_update (statistics,
                             "Name shorten attempts", 1, GNUNET_NO);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -875,39 +880,39 @@ handle_shorten (void *cls,
  * Send get authority response back to client
  * 
  * @param cls the closure containing a client get auth handle
- * @param name the shortened name result or NULL if cannot be shortened
+ * @param name the name of the authority, or NULL on error
  */
 static void 
-send_get_auth_response(void *cls, const char* name)
+send_get_auth_response (void *cls, 
+                       const char* name)
 {
   struct ClientGetAuthHandle *cah = cls;
   struct GNUNET_GNS_ClientGetAuthResultMessage *rmsg;
   
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message with %s\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+             "Sending `%s' message with `%s'\n",
               "GET_AUTH_RESULT", name);
-  if (name != NULL)
+  if (NULL != name)
   {
     GNUNET_STATISTICS_update (statistics,
                               "Authorities resolved", 1, GNUNET_NO);
   }  
-  if (name == NULL)  
+  if (NULL == name)  
     name = "";  
-
-  rmsg = GNUNET_malloc(sizeof(struct GNUNET_GNS_ClientGetAuthResultMessage)
-                       + strlen(name) + 1);
+  rmsg = GNUNET_malloc (sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage)
+                       + strlen (name) + 1);
   
   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) +
-          strlen(name) + 1);
+          strlen (name) + 1);
   strcpy ((char*)&rmsg[1], name);
 
   GNUNET_SERVER_notification_context_unicast (nc, cah->client,
                                              &rmsg->header,
                                              GNUNET_NO);
   GNUNET_SERVER_receive_done (cah->client, GNUNET_OK);
-  
   GNUNET_free(rmsg);
   GNUNET_free_non_null(cah->name);
   GNUNET_free(cah);  
@@ -928,25 +933,30 @@ handle_get_authority (void *cls,
 {
   struct ClientGetAuthHandle *cah;
   const char *utf_in;
-  char name[MAX_DNS_NAME_LENGTH];
+  char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
   char* nameptr = name;
+  uint16_t msg_size;
+  const struct GNUNET_GNS_ClientGetAuthMessage *sh_msg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "GET_AUTH");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+             "Received `%s' message\n", "GET_AUTH");
   msg_size = ntohs(message->size);
   if (msg_size < sizeof (struct GNUNET_GNS_ClientGetAuthMessage))
   {
     GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
   GNUNET_SERVER_notification_context_add (nc, client);
-
-  struct GNUNET_GNS_ClientGetAuthMessage *sh_msg =
-    (struct GNUNET_GNS_ClientGetAuthMessage *) message;
-  
-  GNUNET_STRINGS_utf8_tolower((const char*)&sh_msg[1], &nameptr);
-
-
+  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);
   cah = GNUNET_malloc(sizeof(struct ClientGetAuthHandle));
   cah->client = client;
   cah->request_id = sh_msg->id;
@@ -958,7 +968,7 @@ handle_get_authority (void *cls,
     send_get_auth_response(cah, name);
     return;
   }  
-  if (strlen (name) > MAX_DNS_NAME_LENGTH) 
+  if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) 
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                "GET_AUTH: `%s' is too long", name);
@@ -966,17 +976,17 @@ handle_get_authority (void *cls,
     send_get_auth_response(cah, name);
     return;
   }  
-  if (0 != strcmp (name + strlen (name) - strlen(GNUNET_GNS_TLD),
+  if (0 != strcmp (name + strlen (name) - strlen (GNUNET_GNS_TLD),
                   GNUNET_GNS_TLD))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "GET_AUTH: %s is not our domain. Returning\n", name);
     cah->name = NULL;
-    send_get_auth_response(cah, name);
+    send_get_auth_response (cah, name);
     return;
   }
 
-  if (0 == strcmp(name, GNUNET_GNS_TLD))
+  if (0 == strcmp (name, GNUNET_GNS_TLD))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "GET_AUTH: %s is us. Returning\n", name);
@@ -987,8 +997,8 @@ handle_get_authority (void *cls,
   
   cah->name = GNUNET_malloc (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,
@@ -998,7 +1008,6 @@ handle_get_authority (void *cls,
 }
 
 
-
 /**
  * Reply to client with the result from our lookup.
  *
@@ -1007,9 +1016,9 @@ handle_get_authority (void *cls,
  * @param rd the record data
  */
 static void
-send_lookup_response(void* cls,
-                     uint32_t rd_count,
-                     const struct GNUNET_NAMESTORE_RecordData *rd)
+send_lookup_response (void* cls,
+                     uint32_t rd_count,
+                     const struct GNUNET_NAMESTORE_RecordData *rd)
 {
   struct ClientLookupHandle* clh = cls;
   struct GNUNET_GNS_ClientLookupResultMessage *rmsg;
@@ -1019,8 +1028,7 @@ 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->request_id;
   rmsg->rd_count = htonl(rd_count);
@@ -1039,12 +1047,11 @@ send_lookup_response(void* cls,
   GNUNET_free(clh->name);
   
   if (NULL != clh->shorten_key)
-    GNUNET_CRYPTO_rsa_key_free (clh->shorten_key);
-  GNUNET_free(clh);
-
+    GNUNET_CRYPTO_ecc_key_free (clh->shorten_key);
+  GNUNET_free (clh);
   GNUNET_STATISTICS_update (statistics,
                             "Completed lookups", 1, GNUNET_NO);
-  if (rd != NULL)
+  if (NULL != rd)
     GNUNET_STATISTICS_update (statistics,
                               "Records resolved", rd_count, GNUNET_NO);
 }
@@ -1058,49 +1065,49 @@ send_lookup_response(void* cls,
  * @param message the message
  */
 static void
-handle_lookup(void *cls,
-              struct GNUNET_SERVER_Client * client,
-              const struct GNUNET_MessageHeader * message)
+handle_lookup (void *cls,
+              struct GNUNET_SERVER_Client * client,
+              const struct GNUNET_MessageHeader * message)
 {
   size_t namelen;
-  char name[MAX_DNS_NAME_LENGTH];
+  char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
   struct ClientLookupHandle *clh;
   char* nameptr = name;
   const char *utf_in;
   int only_cached;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key;
-  struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey;
-  char* tmp_pkey;
+  const struct GNUNET_CRYPTO_EccPrivateKey *key;
+  uint16_t msg_size;
+  const struct GNUNET_GNS_ClientLookupMessage *sh_msg;
   
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "LOOKUP");
-  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))
   {
     GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
   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);
+    key = &sh_msg->shorten_key;
   }
   else
   {
     key = NULL;
-    GNUNET_STRINGS_utf8_tolower ((char*) &sh_msg[1], &nameptr);
   }
+  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;
+  namelen = strlen (name) + 1;
   clh = GNUNET_malloc (sizeof (struct ClientLookupHandle));
   memset (clh, 0, sizeof (struct ClientLookupHandle));
   clh->client = client;
@@ -1108,11 +1115,14 @@ handle_lookup(void *cls,
   strcpy (clh->name, name);
   clh->request_id = sh_msg->id;
   clh->type = ntohl (sh_msg->type);
-  clh->shorten_key = key;
-
+  if (NULL != key)
+  {
+    clh->shorten_key = GNUNET_new (struct GNUNET_CRYPTO_EccPrivateKey);
+    *clh->shorten_key = *key;
+  }
   only_cached = ntohl (sh_msg->only_cached);
   
-  if (strlen (name) > MAX_DNS_NAME_LENGTH) {
+  if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "LOOKUP: %s is too long", name);
     clh->name = NULL;
@@ -1120,7 +1130,7 @@ handle_lookup(void *cls,
     return;
   }
 
-  if ((clh->type == GNUNET_GNS_RECORD_A) &&
+  if ((GNUNET_GNS_RECORD_A == clh->type) &&
       (GNUNET_OK != v4_enabled))
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
@@ -1130,7 +1140,7 @@ handle_lookup(void *cls,
     return;
   }
   
-  if ((clh->type == GNUNET_GNS_RECORD_AAAA) &&
+  if ((GNUNET_GNS_RECORD_AAAA == clh->type) &&
       (GNUNET_OK != v6_enabled))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1140,8 +1150,8 @@ handle_lookup(void *cls,
     return;
   }
   
-  if (1 == ntohl (sh_msg->use_default_zone))
-    clh->zone = zone_hash; //Default zone
+  if (GNUNET_NO == ntohl (sh_msg->have_zone))
+    clh->zone = zone_hash;  /* Default zone */
   else
     clh->zone = sh_msg->zone;
   
@@ -1161,44 +1171,15 @@ handle_lookup(void *cls,
                                 only_cached,
                                 &send_lookup_response, clh);
   }
-
   GNUNET_STATISTICS_update (statistics,
                             "Record lookup attempts", 1, GNUNET_NO);
 }
 
 
-/**
- * Test if the given AF is supported by this system.
- *
- * @param af to test
- * @return GNUNET_OK if the AF is supported
- */
-static int
-test_af (int af)
-{
-  int s;
-
-  s = socket (af, SOCK_STREAM, 0);
-  if (-1 == s)
-  {
-    if (EAFNOSUPPORT == errno)
-      return GNUNET_NO;
-    fprintf (stderr, "Failed to create test socket: %s\n", STRERROR (errno));
-    return GNUNET_SYSERR;
-  }
-#if WINDOWS
-  closesocket (s);
-#else
-  close (s);
-#endif
-  return GNUNET_OK;
-}
-
-
 /**
  * Process GNS requests.
  *
- * @param cls closure)
+ * @param cls closure
  * @param server the initialized server
  * @param c configuration to use
  */
@@ -1206,23 +1187,21 @@ static void
 run (void *cls, struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char* keyfile;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
-  unsigned long long max_parallel_bg_queries = 0;
-  unsigned long long default_lookup_timeout_secs = 0;
-  int ignore_pending = GNUNET_NO;
-
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
     {&handle_shorten, NULL, GNUNET_MESSAGE_TYPE_GNS_SHORTEN, 0},
     {&handle_lookup, NULL, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, 0},
     {&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
   };
+  char* keyfile;
+  struct GNUNET_CRYPTO_EccPublicKey pkey;
+  unsigned long long max_parallel_bg_queries = 0;
+  int ignore_pending = GNUNET_NO;
 
-  v6_enabled = test_af (AF_INET6);
-  v4_enabled = test_af (AF_INET);
+  v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
+  v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
 
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c, "gns",
-                                             "ZONEKEY", &keyfile))
+                                                           "ZONEKEY", &keyfile))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "No private key for root zone specified!\n");
@@ -1233,12 +1212,11 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
              "Using keyfile %s for root zone.\n", keyfile);
 
-  zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
-
-  GNUNET_CRYPTO_short_hash(&pkey,
-                     sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                     &zone_hash);
+  zone_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
+  GNUNET_CRYPTO_ecc_key_get_public (zone_key, &pkey);
+  GNUNET_CRYPTO_short_hash (&pkey,
+                           sizeof(struct GNUNET_CRYPTO_EccPublicKey),
+                           &zone_hash);
   GNUNET_free(keyfile);
   namestore_handle = GNUNET_NAMESTORE_connect (c);
   if (NULL == namestore_handle)
@@ -1254,76 +1232,69 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
       GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
                                             "AUTO_IMPORT_PKEY"))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Automatic PKEY import is enabled.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Automatic PKEY import is enabled.\n");
     auto_import_pkey = GNUNET_YES;
-
   }
-
   put_interval = INITIAL_PUT_INTERVAL;
-
   zone_publish_time_window = DEFAULT_ZONE_PUBLISH_TIME_WINDOW;
 
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_time (c, "gns",
-                                             "ZONE_PUBLISH_TIME_WINDOW",
-                                             &zone_publish_time_window))
+                                          "ZONE_PUBLISH_TIME_WINDOW",
+                                          &zone_publish_time_window))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Time window for zone iteration: %s\n",
                GNUNET_STRINGS_relative_time_to_string (zone_publish_time_window, GNUNET_YES));
   }
-
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (c, "gns",
                                             "MAX_PARALLEL_BACKGROUND_QUERIES",
                                             &max_parallel_bg_queries))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Number of allowed parallel background queries: %llu\n",
-               max_parallel_bg_queries);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Number of allowed parallel background queries: %llu\n",
+               max_parallel_bg_queries);
   }
 
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
                                             "AUTO_IMPORT_CONFIRMATION_REQ"))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Auto import requires user confirmation\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Auto import requires user confirmation\n");
     ignore_pending = GNUNET_YES;
   }
 
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number(c, "gns",
-                                            "DEFAULT_LOOKUP_TIMEOUT",
-                                            &default_lookup_timeout_secs))
+      GNUNET_CONFIGURATION_get_value_time (c, "gns",
+                                          "DEFAULT_LOOKUP_TIMEOUT",
+                                          &default_lookup_timeout))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Default lookup timeout: %llus\n", default_lookup_timeout_secs);
-    default_lookup_timeout = GNUNET_TIME_relative_multiply(
-                                            GNUNET_TIME_UNIT_SECONDS,
-                                            default_lookup_timeout_secs);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Default lookup timeout: %s\n",
+               GNUNET_STRINGS_relative_time_to_string (default_lookup_timeout,
+                                                       GNUNET_YES));
   }
   
-  /**
-   * handle to the dht
-   */
-  dht_handle = GNUNET_DHT_connect(c,
-                       //max_parallel_bg_queries); //FIXME get ht_len from cfg
-                       1024);
-
+  dht_handle = GNUNET_DHT_connect (c,
+                                  (unsigned int) max_parallel_bg_queries);
   if (NULL == dht_handle)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to DHT!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+               _("Could not connect to DHT!\n"));
+    GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
+    return;
   }
   
-  if (gns_resolver_init(namestore_handle, dht_handle, zone_hash, c,
-                        max_parallel_bg_queries,
-                        ignore_pending)
-      == GNUNET_SYSERR)
+  if (GNUNET_SYSERR ==
+      gns_resolver_init (namestore_handle, dht_handle, zone_hash, c,
+                        max_parallel_bg_queries,
+                        ignore_pending))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               "Unable to initialize resolver!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+               _("Unable to initialize resolver!\n"));
     GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
     return;
   }
@@ -1331,13 +1302,14 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (c, "gns", "HIJACK_DNS"))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "DNS hijacking enabled... connecting to service.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+               "DNS hijacking enabled. Connecting to DNS service.\n");
 
-    if (gns_interceptor_init(zone_hash, zone_key, c) == GNUNET_SYSERR)
+    if (GNUNET_SYSERR ==
+       gns_interceptor_init (zone_hash, zone_key, c))
     {
       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               "Failed to enable the dns interceptor!\n");
+               "Failed to enable the DNS interceptor!\n");
     }
   }
   
@@ -1348,18 +1320,9 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
    */
   first_zone_iteration = GNUNET_YES;
   zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start, NULL);
-
   GNUNET_SERVER_add_handlers (server, handlers);
-  
-  //FIXME
-  //GNUNET_SERVER_disconnect_notify (server,
-  //                                 &client_disconnect_notification,
-  //                                 NULL);
-
   statistics = GNUNET_STATISTICS_create ("gns", c);
-
   nc = GNUNET_SERVER_notification_context_create (server, 1);
-
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
                                 NULL);
 }