uncrustify as demanded.

30 files changed, 7889 insertions, 7848 deletions

diff --git a/src/gns/gns.h b/src/gns/gns.h
index 3b41de83c..8465f49f9 100644
--- a/src/gns/gns.h
+++ b/src/gns/gns.h
@@ -11,7 +11,7 @@
       WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       Affero General Public License for more details.
-     
+
       You should have received a copy of the GNU Affero General Public License
       along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -33,8 +33,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * Message from client to GNS service to lookup records.
  */
-struct LookupMessage
-{
+struct LookupMessage {
   /**
    * Header of type #GNUNET_MESSAGE_TYPE_GNS_LOOKUP
    */
@@ -73,10 +72,9 @@ struct LookupMessage
 /**
  * Message from GNS service to client: new results.
  */
-struct LookupResultMessage
-{
+struct LookupResultMessage {
   /**
-    * Header of type #GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT
+   * Header of type #GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT
    */
   struct GNUNET_MessageHeader header;
 
@@ -91,7 +89,6 @@ struct LookupResultMessage
   uint32_t rd_count GNUNET_PACKED;
 
   /* followed by rd_count GNUNET_GNSRECORD_Data structs*/
-
 };
 
 
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c
index ba83b73cd..62f250959 100644
--- a/src/gns/gns_api.c
+++ b/src/gns/gns_api.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gns_api.c
  * @brief library to access the GNS service
@@ -34,14 +34,12 @@
 #include "gns_api.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "gns-api",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "gns-api", __VA_ARGS__)
 
 /**
  * Handle to a lookup request
  */
-struct GNUNET_GNS_LookupRequest
-{
-
+struct GNUNET_GNS_LookupRequest {
   /**
    * DLL
    */
@@ -76,7 +74,6 @@ struct GNUNET_GNS_LookupRequest
    * request id
    */
   uint32_t r_id;
-
 };
 
 
@@ -86,7 +83,7 @@ struct GNUNET_GNS_LookupRequest
  * @param handle the handle to the GNS service
  */
 static void
-reconnect (struct GNUNET_GNS_Handle *handle);
+reconnect(struct GNUNET_GNS_Handle *handle);
 
 
 /**
@@ -95,12 +92,12 @@ reconnect (struct GNUNET_GNS_Handle *handle);
  * @param cls the handle
  */
 static void
-reconnect_task (void *cls)
+reconnect_task(void *cls)
 {
   struct GNUNET_GNS_Handle *handle = cls;
 
   handle->reconnect_task = NULL;
-  reconnect (handle);
+  reconnect(handle);
 }
 
 
@@ -110,16 +107,16 @@ reconnect_task (void *cls)
  * @param handle our handle
  */
 static void
-force_reconnect (struct GNUNET_GNS_Handle *handle)
+force_reconnect(struct GNUNET_GNS_Handle *handle)
 {
-  GNUNET_MQ_destroy (handle->mq);
+  GNUNET_MQ_destroy(handle->mq);
   handle->mq = NULL;
   handle->reconnect_backoff
-    = GNUNET_TIME_STD_BACKOFF (handle->reconnect_backoff);
+    = GNUNET_TIME_STD_BACKOFF(handle->reconnect_backoff);
   handle->reconnect_task
-    = GNUNET_SCHEDULER_add_delayed (handle->reconnect_backoff,
-                                    &reconnect_task,
-                                    handle);
+    = GNUNET_SCHEDULER_add_delayed(handle->reconnect_backoff,
+                                   &reconnect_task,
+                                   handle);
 }
 
 
@@ -132,15 +129,15 @@ force_reconnect (struct GNUNET_GNS_Handle *handle)
  * @param error error code
  */
 static void
-mq_error_handler (void *cls,
-                  enum GNUNET_MQ_Error error)
+mq_error_handler(void *cls,
+                 enum GNUNET_MQ_Error error)
 {
   struct GNUNET_GNS_Handle *handle = cls;
 
-  LOG (GNUNET_ERROR_TYPE_WARNING,
-       "Problem with message queue. error: %i\n",
-       error);
-  force_reconnect (handle);
+  LOG(GNUNET_ERROR_TYPE_WARNING,
+      "Problem with message queue. error: %i\n",
+      error);
+  force_reconnect(handle);
 }
 
 
@@ -151,23 +148,23 @@ mq_error_handler (void *cls,
  * @param loookup_msg the incoming message
  */
 static int
-check_result (void *cls,
-              const struct LookupResultMessage *lookup_msg)
+check_result(void *cls,
+             const struct LookupResultMessage *lookup_msg)
 {
-  size_t mlen = ntohs (lookup_msg->header.size) - sizeof (*lookup_msg);
-  uint32_t rd_count = ntohl (lookup_msg->rd_count);
+  size_t mlen = ntohs(lookup_msg->header.size) - sizeof(*lookup_msg);
+  uint32_t rd_count = ntohl(lookup_msg->rd_count);
   struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-  (void) cls;
+  (void)cls;
   if (GNUNET_SYSERR ==
-      GNUNET_GNSRECORD_records_deserialize (mlen,
-                                            (const char*) &lookup_msg[1],
-                                            rd_count,
-                                            rd))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_GNSRECORD_records_deserialize(mlen,
+                                           (const char*)&lookup_msg[1],
+                                           rd_count,
+                                           rd))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -179,21 +176,21 @@ check_result (void *cls,
  * @param loookup_msg the incoming message
  */
 static void
-handle_result (void *cls,
-               const struct LookupResultMessage *lookup_msg)
+handle_result(void *cls,
+              const struct LookupResultMessage *lookup_msg)
 {
   struct GNUNET_GNS_Handle *handle = cls;
-  size_t mlen = ntohs (lookup_msg->header.size) - sizeof (*lookup_msg);
-  uint32_t rd_count = ntohl (lookup_msg->rd_count);
+  size_t mlen = ntohs(lookup_msg->header.size) - sizeof(*lookup_msg);
+  uint32_t rd_count = ntohl(lookup_msg->rd_count);
   struct GNUNET_GNSRECORD_Data rd[rd_count];
-  uint32_t r_id = ntohl (lookup_msg->id);
+  uint32_t r_id = ntohl(lookup_msg->id);
   struct GNUNET_GNS_LookupRequest *lr;
   GNUNET_GNS_LookupResultProcessor proc;
   void *proc_cls;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received lookup reply from GNS service (%u records)\n",
-       (unsigned int) rd_count);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received lookup reply from GNS service (%u records)\n",
+      (unsigned int)rd_count);
   for (lr = handle->lookup_head; NULL != lr; lr = lr->next)
     if (lr->r_id == r_id)
       break;
@@ -202,20 +199,20 @@ handle_result (void *cls,
   proc = lr->lookup_proc;
   proc_cls = lr->proc_cls;
 
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_GNSRECORD_records_deserialize (mlen,
-                                                       (const char*) &lookup_msg[1],
-                                                       rd_count,
-                                                       rd));
-  proc (proc_cls,
-        rd_count,
-        rd);
-  GNUNET_CONTAINER_DLL_remove (handle->lookup_head,
-                               handle->lookup_tail,
-                               lr);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_GNSRECORD_records_deserialize(mlen,
+                                                     (const char*)&lookup_msg[1],
+                                                     rd_count,
+                                                     rd));
+  proc(proc_cls,
+       rd_count,
+       rd);
+  GNUNET_CONTAINER_DLL_remove(handle->lookup_head,
+                              handle->lookup_tail,
+                              lr);
   if (NULL != lr->env)
-    GNUNET_MQ_discard (lr->env);
-  GNUNET_free (lr);
+    GNUNET_MQ_discard(lr->env);
+  GNUNET_free(lr);
 }
 
 
@@ -225,31 +222,31 @@ handle_result (void *cls,
  * @param handle the handle to the GNS service
  */
 static void
-reconnect (struct GNUNET_GNS_Handle *handle)
+reconnect(struct GNUNET_GNS_Handle *handle)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (result,
-                           GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT,
-                           struct LookupResultMessage,
-                           handle),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_var_size(result,
+                          GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT,
+                          struct LookupResultMessage,
+                          handle),
+    GNUNET_MQ_handler_end()
   };
 
-  GNUNET_assert (NULL == handle->mq);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Trying to connect to GNS\n");
-  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
-                                      "gns",
-                                      handlers,
-                                      &mq_error_handler,
-                                      handle);
+  GNUNET_assert(NULL == handle->mq);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to connect to GNS\n");
+  handle->mq = GNUNET_CLIENT_connect(handle->cfg,
+                                     "gns",
+                                     handlers,
+                                     &mq_error_handler,
+                                     handle);
   if (NULL == handle->mq)
     return;
   for (struct GNUNET_GNS_LookupRequest *lh = handle->lookup_head;
        NULL != lh;
        lh = lh->next)
-    GNUNET_MQ_send_copy (handle->mq,
-                         lh->env);
+    GNUNET_MQ_send_copy(handle->mq,
+                        lh->env);
 }
 
 
@@ -260,18 +257,18 @@ reconnect (struct GNUNET_GNS_Handle *handle)
  * @return handle to the GNS service, or NULL on error
  */
 struct GNUNET_GNS_Handle *
-GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_GNS_Handle *handle;
 
-  handle = GNUNET_new (struct GNUNET_GNS_Handle);
+  handle = GNUNET_new(struct GNUNET_GNS_Handle);
   handle->cfg = cfg;
-  reconnect (handle);
+  reconnect(handle);
   if (NULL == handle->mq)
-  {
-    GNUNET_free (handle);
-    return NULL;
-  }
+    {
+      GNUNET_free(handle);
+      return NULL;
+    }
   return handle;
 }
 
@@ -282,20 +279,20 @@ GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param handle handle of the GNS connection to stop
  */
 void
-GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle)
+GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
 {
   if (NULL != handle->mq)
-  {
-    GNUNET_MQ_destroy (handle->mq);
-    handle->mq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(handle->mq);
+      handle->mq = NULL;
+    }
   if (NULL != handle->reconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
-    handle->reconnect_task = NULL;
-  }
-  GNUNET_assert (NULL == handle->lookup_head);
-  GNUNET_free (handle);
+    {
+      GNUNET_SCHEDULER_cancel(handle->reconnect_task);
+      handle->reconnect_task = NULL;
+    }
+  GNUNET_assert(NULL == handle->lookup_head);
+  GNUNET_free(handle);
 }
 
 
@@ -306,17 +303,17 @@ GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle)
  * @return closure from the lookup result processor
  */
 void *
-GNUNET_GNS_lookup_cancel (struct GNUNET_GNS_LookupRequest *lr)
+GNUNET_GNS_lookup_cancel(struct GNUNET_GNS_LookupRequest *lr)
 {
   struct GNUNET_GNS_Handle *handle = lr->gns_handle;
   void *ret;
 
-  GNUNET_CONTAINER_DLL_remove (handle->lookup_head,
-                               handle->lookup_tail,
-                               lr);
-  GNUNET_MQ_discard (lr->env);
+  GNUNET_CONTAINER_DLL_remove(handle->lookup_head,
+                              handle->lookup_tail,
+                              lr);
+  GNUNET_MQ_discard(lr->env);
   ret = lr->proc_cls;
-  GNUNET_free (lr);
+  GNUNET_free(lr);
   return ret;
 }
 
@@ -334,13 +331,13 @@ GNUNET_GNS_lookup_cancel (struct GNUNET_GNS_LookupRequest *lr)
  * @return handle to the get request
  */
 struct GNUNET_GNS_LookupRequest*
-GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
-                   const char *name,
-                   const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
-                   uint32_t type,
-                   enum GNUNET_GNS_LocalOptions options,
-                   GNUNET_GNS_LookupResultProcessor proc,
-                   void *proc_cls)
+GNUNET_GNS_lookup(struct GNUNET_GNS_Handle *handle,
+                  const char *name,
+                  const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
+                  uint32_t type,
+                  enum GNUNET_GNS_LocalOptions options,
+                  GNUNET_GNS_LookupResultProcessor proc,
+                  void *proc_cls)
 {
   /* IPC to shorten gns names, return shorten_handle */
   struct LookupMessage *lookup_msg;
@@ -348,40 +345,40 @@ GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle,
   size_t nlen;
 
   if (NULL == name)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Trying to lookup `%s' in GNS\n",
-       name);
-  nlen = strlen (name) + 1;
-  if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*lr))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  lr = GNUNET_new (struct GNUNET_GNS_LookupRequest);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to lookup `%s' in GNS\n",
+      name);
+  nlen = strlen(name) + 1;
+  if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*lr))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  lr = GNUNET_new(struct GNUNET_GNS_LookupRequest);
   lr->gns_handle = handle;
   lr->lookup_proc = proc;
   lr->proc_cls = proc_cls;
   lr->r_id = handle->r_id_gen++;
-  lr->env = GNUNET_MQ_msg_extra (lookup_msg,
-                                 nlen,
-                                 GNUNET_MESSAGE_TYPE_GNS_LOOKUP);
-  lookup_msg->id = htonl (lr->r_id);
-  lookup_msg->options = htons ((uint16_t) options);
+  lr->env = GNUNET_MQ_msg_extra(lookup_msg,
+                                nlen,
+                                GNUNET_MESSAGE_TYPE_GNS_LOOKUP);
+  lookup_msg->id = htonl(lr->r_id);
+  lookup_msg->options = htons((uint16_t)options);
   lookup_msg->zone = *zone;
-  lookup_msg->type = htonl (type);
-  GNUNET_memcpy (&lookup_msg[1],
-                 name,
-                 nlen);
-  GNUNET_CONTAINER_DLL_insert (handle->lookup_head,
-                               handle->lookup_tail,
-                               lr);
+  lookup_msg->type = htonl(type);
+  GNUNET_memcpy(&lookup_msg[1],
+                name,
+                nlen);
+  GNUNET_CONTAINER_DLL_insert(handle->lookup_head,
+                              handle->lookup_tail,
+                              lr);
   if (NULL != handle->mq)
-    GNUNET_MQ_send_copy (handle->mq,
-                         lr->env);
+    GNUNET_MQ_send_copy(handle->mq,
+                        lr->env);
   return lr;
 }
 
diff --git a/src/gns/gns_api.h b/src/gns/gns_api.h
index 40fdbfacd..7e07f909f 100644
--- a/src/gns/gns_api.h
+++ b/src/gns/gns_api.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gns_api.h
  * @brief shared data structures of libgnunetgns
@@ -32,9 +32,7 @@
 /**
  * Connection to the GNS service.
  */
-struct GNUNET_GNS_Handle
-{
-
+struct GNUNET_GNS_Handle {
   /**
    * Configuration to use.
    */
@@ -69,7 +67,6 @@ struct GNUNET_GNS_Handle
    * Request Id generator.  Incremented by one for each request.
    */
   uint32_t r_id_gen;
-
 };
 
 
diff --git a/src/gns/gns_tld_api.c b/src/gns/gns_tld_api.c
index f36b31acf..0692199e3 100644
--- a/src/gns/gns_tld_api.c
+++ b/src/gns/gns_tld_api.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gns_tld_api.c
  * @brief library to access the GNS service, including TLD lookup
@@ -35,15 +35,13 @@
 #include "gns_api.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "gns-tld-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "gns-tld-api", __VA_ARGS__)
 
 
 /**
  * Handle to a lookup request
  */
-struct GNUNET_GNS_LookupWithTldRequest
-{
-
+struct GNUNET_GNS_LookupWithTldRequest {
   /**
    * handle to gns
    */
@@ -105,11 +103,11 @@ struct GNUNET_GNS_LookupWithTldRequest
  *         or @a name if @a name does not contain a "."
  */
 static const char *
-get_tld (const char *name)
+get_tld(const char *name)
 {
   const char *tld;
 
-  tld = strrchr (name, (unsigned char) '.');
+  tld = strrchr(name, (unsigned char)'.');
   if (NULL == tld)
     tld = name;
   else
@@ -125,18 +123,18 @@ get_tld (const char *name)
  * @param tld what to eat (can be more than just the tld)
  */
 static void
-eat_tld (char *name, const char *tld)
+eat_tld(char *name, const char *tld)
 {
-  GNUNET_assert (0 < strlen (name));
-  if ((NULL == tld) || (strlen (name) == strlen (tld)))
-  {
-    strcpy (name, GNUNET_GNS_EMPTY_LABEL_AT);
-  }
+  GNUNET_assert(0 < strlen(name));
+  if ((NULL == tld) || (strlen(name) == strlen(tld)))
+    {
+      strcpy(name, GNUNET_GNS_EMPTY_LABEL_AT);
+    }
   else
-  {
-    GNUNET_assert (strlen (tld) < strlen (name));
-    name[strlen (name) - strlen (tld) - 1] = '\0';
-  }
+    {
+      GNUNET_assert(strlen(tld) < strlen(name));
+      name[strlen(name) - strlen(tld) - 1] = '\0';
+    }
 }
 
 
@@ -148,15 +146,15 @@ eat_tld (char *name, const char *tld)
  * @param rd array of @a rd_count records with the results
  */
 static void
-process_lookup_result (void *cls,
-                       uint32_t rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+process_lookup_result(void *cls,
+                      uint32_t rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNS_LookupWithTldRequest *ltr = cls;
 
   ltr->lr = NULL;
-  ltr->lookup_proc (ltr->lookup_proc_cls, GNUNET_YES, rd_count, rd);
-  GNUNET_GNS_lookup_with_tld_cancel (ltr);
+  ltr->lookup_proc(ltr->lookup_proc_cls, GNUNET_YES, rd_count, rd);
+  GNUNET_GNS_lookup_with_tld_cancel(ltr);
 }
 
 
@@ -167,16 +165,16 @@ process_lookup_result (void *cls,
  * @param pkey public key to use for the zone, can be NULL
  */
 static void
-lookup_with_public_key (struct GNUNET_GNS_LookupWithTldRequest *ltr,
-                        const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
+lookup_with_public_key(struct GNUNET_GNS_LookupWithTldRequest *ltr,
+                       const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 {
-  ltr->lr = GNUNET_GNS_lookup (ltr->gns_handle,
-                               ltr->name,
-                               pkey,
-                               ltr->type,
-                               ltr->options,
-                               &process_lookup_result,
-                               ltr);
+  ltr->lr = GNUNET_GNS_lookup(ltr->gns_handle,
+                              ltr->name,
+                              pkey,
+                              ltr->type,
+                              ltr->options,
+                              &process_lookup_result,
+                              ltr);
 }
 
 
@@ -190,38 +188,38 @@ lookup_with_public_key (struct GNUNET_GNS_LookupWithTldRequest *ltr,
  * @param name name of the ego
  */
 static void
-identity_zone_cb (void *cls,
-                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
-                  const char *ego_name)
+identity_zone_cb(void *cls,
+                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
+                 const char *ego_name)
 {
   struct GNUNET_GNS_LookupWithTldRequest *ltr = cls;
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 
   ltr->id_co = NULL;
   if (NULL == priv)
-  {
-    /* no matching ego found */
-    ltr->lookup_proc (ltr->lookup_proc_cls, GNUNET_NO, 0, NULL);
-    return;
-  }
+    {
+      /* no matching ego found */
+      ltr->lookup_proc(ltr->lookup_proc_cls, GNUNET_NO, 0, NULL);
+      return;
+    }
   /* Final case: TLD matches one of our egos */
-  if (0 == strcmp (ltr->name, ego_name))
-  {
-    /* name matches ego name perfectly, only "@" remains */
-    strcpy (ltr->name, GNUNET_GNS_EMPTY_LABEL_AT);
-  }
+  if (0 == strcmp(ltr->name, ego_name))
+    {
+      /* name matches ego name perfectly, only "@" remains */
+      strcpy(ltr->name, GNUNET_GNS_EMPTY_LABEL_AT);
+    }
   else
-  {
-    GNUNET_assert (strlen (ego_name) < strlen (ltr->name));
-    ltr->name[strlen (ltr->name) - strlen (ego_name) - 1] = '\0';
-  }
+    {
+      GNUNET_assert(strlen(ego_name) < strlen(ltr->name));
+      ltr->name[strlen(ltr->name) - strlen(ego_name) - 1] = '\0';
+    }
   /* if the name is of the form 'label' (and not 'label.SUBDOMAIN'), never go to the DHT */
-  if (NULL == strchr (ltr->name, (unsigned char) '.'))
+  if (NULL == strchr(ltr->name, (unsigned char)'.'))
     ltr->options = GNUNET_GNS_LO_NO_DHT;
   else
     ltr->options = GNUNET_GNS_LO_LOCAL_MASTER;
-  GNUNET_CRYPTO_ecdsa_key_get_public (priv, &pkey);
-  lookup_with_public_key (ltr, &pkey);
+  GNUNET_CRYPTO_ecdsa_key_get_public(priv, &pkey);
+  lookup_with_public_key(ltr, &pkey);
 }
 
 
@@ -239,12 +237,12 @@ identity_zone_cb (void *cls,
  * @return handle to the get request, NULL on error (i.e. bad configuration)
  */
 struct GNUNET_GNS_LookupWithTldRequest *
-GNUNET_GNS_lookup_with_tld (struct GNUNET_GNS_Handle *handle,
-                            const char *name,
-                            uint32_t type,
-                            enum GNUNET_GNS_LocalOptions options,
-                            GNUNET_GNS_LookupResultProcessor2 proc,
-                            void *proc_cls)
+GNUNET_GNS_lookup_with_tld(struct GNUNET_GNS_Handle *handle,
+                           const char *name,
+                           uint32_t type,
+                           enum GNUNET_GNS_LocalOptions options,
+                           GNUNET_GNS_LookupResultProcessor2 proc,
+                           void *proc_cls)
 {
   struct GNUNET_GNS_LookupWithTldRequest *ltr;
   const char *tld;
@@ -252,70 +250,70 @@ GNUNET_GNS_lookup_with_tld (struct GNUNET_GNS_Handle *handle,
   char *zonestr;
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 
-  ltr = GNUNET_new (struct GNUNET_GNS_LookupWithTldRequest);
+  ltr = GNUNET_new(struct GNUNET_GNS_LookupWithTldRequest);
   ltr->gns_handle = handle;
-  ltr->name = GNUNET_strdup (name);
+  ltr->name = GNUNET_strdup(name);
   ltr->type = type;
   ltr->options = options;
   ltr->lookup_proc = proc;
   ltr->lookup_proc_cls = proc_cls;
   /* start with trivial case: TLD is zkey */
-  tld = get_tld (ltr->name);
+  tld = get_tld(ltr->name);
   if (GNUNET_OK ==
-      GNUNET_CRYPTO_ecdsa_public_key_from_string (tld, strlen (tld), &pkey))
-  {
-    eat_tld (ltr->name, tld);
-    lookup_with_public_key (ltr, &pkey);
-    return ltr;
-  }
+      GNUNET_CRYPTO_ecdsa_public_key_from_string(tld, strlen(tld), &pkey))
+    {
+      eat_tld(ltr->name, tld);
+      lookup_with_public_key(ltr, &pkey);
+      return ltr;
+    }
 
   /* second case: domain is mapped in our configuration file */
   for (const char *domain = name; NULL != domain;
-       domain = strchr (domain, (unsigned char) '.'))
-  {
-    if ('.' == domain[0])
-      domain++;
-    GNUNET_asprintf (&dot_tld, ".%s", domain);
-    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (handle->cfg,
-                                                            "gns",
-                                                            dot_tld,
-                                                            &zonestr))
+       domain = strchr(domain, (unsigned char)'.'))
     {
-      if (GNUNET_OK !=
-          GNUNET_CRYPTO_ecdsa_public_key_from_string (zonestr,
-                                                      strlen (zonestr),
-                                                      &pkey))
-      {
-        GNUNET_log_config_invalid (
-          GNUNET_ERROR_TYPE_ERROR,
-          "gns",
-          dot_tld,
-          _ ("Expected a base32-encoded public zone key\n"));
-        GNUNET_free (zonestr);
-        GNUNET_free (dot_tld);
-        GNUNET_free (ltr->name);
-        GNUNET_free (ltr);
-        return NULL;
-      }
-      eat_tld (ltr->name, &dot_tld[1]);
-      GNUNET_free (zonestr);
-      GNUNET_free (dot_tld);
-      lookup_with_public_key (ltr, &pkey);
-      return ltr;
+      if ('.' == domain[0])
+        domain++;
+      GNUNET_asprintf(&dot_tld, ".%s", domain);
+      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(handle->cfg,
+                                                             "gns",
+                                                             dot_tld,
+                                                             &zonestr))
+        {
+          if (GNUNET_OK !=
+              GNUNET_CRYPTO_ecdsa_public_key_from_string(zonestr,
+                                                         strlen(zonestr),
+                                                         &pkey))
+            {
+              GNUNET_log_config_invalid(
+                GNUNET_ERROR_TYPE_ERROR,
+                "gns",
+                dot_tld,
+                _("Expected a base32-encoded public zone key\n"));
+              GNUNET_free(zonestr);
+              GNUNET_free(dot_tld);
+              GNUNET_free(ltr->name);
+              GNUNET_free(ltr);
+              return NULL;
+            }
+          eat_tld(ltr->name, &dot_tld[1]);
+          GNUNET_free(zonestr);
+          GNUNET_free(dot_tld);
+          lookup_with_public_key(ltr, &pkey);
+          return ltr;
+        }
+      GNUNET_free(dot_tld);
     }
-    GNUNET_free (dot_tld);
-  }
   ltr->id_co =
-    GNUNET_IDENTITY_ego_lookup_by_suffix (ltr->gns_handle->cfg,
-                                          ltr->name,
-                                          &identity_zone_cb,
-                                          ltr);
+    GNUNET_IDENTITY_ego_lookup_by_suffix(ltr->gns_handle->cfg,
+                                         ltr->name,
+                                         &identity_zone_cb,
+                                         ltr);
   if (NULL == ltr->id_co)
-  {
-    GNUNET_free (ltr->name);
-    GNUNET_free (ltr);
-    return NULL;
-  }
+    {
+      GNUNET_free(ltr->name);
+      GNUNET_free(ltr);
+      return NULL;
+    }
   return ltr;
 }
 
@@ -327,23 +325,23 @@ GNUNET_GNS_lookup_with_tld (struct GNUNET_GNS_Handle *handle,
  * @return closure from the lookup result processor
  */
 void *
-GNUNET_GNS_lookup_with_tld_cancel (struct GNUNET_GNS_LookupWithTldRequest *ltr)
+GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
 {
   void *ret = ltr->lookup_proc_cls;
 
   if (NULL != ltr->id_co)
-  {
-    GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (ltr->id_co);
-    ltr->id_co = NULL;
-  }
+    {
+      GNUNET_IDENTITY_ego_lookup_by_suffix_cancel(ltr->id_co);
+      ltr->id_co = NULL;
+    }
   if (NULL != ltr->lr)
-  {
-    GNUNET_GNS_lookup_cancel (ltr->lr);
-    ltr->lr = NULL;
-  }
-  GNUNET_free_non_null (ltr->longest_match);
-  GNUNET_free (ltr->name);
-  GNUNET_free (ltr);
+    {
+      GNUNET_GNS_lookup_cancel(ltr->lr);
+      ltr->lr = NULL;
+    }
+  GNUNET_free_non_null(ltr->longest_match);
+  GNUNET_free(ltr->name);
+  GNUNET_free(ltr);
   return ret;
 }
 
diff --git a/src/gns/gnunet-bcd.c b/src/gns/gnunet-bcd.c
index 368afbbf5..181c30d8d 100644
--- a/src/gns/gnunet-bcd.c
+++ b/src/gns/gnunet-bcd.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file gns/gnunet-bcd.c
@@ -81,8 +81,7 @@ static char *resfile;
 static uint16_t port = 8888;
 
 
-struct Entry
-{
+struct Entry {
   const char *formname;
   const char *texname;
 };
@@ -92,175 +91,175 @@ struct Entry
  * Main request handler.
  */
 static int
-access_handler_callback (void *cls,
-                         struct MHD_Connection *connection,
-                         const char *url,
-                         const char *method,
-                         const char *version,
-                         const char *upload_data,
-                         size_t *upload_data_size,
-                         void **con_cls)
+access_handler_callback(void *cls,
+                        struct MHD_Connection *connection,
+                        const char *url,
+                        const char *method,
+                        const char *version,
+                        const char *upload_data,
+                        size_t *upload_data_size,
+                        void **con_cls)
 {
   static int dummy;
-  static const struct Entry map[] = {{"prefix", "prefix"},
-                                     {"name", "name"},
-                                     {"suffix", "suffix"},
-                                     {"street", "street"},
-                                     {"city", "city"},
-                                     {"phone", "phone"},
-                                     {"fax", "fax"},
-                                     {"email", "email"},
-                                     {"homepage", "homepage"},
-                                     {"orga", "orga"},
-                                     {"departmenti18n", "departmentde"},
-                                     {"departmenten", "departmenten"},
-                                     {"subdepartmenti18n", "subdepartmentde"},
-                                     {"subdepartmenten", "subdepartmenten"},
-                                     {"jobtitlei18n", "jobtitlegerman"},
-                                     {"jobtitleen", "jobtitleenglish"},
-                                     {"subdepartmenten", "subdepartmenten"},
-                                     {NULL, NULL}};
-
-  (void) cls;
-  (void) version;
-  (void) upload_data;
-  (void) upload_data_size;
-  if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Refusing `%s' request to HTTP server\n"),
-                method);
-    return MHD_NO;
-  }
-  if (NULL == *con_cls)
-  {
-    (*con_cls) = &dummy;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending 100 CONTINUE reply\n");
-    return MHD_YES; /* send 100 continue */
-  }
-  if (0 == strcasecmp (url, "/"))
-    return MHD_queue_response (connection, MHD_HTTP_OK, main_response);
-  if (0 == strcasecmp (url, "/submit.pdf"))
-  {
-    unsigned int i;
-    char *p;
-    char *tmp;
-    char *deffile;
-    struct GNUNET_CRYPTO_EcdsaPublicKey pub;
-    size_t slen;
-    FILE *f;
-    struct stat st;
-    struct MHD_Response *response;
-    int fd;
-    int ret;
-
-    const char *gpg_fp = MHD_lookup_connection_value (connection,
-                                                      MHD_GET_ARGUMENT_KIND,
-                                                      "gpgfingerprint");
-    const char *gns_nick = MHD_lookup_connection_value (connection,
-                                                        MHD_GET_ARGUMENT_KIND,
-                                                        "gnsnick");
-    const char *gnskey =
-      MHD_lookup_connection_value (connection, MHD_GET_ARGUMENT_KIND, "gnskey");
-    if ((NULL == gnskey) ||
-        (GNUNET_OK !=
-         GNUNET_CRYPTO_ecdsa_public_key_from_string (gnskey,
-                                                     strlen (gnskey),
-                                                     &pub)))
-    {
-      return MHD_queue_response (connection,
-                                 MHD_HTTP_OK,
-                                 invalid_gnskey_response);
-    }
-    tmp = GNUNET_DISK_mkdtemp (gnskey);
-    if (NULL == tmp)
-    {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mktemp", gnskey);
-      return MHD_NO;
-    }
-    GNUNET_asprintf (&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "def.tex");
-    f = fopen (deffile, "w");
-    if (NULL == f)
+  static const struct Entry map[] = { { "prefix", "prefix" },
+                                      { "name", "name" },
+                                      { "suffix", "suffix" },
+                                      { "street", "street" },
+                                      { "city", "city" },
+                                      { "phone", "phone" },
+                                      { "fax", "fax" },
+                                      { "email", "email" },
+                                      { "homepage", "homepage" },
+                                      { "orga", "orga" },
+                                      { "departmenti18n", "departmentde" },
+                                      { "departmenten", "departmenten" },
+                                      { "subdepartmenti18n", "subdepartmentde" },
+                                      { "subdepartmenten", "subdepartmenten" },
+                                      { "jobtitlei18n", "jobtitlegerman" },
+                                      { "jobtitleen", "jobtitleenglish" },
+                                      { "subdepartmenten", "subdepartmenten" },
+                                      { NULL, NULL } };
+
+  (void)cls;
+  (void)version;
+  (void)upload_data;
+  (void)upload_data_size;
+  if (0 != strcmp(method, MHD_HTTP_METHOD_GET))
     {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", deffile);
-      GNUNET_free (deffile);
-      GNUNET_DISK_directory_remove (tmp);
-      GNUNET_free (tmp);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Refusing `%s' request to HTTP server\n"),
+                 method);
       return MHD_NO;
     }
-    for (i = 0; NULL != map[i].formname; i++)
-    {
-      const char *val = MHD_lookup_connection_value (connection,
-                                                     MHD_GET_ARGUMENT_KIND,
-                                                     map[i].formname);
-      if (NULL != val)
-        fprintf (f, "\\def\\%s{%s}\n", map[i].texname, val);
-      else
-        fprintf (f, "\\def\\%s{}\n", map[i].texname);
-    }
-    if (NULL != gpg_fp)
-    {
-      char *gpg1;
-      char *gpg2;
-
-      slen = strlen (gpg_fp);
-      gpg1 = GNUNET_strndup (gpg_fp, slen / 2);
-      gpg2 = GNUNET_strdup (&gpg_fp[slen / 2]);
-      fprintf (f, "\\def\\gpglineone{%s}\n\\def\\gpglinetwo{%s}\n", gpg1, gpg2);
-      GNUNET_free (gpg2);
-      GNUNET_free (gpg1);
-    }
-    fprintf (f,
-             "\\def\\gns{%s/%s}\n",
-             gnskey,
-             (NULL == gns_nick) ? "" : gns_nick);
-    fclose (f);
-    GNUNET_asprintf (
-      &p,
-      "cd %s; cp %s gns-bcd.tex | pdflatex --enable-write18 gns-bcd.tex > /dev/null 2> /dev/null",
-      tmp,
-      resfile);
-    GNUNET_free (deffile);
-    ret = system (p);
-    if (WIFSIGNALED (ret) || (0 != WEXITSTATUS (ret)))
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "system", p);
-    GNUNET_asprintf (&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "gns-bcd.pdf");
-    fd = open (deffile, O_RDONLY);
-    if (-1 == fd)
+  if (NULL == *con_cls)
     {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", deffile);
-      GNUNET_free (deffile);
-      GNUNET_free (p);
-      GNUNET_DISK_directory_remove (tmp);
-      GNUNET_free (tmp);
-      return MHD_NO;
+      (*con_cls) = &dummy;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending 100 CONTINUE reply\n");
+      return MHD_YES; /* send 100 continue */
     }
-    GNUNET_break (0 == STAT (deffile, &st));
-    if (NULL ==
-        (response = MHD_create_response_from_fd ((size_t) st.st_size, fd)))
+  if (0 == strcasecmp(url, "/"))
+    return MHD_queue_response(connection, MHD_HTTP_OK, main_response);
+  if (0 == strcasecmp(url, "/submit.pdf"))
     {
-      GNUNET_break (0);
-      GNUNET_break (0 == CLOSE (fd));
-      GNUNET_free (deffile);
-      GNUNET_free (p);
-      GNUNET_DISK_directory_remove (tmp);
-      GNUNET_free (tmp);
-      return MHD_NO;
-    }
-    (void) MHD_add_response_header (response,
+      unsigned int i;
+      char *p;
+      char *tmp;
+      char *deffile;
+      struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+      size_t slen;
+      FILE *f;
+      struct stat st;
+      struct MHD_Response *response;
+      int fd;
+      int ret;
+
+      const char *gpg_fp = MHD_lookup_connection_value(connection,
+                                                       MHD_GET_ARGUMENT_KIND,
+                                                       "gpgfingerprint");
+      const char *gns_nick = MHD_lookup_connection_value(connection,
+                                                         MHD_GET_ARGUMENT_KIND,
+                                                         "gnsnick");
+      const char *gnskey =
+        MHD_lookup_connection_value(connection, MHD_GET_ARGUMENT_KIND, "gnskey");
+      if ((NULL == gnskey) ||
+          (GNUNET_OK !=
+           GNUNET_CRYPTO_ecdsa_public_key_from_string(gnskey,
+                                                      strlen(gnskey),
+                                                      &pub)))
+        {
+          return MHD_queue_response(connection,
+                                    MHD_HTTP_OK,
+                                    invalid_gnskey_response);
+        }
+      tmp = GNUNET_DISK_mkdtemp(gnskey);
+      if (NULL == tmp)
+        {
+          GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mktemp", gnskey);
+          return MHD_NO;
+        }
+      GNUNET_asprintf(&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "def.tex");
+      f = fopen(deffile, "w");
+      if (NULL == f)
+        {
+          GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", deffile);
+          GNUNET_free(deffile);
+          GNUNET_DISK_directory_remove(tmp);
+          GNUNET_free(tmp);
+          return MHD_NO;
+        }
+      for (i = 0; NULL != map[i].formname; i++)
+        {
+          const char *val = MHD_lookup_connection_value(connection,
+                                                        MHD_GET_ARGUMENT_KIND,
+                                                        map[i].formname);
+          if (NULL != val)
+            fprintf(f, "\\def\\%s{%s}\n", map[i].texname, val);
+          else
+            fprintf(f, "\\def\\%s{}\n", map[i].texname);
+        }
+      if (NULL != gpg_fp)
+        {
+          char *gpg1;
+          char *gpg2;
+
+          slen = strlen(gpg_fp);
+          gpg1 = GNUNET_strndup(gpg_fp, slen / 2);
+          gpg2 = GNUNET_strdup(&gpg_fp[slen / 2]);
+          fprintf(f, "\\def\\gpglineone{%s}\n\\def\\gpglinetwo{%s}\n", gpg1, gpg2);
+          GNUNET_free(gpg2);
+          GNUNET_free(gpg1);
+        }
+      fprintf(f,
+              "\\def\\gns{%s/%s}\n",
+              gnskey,
+              (NULL == gns_nick) ? "" : gns_nick);
+      fclose(f);
+      GNUNET_asprintf(
+        &p,
+        "cd %s; cp %s gns-bcd.tex | pdflatex --enable-write18 gns-bcd.tex > /dev/null 2> /dev/null",
+        tmp,
+        resfile);
+      GNUNET_free(deffile);
+      ret = system(p);
+      if (WIFSIGNALED(ret) || (0 != WEXITSTATUS(ret)))
+        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "system", p);
+      GNUNET_asprintf(&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "gns-bcd.pdf");
+      fd = open(deffile, O_RDONLY);
+      if (-1 == fd)
+        {
+          GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", deffile);
+          GNUNET_free(deffile);
+          GNUNET_free(p);
+          GNUNET_DISK_directory_remove(tmp);
+          GNUNET_free(tmp);
+          return MHD_NO;
+        }
+      GNUNET_break(0 == STAT(deffile, &st));
+      if (NULL ==
+          (response = MHD_create_response_from_fd((size_t)st.st_size, fd)))
+        {
+          GNUNET_break(0);
+          GNUNET_break(0 == CLOSE(fd));
+          GNUNET_free(deffile);
+          GNUNET_free(p);
+          GNUNET_DISK_directory_remove(tmp);
+          GNUNET_free(tmp);
+          return MHD_NO;
+        }
+      (void)MHD_add_response_header(response,
                                     MHD_HTTP_HEADER_CONTENT_TYPE,
                                     "application/pdf");
-    ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
-    MHD_destroy_response (response);
-    GNUNET_free (deffile);
-    GNUNET_free (p);
-    GNUNET_DISK_directory_remove (tmp);
-    GNUNET_free (tmp);
-    return ret;
-  }
-  return MHD_queue_response (connection,
-                             MHD_HTTP_NOT_FOUND,
-                             not_found_response);
+      ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
+      MHD_destroy_response(response);
+      GNUNET_free(deffile);
+      GNUNET_free(p);
+      GNUNET_DISK_directory_remove(tmp);
+      GNUNET_free(tmp);
+      return ret;
+    }
+  return MHD_queue_response(connection,
+                            MHD_HTTP_NOT_FOUND,
+                            not_found_response);
 }
 
 
@@ -269,7 +268,7 @@ access_handler_callback (void *cls,
  * starts the task waiting for them.
  */
 static struct GNUNET_SCHEDULER_Task *
-prepare_daemon (struct MHD_Daemon *daemon_handle);
+prepare_daemon(struct MHD_Daemon *daemon_handle);
 
 
 /**
@@ -277,13 +276,13 @@ prepare_daemon (struct MHD_Daemon *daemon_handle);
  * and schedule the next run.
  */
 static void
-run_daemon (void *cls)
+run_daemon(void *cls)
 {
   struct MHD_Daemon *daemon_handle = cls;
 
   http_task = NULL;
-  GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
-  http_task = prepare_daemon (daemon_handle);
+  GNUNET_assert(MHD_YES == MHD_run(daemon_handle));
+  http_task = prepare_daemon(daemon_handle);
 }
 
 
@@ -292,7 +291,7 @@ run_daemon (void *cls)
  * starts the task waiting for them.
  */
 static struct GNUNET_SCHEDULER_Task *
-prepare_daemon (struct MHD_Daemon *daemon_handle)
+prepare_daemon(struct MHD_Daemon *daemon_handle)
 {
   struct GNUNET_SCHEDULER_Task *ret;
   fd_set rs;
@@ -305,28 +304,28 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
   int haveto;
   struct GNUNET_TIME_Relative tv;
 
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
-  wrs = GNUNET_NETWORK_fdset_create ();
-  wws = GNUNET_NETWORK_fdset_create ();
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
+  wrs = GNUNET_NETWORK_fdset_create();
+  wws = GNUNET_NETWORK_fdset_create();
   max = -1;
-  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
-  haveto = MHD_get_timeout (daemon_handle, &timeout);
+  GNUNET_assert(MHD_YES == MHD_get_fdset(daemon_handle, &rs, &ws, &es, &max));
+  haveto = MHD_get_timeout(daemon_handle, &timeout);
   if (haveto == MHD_YES)
-    tv.rel_value_us = (uint64_t) timeout * 1000LL;
+    tv.rel_value_us = (uint64_t)timeout * 1000LL;
   else
     tv = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
-  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
-  ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                     tv,
-                                     wrs,
-                                     wws,
-                                     &run_daemon,
-                                     daemon_handle);
-  GNUNET_NETWORK_fdset_destroy (wrs);
-  GNUNET_NETWORK_fdset_destroy (wws);
+  GNUNET_NETWORK_fdset_copy_native(wrs, &rs, max + 1);
+  GNUNET_NETWORK_fdset_copy_native(wws, &ws, max + 1);
+  ret = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                    tv,
+                                    wrs,
+                                    wws,
+                                    &run_daemon,
+                                    daemon_handle);
+  GNUNET_NETWORK_fdset_destroy(wrs);
+  GNUNET_NETWORK_fdset_destroy(wws);
   return ret;
 }
 
@@ -337,41 +336,41 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
  * @return #GNUNET_OK on success
  */
 static int
-server_start ()
+server_start()
 {
   if (0 == port)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Invalid port number %u.  Exiting.\n"),
-                port);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _ ("Businesscard HTTP server starts on %u\n"),
-              port);
-  daemon_handle = MHD_start_daemon (MHD_USE_DUAL_STACK | MHD_USE_DEBUG,
-                                    port,
-                                    NULL /* accept_policy_callback */,
-                                    NULL,
-                                    &access_handler_callback,
-                                    NULL,
-                                    MHD_OPTION_CONNECTION_LIMIT,
-                                    (unsigned int) 512,
-                                    MHD_OPTION_PER_IP_CONNECTION_LIMIT,
-                                    (unsigned int) 2,
-                                    MHD_OPTION_CONNECTION_TIMEOUT,
-                                    (unsigned int) 60,
-                                    MHD_OPTION_CONNECTION_MEMORY_LIMIT,
-                                    (size_t) (16 * 1024),
-                                    MHD_OPTION_END);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Invalid port number %u.  Exiting.\n"),
+                 port);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             _("Businesscard HTTP server starts on %u\n"),
+             port);
+  daemon_handle = MHD_start_daemon(MHD_USE_DUAL_STACK | MHD_USE_DEBUG,
+                                   port,
+                                   NULL /* accept_policy_callback */,
+                                   NULL,
+                                   &access_handler_callback,
+                                   NULL,
+                                   MHD_OPTION_CONNECTION_LIMIT,
+                                   (unsigned int)512,
+                                   MHD_OPTION_PER_IP_CONNECTION_LIMIT,
+                                   (unsigned int)2,
+                                   MHD_OPTION_CONNECTION_TIMEOUT,
+                                   (unsigned int)60,
+                                   MHD_OPTION_CONNECTION_MEMORY_LIMIT,
+                                   (size_t)(16 * 1024),
+                                   MHD_OPTION_END);
   if (NULL == daemon_handle)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not start businesscard HTTP server on port %u\n"),
-                (unsigned int) port);
-    return GNUNET_SYSERR;
-  }
-  http_task = prepare_daemon (daemon_handle);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not start businesscard HTTP server on port %u\n"),
+                 (unsigned int)port);
+      return GNUNET_SYSERR;
+    }
+  http_task = prepare_daemon(daemon_handle);
   return GNUNET_OK;
 }
 
@@ -380,40 +379,40 @@ server_start ()
  * Stop HTTP server.
  */
 static void
-server_stop (void *cls)
+server_stop(void *cls)
 {
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "HTTP server shutdown\n");
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "HTTP server shutdown\n");
   if (NULL != http_task)
-  {
-    GNUNET_SCHEDULER_cancel (http_task);
-    http_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(http_task);
+      http_task = NULL;
+    }
   if (NULL != daemon_handle)
-  {
-    MHD_stop_daemon (daemon_handle);
-    daemon_handle = NULL;
-  }
+    {
+      MHD_stop_daemon(daemon_handle);
+      daemon_handle = NULL;
+    }
   if (NULL != main_response)
-  {
-    MHD_destroy_response (main_response);
-    main_response = NULL;
-  }
+    {
+      MHD_destroy_response(main_response);
+      main_response = NULL;
+    }
   if (NULL != invalid_gnskey_response)
-  {
-    MHD_destroy_response (invalid_gnskey_response);
-    invalid_gnskey_response = NULL;
-  }
+    {
+      MHD_destroy_response(invalid_gnskey_response);
+      invalid_gnskey_response = NULL;
+    }
   if (NULL != not_found_response)
-  {
-    MHD_destroy_response (not_found_response);
-    not_found_response = NULL;
-  }
+    {
+      MHD_destroy_response(not_found_response);
+      not_found_response = NULL;
+    }
   if (NULL != resfile)
-  {
-    GNUNET_free (resfile);
-    resfile = NULL;
-  }
+    {
+      GNUNET_free(resfile);
+      resfile = NULL;
+    }
 }
 
 
@@ -426,66 +425,66 @@ server_stop (void *cls)
  * @param c configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct stat st;
   char *dir;
   char *fn;
   int fd;
 
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
   cfg = c;
-  dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
-  GNUNET_assert (NULL != dir);
-  GNUNET_asprintf (&fn, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.html");
-  GNUNET_asprintf (&resfile, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.tex");
-  GNUNET_free (dir);
-  fd = open (fn, O_RDONLY);
+  dir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
+  GNUNET_assert(NULL != dir);
+  GNUNET_asprintf(&fn, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.html");
+  GNUNET_asprintf(&resfile, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.tex");
+  GNUNET_free(dir);
+  fd = open(fn, O_RDONLY);
   if (-1 == fd)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
-    GNUNET_free (fn);
-    return;
-  }
-  if (0 != STAT (fn, &st))
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
-    GNUNET_free (fn);
-    GNUNET_break (0 == CLOSE (fd));
-    return;
-  }
-  GNUNET_free (fn);
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", fn);
+      GNUNET_free(fn);
+      return;
+    }
+  if (0 != STAT(fn, &st))
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", fn);
+      GNUNET_free(fn);
+      GNUNET_break(0 == CLOSE(fd));
+      return;
+    }
+  GNUNET_free(fn);
   if (NULL ==
-      (main_response = MHD_create_response_from_fd ((size_t) st.st_size, fd)))
-  {
-    GNUNET_break (0);
-    GNUNET_break (0 == CLOSE (fd));
-    return;
-  }
-  (void) MHD_add_response_header (main_response,
-                                  MHD_HTTP_HEADER_CONTENT_TYPE,
-                                  "text/html");
+      (main_response = MHD_create_response_from_fd((size_t)st.st_size, fd)))
+    {
+      GNUNET_break(0);
+      GNUNET_break(0 == CLOSE(fd));
+      return;
+    }
+  (void)MHD_add_response_header(main_response,
+                                MHD_HTTP_HEADER_CONTENT_TYPE,
+                                "text/html");
   invalid_gnskey_response =
-    MHD_create_response_from_buffer (strlen (INVALID_GNSKEY),
-                                     INVALID_GNSKEY,
-                                     MHD_RESPMEM_PERSISTENT);
-  (void) MHD_add_response_header (invalid_gnskey_response,
-                                  MHD_HTTP_HEADER_CONTENT_TYPE,
-                                  "text/html");
-  not_found_response = MHD_create_response_from_buffer (strlen (NOT_FOUND),
-                                                        NOT_FOUND,
-                                                        MHD_RESPMEM_PERSISTENT);
-  (void) MHD_add_response_header (not_found_response,
-                                  MHD_HTTP_HEADER_CONTENT_TYPE,
-                                  "text/html");
-  if (GNUNET_OK != server_start ())
+    MHD_create_response_from_buffer(strlen(INVALID_GNSKEY),
+                                    INVALID_GNSKEY,
+                                    MHD_RESPMEM_PERSISTENT);
+  (void)MHD_add_response_header(invalid_gnskey_response,
+                                MHD_HTTP_HEADER_CONTENT_TYPE,
+                                "text/html");
+  not_found_response = MHD_create_response_from_buffer(strlen(NOT_FOUND),
+                                                       NOT_FOUND,
+                                                       MHD_RESPMEM_PERSISTENT);
+  (void)MHD_add_response_header(not_found_response,
+                                MHD_HTTP_HEADER_CONTENT_TYPE,
+                                "text/html");
+  if (GNUNET_OK != server_start())
     return;
-  GNUNET_SCHEDULER_add_shutdown (&server_stop, NULL);
+  GNUNET_SCHEDULER_add_shutdown(&server_stop, NULL);
 }
 
 
@@ -497,33 +496,33 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-
-    GNUNET_GETOPT_option_uint16 ('p',
-                                 "port",
-                                 "PORT",
-                                 gettext_noop (
-                                   "Run HTTP serve on port PORT (default is 8888)"),
-                                 &port),
-    GNUNET_GETOPT_OPTION_END};
+    GNUNET_GETOPT_option_uint16('p',
+                                "port",
+                                "PORT",
+                                gettext_noop(
+                                  "Run HTTP serve on port PORT (default is 8888)"),
+                                &port),
+    GNUNET_GETOPT_OPTION_END
+  };
   int ret;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
     return 2;
-  GNUNET_log_setup ("gnunet-bcd", "WARNING", NULL);
+  GNUNET_log_setup("gnunet-bcd", "WARNING", NULL);
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run (argc,
-                             argv,
-                             "gnunet-bcd",
-                             _ ("GNUnet HTTP server to create business cards"),
-                             options,
-                             &run,
-                             NULL))
-          ? 0
-          : 1;
-  GNUNET_free ((void *) argv);
+         GNUNET_PROGRAM_run(argc,
+                            argv,
+                            "gnunet-bcd",
+                            _("GNUnet HTTP server to create business cards"),
+                            options,
+                            &run,
+                            NULL))
+        ? 0
+        : 1;
+  GNUNET_free((void *)argv);
   return ret;
 }
 
diff --git a/src/gns/gnunet-dns2gns.c b/src/gns/gnunet-dns2gns.c
index d2eabf02c..4058aba99 100644
--- a/src/gns/gnunet-dns2gns.c
+++ b/src/gns/gnunet-dns2gns.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gnunet-dns2gns.c
  * @brief DNS server that translates DNS requests to GNS
@@ -37,8 +37,7 @@
 /**
  * Data kept per request.
  */
-struct Request
-{
+struct Request {
   /**
    * Socket to use for sending the reply.
    */
@@ -156,39 +155,39 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
  * @param cls unused
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != t4)
-  {
-    GNUNET_SCHEDULER_cancel (t4);
-    t4 = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(t4);
+      t4 = NULL;
+    }
   if (NULL != t6)
-  {
-    GNUNET_SCHEDULER_cancel (t6);
-    t6 = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(t6);
+      t6 = NULL;
+    }
   if (NULL != listen_socket4)
-  {
-    GNUNET_NETWORK_socket_close (listen_socket4);
-    listen_socket4 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(listen_socket4);
+      listen_socket4 = NULL;
+    }
   if (NULL != listen_socket6)
-  {
-    GNUNET_NETWORK_socket_close (listen_socket6);
-    listen_socket6 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(listen_socket6);
+      listen_socket6 = NULL;
+    }
   if (NULL != gns)
-  {
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+    }
   if (NULL != dns_stub)
-  {
-    GNUNET_DNSSTUB_stop (dns_stub);
-    dns_stub = NULL;
-  }
+    {
+      GNUNET_DNSSTUB_stop(dns_stub);
+      dns_stub = NULL;
+    }
 }
 
 
@@ -198,38 +197,38 @@ do_shutdown (void *cls)
  * @param request context for the request.
  */
 static void
-send_response (struct Request *request)
+send_response(struct Request *request)
 {
   char *buf;
   size_t size;
   ssize_t sret;
 
   if (GNUNET_SYSERR ==
-      GNUNET_DNSPARSER_pack (request->packet,
-                             UINT16_MAX /* is this not too much? */,
-                             &buf,
-                             &size))
+      GNUNET_DNSPARSER_pack(request->packet,
+                            UINT16_MAX /* is this not too much? */,
+                            &buf,
+                            &size))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to pack DNS response into UDP packet!\n"));
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to pack DNS response into UDP packet!\n"));
     }
   else
     {
-      sret = GNUNET_NETWORK_socket_sendto (request->lsock,
-                                           buf,
-                                           size,
-                                           request->addr,
-                                           request->addr_len);
-      if ( (sret < 0) ||
-           (size != (size_t) sret) )
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                             "sendto");
-      GNUNET_free (buf);
+      sret = GNUNET_NETWORK_socket_sendto(request->lsock,
+                                          buf,
+                                          size,
+                                          request->addr,
+                                          request->addr_len);
+      if ((sret < 0) ||
+          (size != (size_t)sret))
+        GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
+                            "sendto");
+      GNUNET_free(buf);
     }
-  GNUNET_SCHEDULER_cancel (request->timeout_task);
-  GNUNET_DNSPARSER_free_packet (request->packet);
-  GNUNET_free (request->udp_msg);
-  GNUNET_free (request);
+  GNUNET_SCHEDULER_cancel(request->timeout_task);
+  GNUNET_DNSPARSER_free_packet(request->packet);
+  GNUNET_free(request->udp_msg);
+  GNUNET_free(request);
 }
 
 
@@ -239,18 +238,18 @@ send_response (struct Request *request)
  * @param cls `struct Request *` of the request to clean up
  */
 static void
-do_timeout (void *cls)
+do_timeout(void *cls)
 {
   struct Request *request = cls;
 
   if (NULL != request->packet)
-    GNUNET_DNSPARSER_free_packet (request->packet);
+    GNUNET_DNSPARSER_free_packet(request->packet);
   if (NULL != request->lookup)
-    GNUNET_GNS_lookup_with_tld_cancel (request->lookup);
+    GNUNET_GNS_lookup_with_tld_cancel(request->lookup);
   if (NULL != request->dns_lookup)
-    GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup);
-  GNUNET_free (request->udp_msg);
-  GNUNET_free (request);
+    GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup);
+  GNUNET_free(request->udp_msg);
+  GNUNET_free(request);
 }
 
 
@@ -262,28 +261,28 @@ do_timeout (void *cls)
  * @param r size of the DNS payload
  */
 static void
-dns_result_processor (void *cls,
-                      const struct GNUNET_TUN_DnsHeader *dns,
-                      size_t r)
+dns_result_processor(void *cls,
+                     const struct GNUNET_TUN_DnsHeader *dns,
+                     size_t r)
 {
   struct Request *request = cls;
 
   if (NULL == dns)
-  {
-    /* DNSSTUB gave up, so we trigger timeout early */
-    GNUNET_SCHEDULER_cancel (request->timeout_task);
-    do_timeout (request);
-    return;
-  }
+    {
+      /* DNSSTUB gave up, so we trigger timeout early */
+      GNUNET_SCHEDULER_cancel(request->timeout_task);
+      do_timeout(request);
+      return;
+    }
   if (request->original_request_id != dns->id)
-  {
-    /* for a another query, ignore */
-    return;
-  }
-  request->packet = GNUNET_DNSPARSER_parse ((char*)dns,
-                                            r);
-  GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup);
-  send_response (request);
+    {
+      /* for a another query, ignore */
+      return;
+    }
+  request->packet = GNUNET_DNSPARSER_parse((char*)dns,
+                                           r);
+  GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup);
+  send_response(request);
 }
 
 
@@ -296,10 +295,10 @@ dns_result_processor (void *cls,
  * @param rd the records in reply
  */
 static void
-result_processor (void *cls,
-                  int was_gns,
-                  uint32_t rd_count,
-                  const struct GNUNET_GNSRECORD_Data *rd)
+result_processor(void *cls,
+                 int was_gns,
+                 uint32_t rd_count,
+                 const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Request *request = cls;
   struct GNUNET_DNSPARSER_Packet *packet;
@@ -307,22 +306,22 @@ result_processor (void *cls,
 
   request->lookup = NULL;
   if (GNUNET_NO == was_gns)
-  {
-    /* TLD not configured for GNS, fall back to DNS */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Using DNS resolver IP `%s' to resolve `%s'\n",
-                dns_ip,
-                request->packet->queries[0].name);
-    request->original_request_id = request->packet->id;
-    GNUNET_DNSPARSER_free_packet (request->packet);
-    request->packet = NULL;
-    request->dns_lookup = GNUNET_DNSSTUB_resolve (dns_stub,
-                                                  request->udp_msg,
-                                                  request->udp_msg_size,
-                                                  &dns_result_processor,
-                                                  request);
-    return;
-  }
+    {
+      /* TLD not configured for GNS, fall back to DNS */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Using DNS resolver IP `%s' to resolve `%s'\n",
+                 dns_ip,
+                 request->packet->queries[0].name);
+      request->original_request_id = request->packet->id;
+      GNUNET_DNSPARSER_free_packet(request->packet);
+      request->packet = NULL;
+      request->dns_lookup = GNUNET_DNSSTUB_resolve(dns_stub,
+                                                   request->udp_msg,
+                                                   request->udp_msg_size,
+                                                   &dns_result_processor,
+                                                   request);
+      return;
+    }
   packet = request->packet;
   packet->flags.query_or_response = 1;
   packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR;
@@ -333,59 +332,62 @@ result_processor (void *cls,
   packet->flags.message_truncated = 0;
   packet->flags.authoritative_answer = 0;
   //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
-  for (uint32_t i=0;i<rd_count;i++)
+  for (uint32_t i = 0; i < rd_count; i++)
     {
       // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD
       // here? Or should we do this in libgnunetgns?
       rec.expiration_time.abs_value_us = rd[i].expiration_time;
       switch (rd[i].record_type)
-        {
-        case GNUNET_DNSPARSER_TYPE_A:
-          GNUNET_assert (sizeof (struct in_addr) == rd[i].data_size);
-          rec.name = GNUNET_strdup (packet->queries[0].name);
-          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-          rec.type = GNUNET_DNSPARSER_TYPE_A;
-          rec.data.raw.data = GNUNET_new (struct in_addr);
-          GNUNET_memcpy (rec.data.raw.data,
-                  rd[i].data,
-                  rd[i].data_size);
-          rec.data.raw.data_len = sizeof (struct in_addr);
-          GNUNET_array_append (packet->answers,
-                               packet->num_answers,
-                               rec);
-          break;
-        case GNUNET_DNSPARSER_TYPE_AAAA:
-          GNUNET_assert (sizeof (struct in6_addr) == rd[i].data_size);
-          rec.name = GNUNET_strdup (packet->queries[0].name);
-          rec.data.raw.data = GNUNET_new (struct in6_addr);
-          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-          rec.type = GNUNET_DNSPARSER_TYPE_AAAA;
-          GNUNET_memcpy (rec.data.raw.data,
-                  rd[i].data,
-                  rd[i].data_size);
-          rec.data.raw.data_len = sizeof (struct in6_addr);
-          GNUNET_array_append (packet->answers,
-                               packet->num_answers,
-                               rec);
-          break;
-        case GNUNET_DNSPARSER_TYPE_CNAME:
-          rec.name = GNUNET_strdup (packet->queries[0].name);
-          rec.data.hostname = GNUNET_strdup (rd[i].data);
-          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-          rec.type = GNUNET_DNSPARSER_TYPE_CNAME;
-          GNUNET_memcpy (rec.data.hostname,
-                  rd[i].data,
-                  rd[i].data_size);
-          GNUNET_array_append (packet->answers,
-                               packet->num_answers,
-                               rec);
-          break;
-        default:
-          /* skip */
-          break;
-        }
+        {
+        case GNUNET_DNSPARSER_TYPE_A:
+          GNUNET_assert(sizeof(struct in_addr) == rd[i].data_size);
+          rec.name = GNUNET_strdup(packet->queries[0].name);
+          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+          rec.type = GNUNET_DNSPARSER_TYPE_A;
+          rec.data.raw.data = GNUNET_new(struct in_addr);
+          GNUNET_memcpy(rec.data.raw.data,
+                        rd[i].data,
+                        rd[i].data_size);
+          rec.data.raw.data_len = sizeof(struct in_addr);
+          GNUNET_array_append(packet->answers,
+                              packet->num_answers,
+                              rec);
+          break;
+
+        case GNUNET_DNSPARSER_TYPE_AAAA:
+          GNUNET_assert(sizeof(struct in6_addr) == rd[i].data_size);
+          rec.name = GNUNET_strdup(packet->queries[0].name);
+          rec.data.raw.data = GNUNET_new(struct in6_addr);
+          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+          rec.type = GNUNET_DNSPARSER_TYPE_AAAA;
+          GNUNET_memcpy(rec.data.raw.data,
+                        rd[i].data,
+                        rd[i].data_size);
+          rec.data.raw.data_len = sizeof(struct in6_addr);
+          GNUNET_array_append(packet->answers,
+                              packet->num_answers,
+                              rec);
+          break;
+
+        case GNUNET_DNSPARSER_TYPE_CNAME:
+          rec.name = GNUNET_strdup(packet->queries[0].name);
+          rec.data.hostname = GNUNET_strdup(rd[i].data);
+          rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+          rec.type = GNUNET_DNSPARSER_TYPE_CNAME;
+          GNUNET_memcpy(rec.data.hostname,
+                        rd[i].data,
+                        rd[i].data_size);
+          GNUNET_array_append(packet->answers,
+                              packet->num_answers,
+                              rec);
+          break;
+
+        default:
+          /* skip */
+          break;
+        }
     }
-  send_response (request);
+  send_response(request);
 }
 
 
@@ -399,73 +401,73 @@ result_processor (void *cls,
  * @param udp_msg_size number of bytes in @a udp_msg
  */
 static void
-handle_request (struct GNUNET_NETWORK_Handle *lsock,
-                const void *addr,
-                size_t addr_len,
-                const char *udp_msg,
-                size_t udp_msg_size)
+handle_request(struct GNUNET_NETWORK_Handle *lsock,
+               const void *addr,
+               size_t addr_len,
+               const char *udp_msg,
+               size_t udp_msg_size)
 {
   struct Request *request;
   struct GNUNET_DNSPARSER_Packet *packet;
 
-  packet = GNUNET_DNSPARSER_parse (udp_msg,
-                                   udp_msg_size);
+  packet = GNUNET_DNSPARSER_parse(udp_msg,
+                                  udp_msg_size);
   if (NULL == packet)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Cannot parse DNS request from %s\n"),
-                GNUNET_a2s (addr, addr_len));
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
-              packet->queries[0].name,
-              (unsigned int) packet->flags.query_or_response,
-              (int) packet->num_answers,
-              (int) packet->num_authority_records,
-              (int) packet->num_additional_records);
-  if ( (0 != packet->flags.query_or_response) ||
-       (0 != packet->num_answers) ||
-       (0 != packet->num_authority_records))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Received malformed DNS request from %s\n"),
-                GNUNET_a2s (addr, addr_len));
-    GNUNET_DNSPARSER_free_packet (packet);
-    return;
-  }
-  if ( (1 != packet->num_queries) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Received unsupported DNS request from %s\n"),
-                GNUNET_a2s (addr,
-                            addr_len));
-    GNUNET_DNSPARSER_free_packet (packet);
-    return;
-  }
-  request = GNUNET_malloc (sizeof (struct Request) + addr_len);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Cannot parse DNS request from %s\n"),
+                 GNUNET_a2s(addr, addr_len));
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
+             packet->queries[0].name,
+             (unsigned int)packet->flags.query_or_response,
+             (int)packet->num_answers,
+             (int)packet->num_authority_records,
+             (int)packet->num_additional_records);
+  if ((0 != packet->flags.query_or_response) ||
+      (0 != packet->num_answers) ||
+      (0 != packet->num_authority_records))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Received malformed DNS request from %s\n"),
+                 GNUNET_a2s(addr, addr_len));
+      GNUNET_DNSPARSER_free_packet(packet);
+      return;
+    }
+  if ((1 != packet->num_queries))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Received unsupported DNS request from %s\n"),
+                 GNUNET_a2s(addr,
+                            addr_len));
+      GNUNET_DNSPARSER_free_packet(packet);
+      return;
+    }
+  request = GNUNET_malloc(sizeof(struct Request) + addr_len);
   request->lsock = lsock;
   request->packet = packet;
   request->addr = &request[1];
   request->addr_len = addr_len;
-  GNUNET_memcpy (&request[1],
-                 addr,
-                 addr_len);
+  GNUNET_memcpy(&request[1],
+                addr,
+                addr_len);
   request->udp_msg_size = udp_msg_size;
-  request->udp_msg = GNUNET_memdup (udp_msg,
-                                    udp_msg_size);
-  request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                        &do_timeout,
-                                                        request);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Calling GNS on `%s'\n",
-              packet->queries[0].name);
-  request->lookup = GNUNET_GNS_lookup_with_tld (gns,
-                                                packet->queries[0].name,
-                                                packet->queries[0].type,
-                                                GNUNET_NO,
-                                                &result_processor,
-                                                request);
+  request->udp_msg = GNUNET_memdup(udp_msg,
+                                   udp_msg_size);
+  request->timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                                       &do_timeout,
+                                                       request);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Calling GNS on `%s'\n",
+             packet->queries[0].name);
+  request->lookup = GNUNET_GNS_lookup_with_tld(gns,
+                                               packet->queries[0].name,
+                                               packet->queries[0].type,
+                                               GNUNET_NO,
+                                               &result_processor,
+                                               request);
 }
 
 
@@ -475,49 +477,49 @@ handle_request (struct GNUNET_NETWORK_Handle *lsock,
  * @param cls the 'listen_socket4'
  */
 static void
-read_dns4 (void *cls)
+read_dns4(void *cls)
 {
   struct sockaddr_in v4;
   socklen_t addrlen;
   ssize_t size;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
-  GNUNET_assert (listen_socket4 == cls);
-  t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      listen_socket4,
-                                      &read_dns4,
-                                      listen_socket4);
-  tc = GNUNET_SCHEDULER_get_task_context ();
+  GNUNET_assert(listen_socket4 == cls);
+  t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                     listen_socket4,
+                                     &read_dns4,
+                                     listen_socket4);
+  tc = GNUNET_SCHEDULER_get_task_context();
   if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
     return; /* shutdown? */
-  size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4);
+  size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket4);
   if (0 > size)
     {
-      GNUNET_break (0);
+      GNUNET_break(0);
       return; /* read error!? */
     }
   {
     char buf[size + 1];
     ssize_t sret;
 
-    addrlen = sizeof (v4);
-    sret = GNUNET_NETWORK_socket_recvfrom (listen_socket4,
-                                           buf,
-                                           size + 1,
-                                           (struct sockaddr *) &v4,
-                                           &addrlen);
+    addrlen = sizeof(v4);
+    sret = GNUNET_NETWORK_socket_recvfrom(listen_socket4,
+                                          buf,
+                                          size + 1,
+                                          (struct sockaddr *)&v4,
+                                          &addrlen);
     if (0 > sret)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                           "recvfrom");
-      return;
-    }
-    GNUNET_break (size == sret);
-    handle_request (listen_socket4,
-                    &v4,
-                    addrlen,
-                    buf,
-                    size);
+      {
+        GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
+                            "recvfrom");
+        return;
+      }
+    GNUNET_break(size == sret);
+    handle_request(listen_socket4,
+                   &v4,
+                   addrlen,
+                   buf,
+                   size);
   }
 }
 
@@ -528,49 +530,49 @@ read_dns4 (void *cls)
  * @param cls the 'listen_socket6'
  */
 static void
-read_dns6 (void *cls)
+read_dns6(void *cls)
 {
   struct sockaddr_in6 v6;
   socklen_t addrlen;
   ssize_t size;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
-  GNUNET_assert (listen_socket6 == cls);
-  t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      listen_socket6,
-                                      &read_dns6,
-                                      listen_socket6);
-  tc = GNUNET_SCHEDULER_get_task_context ();
+  GNUNET_assert(listen_socket6 == cls);
+  t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                     listen_socket6,
+                                     &read_dns6,
+                                     listen_socket6);
+  tc = GNUNET_SCHEDULER_get_task_context();
   if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
     return; /* shutdown? */
-  size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6);
+  size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket6);
   if (0 > size)
     {
-      GNUNET_break (0);
+      GNUNET_break(0);
       return; /* read error!? */
     }
   {
     char buf[size];
     ssize_t sret;
 
-    addrlen = sizeof (v6);
-    sret = GNUNET_NETWORK_socket_recvfrom (listen_socket6,
-                                           buf,
-                                           size,
-                                           (struct sockaddr *) &v6,
-                                           &addrlen);
+    addrlen = sizeof(v6);
+    sret = GNUNET_NETWORK_socket_recvfrom(listen_socket6,
+                                          buf,
+                                          size,
+                                          (struct sockaddr *)&v6,
+                                          &addrlen);
     if (0 > sret)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                           "recvfrom");
-      return;
-    }
-    GNUNET_break (size == sret);
-    handle_request (listen_socket6,
-                    &v6,
-                    addrlen,
-                    buf,
-                    size);
+      {
+        GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
+                            "recvfrom");
+        return;
+      }
+    GNUNET_break(size == sret);
+    handle_request(listen_socket6,
+                   &v6,
+                   addrlen,
+                   buf,
+                   size);
   }
 }
 
@@ -584,149 +586,150 @@ read_dns6 (void *cls)
  * @param c configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
   char *addr_str;
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
+
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
   cfg = c;
   if (NULL == dns_ip)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("No DNS server specified!\n"));
-    return;
-  }
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
-  if (NULL == (gns = GNUNET_GNS_connect (cfg)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("No DNS server specified!\n"));
+      return;
+    }
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
+  if (NULL == (gns = GNUNET_GNS_connect(cfg)))
     return;
-  GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128)));
+  GNUNET_assert(NULL != (dns_stub = GNUNET_DNSSTUB_start(128)));
   if (GNUNET_OK !=
-      GNUNET_DNSSTUB_add_dns_ip (dns_stub,
-                                 dns_ip))
-  {
-    GNUNET_DNSSTUB_stop (dns_stub);
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-    return;
-  }
+      GNUNET_DNSSTUB_add_dns_ip(dns_stub,
+                                dns_ip))
+    {
+      GNUNET_DNSSTUB_stop(dns_stub);
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+      return;
+    }
 
   /* Get address to bind to */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns",
-                                                          "BIND_TO",
-                                                          &addr_str))
-  {
-    //No address specified
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Don't know what to bind to...\n");
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (1 != inet_pton (AF_INET, addr_str, &address))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse address %s\n",
-                addr_str);
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_free (addr_str);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns",
+                                                         "BIND_TO",
+                                                         &addr_str))
+    {
+      //No address specified
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Don't know what to bind to...\n");
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (1 != inet_pton(AF_INET, addr_str, &address))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to parse address %s\n",
+                 addr_str);
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_free(addr_str);
   /* Get address to bind to */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns",
-                                                          "BIND_TO6",
-                                                          &addr_str))
-  {
-    //No address specified
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Don't know what to bind6 to...\n");
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (1 != inet_pton (AF_INET6, addr_str, &address6))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse IPv6 address %s\n",
-                addr_str);
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_free (addr_str);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns",
+                                                         "BIND_TO6",
+                                                         &addr_str))
+    {
+      //No address specified
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Don't know what to bind6 to...\n");
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (1 != inet_pton(AF_INET6, addr_str, &address6))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to parse IPv6 address %s\n",
+                 addr_str);
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_free(addr_str);
 
-  listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET,
-                                                 SOCK_DGRAM,
-                                                 IPPROTO_UDP);
+  listen_socket4 = GNUNET_NETWORK_socket_create(PF_INET,
+                                                SOCK_DGRAM,
+                                                IPPROTO_UDP);
   if (NULL != listen_socket4)
-  {
-    struct sockaddr_in v4;
+    {
+      struct sockaddr_in v4;
 
-    memset (&v4, 0, sizeof (v4));
-    v4.sin_family = AF_INET;
-    v4.sin_addr.s_addr = address;
+      memset(&v4, 0, sizeof(v4));
+      v4.sin_family = AF_INET;
+      v4.sin_addr.s_addr = address;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    v4.sin_len = sizeof (v4);
+      v4.sin_len = sizeof(v4);
 #endif
-    v4.sin_port = htons (listen_port);
-    if (GNUNET_OK !=
-        GNUNET_NETWORK_socket_bind (listen_socket4,
-                                    (struct sockaddr *) &v4,
-                                    sizeof (v4)))
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
-      GNUNET_NETWORK_socket_close (listen_socket4);
-      listen_socket4 = NULL;
+      v4.sin_port = htons(listen_port);
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind(listen_socket4,
+                                     (struct sockaddr *)&v4,
+                                     sizeof(v4)))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind");
+          GNUNET_NETWORK_socket_close(listen_socket4);
+          listen_socket4 = NULL;
+        }
     }
-  }
-  listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6,
-                                                SOCK_DGRAM,
-                                                IPPROTO_UDP);
+  listen_socket6 = GNUNET_NETWORK_socket_create(PF_INET6,
+                                                SOCK_DGRAM,
+                                                IPPROTO_UDP);
   if (NULL != listen_socket6)
-  {
-    struct sockaddr_in6 v6;
+    {
+      struct sockaddr_in6 v6;
 
-    memset (&v6, 0, sizeof (v6));
-    v6.sin6_family = AF_INET6;
-    v6.sin6_addr = address6;
+      memset(&v6, 0, sizeof(v6));
+      v6.sin6_family = AF_INET6;
+      v6.sin6_addr = address6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    v6.sin6_len = sizeof (v6);
+      v6.sin6_len = sizeof(v6);
 #endif
-    v6.sin6_port = htons (listen_port);
-    if (GNUNET_OK !=
-        GNUNET_NETWORK_socket_bind (listen_socket6,
-                                    (struct sockaddr *) &v6,
-                                    sizeof (v6)))
+      v6.sin6_port = htons(listen_port);
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind(listen_socket6,
+                                     (struct sockaddr *)&v6,
+                                     sizeof(v6)))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind");
+          GNUNET_NETWORK_socket_close(listen_socket6);
+          listen_socket6 = NULL;
+        }
+    }
+  if ((NULL == listen_socket4) &&
+      (NULL == listen_socket6))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
-      GNUNET_NETWORK_socket_close (listen_socket6);
-      listen_socket6 = NULL;
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+      GNUNET_DNSSTUB_stop(dns_stub);
+      dns_stub = NULL;
+      return;
     }
-  }
-  if ( (NULL == listen_socket4) &&
-       (NULL == listen_socket6) )
-  {
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-    GNUNET_DNSSTUB_stop (dns_stub);
-    dns_stub = NULL;
-    return;
-  }
   if (NULL != listen_socket4)
-    t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        listen_socket4,
-                                        &read_dns4,
-                                        listen_socket4);
+    t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       listen_socket4,
+                                       &read_dns4,
+                                       listen_socket4);
   if (NULL != listen_socket6)
-    t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        listen_socket6,
-                                        &read_dns6,
-                                        listen_socket6);
+    t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       listen_socket6,
+                                       &read_dns6,
+                                       listen_socket6);
 }
 
 
@@ -738,39 +741,39 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc,
-      char *const *argv)
+main(int argc,
+     char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_string ('d',
-                                 "dns",
-                                 "IP",
-                                 gettext_noop ("IP of recursive DNS resolver to use (required)"),
-                                 &dns_ip),
-    GNUNET_GETOPT_option_uint ('p',
-                               "port",
-                               "UDPPORT",
-                               gettext_noop ("UDP port to listen on for inbound DNS requests; default: 2853"),
-                               &listen_port),
+    GNUNET_GETOPT_option_string('d',
+                                "dns",
+                                "IP",
+                                gettext_noop("IP of recursive DNS resolver to use (required)"),
+                                &dns_ip),
+    GNUNET_GETOPT_option_uint('p',
+                              "port",
+                              "UDPPORT",
+                              gettext_noop("UDP port to listen on for inbound DNS requests; default: 2853"),
+                              &listen_port),
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_get_utf8_args (argc, argv,
-                                    &argc, &argv))
+      GNUNET_STRINGS_get_utf8_args(argc, argv,
+                                   &argc, &argv))
     return 2;
-  GNUNET_log_setup ("gnunet-dns2gns",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("gnunet-dns2gns",
+                   "WARNING",
+                   NULL);
   ret =
-      (GNUNET_OK ==
-       GNUNET_PROGRAM_run (argc, argv,
-                           "gnunet-dns2gns",
-                           _("GNUnet DNS-to-GNS proxy (a DNS server)"),
-                           options,
-                           &run, NULL)) ? 0 : 1;
-  GNUNET_free ((void*) argv);
+    (GNUNET_OK ==
+     GNUNET_PROGRAM_run(argc, argv,
+                        "gnunet-dns2gns",
+                        _("GNUnet DNS-to-GNS proxy (a DNS server)"),
+                        options,
+                        &run, NULL)) ? 0 : 1;
+  GNUNET_free((void*)argv);
   return ret;
 }
 
diff --git a/src/gns/gnunet-gns-benchmark.c b/src/gns/gnunet-gns-benchmark.c
index 77066fd3f..b64201f10 100644
--- a/src/gns/gnunet-gns-benchmark.c
+++ b/src/gns/gnunet-gns-benchmark.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file src/gns/gnunet-gns-benchmark.c
  * @brief issue many queries to GNS and compute performance statistics
@@ -31,12 +31,12 @@
 /**
  * How long do we wait at least between requests by default?
  */
-#define DEF_REQUEST_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 1)
+#define DEF_REQUEST_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1)
 
 /**
  * How long do we wait until we consider a request failed by default?
  */
-#define DEF_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
+#define DEF_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1)
 
 
 /**
@@ -45,8 +45,7 @@
  * However, this process does not change how it acts
  * based on the category.
  */
-enum RequestCategory
-{
+enum RequestCategory {
   RC_SHARED = 0,
   RC_PRIVATE = 1,
   /**
@@ -61,9 +60,7 @@ enum RequestCategory
  * thus optimizing it is crucial for the overall memory consumption of
  * the zone importer.
  */
-struct Request
-{
-
+struct Request {
   /**
    * Active requests are kept in a DLL.
    */
@@ -101,7 +98,6 @@ struct Request
    * Category of the request.
    */
   enum RequestCategory cat;
-
 };
 
 
@@ -192,11 +188,11 @@ static int g2d;
  * @param req request to free
  */
 static void
-free_request (struct Request *req)
+free_request(struct Request *req)
 {
   if (NULL != req->lr)
-    GNUNET_GNS_lookup_with_tld_cancel (req->lr);
-  GNUNET_free (req);
+    GNUNET_GNS_lookup_with_tld_cancel(req->lr);
+  GNUNET_free(req);
 }
 
 
@@ -209,32 +205,32 @@ free_request (struct Request *req)
  * @param rd the records in reply
  */
 static void
-process_result (void *cls,
-                int gns_tld,
-                uint32_t rd_count,
-                const struct GNUNET_GNSRECORD_Data *rd)
+process_result(void *cls,
+               int gns_tld,
+               uint32_t rd_count,
+               const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Request *req = cls;
 
-  (void) gns_tld;
-  (void) rd_count;
-  (void) rd;
+  (void)gns_tld;
+  (void)rd_count;
+  (void)rd;
   active_cnt--;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got response for request `%s'\n",
-              req->hostname);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got response for request `%s'\n",
+             req->hostname);
   req->lr = NULL;
-  req->latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
-  GNUNET_CONTAINER_DLL_remove (act_head,
-                               act_tail,
-                               req);
-  GNUNET_CONTAINER_DLL_insert (succ_head,
-                               succ_tail,
-                               req);
+  req->latency = GNUNET_TIME_absolute_get_duration(req->op_start_time);
+  GNUNET_CONTAINER_DLL_remove(act_head,
+                              act_tail,
+                              req);
+  GNUNET_CONTAINER_DLL_insert(succ_head,
+                              succ_tail,
+                              req);
   replies[req->cat]++;
   latency_sum[req->cat]
-    = GNUNET_TIME_relative_add (latency_sum[req->cat],
-                                req->latency);
+    = GNUNET_TIME_relative_add(latency_sum[req->cat],
+                               req->latency);
 }
 
 
@@ -244,69 +240,69 @@ process_result (void *cls,
  * @param cls NULL
  */
 static void
-process_queue (void *cls)
+process_queue(void *cls)
 {
   struct Request *req;
   struct GNUNET_TIME_Relative duration;
 
-  (void) cls;
+  (void)cls;
   t = NULL;
   /* check for expired requests */
   while (NULL != (req = act_head))
-  {
-    duration = GNUNET_TIME_absolute_get_duration (req->op_start_time);
-    if (duration.rel_value_us < timeout.rel_value_us)
-      break;
-    GNUNET_CONTAINER_DLL_remove (act_head,
-                                 act_tail,
-                                 req);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Failing request `%s' due to timeout\n",
-                req->hostname);
-    failures[req->cat]++;
-    active_cnt--;
-    free_request (req);
-  }
+    {
+      duration = GNUNET_TIME_absolute_get_duration(req->op_start_time);
+      if (duration.rel_value_us < timeout.rel_value_us)
+        break;
+      GNUNET_CONTAINER_DLL_remove(act_head,
+                                  act_tail,
+                                  req);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Failing request `%s' due to timeout\n",
+                 req->hostname);
+      failures[req->cat]++;
+      active_cnt--;
+      free_request(req);
+    }
   if (NULL == (req = todo_head))
-  {
-    struct GNUNET_TIME_Absolute at;
-
-    if (NULL == (req = act_head))
     {
-      GNUNET_SCHEDULER_shutdown ();
+      struct GNUNET_TIME_Absolute at;
+
+      if (NULL == (req = act_head))
+        {
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      at = GNUNET_TIME_absolute_add(req->op_start_time,
+                                    timeout);
+      t = GNUNET_SCHEDULER_add_at(at,
+                                  &process_queue,
+                                  NULL);
       return;
     }
-    at = GNUNET_TIME_absolute_add (req->op_start_time,
-                                   timeout);
-    t = GNUNET_SCHEDULER_add_at (at,
-                                 &process_queue,
-                                 NULL);
-    return;
-  }
-  GNUNET_CONTAINER_DLL_remove (todo_head,
-                               todo_tail,
-                               req);
-  GNUNET_CONTAINER_DLL_insert_tail (act_head,
-                                    act_tail,
-                                    req);
+  GNUNET_CONTAINER_DLL_remove(todo_head,
+                              todo_tail,
+                              req);
+  GNUNET_CONTAINER_DLL_insert_tail(act_head,
+                                   act_tail,
+                                   req);
   lookups[req->cat]++;
   active_cnt++;
-  req->op_start_time = GNUNET_TIME_absolute_get ();
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting request `%s' (%u in parallel)\n",
-              req->hostname,
-              active_cnt);
-  req->lr = GNUNET_GNS_lookup_with_tld (gns,
-                                        req->hostname,
-                                        g2d
-                                        ? GNUNET_GNSRECORD_TYPE_GNS2DNS
-                                        : GNUNET_GNSRECORD_TYPE_ANY,
-                                        GNUNET_GNS_LO_DEFAULT,
-                                        &process_result,
-                                        req);
-  t = GNUNET_SCHEDULER_add_delayed (request_delay,
-                                    &process_queue,
-                                    NULL);
+  req->op_start_time = GNUNET_TIME_absolute_get();
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting request `%s' (%u in parallel)\n",
+             req->hostname,
+             active_cnt);
+  req->lr = GNUNET_GNS_lookup_with_tld(gns,
+                                       req->hostname,
+                                       g2d
+                                       ? GNUNET_GNSRECORD_TYPE_GNS2DNS
+                                       : GNUNET_GNSRECORD_TYPE_ANY,
+                                       GNUNET_GNS_LO_DEFAULT,
+                                       &process_result,
+                                       req);
+  t = GNUNET_SCHEDULER_add_delayed(request_delay,
+                                   &process_queue,
+                                   NULL);
 }
 
 
@@ -318,11 +314,11 @@ process_queue (void *cls)
  * @return -1 if c1<c2, 1 if c1>c2, 0 if c1==c2.
  */
 static int
-compare_req (const void *c1,
-             const void *c2)
+compare_req(const void *c1,
+            const void *c2)
 {
-  const struct Request *r1 = *(void **) c1;
-  const struct Request *r2 = *(void **) c2;
+  const struct Request *r1 = *(void **)c1;
+  const struct Request *r2 = *(void **)c2;
 
   if (r1->latency.rel_value_us < r2->latency.rel_value_us)
     return -1;
@@ -338,101 +334,101 @@ compare_req (const void *c1,
  * @param cls NULL
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
   struct Request *req;
   struct Request **ra[RC_MAX];
   unsigned int rp[RC_MAX];
 
-  (void) cls;
-  for (enum RequestCategory rc = 0;rc < RC_MAX;rc++)
-  {
-    ra[rc] = GNUNET_new_array (replies[rc],
-                               struct Request *);
-    rp[rc] = 0;
-  }
-  for (req = succ_head;NULL != req; req = req->next)
-  {
-    GNUNET_assert (rp[req->cat] < replies[req->cat]);
-    ra[req->cat][rp[req->cat]++] = req;
-  }
-  for (enum RequestCategory rc = 0;rc < RC_MAX;rc++)
-  {
-    unsigned int off;
-
-    fprintf (stdout,
-             "Category %u\n",
-             rc);
-    fprintf (stdout,
-             "\tlookups: %u replies: %u failures: %u\n",
-             lookups[rc],
-             replies[rc],
-             failures[rc]);
-    if (0 == rp[rc])
-      continue;
-    qsort (ra[rc],
-           rp[rc],
-           sizeof (struct Request *),
-           &compare_req);
-    latency_sum[rc] = GNUNET_TIME_relative_divide (latency_sum[rc],
-                                                   replies[rc]);
-    fprintf (stdout,
-             "\taverage: %s\n",
-             GNUNET_STRINGS_relative_time_to_string (latency_sum[rc],
-                                                     GNUNET_YES));
-    off = rp[rc] * 50 / 100;
-    fprintf (stdout,
-             "\tmedian(50): %s\n",
-             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
-                                                     GNUNET_YES));
-    off = rp[rc] * 75 / 100;
-    fprintf (stdout,
-             "\tquantile(75): %s\n",
-             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
-                                                     GNUNET_YES));
-    off = rp[rc] * 90 / 100;
-    fprintf (stdout,
-             "\tquantile(90): %s\n",
-             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
-                                                     GNUNET_YES));
-    off = rp[rc] * 99 / 100;
-    fprintf (stdout,
-             "\tquantile(99): %s\n",
-             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
-                                                     GNUNET_YES));
-    GNUNET_free (ra[rc]);
-  }
+  (void)cls;
+  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
+    {
+      ra[rc] = GNUNET_new_array(replies[rc],
+                                struct Request *);
+      rp[rc] = 0;
+    }
+  for (req = succ_head; NULL != req; req = req->next)
+    {
+      GNUNET_assert(rp[req->cat] < replies[req->cat]);
+      ra[req->cat][rp[req->cat]++] = req;
+    }
+  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
+    {
+      unsigned int off;
+
+      fprintf(stdout,
+              "Category %u\n",
+              rc);
+      fprintf(stdout,
+              "\tlookups: %u replies: %u failures: %u\n",
+              lookups[rc],
+              replies[rc],
+              failures[rc]);
+      if (0 == rp[rc])
+        continue;
+      qsort(ra[rc],
+            rp[rc],
+            sizeof(struct Request *),
+            &compare_req);
+      latency_sum[rc] = GNUNET_TIME_relative_divide(latency_sum[rc],
+                                                    replies[rc]);
+      fprintf(stdout,
+              "\taverage: %s\n",
+              GNUNET_STRINGS_relative_time_to_string(latency_sum[rc],
+                                                     GNUNET_YES));
+      off = rp[rc] * 50 / 100;
+      fprintf(stdout,
+              "\tmedian(50): %s\n",
+              GNUNET_STRINGS_relative_time_to_string(ra[rc][off]->latency,
+                                                     GNUNET_YES));
+      off = rp[rc] * 75 / 100;
+      fprintf(stdout,
+              "\tquantile(75): %s\n",
+              GNUNET_STRINGS_relative_time_to_string(ra[rc][off]->latency,
+                                                     GNUNET_YES));
+      off = rp[rc] * 90 / 100;
+      fprintf(stdout,
+              "\tquantile(90): %s\n",
+              GNUNET_STRINGS_relative_time_to_string(ra[rc][off]->latency,
+                                                     GNUNET_YES));
+      off = rp[rc] * 99 / 100;
+      fprintf(stdout,
+              "\tquantile(99): %s\n",
+              GNUNET_STRINGS_relative_time_to_string(ra[rc][off]->latency,
+                                                     GNUNET_YES));
+      GNUNET_free(ra[rc]);
+    }
   if (NULL != t)
-  {
-    GNUNET_SCHEDULER_cancel (t);
-    t = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(t);
+      t = NULL;
+    }
   while (NULL != (req = act_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (act_head,
-                                 act_tail,
-                                 req);
-    free_request (req);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(act_head,
+                                  act_tail,
+                                  req);
+      free_request(req);
+    }
   while (NULL != (req = succ_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (succ_head,
-                                 succ_tail,
-                                 req);
-    free_request (req);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(succ_head,
+                                  succ_tail,
+                                  req);
+      free_request(req);
+    }
   while (NULL != (req = todo_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (todo_head,
-                                 todo_tail,
-                                 req);
-    free_request (req);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(todo_head,
+                                  todo_tail,
+                                  req);
+      free_request(req);
+    }
   if (NULL != gns)
-  {
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+    }
 }
 
 
@@ -443,32 +439,32 @@ do_shutdown (void *cls)
  * @param cat category of the @a hostname
  */
 static void
-queue (const char *hostname,
-       enum RequestCategory cat)
+queue(const char *hostname,
+      enum RequestCategory cat)
 {
   struct Request *req;
   const char *dot;
   size_t hlen;
 
-  dot = strchr (hostname,
-                (unsigned char) '.');
+  dot = strchr(hostname,
+               (unsigned char)'.');
   if (NULL == dot)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Refusing invalid hostname `%s' (lacks '.')\n",
-                hostname);
-    return;
-  }
-  hlen = strlen (hostname) + 1;
-  req = GNUNET_malloc (sizeof (struct Request) + hlen);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Refusing invalid hostname `%s' (lacks '.')\n",
+                 hostname);
+      return;
+    }
+  hlen = strlen(hostname) + 1;
+  req = GNUNET_malloc(sizeof(struct Request) + hlen);
   req->cat = cat;
-  req->hostname = (char *) &req[1];
-  GNUNET_memcpy (&req[1],
-                 hostname,
-                 hlen);
-  GNUNET_CONTAINER_DLL_insert (todo_head,
-                               todo_tail,
-                               req);
+  req->hostname = (char *)&req[1];
+  GNUNET_memcpy(&req[1],
+                hostname,
+                hlen);
+  GNUNET_CONTAINER_DLL_insert(todo_head,
+                              todo_tail,
+                              req);
 }
 
 
@@ -478,7 +474,7 @@ queue (const char *hostname,
  * @param cls NULL
  */
 static void
-process_stdin (void *cls)
+process_stdin(void *cls)
 {
   static struct GNUNET_TIME_Absolute last;
   static uint64_t idot;
@@ -486,48 +482,48 @@ process_stdin (void *cls)
   char hn[256];
   char in[270];
 
-  (void) cls;
+  (void)cls;
   t = NULL;
   while (NULL !=
-         fgets (in,
-                sizeof (in),
-                stdin))
-  {
-    if (strlen(in) > 0)
-      hn[strlen(in)-1] = '\0'; /* eat newline */
-    if ( (2 != sscanf (in,
-                       "%u %255s",
-                       &cat,
-                       hn)) ||
-         (cat >= RC_MAX) )
-    {
-      fprintf (stderr,
-               "Malformed input line `%s', skipping\n",
-               in);
-      continue;
-    }
-    if (0 == idot)
-      last = GNUNET_TIME_absolute_get ();
-    idot++;
-    if (0 == idot % 100000)
+         fgets(in,
+               sizeof(in),
+               stdin))
     {
-      struct GNUNET_TIME_Relative delta;
-
-      delta = GNUNET_TIME_absolute_get_duration (last);
-      last = GNUNET_TIME_absolute_get ();
-      fprintf (stderr,
-               "Read 100000 domain names in %s\n",
-               GNUNET_STRINGS_relative_time_to_string (delta,
-                                                       GNUNET_YES));
+      if (strlen(in) > 0)
+        hn[strlen(in) - 1] = '\0'; /* eat newline */
+      if ((2 != sscanf(in,
+                       "%u %255s",
+                       &cat,
+                       hn)) ||
+          (cat >= RC_MAX))
+        {
+          fprintf(stderr,
+                  "Malformed input line `%s', skipping\n",
+                  in);
+          continue;
+        }
+      if (0 == idot)
+        last = GNUNET_TIME_absolute_get();
+      idot++;
+      if (0 == idot % 100000)
+        {
+          struct GNUNET_TIME_Relative delta;
+
+          delta = GNUNET_TIME_absolute_get_duration(last);
+          last = GNUNET_TIME_absolute_get();
+          fprintf(stderr,
+                  "Read 100000 domain names in %s\n",
+                  GNUNET_STRINGS_relative_time_to_string(delta,
+                                                         GNUNET_YES));
+        }
+      queue(hn,
+            (enum RequestCategory)cat);
     }
-    queue (hn,
-           (enum RequestCategory) cat);
-  }
-  fprintf (stderr,
-           "Done reading %llu domain names\n",
-           (unsigned long long) idot);
-  t = GNUNET_SCHEDULER_add_now (&process_queue,
-                                NULL);
+  fprintf(stderr,
+          "Done reading %llu domain names\n",
+          (unsigned long long)idot);
+  t = GNUNET_SCHEDULER_add_now(&process_queue,
+                               NULL);
 }
 
 
@@ -541,25 +537,25 @@ process_stdin (void *cls)
  * @param cfg configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
-  gns = GNUNET_GNS_connect (cfg);
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
+  gns = GNUNET_GNS_connect(cfg);
   if (NULL == gns)
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  t = GNUNET_SCHEDULER_add_now (&process_stdin,
-                                NULL);
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  t = GNUNET_SCHEDULER_add_now(&process_stdin,
+                               NULL);
 }
 
 
@@ -571,44 +567,44 @@ run (void *cls,
  * @return 0 on success
  */
 int
-main (int argc,
-      char *const*argv)
+main(int argc,
+     char *const*argv)
 {
   int ret = 0;
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_relative_time ('d',
-                                        "delay",
-                                        "RELATIVETIME",
-                                        gettext_noop ("how long to wait between queries"),
-                                        &request_delay),
-    GNUNET_GETOPT_option_relative_time ('t',
-                                        "timeout",
-                                        "RELATIVETIME",
-                                        gettext_noop ("how long to wait for an answer"),
-                                        &timeout),
-    GNUNET_GETOPT_option_flag ('2',
-                               "g2d",
-                               gettext_noop ("look for GNS2DNS records instead of ANY"),
-                               &g2d),
+    GNUNET_GETOPT_option_relative_time('d',
+                                       "delay",
+                                       "RELATIVETIME",
+                                       gettext_noop("how long to wait between queries"),
+                                       &request_delay),
+    GNUNET_GETOPT_option_relative_time('t',
+                                       "timeout",
+                                       "RELATIVETIME",
+                                       gettext_noop("how long to wait for an answer"),
+                                       &timeout),
+    GNUNET_GETOPT_option_flag('2',
+                              "g2d",
+                              gettext_noop("look for GNS2DNS records instead of ANY"),
+                              &g2d),
     GNUNET_GETOPT_OPTION_END
   };
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_get_utf8_args (argc, argv,
-                                    &argc, &argv))
+      GNUNET_STRINGS_get_utf8_args(argc, argv,
+                                   &argc, &argv))
     return 2;
   timeout = DEF_TIMEOUT;
   request_delay = DEF_REQUEST_DELAY;
   if (GNUNET_OK !=
-      GNUNET_PROGRAM_run (argc,
-                          argv,
-                          "gnunet-gns-benchmark",
-                          "resolve GNS names and measure performance",
-                          options,
-                          &run,
-                          NULL))
+      GNUNET_PROGRAM_run(argc,
+                         argv,
+                         "gnunet-gns-benchmark",
+                         "resolve GNS names and measure performance",
+                         options,
+                         &run,
+                         NULL))
     ret = 1;
-  GNUNET_free ((void*) argv);
+  GNUNET_free((void*)argv);
   return ret;
 }
 
diff --git a/src/gns/gnunet-gns-helper-service-w32.c b/src/gns/gnunet-gns-helper-service-w32.c
index 4eb965e24..4c4803556 100644
--- a/src/gns/gnunet-gns-helper-service-w32.c
+++ b/src/gns/gnunet-gns-helper-service-w32.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gnunet-gns-helper-service-w32.c
  * @brief an intermediary service to access distributed GNS
@@ -35,7 +35,7 @@
 #include <nspapi.h>
 #include <unistr.h>
 
-#define DEFINE_DNS_GUID(a,x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
+#define DEFINE_DNS_GUID(a, x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_A, 0x0001);
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_NS, 0x0002);
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_CNAME, 0x0005);
@@ -49,8 +49,7 @@ DEFINE_GUID(SVCID_HOSTNAME, 0x0002a800, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00,
 DEFINE_GUID(SVCID_INET_HOSTADDRBYNAME, 0x0002a803, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
 
 
-struct request
-{
+struct request {
   /**
    * We keep these in a doubly-linked list (for cleanup).
    */
@@ -120,83 +119,83 @@ static int got_egos;
  * @param cls unused
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
   struct request *rq;
 
   if (NULL != id_op)
-  {
-    GNUNET_IDENTITY_cancel (id_op);
-    id_op = NULL;
-  }
+    {
+      GNUNET_IDENTITY_cancel(id_op);
+      id_op = NULL;
+    }
   if (NULL != identity)
-  {
-    GNUNET_IDENTITY_disconnect (identity);
-    identity = NULL;
-  }
+    {
+      GNUNET_IDENTITY_disconnect(identity);
+      identity = NULL;
+    }
   while (NULL != (rq = rq_head))
-  {
-    if (NULL != rq->lookup_request)
-      GNUNET_GNS_lookup_cancel (rq->lookup_request);
-    GNUNET_CONTAINER_DLL_remove (rq_head,
-                                 rq_tail,
-                                 rq);
-    GNUNET_free_non_null (rq->name);
-    if (rq->u8name)
-      free (rq->u8name);
-    GNUNET_free (rq);
-  }
+    {
+      if (NULL != rq->lookup_request)
+        GNUNET_GNS_lookup_cancel(rq->lookup_request);
+      GNUNET_CONTAINER_DLL_remove(rq_head,
+                                  rq_tail,
+                                  rq);
+      GNUNET_free_non_null(rq->name);
+      if (rq->u8name)
+        free(rq->u8name);
+      GNUNET_free(rq);
+    }
   if (NULL != gns)
-  {
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+    }
 }
 
 
 #define MarshallPtr(ptr, base, type) \
   if (ptr) \
-    ptr = (type *) ((char *) ptr - (char *) base)
+  ptr = (type *) ((char *)ptr - (char *)base)
 
 
 void
-MarshallWSAQUERYSETW (WSAQUERYSETW *qs, GUID *sc)
+MarshallWSAQUERYSETW(WSAQUERYSETW *qs, GUID *sc)
 {
-  MarshallPtr (qs->lpszServiceInstanceName, qs, wchar_t);
-  MarshallPtr (qs->lpServiceClassId, qs, GUID);
-  MarshallPtr (qs->lpVersion, qs, WSAVERSION);
-  MarshallPtr (qs->lpNSProviderId, qs, GUID);
-  MarshallPtr (qs->lpszContext, qs, wchar_t);
-  MarshallPtr (qs->lpafpProtocols, qs, AFPROTOCOLS);
-  MarshallPtr (qs->lpszQueryString, qs, wchar_t);
+  MarshallPtr(qs->lpszServiceInstanceName, qs, wchar_t);
+  MarshallPtr(qs->lpServiceClassId, qs, GUID);
+  MarshallPtr(qs->lpVersion, qs, WSAVERSION);
+  MarshallPtr(qs->lpNSProviderId, qs, GUID);
+  MarshallPtr(qs->lpszContext, qs, wchar_t);
+  MarshallPtr(qs->lpafpProtocols, qs, AFPROTOCOLS);
+  MarshallPtr(qs->lpszQueryString, qs, wchar_t);
   for (int i = 0; i < qs->dwNumberOfCsAddrs; i++)
-  {
-    MarshallPtr (qs->lpcsaBuffer[i].LocalAddr.lpSockaddr, qs, SOCKADDR);
-    MarshallPtr (qs->lpcsaBuffer[i].RemoteAddr.lpSockaddr, qs, SOCKADDR);
-  }
-  MarshallPtr (qs->lpcsaBuffer, qs, CSADDR_INFO);
-  if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, sc) && qs->lpBlob != NULL && qs->lpBlob->pBlobData != NULL)
-  {
-    struct hostent *he;
-
-    he = (struct hostent *) qs->lpBlob->pBlobData;
-    for (int i = 0; he->h_aliases[i] != NULL; i++)
-      MarshallPtr (he->h_aliases[i], he, char);
-    MarshallPtr (he->h_aliases, he, char *);
-    MarshallPtr (he->h_name, he, char);
-    for (int i = 0; he->h_addr_list[i] != NULL; i++)
-      MarshallPtr (he->h_addr_list[i], he, void);
-    MarshallPtr (he->h_addr_list, he, char *);
-    MarshallPtr (qs->lpBlob->pBlobData, qs, void);
-  }
-  MarshallPtr (qs->lpBlob, qs, BLOB);
+    {
+      MarshallPtr(qs->lpcsaBuffer[i].LocalAddr.lpSockaddr, qs, SOCKADDR);
+      MarshallPtr(qs->lpcsaBuffer[i].RemoteAddr.lpSockaddr, qs, SOCKADDR);
+    }
+  MarshallPtr(qs->lpcsaBuffer, qs, CSADDR_INFO);
+  if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, sc) && qs->lpBlob != NULL && qs->lpBlob->pBlobData != NULL)
+    {
+      struct hostent *he;
+
+      he = (struct hostent *)qs->lpBlob->pBlobData;
+      for (int i = 0; he->h_aliases[i] != NULL; i++)
+        MarshallPtr(he->h_aliases[i], he, char);
+      MarshallPtr(he->h_aliases, he, char *);
+      MarshallPtr(he->h_name, he, char);
+      for (int i = 0; he->h_addr_list[i] != NULL; i++)
+        MarshallPtr(he->h_addr_list[i], he, void);
+      MarshallPtr(he->h_addr_list, he, char *);
+      MarshallPtr(qs->lpBlob->pBlobData, qs, void);
+    }
+  MarshallPtr(qs->lpBlob, qs, BLOB);
 }
 
 
 static void
-process_lookup_result (void *cls,
-                       uint32_t rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+process_lookup_result(void *cls,
+                      uint32_t rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct request *rq = cls;
   int i, j, csanum;
@@ -211,269 +210,272 @@ process_lookup_result (void *cls,
   size_t blobsize = 0;
   size_t blobaddrcount = 0;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got lookup result with count %u for rq %p with client %p\n",
-              rd_count,
-              rq,
-              rq->client);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got lookup result with count %u for rq %p with client %p\n",
+             rd_count,
+             rq,
+             rq->client);
   rq->lookup_request = NULL;
 
   if (0 == rd_count)
-  {
-    msgend_env = GNUNET_MQ_msg (msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
-    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client),
-                    msgend_env);
-    GNUNET_CONTAINER_DLL_remove (rq_head,
-                                 rq_tail,
-                                 rq);
-    GNUNET_free_non_null (rq->name);
-    if (rq->u8name)
-      free (rq->u8name);
-    GNUNET_free (rq);
-    return;
-  }
-
-  size = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW);
-  size += (wcslen (rq->name) + 1) * sizeof (wchar_t);
-  size += sizeof (GUID);
+    {
+      msgend_env = GNUNET_MQ_msg(msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
+      GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
+                     msgend_env);
+      GNUNET_CONTAINER_DLL_remove(rq_head,
+                                  rq_tail,
+                                  rq);
+      GNUNET_free_non_null(rq->name);
+      if (rq->u8name)
+        free(rq->u8name);
+      GNUNET_free(rq);
+      return;
+    }
+
+  size = sizeof(struct GNUNET_W32RESOLVER_GetMessage) + sizeof(WSAQUERYSETW);
+  size += (wcslen(rq->name) + 1) * sizeof(wchar_t);
+  size += sizeof(GUID);
   /* lpszComment ? a TXT record? */
-  size += sizeof (GUID);
+  size += sizeof(GUID);
   /* lpszContext ? Not sure what it is */
   csanum = 0;
   for (i = 0; i < rd_count; i++)
-  {
-    switch (rd[i].record_type)
     {
-    case GNUNET_DNSPARSER_TYPE_A:
-      if (rd[i].data_size != sizeof (struct in_addr))
-        continue;
-      size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2;
-      csanum++;
-      break;
-    case GNUNET_DNSPARSER_TYPE_AAAA:
-      if (rd[i].data_size != sizeof (struct in6_addr))
-        continue;
-      size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2;
-      csanum++;
-      break;
+      switch (rd[i].record_type)
+        {
+        case GNUNET_DNSPARSER_TYPE_A:
+          if (rd[i].data_size != sizeof(struct in_addr))
+            continue;
+          size += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in) * 2;
+          csanum++;
+          break;
+
+        case GNUNET_DNSPARSER_TYPE_AAAA:
+          if (rd[i].data_size != sizeof(struct in6_addr))
+            continue;
+          size += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in6) * 2;
+          csanum++;
+          break;
+        }
     }
-  }
-  if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
-  {
-    size += sizeof (BLOB);
-    blobsize += sizeof (struct hostent);
-    blobsize += strlen (rq->u8name) + 1;
-    blobsize += sizeof (void *); /* For aliases */
-    blobsize += sizeof (void *); /* For addresses */
-    for (i = 0; i < rd_count; i++)
+  if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
     {
-      if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
-      {
-        blobsize += sizeof (void *);
-        blobsize += sizeof (struct in_addr);
-        blobaddrcount++;
-      }
-      else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
-      {
-        blobsize += sizeof (void *);
-        blobsize += sizeof (struct in6_addr);
-        blobaddrcount++;
-      }
+      size += sizeof(BLOB);
+      blobsize += sizeof(struct hostent);
+      blobsize += strlen(rq->u8name) + 1;
+      blobsize += sizeof(void *); /* For aliases */
+      blobsize += sizeof(void *); /* For addresses */
+      for (i = 0; i < rd_count; i++)
+        {
+          if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
+            {
+              blobsize += sizeof(void *);
+              blobsize += sizeof(struct in_addr);
+              blobaddrcount++;
+            }
+          else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
+            {
+              blobsize += sizeof(void *);
+              blobsize += sizeof(struct in6_addr);
+              blobaddrcount++;
+            }
+        }
+      size += blobsize;
     }
-    size += blobsize;
-  }
-  size_recalc = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW);
-  msg_env = GNUNET_MQ_msg_extra (msg,
-                                 size - sizeof (struct GNUNET_MessageHeader),
-                                 GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
-  msg->af = htonl (rq->af);
-  msg->sc_data1 = htonl (rq->sc.Data1);
-  msg->sc_data2 = htons (rq->sc.Data2);
-  msg->sc_data3 = htons (rq->sc.Data3);
+  size_recalc = sizeof(struct GNUNET_W32RESOLVER_GetMessage) + sizeof(WSAQUERYSETW);
+  msg_env = GNUNET_MQ_msg_extra(msg,
+                                size - sizeof(struct GNUNET_MessageHeader),
+                                GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
+  msg->af = htonl(rq->af);
+  msg->sc_data1 = htonl(rq->sc.Data1);
+  msg->sc_data2 = htons(rq->sc.Data2);
+  msg->sc_data3 = htons(rq->sc.Data3);
   for (i = 0; i < 8; i++)
     msg->sc_data4[i] = rq->sc.Data4[i];
-  qs = (WSAQUERYSETW *) &msg[1];
-  ptr = (char *) &qs[1];
-  GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-  qs->dwSize = sizeof (WSAQUERYSETW);
-  qs->lpszServiceInstanceName = (wchar_t *) ptr;
-  ptr += (wcslen (rq->name) + 1) * sizeof (wchar_t);
-  size_recalc += (wcslen (rq->name) + 1) * sizeof (wchar_t);
-  GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-  wcscpy (qs->lpszServiceInstanceName, rq->name);
-  qs->lpServiceClassId = (GUID *) ptr;
-  ptr += sizeof (GUID);
-  size_recalc += sizeof (GUID);
-  GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-  GNUNET_memcpy (qs->lpServiceClassId, &rq->sc, sizeof (GUID));
+  qs = (WSAQUERYSETW *)&msg[1];
+  ptr = (char *)&qs[1];
+  GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+  qs->dwSize = sizeof(WSAQUERYSETW);
+  qs->lpszServiceInstanceName = (wchar_t *)ptr;
+  ptr += (wcslen(rq->name) + 1) * sizeof(wchar_t);
+  size_recalc += (wcslen(rq->name) + 1) * sizeof(wchar_t);
+  GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+  wcscpy(qs->lpszServiceInstanceName, rq->name);
+  qs->lpServiceClassId = (GUID *)ptr;
+  ptr += sizeof(GUID);
+  size_recalc += sizeof(GUID);
+  GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+  GNUNET_memcpy(qs->lpServiceClassId, &rq->sc, sizeof(GUID));
   qs->lpVersion = NULL;
   qs->dwNameSpace = NS_DNS;
-  qs->lpNSProviderId = (GUID *) ptr;
-  ptr += sizeof (GUID);
-  size_recalc += sizeof (GUID);
-  GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-  GNUNET_memcpy (qs->lpNSProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS, sizeof (GUID));
+  qs->lpNSProviderId = (GUID *)ptr;
+  ptr += sizeof(GUID);
+  size_recalc += sizeof(GUID);
+  GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+  GNUNET_memcpy(qs->lpNSProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS, sizeof(GUID));
   qs->lpszContext = NULL;
   qs->dwNumberOfProtocols = 0;
   qs->lpafpProtocols = NULL;
   /* Don't bother with this... */
   qs->lpszQueryString = NULL;
   qs->dwNumberOfCsAddrs = rd_count;
-  qs->lpcsaBuffer = (CSADDR_INFO *) ptr;
-  ptr += sizeof (CSADDR_INFO) * csanum;
+  qs->lpcsaBuffer = (CSADDR_INFO *)ptr;
+  ptr += sizeof(CSADDR_INFO) * csanum;
   j = 0;
   for (i = 0; i < rd_count; i++)
-  {
-    switch (rd[i].record_type)
     {
-    case GNUNET_DNSPARSER_TYPE_A:
-      if (rd[i].data_size != sizeof (struct in_addr))
-        continue;
-      qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
-      qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
-
-      qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in);
-      qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr;
-      ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
-      memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
-      ((struct sockaddr_in *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin_family = AF_INET;
-
-      qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in);
-      qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr;
-      ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
-      memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
-      ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_family = AF_INET;
-      ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_port = htonl (53); /* Don't ask why it's 53 */
-      ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_addr = *(struct in_addr *) rd[i].data;
-      size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2;
-      j++;
-      break;
-    case GNUNET_DNSPARSER_TYPE_AAAA:
-      if (rd[i].data_size != sizeof (struct in6_addr))
-        continue;
-      qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
-      qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
-
-      qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in6);
-      qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr;
-      ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
-      memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
-      ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin6_family = AF_INET6;
-
-      qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in6);
-      qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr;
-      ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
-      memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
-      ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_family = AF_INET6;
-      ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_port = htonl (53); /* Don't ask why it's 53 */
-      ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_addr = *(struct in6_addr *) rd[i].data;
-      size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2;
-      j++;
-      break;
-    default:
-      break;
+      switch (rd[i].record_type)
+        {
+        case GNUNET_DNSPARSER_TYPE_A:
+          if (rd[i].data_size != sizeof(struct in_addr))
+            continue;
+          qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
+          qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
+
+          qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof(struct sockaddr_in);
+          qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *)ptr;
+          ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
+          memset(qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
+          ((struct sockaddr_in *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin_family = AF_INET;
+
+          qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof(struct sockaddr_in);
+          qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *)ptr;
+          ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
+          memset(qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
+          ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_family = AF_INET;
+          ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_port = htonl(53); /* Don't ask why it's 53 */
+          ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_addr = *(struct in_addr *)rd[i].data;
+          size_recalc += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in) * 2;
+          j++;
+          break;
+
+        case GNUNET_DNSPARSER_TYPE_AAAA:
+          if (rd[i].data_size != sizeof(struct in6_addr))
+            continue;
+          qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
+          qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
+
+          qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof(struct sockaddr_in6);
+          qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *)ptr;
+          ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
+          memset(qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
+          ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin6_family = AF_INET6;
+
+          qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof(struct sockaddr_in6);
+          qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *)ptr;
+          ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
+          memset(qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
+          ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_family = AF_INET6;
+          ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_port = htonl(53); /* Don't ask why it's 53 */
+          ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_addr = *(struct in6_addr *)rd[i].data;
+          size_recalc += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in6) * 2;
+          j++;
+          break;
+
+        default:
+          break;
+        }
     }
-  }
-  GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
+  GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
   qs->dwOutputFlags = 0;
-  if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
-  {
-    struct hostent *he;
-    qs->lpBlob = (BLOB *) ptr;
-    ptr += sizeof (BLOB);
-
-    size_recalc += sizeof (BLOB);
-    GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-    qs->lpBlob->cbSize = blobsize;
-    qs->lpBlob->pBlobData = (BYTE *) ptr;
-    ptr += sizeof (struct hostent);
-
-    size_recalc += sizeof (struct hostent);
-    GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-    he = (struct hostent *) qs->lpBlob->pBlobData;
-    he->h_name = (char *) ptr;
-    ptr += strlen (rq->u8name) + 1;
-
-    size_recalc += strlen (rq->u8name) + 1;
-    GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-    strcpy (he->h_name, rq->u8name);
-    he->h_aliases = (char **) ptr;
-    ptr += sizeof (void *);
-
-    size_recalc += sizeof (void *); /* For aliases */
-    GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-    he->h_aliases[0] = NULL;
-    he->h_addrtype = rq->af;
-    he->h_length = rq->af == AF_INET || rq->af == AF_UNSPEC ? sizeof (struct in_addr) : sizeof (struct in6_addr);
-    he->h_addr_list = (char **) ptr;
-    ptr += sizeof (void *) * (blobaddrcount + 1);
-
-    size_recalc += sizeof (void *) * (blobaddrcount + 1); /* For addresses */
-    GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
+  if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
+    {
+      struct hostent *he;
+      qs->lpBlob = (BLOB *)ptr;
+      ptr += sizeof(BLOB);
+
+      size_recalc += sizeof(BLOB);
+      GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+      qs->lpBlob->cbSize = blobsize;
+      qs->lpBlob->pBlobData = (BYTE *)ptr;
+      ptr += sizeof(struct hostent);
+
+      size_recalc += sizeof(struct hostent);
+      GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+      he = (struct hostent *)qs->lpBlob->pBlobData;
+      he->h_name = (char *)ptr;
+      ptr += strlen(rq->u8name) + 1;
+
+      size_recalc += strlen(rq->u8name) + 1;
+      GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+      strcpy(he->h_name, rq->u8name);
+      he->h_aliases = (char **)ptr;
+      ptr += sizeof(void *);
+
+      size_recalc += sizeof(void *); /* For aliases */
+      GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+      he->h_aliases[0] = NULL;
+      he->h_addrtype = rq->af;
+      he->h_length = rq->af == AF_INET || rq->af == AF_UNSPEC ? sizeof(struct in_addr) : sizeof(struct in6_addr);
+      he->h_addr_list = (char **)ptr;
+      ptr += sizeof(void *) * (blobaddrcount + 1);
+
+      size_recalc += sizeof(void *) * (blobaddrcount + 1); /* For addresses */
+      GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+      j = 0;
+      for (i = 0; i < rd_count; i++)
+        {
+          if ((rq->af == AF_INET || rq->af == AF_UNSPEC) &&
+              rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
+            {
+              he->h_addr_list[j] = (char *)ptr;
+              ptr += sizeof(struct in_addr);
+
+              size_recalc += sizeof(struct in_addr);
+              GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+              GNUNET_memcpy(he->h_addr_list[j], rd[i].data, sizeof(struct in_addr));
+              j++;
+            }
+          else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
+            {
+              he->h_addr_list[j] = (char *)ptr;
+              ptr += sizeof(struct in6_addr);
+
+              size_recalc += sizeof(struct in6_addr);
+              GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
+
+              GNUNET_memcpy(he->h_addr_list[j], rd[i].data, sizeof(struct in6_addr));
+              j++;
+            }
+        }
+      he->h_addr_list[j] = NULL;
+    }
+  msgend_env = GNUNET_MQ_msg(msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
 
-    j = 0;
-    for (i = 0; i < rd_count; i++)
+  if ((char *)ptr - (char *)msg != size || size_recalc != size || size_recalc != ((char *)ptr - (char *)msg))
     {
-      if ((rq->af == AF_INET || rq->af == AF_UNSPEC) &&
-          rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
-      {
-        he->h_addr_list[j] = (char *) ptr;
-        ptr += sizeof (struct in_addr);
-
-        size_recalc += sizeof (struct in_addr);
-        GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-        GNUNET_memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in_addr));
-        j++;
-      }
-      else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
-      {
-        he->h_addr_list[j] = (char *) ptr;
-        ptr += sizeof (struct in6_addr);
-
-        size_recalc += sizeof (struct in6_addr);
-        GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
-
-        GNUNET_memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in6_addr));
-        j++;
-      }
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Error in WSAQUERYSETW size calc: expected %u, got %lu (recalc %u)\n",
+                 size,
+                 (unsigned long)((char *)ptr - (char *)msg),
+                 size_recalc);
     }
-    he->h_addr_list[j] = NULL;
-  }
-  msgend_env = GNUNET_MQ_msg (msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
-
-  if ((char *) ptr - (char *) msg != size || size_recalc != size || size_recalc != ((char *) ptr - (char *) msg))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error in WSAQUERYSETW size calc: expected %u, got %lu (recalc %u)\n",
-                size,
-                (unsigned long) ((char *) ptr - (char *) msg),
-                size_recalc);
-  }
-  MarshallWSAQUERYSETW (qs, &rq->sc);
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client),
-                  msg_env);
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client),
-                  msgend_env);
-  GNUNET_CONTAINER_DLL_remove (rq_head,
-                               rq_tail,
-                               rq);
-  GNUNET_free_non_null (rq->name);
+  MarshallWSAQUERYSETW(qs, &rq->sc);
+  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
+                 msg_env);
+  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
+                 msgend_env);
+  GNUNET_CONTAINER_DLL_remove(rq_head,
+                              rq_tail,
+                              rq);
+  GNUNET_free_non_null(rq->name);
   if (rq->u8name)
-    free (rq->u8name);
-  GNUNET_free (rq);
+    free(rq->u8name);
+  GNUNET_free(rq);
 }
 
 
 static void
-get_ip_from_hostname (struct GNUNET_SERVICE_Client *client,
-                      const wchar_t *name,
-                      int af,
-                      GUID sc)
+get_ip_from_hostname(struct GNUNET_SERVICE_Client *client,
+                     const wchar_t *name,
+                     int af,
+                     GUID sc)
 {
   struct request *rq;
   char *hostname;
@@ -481,104 +483,104 @@ get_ip_from_hostname (struct GNUNET_SERVICE_Client *client,
   size_t namelen;
   uint32_t rtype;
 
-  if (IsEqualGUID (&SVCID_DNS_TYPE_A, &sc))
+  if (IsEqualGUID(&SVCID_DNS_TYPE_A, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_A;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_NS, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_NS, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_NS;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_CNAME, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_CNAME, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_CNAME;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_SOA, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_SOA, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_SOA;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_PTR, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_PTR, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_PTR;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_MX, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_MX, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_MX;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_TEXT, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_TEXT, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_TXT;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_AAAA, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_AAAA, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_AAAA;
-  else if (IsEqualGUID (&SVCID_DNS_TYPE_SRV, &sc))
+  else if (IsEqualGUID(&SVCID_DNS_TYPE_SRV, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_SRV;
-  else if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &sc))
+  else if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &sc))
     rtype = GNUNET_DNSPARSER_TYPE_A;
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Unknown GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
-                sc.Data1,
-                sc.Data2,
-                sc.Data3,
-                sc.Data4[0],
-                sc.Data4[1],
-                sc.Data4[2],
-                sc.Data4[3],
-                sc.Data4[4],
-                sc.Data4[5],
-                sc.Data4[6],
-                sc.Data4[7]);
-    GNUNET_SERVICE_client_drop (client);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Unknown GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
+                 sc.Data1,
+                 sc.Data2,
+                 sc.Data3,
+                 sc.Data4[0],
+                 sc.Data4[1],
+                 sc.Data4[2],
+                 sc.Data4[3],
+                 sc.Data4[4],
+                 sc.Data4[5],
+                 sc.Data4[6],
+                 sc.Data4[7]);
+      GNUNET_SERVICE_client_drop(client);
+      return;
+    }
 
   if (name)
-    namelen = wcslen (name);
+    namelen = wcslen(name);
   else
     namelen = 0;
   if (namelen > 0)
-    hostname = (char *) u16_to_u8 (name, namelen + 1, NULL, &strl);
+    hostname = (char *)u16_to_u8(name, namelen + 1, NULL, &strl);
   else
     hostname = NULL;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "W32 DNS resolver asked to look up %s for `%s'.\n",
-              af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything",
-              hostname);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "W32 DNS resolver asked to look up %s for `%s'.\n",
+             af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything",
+             hostname);
 
-  rq = GNUNET_new (struct request);
+  rq = GNUNET_new(struct request);
   rq->sc = sc;
   rq->client = client;
   rq->af = af;
   if (rq->af != AF_INET && rq->af != AF_INET6)
     rq->af = AF_INET;
   if (namelen)
-  {
-    rq->name = GNUNET_malloc ((namelen + 1) * sizeof (wchar_t));
-    GNUNET_memcpy (rq->name,
-                   name,
-                   (namelen + 1) * sizeof (wchar_t));
-    rq->u8name = hostname;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Launching a lookup for client %p with rq %p\n",
-              client,
-              rq);
-  rq->lookup_request = GNUNET_GNS_lookup (gns,
-                                          hostname,
-                                          &gns_master_pubkey,
-                                          rtype,
-                                          GNUNET_NO /* Use DHT */,
-                                          &process_lookup_result,
-                                          rq);
+    {
+      rq->name = GNUNET_malloc((namelen + 1) * sizeof(wchar_t));
+      GNUNET_memcpy(rq->name,
+                    name,
+                    (namelen + 1) * sizeof(wchar_t));
+      rq->u8name = hostname;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Launching a lookup for client %p with rq %p\n",
+             client,
+             rq);
+  rq->lookup_request = GNUNET_GNS_lookup(gns,
+                                         hostname,
+                                         &gns_master_pubkey,
+                                         rtype,
+                                         GNUNET_NO /* Use DHT */,
+                                         &process_lookup_result,
+                                         rq);
   if (NULL != rq->lookup_request)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Lookup launched, waiting for a reply\n");
-    GNUNET_SERVICE_client_continue (client);
-    GNUNET_CONTAINER_DLL_insert (rq_head,
-                                 rq_tail,
-                                 rq);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Lookup launched, waiting for a reply\n");
+      GNUNET_SERVICE_client_continue(client);
+      GNUNET_CONTAINER_DLL_insert(rq_head,
+                                  rq_tail,
+                                  rq);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Lookup was not launched, disconnecting the client\n");
-    GNUNET_free_non_null (rq->name);
-    if (rq->u8name)
-      free (rq->u8name);
-    GNUNET_free (rq);
-    GNUNET_SERVICE_client_drop (client);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Lookup was not launched, disconnecting the client\n");
+      GNUNET_free_non_null(rq->name);
+      if (rq->u8name)
+        free(rq->u8name);
+      GNUNET_free(rq);
+      GNUNET_SERVICE_client_drop(client);
+    }
 }
 
 
@@ -590,25 +592,25 @@ get_ip_from_hostname (struct GNUNET_SERVICE_Client *client,
  * @return #GNUNET_OK if @a msg is well-formed
  */
 static int
-check_get (void *cls,
-            const struct GNUNET_W32RESOLVER_GetMessage *msg)
+check_get(void *cls,
+          const struct GNUNET_W32RESOLVER_GetMessage *msg)
 {
   uint16_t size;
   const wchar_t *hostname;
 
-  if (! got_egos)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Not ready to process requests, lacking ego data\n"));
-    return GNUNET_SYSERR;
-  }
-  size = ntohs (msg->header.size) - sizeof (struct GNUNET_W32RESOLVER_GetMessage);
-  hostname = (const wchar_t *) &msg[1];
+  if (!got_egos)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Not ready to process requests, lacking ego data\n"));
+      return GNUNET_SYSERR;
+    }
+  size = ntohs(msg->header.size) - sizeof(struct GNUNET_W32RESOLVER_GetMessage);
+  hostname = (const wchar_t *)&msg[1];
   if (hostname[size / 2 - 1] != L'\0')
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -620,8 +622,8 @@ check_get (void *cls,
  * @param msg the actual message
  */
 static void
-handle_get (void *cls,
-            const struct GNUNET_W32RESOLVER_GetMessage *msg)
+handle_get(void *cls,
+           const struct GNUNET_W32RESOLVER_GetMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   GUID sc;
@@ -629,50 +631,50 @@ handle_get (void *cls,
   const wchar_t *hostname;
   int af;
 
-  size = ntohs (msg->header.size) - sizeof (struct GNUNET_W32RESOLVER_GetMessage);
-  af = ntohl (msg->af);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got NBO GUID: %08X-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
-              msg->sc_data1,
-              msg->sc_data2,
-              msg->sc_data3,
-              msg->sc_data4[0],
-              msg->sc_data4[1],
-              msg->sc_data4[2],
-              msg->sc_data4[3],
-              msg->sc_data4[4],
-              msg->sc_data4[5],
-              msg->sc_data4[6],
-              msg->sc_data4[7]);
-  sc.Data1 = ntohl (msg->sc_data1);
-  sc.Data2 = ntohs (msg->sc_data2);
-  sc.Data3 = ntohs (msg->sc_data3);
+  size = ntohs(msg->header.size) - sizeof(struct GNUNET_W32RESOLVER_GetMessage);
+  af = ntohl(msg->af);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got NBO GUID: %08X-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
+             msg->sc_data1,
+             msg->sc_data2,
+             msg->sc_data3,
+             msg->sc_data4[0],
+             msg->sc_data4[1],
+             msg->sc_data4[2],
+             msg->sc_data4[3],
+             msg->sc_data4[4],
+             msg->sc_data4[5],
+             msg->sc_data4[6],
+             msg->sc_data4[7]);
+  sc.Data1 = ntohl(msg->sc_data1);
+  sc.Data2 = ntohs(msg->sc_data2);
+  sc.Data3 = ntohs(msg->sc_data3);
   for (int i = 0; i < 8; i++)
     sc.Data4[i] = msg->sc_data4[i];
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
-              sc.Data1,
-              sc.Data2,
-              sc.Data3,
-              sc.Data4[0],
-              sc.Data4[1],
-              sc.Data4[2],
-              sc.Data4[3],
-              sc.Data4[4],
-              sc.Data4[5],
-              sc.Data4[6],
-              sc.Data4[7]);
-  hostname = (const wchar_t *) &msg[1];
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name of %u bytes (last word is 0x%0X): %*S\n",
-              size,
-              hostname[size / 2 - 2],
-              size / 2,
-              hostname);
-  get_ip_from_hostname (client,
-                        hostname,
-                        af,
-                        sc);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
+             sc.Data1,
+             sc.Data2,
+             sc.Data3,
+             sc.Data4[0],
+             sc.Data4[1],
+             sc.Data4[2],
+             sc.Data4[3],
+             sc.Data4[4],
+             sc.Data4[5],
+             sc.Data4[6],
+             sc.Data4[7]);
+  hostname = (const wchar_t *)&msg[1];
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name of %u bytes (last word is 0x%0X): %*S\n",
+             size,
+             hostname[size / 2 - 2],
+             size / 2,
+             hostname);
+  get_ip_from_hostname(client,
+                       hostname,
+                       af,
+                       sc);
 }
 
 
@@ -689,21 +691,21 @@ handle_get (void *cls,
  *                   must thus no longer be used
  */
 static void
-identity_master_cb (void *cls,
-                    struct GNUNET_IDENTITY_Ego *ego,
-                    void **ctx,
-                    const char *name)
+identity_master_cb(void *cls,
+                   struct GNUNET_IDENTITY_Ego *ego,
+                   void **ctx,
+                   const char *name)
 {
   id_op = NULL;
   if (NULL == ego)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Ego for `gns-master' not found, cannot perform lookup.  Did you run gnunet-gns-import.sh?\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_IDENTITY_ego_get_public_key (ego,
-                                      &gns_master_pubkey);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Ego for `gns-master' not found, cannot perform lookup.  Did you run gnunet-gns-import.sh?\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_IDENTITY_ego_get_public_key(ego,
+                                     &gns_master_pubkey);
   got_egos = 1;
 }
 
@@ -716,35 +718,35 @@ identity_master_cb (void *cls,
  * @param service the initialized service
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_SERVICE_Handle *service)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_SERVICE_Handle *service)
 {
-  gns = GNUNET_GNS_connect (cfg);
+  gns = GNUNET_GNS_connect(cfg);
   if (NULL == gns)
-  {
-    fprintf (stderr,
-             _("Failed to connect to GNS\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
-  identity = GNUNET_IDENTITY_connect (cfg,
-                                      NULL,
-                                      NULL);
+    {
+      fprintf(stderr,
+              _("Failed to connect to GNS\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
+  identity = GNUNET_IDENTITY_connect(cfg,
+                                     NULL,
+                                     NULL);
   if (NULL == identity)
-  {
-    fprintf (stderr,
-             _("Failed to connect to identity service\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  id_op = GNUNET_IDENTITY_get (identity,
-                               "gns-master",
-                               &identity_master_cb,
-                               NULL);
-  GNUNET_assert (NULL != id_op);
+    {
+      fprintf(stderr,
+              _("Failed to connect to identity service\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  id_op = GNUNET_IDENTITY_get(identity,
+                              "gns-master",
+                              &identity_master_cb,
+                              NULL);
+  GNUNET_assert(NULL != id_op);
 }
 
 
@@ -757,9 +759,9 @@ run (void *cls,
  * @return @a client
  */
 static void *
-client_connect_cb (void *cls,
-                   struct GNUNET_SERVICE_Client *client,
-                   struct GNUNET_MQ_Handle *mq)
+client_connect_cb(void *cls,
+                  struct GNUNET_SERVICE_Client *client,
+                  struct GNUNET_MQ_Handle *mq)
 {
   return client;
 }
@@ -773,11 +775,11 @@ client_connect_cb (void *cls,
  * @param internal_cls should be equal to @a c
  */
 static void
-client_disconnect_cb (void *cls,
-                      struct GNUNET_SERVICE_Client *client,
-                      void *internal_cls)
+client_disconnect_cb(void *cls,
+                     struct GNUNET_SERVICE_Client *client,
+                     void *internal_cls)
 {
-  GNUNET_assert (internal_cls == client);
+  GNUNET_assert(internal_cls == client);
 }
 
 
@@ -785,17 +787,17 @@ client_disconnect_cb (void *cls,
  * Define "main" method using service macro.
  */
 GNUNET_SERVICE_MAIN
-("gns-helper-service-w32",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_var_size (get,
+  ("gns-helper-service-w32",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size(get,
                         GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST,
                         struct GNUNET_W32RESOLVER_GetMessage,
                         NULL),
- GNUNET_MQ_handler_end());
+  GNUNET_MQ_handler_end());
 
 
 /* end of gnunet-gns-helper-service-w32.c */
diff --git a/src/gns/gnunet-gns-import.c b/src/gns/gnunet-gns-import.c
index 5e3560313..82710b803 100644
--- a/src/gns/gnunet-gns-import.c
+++ b/src/gns/gnunet-gns-import.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gnunet-gns.c
  * @brief binary version of gnunet-gns-import.sh
@@ -86,13 +86,13 @@ static int ret;
 
 
 static int
-run_process_and_wait (int pipe_control,
-                      enum GNUNET_OS_InheritStdioFlags std_inheritance,
-                      struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                      struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                      enum GNUNET_OS_ProcessStatusType *st,
-                      unsigned long *code,
-                      const char *filename, ...)
+run_process_and_wait(int pipe_control,
+                     enum GNUNET_OS_InheritStdioFlags std_inheritance,
+                     struct GNUNET_DISK_PipeHandle *pipe_stdin,
+                     struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                     enum GNUNET_OS_ProcessStatusType *st,
+                     unsigned long *code,
+                     const char *filename, ...)
 {
   static struct GNUNET_OS_Process *p;
   int arglen;
@@ -101,93 +101,96 @@ run_process_and_wait (int pipe_control,
   char *argp;
   va_list ap, apc1, apc2;
 
-  va_start (ap, filename);
-  va_copy (apc1, ap);
-  va_copy (apc2, ap);
+  va_start(ap, filename);
+  va_copy(apc1, ap);
+  va_copy(apc2, ap);
   arglen = 0;
-  while (NULL != (arg = va_arg (apc1, char *)))
-    arglen += strlen (arg) + 1;
-  va_end (apc1);
-  args = argp = GNUNET_malloc (arglen);
-  while (NULL != (arg = va_arg (apc2, char *)))
-  {
-    strcpy (argp, arg);
-    argp += strlen (arg);
-    *argp = ' ';
-    argp += 1;
-  }
-  va_end (apc2);
+  while (NULL != (arg = va_arg(apc1, char *)))
+    arglen += strlen(arg) + 1;
+  va_end(apc1);
+  args = argp = GNUNET_malloc(arglen);
+  while (NULL != (arg = va_arg(apc2, char *)))
+    {
+      strcpy(argp, arg);
+      argp += strlen(arg);
+      *argp = ' ';
+      argp += 1;
+    }
+  va_end(apc2);
   if (arglen > 0)
     argp[-1] = '\0';
-  p = GNUNET_OS_start_process_va (pipe_control, std_inheritance,
-                                  pipe_stdin,
-                                  pipe_stdout,
-                                  NULL,
-                                  filename, ap);
-  va_end (ap);
+  p = GNUNET_OS_start_process_va(pipe_control, std_inheritance,
+                                 pipe_stdin,
+                                 pipe_stdout,
+                                 NULL,
+                                 filename, ap);
+  va_end(ap);
   if (NULL == p)
-  {
-    ret = 3;
-    fprintf (stderr, "Failed to run `%s'\n", args);
-    GNUNET_free (args);
-    return 1;
-  }
-
-  if (GNUNET_OK != GNUNET_OS_process_wait (p))
-  {
-    ret = 4;
-    fprintf (stderr, "Failed to wait for `%s'\n", args);
-    GNUNET_free (args);
-    return 1;
-  }
-
-  switch (GNUNET_OS_process_status (p, st, code))
-  {
+    {
+      ret = 3;
+      fprintf(stderr, "Failed to run `%s'\n", args);
+      GNUNET_free(args);
+      return 1;
+    }
+
+  if (GNUNET_OK != GNUNET_OS_process_wait(p))
+    {
+      ret = 4;
+      fprintf(stderr, "Failed to wait for `%s'\n", args);
+      GNUNET_free(args);
+      return 1;
+    }
+
+  switch (GNUNET_OS_process_status(p, st, code))
+    {
     case GNUNET_OK:
       break;
+
     case GNUNET_NO:
       ret = 5;
-      fprintf (stderr, "`%s' is still running\n", args);
-      GNUNET_free (args);
+      fprintf(stderr, "`%s' is still running\n", args);
+      GNUNET_free(args);
       return 1;
+
     default:
     case GNUNET_SYSERR:
       ret = 6;
-      fprintf (stderr, "Failed to check the status of `%s'\n", args);
-      GNUNET_free (args);
+      fprintf(stderr, "Failed to check the status of `%s'\n", args);
+      GNUNET_free(args);
       return 1;
-  }
+    }
 #ifdef WINDOWS
   if (GNUNET_OS_PROCESS_EXITED != *st || 0 != *code)
-  {
-    ret = 7;
-    fprintf (stderr, "`%s' did not end correctly (%d, %d)\n", args, *st, *code);
-    return 1;
-  }
+    {
+      ret = 7;
+      fprintf(stderr, "`%s' did not end correctly (%d, %d)\n", args, *st, *code);
+      return 1;
+    }
 #endif
   return 0;
 }
 
 static void
-check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
-    char *pk, int *found_rec)
+check_pkey(unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
+           char *pk, int *found_rec)
 {
   int i;
+
   for (i = 0; i < rd_len; i++)
-  {
-    char *s;
-    if (GNUNET_GNSRECORD_TYPE_PKEY != rd[i].record_type ||
-        rd[i].data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
-      continue;
-    s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
-                                          rd[i].data,
-                                          rd[i].data_size);
-    if (NULL == s)
-      continue;
-    if (0 == strcmp (s, pk))
-      *found_rec = GNUNET_YES;
-    GNUNET_free (s);
-  }
+    {
+      char *s;
+      if (GNUNET_GNSRECORD_TYPE_PKEY != rd[i].record_type ||
+          rd[i].data_size != sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))
+        continue;
+      s = GNUNET_GNSRECORD_value_to_string(rd[i].record_type,
+                                           rd[i].data,
+                                           rd[i].data_size);
+      if (NULL == s)
+        continue;
+      if (0 == strcmp(s, pk))
+        *found_rec = GNUNET_YES;
+      GNUNET_free(s);
+    }
 }
 
 /**
@@ -200,53 +203,54 @@ check_pkey (unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd,
  * @param rd array of records with data to store
  */
 static void
-zone_iterator (void *cls,
-    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-    const char *rname, unsigned int rd_len,
-    const struct GNUNET_GNSRECORD_Data *rd)
+zone_iterator(void *cls,
+              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+              const char *rname, unsigned int rd_len,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   if (NULL != rname)
-  {
-    if (0 == strcmp (rname, "private"))
-      check_pkey (rd_len, rd, private_zone_pkey, &found_private_rec);
-    else if (0 == strcmp (rname, "pin"))
-      check_pkey (rd_len, rd, pin_zone_pkey, &found_pin_rec);
-  }
-  GNUNET_NAMESTORE_zone_iterator_next (list_it);
+    {
+      if (0 == strcmp(rname, "private"))
+        check_pkey(rd_len, rd, private_zone_pkey, &found_private_rec);
+      else if (0 == strcmp(rname, "pin"))
+        check_pkey(rd_len, rd, pin_zone_pkey, &found_pin_rec);
+    }
+  GNUNET_NAMESTORE_zone_iterator_next(list_it);
 }
 
 static void
-zone_iteration_error (void *cls)
+zone_iteration_error(void *cls)
 {
   enum GNUNET_OS_ProcessStatusType st;
   unsigned long code;
+
   if (!found_private_rec)
-  {
-    if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-        "gnunet-namestore",
-        "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "private", "-p", "-t", "PKEY", "-V", private_zone_pkey, NULL))
     {
-      ret = 8;
-      return;
+      if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                    "gnunet-namestore",
+                                    "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "private", "-p", "-t", "PKEY", "-V", private_zone_pkey, NULL))
+        {
+          ret = 8;
+          return;
+        }
     }
-  }
   if (!found_pin_rec)
-  {
-    if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-        "gnunet-namestore",
-        "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "pin", "-p", "-t", "PKEY", "-V", pin_zone_pkey, NULL))
     {
-      ret = 10;
-      return;
+      if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                    "gnunet-namestore",
+                                    "gnunet-namestore", "-z", "master-zone", "-a", "-e", "never", "-n", "pin", "-p", "-t", "PKEY", "-V", pin_zone_pkey, NULL))
+        {
+          ret = 10;
+          return;
+        }
     }
-  }
   list_it = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-zone_iteration_finished (void *cls)
+zone_iteration_finished(void *cls)
 {
 }
 
@@ -283,43 +287,44 @@ zone_iteration_finished (void *cls)
  * @param identifier identifier assigned by the user for this ego,
  *                   NULL if the user just deleted the ego and it
  *                   must thus no longer be used
-*/
+ */
 static void
-get_ego (void *cls,
-         struct GNUNET_IDENTITY_Ego *ego,
-         void **ctx,
-         const char *identifier)
+get_ego(void *cls,
+        struct GNUNET_IDENTITY_Ego *ego,
+        void **ctx,
+        const char *identifier)
 {
   static struct GNUNET_CRYPTO_EcdsaPublicKey pk;
+
   if (NULL == ego)
-  {
-    if (NULL == master_zone_pkey ||
-        NULL == private_zone_pkey)
     {
-      ret = 11;
-      GNUNET_SCHEDULER_shutdown ();
+      if (NULL == master_zone_pkey ||
+          NULL == private_zone_pkey)
+        {
+          ret = 11;
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      list_it = GNUNET_NAMESTORE_zone_iteration_start(ns,
+                                                      &master_pk, &zone_iteration_error, NULL, &zone_iterator, NULL, &zone_iteration_finished, NULL);
+      if (NULL == list_it)
+        {
+          ret = 12;
+          GNUNET_SCHEDULER_shutdown();
+        }
       return;
     }
-    list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
-        &master_pk, &zone_iteration_error, NULL, &zone_iterator, NULL, &zone_iteration_finished, NULL);
-    if (NULL == list_it)
-    {
-      ret = 12;
-      GNUNET_SCHEDULER_shutdown ();
-    }
-    return;
-  }
-  GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
+  GNUNET_IDENTITY_ego_get_public_key(ego, &pk);
   if (NULL != identifier)
-  {
-    if (NULL == master_zone_pkey && 0 == strcmp ("master-zone", identifier))
     {
-      master_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
-      master_pk = *GNUNET_IDENTITY_ego_get_private_key (ego);
+      if (NULL == master_zone_pkey && 0 == strcmp("master-zone", identifier))
+        {
+          master_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string(&pk);
+          master_pk = *GNUNET_IDENTITY_ego_get_private_key(ego);
+        }
+      else if (NULL == private_zone_pkey && 0 == strcmp("private-zone", identifier))
+        private_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string(&pk);
     }
-    else if (NULL == private_zone_pkey && 0 == strcmp ("private-zone", identifier))
-      private_zone_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
-  }
 }
 
 /**
@@ -328,27 +333,27 @@ get_ego (void *cls,
  * @param cls NULL
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  GNUNET_free_non_null (master_zone_pkey);
+  GNUNET_free_non_null(master_zone_pkey);
   master_zone_pkey = NULL;
-  GNUNET_free_non_null (private_zone_pkey);
+  GNUNET_free_non_null(private_zone_pkey);
   private_zone_pkey = NULL;
   if (NULL != list_it)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (list_it);
-    list_it = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(list_it);
+      list_it = NULL;
+    }
   if (NULL != ns)
-  {
-    GNUNET_NAMESTORE_disconnect (ns);
-    ns = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(ns);
+      ns = NULL;
+    }
   if (NULL != sh)
-  {
-    GNUNET_IDENTITY_disconnect (sh);
-    sh = NULL;
-  }
+    {
+      GNUNET_IDENTITY_disconnect(sh);
+      sh = NULL;
+    }
 }
 
 /**
@@ -360,71 +365,71 @@ shutdown_task (void *cls)
  * @param c configuration
  */
 static void
-run (void *cls, char *const *args, const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls, char *const *args, const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
   enum GNUNET_OS_ProcessStatusType st;
   unsigned long code;
 
   cfg = c;
 
-  if (0 != run_process_and_wait (GNUNET_NO, 0, NULL, NULL, &st, &code,
-      "gnunet-arm",
-      "gnunet-arm", "-I", NULL))
-  {
-    if (7 == ret)
-      fprintf (stderr, "GNUnet is not running, please start GNUnet before running import\n");
-    return;
-  }
+  if (0 != run_process_and_wait(GNUNET_NO, 0, NULL, NULL, &st, &code,
+                                "gnunet-arm",
+                                "gnunet-arm", "-I", NULL))
+    {
+      if (7 == ret)
+        fprintf(stderr, "GNUnet is not running, please start GNUnet before running import\n");
+      return;
+    }
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-C", "master-zone", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-C", "master-zone", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-C", "private-zone", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-C", "private-zone", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-C", "sks-zone", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-C", "sks-zone", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "master-zone", "-s", "gns-master", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "master-zone", "-s", "gns-master", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "master-zone", "-s", "namestore", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "master-zone", "-s", "namestore", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "master-zone", "-s", "gns-proxy", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "master-zone", "-s", "gns-proxy", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "master-zone", "-s", "gns-intercept", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "master-zone", "-s", "gns-intercept", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "private-zone", "-s", "gns-private", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "private-zone", "-s", "gns-private", NULL))
     return;
 
-  if (0 != run_process_and_wait (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
-      "gnunet-identity",
-      "gnunet-identity", "-e", "sks-zone", "-s", "fs-sks", NULL))
+  if (0 != run_process_and_wait(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, &st, &code,
+                                "gnunet-identity",
+                                "gnunet-identity", "-e", "sks-zone", "-s", "fs-sks", NULL))
     return;
 
-  ns = GNUNET_NAMESTORE_connect (cfg);
-  sh = GNUNET_IDENTITY_connect (cfg, &get_ego, NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  ns = GNUNET_NAMESTORE_connect(cfg);
+  sh = GNUNET_IDENTITY_connect(cfg, &get_ego, NULL);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
 }
 
 
@@ -436,23 +441,23 @@ run (void *cls, char *const *args, const char *cfgfile,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   int r;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
     return 2;
 
-  GNUNET_log_setup ("gnunet-gns-import", "WARNING", NULL);
+  GNUNET_log_setup("gnunet-gns-import", "WARNING", NULL);
   ret = 0;
-  r = GNUNET_PROGRAM_run (argc, argv, "gnunet-gns-import",
-                          _("This program will import some GNS authorities into your GNS namestore."),
-                          options,
-                          &run, NULL);
-  GNUNET_free ((void*) argv);
+  r = GNUNET_PROGRAM_run(argc, argv, "gnunet-gns-import",
+                         _("This program will import some GNS authorities into your GNS namestore."),
+                         options,
+                         &run, NULL);
+  GNUNET_free((void*)argv);
   return GNUNET_OK == r ? ret : 1;
 }
 
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index eb8115026..6285a8fcd 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @author Martin Schanzenbach
  * @author Christian Grothoff
@@ -94,13 +94,13 @@
 /**
  * After how long do we clean up unused MHD TLS instances?
  */
-#define MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+#define MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
 
 /**
  * After how long do we clean up Socks5 handles that failed to show any activity
  * with their respective MHD instance?
  */
-#define HTTP_HANDSHAKE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
+#define HTTP_HANDSHAKE_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)
 
 
 /**
@@ -110,13 +110,13 @@
  * @param fun name of curl_easy-function that gave the error
  * @param rc return code from curl
  */
-#define LOG_CURL_EASY(level,fun,rc) \
-   GNUNET_log (level, \
-               _("%s failed at %s:%d: `%s'\n"), \
-               fun, \
-               __FILE__, \
-               __LINE__, \
-               curl_easy_strerror (rc))
+#define LOG_CURL_EASY(level, fun, rc) \
+  GNUNET_log(level, \
+             _("%s failed at %s:%d: `%s'\n"), \
+             fun, \
+             __FILE__, \
+             __LINE__, \
+             curl_easy_strerror(rc))
 
 
 /* *************** Socks protocol definitions (move to TUN?) ****************** */
@@ -135,8 +135,7 @@
 /**
  * Commands in Socks5.
  */
-enum Socks5Commands
-{
+enum Socks5Commands {
   /**
    * Establish TCP/IP stream.
    */
@@ -157,8 +156,7 @@ enum Socks5Commands
 /**
  * Address types in Socks5.
  */
-enum Socks5AddressType
-{
+enum Socks5AddressType {
   /**
    * IPv4 address.
    */
@@ -173,15 +171,13 @@ enum Socks5AddressType
    * IPv6 address.
    */
   SOCKS5_AT_IPV6 = 4
-
 };
 
 
 /**
  * Status codes in Socks5 response.
  */
-enum Socks5StatusCode
-{
+enum Socks5StatusCode {
   SOCKS5_STATUS_REQUEST_GRANTED = 0,
   SOCKS5_STATUS_GENERAL_FAILURE = 1,
   SOCKS5_STATUS_CONNECTION_NOT_ALLOWED_BY_RULE = 2,
@@ -197,8 +193,7 @@ enum Socks5StatusCode
 /**
  * Client hello in Socks5 protocol.
  */
-struct Socks5ClientHelloMessage
-{
+struct Socks5ClientHelloMessage {
   /**
    * Should be #SOCKS_VERSION_5.
    */
@@ -210,15 +205,13 @@ struct Socks5ClientHelloMessage
   uint8_t num_auth_methods;
 
   /* followed by supported authentication methods, 1 byte per method */
-
 };
 
 
 /**
  * Server hello in Socks5 protocol.
  */
-struct Socks5ServerHelloMessage
-{
+struct Socks5ServerHelloMessage {
   /**
    * Should be #SOCKS_VERSION_5.
    */
@@ -235,8 +228,7 @@ struct Socks5ServerHelloMessage
 /**
  * Client socks request in Socks5 protocol.
  */
-struct Socks5ClientRequestMessage
-{
+struct Socks5ClientRequestMessage {
   /**
    * Should be #SOCKS_VERSION_5.
    */
@@ -268,8 +260,7 @@ struct Socks5ClientRequestMessage
 /**
  * Server response to client requests in Socks5 protocol.
  */
-struct Socks5ServerResponseMessage
-{
+struct Socks5ServerResponseMessage {
   /**
    * Should be #SOCKS_VERSION_5.
    */
@@ -295,7 +286,6 @@ struct Socks5ServerResponseMessage
    * length field (uint8_t) in front (depending on @e addr_type).
    * followed by port number in network byte order (uint16_t).
    */
-
 };
 
 
@@ -305,8 +295,7 @@ struct Socks5ServerResponseMessage
 /**
  * A structure for CA cert/key
  */
-struct ProxyCA
-{
+struct ProxyCA {
   /**
    * The certificate
    */
@@ -322,8 +311,7 @@ struct ProxyCA
 /**
  * Structure for GNS certificates
  */
-struct ProxyGNSCertificate
-{
+struct ProxyGNSCertificate {
   /**
    * The certificate as PEM
    */
@@ -340,8 +328,7 @@ struct ProxyGNSCertificate
 /**
  * A structure for all running Httpds
  */
-struct MhdHttpList
-{
+struct MhdHttpList {
   /**
    * DLL for httpds
    */
@@ -376,7 +363,6 @@ struct MhdHttpList
    * is this an ssl daemon?
    */
   int is_ssl;
-
 };
 
 
@@ -386,8 +372,7 @@ struct MhdHttpList
 /**
  * The socks phases.
  */
-enum SocksPhase
-{
+enum SocksPhase {
   /**
    * We're waiting to get the client hello.
    */
@@ -443,8 +428,7 @@ enum SocksPhase
 /**
  * A header list
  */
-struct HttpResponseHeader
-{
+struct HttpResponseHeader {
   /**
    * DLL
    */
@@ -469,9 +453,7 @@ struct HttpResponseHeader
 /**
  * A structure for socks requests
  */
-struct Socks5Request
-{
-
+struct Socks5Request {
   /**
    * DLL.
    */
@@ -769,7 +751,7 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
  * @param hd the daemon to run now.
  */
 static void
-run_mhd_now (struct MhdHttpList *hd);
+run_mhd_now(struct MhdHttpList *hd);
 
 
 /**
@@ -778,79 +760,79 @@ run_mhd_now (struct MhdHttpList *hd);
  * @param s5r the handle to destroy
  */
 static void
-cleanup_s5r (struct Socks5Request *s5r)
+cleanup_s5r(struct Socks5Request *s5r)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up socks request\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Cleaning up socks request\n");
   if (NULL != s5r->curl)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Cleaning up cURL handle\n");
-    curl_multi_remove_handle (curl_multi,
-                              s5r->curl);
-    curl_easy_cleanup (s5r->curl);
-    s5r->curl = NULL;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Cleaning up cURL handle\n");
+      curl_multi_remove_handle(curl_multi,
+                               s5r->curl);
+      curl_easy_cleanup(s5r->curl);
+      s5r->curl = NULL;
+    }
   if (s5r->suspended)
-  {
-    s5r->suspended = GNUNET_NO;
-    MHD_resume_connection (s5r->con);
-  }
-  curl_slist_free_all (s5r->headers);
+    {
+      s5r->suspended = GNUNET_NO;
+      MHD_resume_connection(s5r->con);
+    }
+  curl_slist_free_all(s5r->headers);
   if (NULL != s5r->hosts)
-  {
-    curl_slist_free_all (s5r->hosts);
-  }
-  if ( (NULL != s5r->response) &&
-       (curl_failure_response != s5r->response) )
-  {
-    MHD_destroy_response (s5r->response);
-    s5r->response = NULL;
-  }
+    {
+      curl_slist_free_all(s5r->hosts);
+    }
+  if ((NULL != s5r->response) &&
+      (curl_failure_response != s5r->response))
+    {
+      MHD_destroy_response(s5r->response);
+      s5r->response = NULL;
+    }
   if (NULL != s5r->rtask)
-  {
-    GNUNET_SCHEDULER_cancel (s5r->rtask);
-    s5r->rtask = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(s5r->rtask);
+      s5r->rtask = NULL;
+    }
   if (NULL != s5r->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (s5r->timeout_task);
-    s5r->timeout_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(s5r->timeout_task);
+      s5r->timeout_task = NULL;
+    }
   if (NULL != s5r->wtask)
-  {
-    GNUNET_SCHEDULER_cancel (s5r->wtask);
-    s5r->wtask = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(s5r->wtask);
+      s5r->wtask = NULL;
+    }
   if (NULL != s5r->gns_lookup)
-  {
-    GNUNET_GNS_lookup_with_tld_cancel (s5r->gns_lookup);
-    s5r->gns_lookup = NULL;
-  }
+    {
+      GNUNET_GNS_lookup_with_tld_cancel(s5r->gns_lookup);
+      s5r->gns_lookup = NULL;
+    }
   if (NULL != s5r->sock)
-  {
-    if (SOCKS5_SOCKET_WITH_MHD <= s5r->state)
-      GNUNET_NETWORK_socket_free_memory_only_ (s5r->sock);
-    else
-      GNUNET_NETWORK_socket_close (s5r->sock);
-    s5r->sock = NULL;
-  }
-  GNUNET_CONTAINER_DLL_remove (s5r_head,
-                               s5r_tail,
-                               s5r);
-  GNUNET_free_non_null (s5r->domain);
-  GNUNET_free_non_null (s5r->leho);
-  GNUNET_free_non_null (s5r->url);
-  for (unsigned int i=0;i<s5r->num_danes;i++)
-    GNUNET_free (s5r->dane_data[i]);
-  GNUNET_free (s5r);
+    {
+      if (SOCKS5_SOCKET_WITH_MHD <= s5r->state)
+        GNUNET_NETWORK_socket_free_memory_only_(s5r->sock);
+      else
+        GNUNET_NETWORK_socket_close(s5r->sock);
+      s5r->sock = NULL;
+    }
+  GNUNET_CONTAINER_DLL_remove(s5r_head,
+                              s5r_tail,
+                              s5r);
+  GNUNET_free_non_null(s5r->domain);
+  GNUNET_free_non_null(s5r->leho);
+  GNUNET_free_non_null(s5r->url);
+  for (unsigned int i = 0; i < s5r->num_danes; i++)
+    GNUNET_free(s5r->dane_data[i]);
+  GNUNET_free(s5r);
 }
 
 
 /* ************************* HTTP handling with cURL *********************** */
 
 static void
-curl_download_prepare ();
+curl_download_prepare();
 
 
 /**
@@ -865,89 +847,89 @@ curl_download_prepare ();
  * @return number of bytes written to @a buf
  */
 static ssize_t
-mhd_content_cb (void *cls,
-                uint64_t pos,
-                char* buf,
-                size_t max)
+mhd_content_cb(void *cls,
+               uint64_t pos,
+               char* buf,
+               size_t max)
 {
   struct Socks5Request *s5r = cls;
   size_t bytes_to_copy;
 
-  if ( (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
-       (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
-  {
-    /* we're still not done with the upload, do not yet
-       start the download, the IO buffer is still full
-       with upload data. */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Pausing MHD download %s%s, not yet ready for download\n",
-                s5r->domain,
-                s5r->url);
-    return 0; /* not yet ready for data download */
-  }
-  bytes_to_copy = GNUNET_MIN (max,
-                              s5r->io_len);
-  if ( (0 == bytes_to_copy) &&
-       (SOCKS5_SOCKET_DOWNLOAD_DONE != s5r->state) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Pausing MHD download %s%s, no data available\n",
-                s5r->domain,
-                s5r->url);
-    if (NULL != s5r->curl)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Continuing CURL interaction for %s%s\n",
-                  s5r->domain,
-                  s5r->url);
-      if (GNUNET_YES == s5r->curl_paused)
-      {
-        s5r->curl_paused = GNUNET_NO;
-        curl_easy_pause (s5r->curl,
-                         CURLPAUSE_CONT);
-      }
-      curl_download_prepare ();
+  if ((SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
+      (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state))
+    {
+      /* we're still not done with the upload, do not yet
+         start the download, the IO buffer is still full
+         with upload data. */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Pausing MHD download %s%s, not yet ready for download\n",
+                 s5r->domain,
+                 s5r->url);
+      return 0; /* not yet ready for data download */
     }
-    if (GNUNET_NO == s5r->suspended)
+  bytes_to_copy = GNUNET_MIN(max,
+                             s5r->io_len);
+  if ((0 == bytes_to_copy) &&
+      (SOCKS5_SOCKET_DOWNLOAD_DONE != s5r->state))
     {
-      MHD_suspend_connection (s5r->con);
-      s5r->suspended = GNUNET_YES;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Pausing MHD download %s%s, no data available\n",
+                 s5r->domain,
+                 s5r->url);
+      if (NULL != s5r->curl)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Continuing CURL interaction for %s%s\n",
+                     s5r->domain,
+                     s5r->url);
+          if (GNUNET_YES == s5r->curl_paused)
+            {
+              s5r->curl_paused = GNUNET_NO;
+              curl_easy_pause(s5r->curl,
+                              CURLPAUSE_CONT);
+            }
+          curl_download_prepare();
+        }
+      if (GNUNET_NO == s5r->suspended)
+        {
+          MHD_suspend_connection(s5r->con);
+          s5r->suspended = GNUNET_YES;
+        }
+      return 0; /* more data later */
     }
-    return 0; /* more data later */
-  }
-  if ( (0 == bytes_to_copy) &&
-       (SOCKS5_SOCKET_DOWNLOAD_DONE == s5r->state) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Completed MHD download %s%s\n",
-                s5r->domain,
-                s5r->url);
-    return MHD_CONTENT_READER_END_OF_STREAM;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Writing %llu/%llu bytes to %s%s\n",
-              (unsigned long long) bytes_to_copy,
-              (unsigned long long) s5r->io_len,
-              s5r->domain,
-              s5r->url);
-  GNUNET_memcpy (buf,
-                 s5r->io_buf,
-                 bytes_to_copy);
-  memmove (s5r->io_buf,
-           &s5r->io_buf[bytes_to_copy],
-           s5r->io_len - bytes_to_copy);
+  if ((0 == bytes_to_copy) &&
+      (SOCKS5_SOCKET_DOWNLOAD_DONE == s5r->state))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Completed MHD download %s%s\n",
+                 s5r->domain,
+                 s5r->url);
+      return MHD_CONTENT_READER_END_OF_STREAM;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Writing %llu/%llu bytes to %s%s\n",
+             (unsigned long long)bytes_to_copy,
+             (unsigned long long)s5r->io_len,
+             s5r->domain,
+             s5r->url);
+  GNUNET_memcpy(buf,
+                s5r->io_buf,
+                bytes_to_copy);
+  memmove(s5r->io_buf,
+          &s5r->io_buf[bytes_to_copy],
+          s5r->io_len - bytes_to_copy);
   s5r->io_len -= bytes_to_copy;
-  if ( (NULL != s5r->curl) &&
-       (GNUNET_YES == s5r->curl_paused) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Continuing CURL interaction for %s%s\n",
-                s5r->domain,
-                s5r->url);
-    s5r->curl_paused = GNUNET_NO;
-    curl_easy_pause (s5r->curl,
-                     CURLPAUSE_CONT);
-  }
+  if ((NULL != s5r->curl) &&
+      (GNUNET_YES == s5r->curl_paused))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Continuing CURL interaction for %s%s\n",
+                 s5r->domain,
+                 s5r->url);
+      s5r->curl_paused = GNUNET_NO;
+      curl_easy_pause(s5r->curl,
+                      CURLPAUSE_CONT);
+    }
   return bytes_to_copy;
 }
 
@@ -961,7 +943,7 @@ mhd_content_cb (void *cls,
  * @return #GNUNET_OK if the certificate is valid
  */
 static int
-check_ssl_certificate (struct Socks5Request *s5r)
+check_ssl_certificate(struct Socks5Request *s5r)
 {
   unsigned int cert_list_size;
   const gnutls_datum_t *chainp;
@@ -973,113 +955,113 @@ check_ssl_certificate (struct Socks5Request *s5r)
   const char *name;
 
   s5r->ssl_checked = GNUNET_YES;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Checking X.509 certificate\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Checking X.509 certificate\n");
   if (CURLE_OK !=
-      curl_easy_getinfo (s5r->curl,
-                         CURLINFO_TLS_SESSION,
-                         &tlsinfo))
+      curl_easy_getinfo(s5r->curl,
+                        CURLINFO_TLS_SESSION,
+                        &tlsinfo))
     return GNUNET_SYSERR;
   if (CURLSSLBACKEND_GNUTLS != tlsinfo->backend)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unsupported CURL TLS backend %d\n"),
-                tlsinfo->backend);
-    return GNUNET_SYSERR;
-  }
-  chainp = gnutls_certificate_get_peers (tlsinfo->internals,
-                                         &cert_list_size);
-  if ( (! chainp) ||
-       (0 == cert_list_size) )
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unsupported CURL TLS backend %d\n"),
+                 tlsinfo->backend);
+      return GNUNET_SYSERR;
+    }
+  chainp = gnutls_certificate_get_peers(tlsinfo->internals,
+                                        &cert_list_size);
+  if ((!chainp) ||
+      (0 == cert_list_size))
     return GNUNET_SYSERR;
 
-  size = sizeof (certdn);
+  size = sizeof(certdn);
   /* initialize an X.509 certificate structure. */
-  gnutls_x509_crt_init (&x509_cert);
-  gnutls_x509_crt_import (x509_cert,
-                          chainp,
-                          GNUTLS_X509_FMT_DER);
-
-  if (0 != (rc = gnutls_x509_crt_get_dn_by_oid (x509_cert,
-                                                GNUTLS_OID_X520_COMMON_NAME,
-                                                0, /* the first and only one */
-                                                0 /* no DER encoding */,
-                                                certdn,
-                                                &size)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to fetch CN from cert: %s\n"),
-                gnutls_strerror(rc));
-    gnutls_x509_crt_deinit (x509_cert);
-    return GNUNET_SYSERR;
-  }
+  gnutls_x509_crt_init(&x509_cert);
+  gnutls_x509_crt_import(x509_cert,
+                         chainp,
+                         GNUTLS_X509_FMT_DER);
+
+  if (0 != (rc = gnutls_x509_crt_get_dn_by_oid(x509_cert,
+                                               GNUTLS_OID_X520_COMMON_NAME,
+                                               0,  /* the first and only one */
+                                               0 /* no DER encoding */,
+                                               certdn,
+                                               &size)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to fetch CN from cert: %s\n"),
+                 gnutls_strerror(rc));
+      gnutls_x509_crt_deinit(x509_cert);
+      return GNUNET_SYSERR;
+    }
   /* check for TLSA/DANE records */
 #if HAVE_GNUTLS_DANE
   if (0 != s5r->num_danes)
-  {
-    dane_state_t dane_state;
-    dane_query_t dane_query;
-    unsigned int verify;
+    {
+      dane_state_t dane_state;
+      dane_query_t dane_query;
+      unsigned int verify;
 
-    /* FIXME: add flags to gnutls to NOT read UNBOUND_ROOT_KEY_FILE here! */
-    if (0 != (rc = dane_state_init (&dane_state,
+      /* FIXME: add flags to gnutls to NOT read UNBOUND_ROOT_KEY_FILE here! */
+      if (0 != (rc = dane_state_init(&dane_state,
 #ifdef DANE_F_IGNORE_DNSSEC
-                                    DANE_F_IGNORE_DNSSEC |
+                                     DANE_F_IGNORE_DNSSEC |
 #endif
-                                    DANE_F_IGNORE_LOCAL_RESOLVER)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to initialize DANE: %s\n"),
-                  dane_strerror(rc));
-      gnutls_x509_crt_deinit (x509_cert);
-      return GNUNET_SYSERR;
-    }
-    s5r->dane_data[s5r->num_danes] = NULL;
-    s5r->dane_data_len[s5r->num_danes] = 0;
-    if (0 != (rc = dane_raw_tlsa (dane_state,
-                                  &dane_query,
-                                  s5r->dane_data,
-                                  s5r->dane_data_len,
-                                  GNUNET_YES,
-                                  GNUNET_NO)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to parse DANE record: %s\n"),
-                  dane_strerror(rc));
-      dane_state_deinit (dane_state);
-      gnutls_x509_crt_deinit (x509_cert);
-      return GNUNET_SYSERR;
-    }
-    if (0 != (rc = dane_verify_crt_raw (dane_state,
-                                        chainp,
-                                        cert_list_size,
-                                        gnutls_certificate_type_get (tlsinfo->internals),
-                                        dane_query,
-                                        0, 0,
-                                        &verify)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to verify TLS connection using DANE: %s\n"),
-                  dane_strerror(rc));
-      dane_query_deinit (dane_query);
-      dane_state_deinit (dane_state);
-      gnutls_x509_crt_deinit (x509_cert);
-      return GNUNET_SYSERR;
-    }
-    if (0 != verify)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed DANE verification failed with GnuTLS verify status code: %u\n"),
-                  verify);
-      dane_query_deinit (dane_query);
-      dane_state_deinit (dane_state);
-      gnutls_x509_crt_deinit (x509_cert);
-      return GNUNET_SYSERR;
+                                     DANE_F_IGNORE_LOCAL_RESOLVER)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Failed to initialize DANE: %s\n"),
+                     dane_strerror(rc));
+          gnutls_x509_crt_deinit(x509_cert);
+          return GNUNET_SYSERR;
+        }
+      s5r->dane_data[s5r->num_danes] = NULL;
+      s5r->dane_data_len[s5r->num_danes] = 0;
+      if (0 != (rc = dane_raw_tlsa(dane_state,
+                                   &dane_query,
+                                   s5r->dane_data,
+                                   s5r->dane_data_len,
+                                   GNUNET_YES,
+                                   GNUNET_NO)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Failed to parse DANE record: %s\n"),
+                     dane_strerror(rc));
+          dane_state_deinit(dane_state);
+          gnutls_x509_crt_deinit(x509_cert);
+          return GNUNET_SYSERR;
+        }
+      if (0 != (rc = dane_verify_crt_raw(dane_state,
+                                         chainp,
+                                         cert_list_size,
+                                         gnutls_certificate_type_get(tlsinfo->internals),
+                                         dane_query,
+                                         0, 0,
+                                         &verify)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Failed to verify TLS connection using DANE: %s\n"),
+                     dane_strerror(rc));
+          dane_query_deinit(dane_query);
+          dane_state_deinit(dane_state);
+          gnutls_x509_crt_deinit(x509_cert);
+          return GNUNET_SYSERR;
+        }
+      if (0 != verify)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Failed DANE verification failed with GnuTLS verify status code: %u\n"),
+                     verify);
+          dane_query_deinit(dane_query);
+          dane_state_deinit(dane_state);
+          gnutls_x509_crt_deinit(x509_cert);
+          return GNUNET_SYSERR;
+        }
+      dane_query_deinit(dane_query);
+      dane_state_deinit(dane_state);
+      /* success! */
     }
-    dane_query_deinit (dane_query);
-    dane_state_deinit (dane_state);
-    /* success! */
-  }
   else
 #endif
   {
@@ -1088,27 +1070,27 @@ check_ssl_certificate (struct Socks5Request *s5r)
     if (NULL != s5r->leho)
       name = s5r->leho;
     if (NULL != name)
-    {
-      if (0 == (rc = gnutls_x509_crt_check_hostname (x509_cert,
-                                                     name)))
       {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _("TLS certificate subject name (%s) does not match `%s': %d\n"),
-                    certdn,
-                    name,
-                    rc);
-        gnutls_x509_crt_deinit (x509_cert);
-        return GNUNET_SYSERR;
+        if (0 == (rc = gnutls_x509_crt_check_hostname(x509_cert,
+                                                      name)))
+          {
+            GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                       _("TLS certificate subject name (%s) does not match `%s': %d\n"),
+                       certdn,
+                       name,
+                       rc);
+            gnutls_x509_crt_deinit(x509_cert);
+            return GNUNET_SYSERR;
+          }
       }
-    }
     else
-    {
-      /* we did not even have the domain name!? */
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+      {
+        /* we did not even have the domain name!? */
+        GNUNET_break(0);
+        return GNUNET_SYSERR;
+      }
   }
-  gnutls_x509_crt_deinit (x509_cert);
+  gnutls_x509_crt_deinit(x509_cert);
   return GNUNET_OK;
 }
 
@@ -1126,10 +1108,10 @@ check_ssl_certificate (struct Socks5Request *s5r)
  * @return size of processed bytes
  */
 static size_t
-curl_check_hdr (void *buffer,
-                size_t size,
-                size_t nmemb,
-                void *cls)
+curl_check_hdr(void *buffer,
+               size_t size,
+               size_t nmemb,
+               void *cls)
 {
   struct Socks5Request *s5r = cls;
   struct HttpResponseHeader *header;
@@ -1145,178 +1127,178 @@ curl_check_hdr (void *buffer,
   int domain_matched;
   char *tok;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving HTTP response header from CURL\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving HTTP response header from CURL\n");
   /* first, check TLS certificate */
-  if ( (GNUNET_YES != s5r->ssl_checked) &&
-       (GNUNET_YES == s5r->is_tls))
-       //(HTTPS_PORT == s5r->port))
-  {
-    if (GNUNET_OK != check_ssl_certificate (s5r))
-      return 0;
-  }
-  ndup = GNUNET_strndup (buffer,
-                         bytes);
-  hdr_type = strtok (ndup,
-                     ":");
+  if ((GNUNET_YES != s5r->ssl_checked) &&
+      (GNUNET_YES == s5r->is_tls))
+  //(HTTPS_PORT == s5r->port))
+    {
+      if (GNUNET_OK != check_ssl_certificate(s5r))
+        return 0;
+    }
+  ndup = GNUNET_strndup(buffer,
+                        bytes);
+  hdr_type = strtok(ndup,
+                    ":");
   if (NULL == hdr_type)
-  {
-    GNUNET_free (ndup);
-    return bytes;
-  }
-  hdr_val = strtok (NULL,
-                    "");
+    {
+      GNUNET_free(ndup);
+      return bytes;
+    }
+  hdr_val = strtok(NULL,
+                   "");
   if (NULL == hdr_val)
-  {
-    GNUNET_free (ndup);
-    return bytes;
-  }
+    {
+      GNUNET_free(ndup);
+      return bytes;
+    }
   if (' ' == *hdr_val)
     hdr_val++;
 
   /* custom logic for certain header types */
   new_cookie_hdr = NULL;
-  if ( (NULL != s5r->leho) &&
-       (0 == strcasecmp (hdr_type,
-                         MHD_HTTP_HEADER_SET_COOKIE)) )
+  if ((NULL != s5r->leho) &&
+      (0 == strcasecmp(hdr_type,
+                       MHD_HTTP_HEADER_SET_COOKIE)))
 
-  {
-    new_cookie_hdr = GNUNET_malloc (strlen (hdr_val) +
-                                    strlen (s5r->domain) + 1);
-    offset = 0;
-    domain_matched = GNUNET_NO; /* make sure we match domain at most once */
-    for (tok = strtok (hdr_val, ";"); NULL != tok; tok = strtok (NULL, ";"))
-    {
-      if ( (0 == strncasecmp (tok,
-                              " domain",
-                              strlen (" domain"))) &&
-           (GNUNET_NO == domain_matched) )
-      {
-        domain_matched = GNUNET_YES;
-        cookie_domain = tok + strlen (" domain") + 1;
-        if (strlen (cookie_domain) < strlen (s5r->leho))
+    {
+      new_cookie_hdr = GNUNET_malloc(strlen(hdr_val) +
+                                     strlen(s5r->domain) + 1);
+      offset = 0;
+      domain_matched = GNUNET_NO; /* make sure we match domain at most once */
+      for (tok = strtok(hdr_val, ";"); NULL != tok; tok = strtok(NULL, ";"))
         {
-          delta_cdomain = strlen (s5r->leho) - strlen (cookie_domain);
-          if (0 == strcasecmp (cookie_domain,
-                               s5r->leho + delta_cdomain))
-          {
-            offset += sprintf (new_cookie_hdr + offset,
-                               " domain=%s;",
-                               s5r->domain);
-            continue;
-          }
+          if ((0 == strncasecmp(tok,
+                                " domain",
+                                strlen(" domain"))) &&
+              (GNUNET_NO == domain_matched))
+            {
+              domain_matched = GNUNET_YES;
+              cookie_domain = tok + strlen(" domain") + 1;
+              if (strlen(cookie_domain) < strlen(s5r->leho))
+                {
+                  delta_cdomain = strlen(s5r->leho) - strlen(cookie_domain);
+                  if (0 == strcasecmp(cookie_domain,
+                                      s5r->leho + delta_cdomain))
+                    {
+                      offset += sprintf(new_cookie_hdr + offset,
+                                        " domain=%s;",
+                                        s5r->domain);
+                      continue;
+                    }
+                }
+              else if (0 == strcmp(cookie_domain,
+                                   s5r->leho))
+                {
+                  offset += sprintf(new_cookie_hdr + offset,
+                                    " domain=%s;",
+                                    s5r->domain);
+                  continue;
+                }
+              else if (('.' == cookie_domain[0]) &&
+                       (0 == strcmp(&cookie_domain[1],
+                                    s5r->leho)))
+                {
+                  offset += sprintf(new_cookie_hdr + offset,
+                                    " domain=.%s;",
+                                    s5r->domain);
+                  continue;
+                }
+              GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                         _("Cookie domain `%s' supplied by server is invalid\n"),
+                         tok);
+            }
+          GNUNET_memcpy(new_cookie_hdr + offset,
+                        tok,
+                        strlen(tok));
+          offset += strlen(tok);
+          new_cookie_hdr[offset++] = ';';
         }
-        else if (0 == strcmp (cookie_domain,
-                              s5r->leho))
+      hdr_val = new_cookie_hdr;
+    }
+
+  new_location = NULL;
+  if (0 == strcasecmp(MHD_HTTP_HEADER_TRANSFER_ENCODING,
+                      hdr_type))
+    {
+      /* Ignore transfer encoding, set automatically by MHD if required */
+      goto cleanup;
+    }
+  if ((0 == strcasecmp(MHD_HTTP_HEADER_LOCATION,
+                       hdr_type)))
+    {
+      char *leho_host;
+
+      GNUNET_asprintf(&leho_host,
+                      (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                      ? "http://%s"
+                      : "https://%s",
+                      s5r->leho);
+      if (0 == strncmp(leho_host,
+                       hdr_val,
+                       strlen(leho_host)))
         {
-          offset += sprintf (new_cookie_hdr + offset,
-                             " domain=%s;",
-                             s5r->domain);
-          continue;
+          GNUNET_asprintf(&new_location,
+                          "%s%s%s",
+                          (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                          ? "http://"
+                          : "https://",
+                          s5r->domain,
+                          hdr_val + strlen(leho_host));
+          hdr_val = new_location;
         }
-        else if ( ('.' == cookie_domain[0]) &&
-                  (0 == strcmp (&cookie_domain[1],
-                                s5r->leho)) )
+      GNUNET_free(leho_host);
+    }
+  if (0 == strcasecmp(MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+                      hdr_type))
+    {
+      char *leho_host;
+
+      GNUNET_asprintf(&leho_host,
+                      (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                      ? "http://%s"
+                      : "https://%s",
+                      s5r->leho);
+      if (0 == strncmp(leho_host,
+                       hdr_val,
+                       strlen(leho_host)))
         {
-          offset += sprintf (new_cookie_hdr + offset,
-                             " domain=.%s;",
-                             s5r->domain);
-          continue;
+          GNUNET_asprintf(&new_location,
+                          "%s%s",
+                          (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                          ? "http://"
+                          : "https://",
+                          s5r->domain);
+          hdr_val = new_location;
         }
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _("Cookie domain `%s' supplied by server is invalid\n"),
-                    tok);
-      }
-      GNUNET_memcpy (new_cookie_hdr + offset,
-                     tok,
-                     strlen (tok));
-      offset += strlen (tok);
-      new_cookie_hdr[offset++] = ';';
+      GNUNET_free(leho_host);
     }
-    hdr_val = new_cookie_hdr;
-  }
-
-  new_location = NULL;
-  if (0 == strcasecmp (MHD_HTTP_HEADER_TRANSFER_ENCODING,
-                       hdr_type))
-  {
-    /* Ignore transfer encoding, set automatically by MHD if required */
-    goto cleanup;
-  }
-  if ((0 == strcasecmp (MHD_HTTP_HEADER_LOCATION,
-                       hdr_type)))
-  {
-    char *leho_host;
-
-    GNUNET_asprintf (&leho_host,
-                     (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                     ? "http://%s"
-                     : "https://%s",
-                     s5r->leho);
-    if (0 == strncmp (leho_host,
-                      hdr_val,
-                      strlen (leho_host)))
-    {
-      GNUNET_asprintf (&new_location,
-                       "%s%s%s",
-                       (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                       ? "http://"
-                       : "https://",
-                       s5r->domain,
-                       hdr_val + strlen (leho_host));
-      hdr_val = new_location;
-    }
-    GNUNET_free (leho_host);
-  }
-  if (0 == strcasecmp (MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-       hdr_type))
-  {
-    char *leho_host;
-
-    GNUNET_asprintf (&leho_host,
-                     (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                     ? "http://%s"
-                     : "https://%s",
-                     s5r->leho);
-    if (0 == strncmp (leho_host,
-                      hdr_val,
-                      strlen (leho_host)))
-    {
-      GNUNET_asprintf (&new_location,
-                       "%s%s",
-                       (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                       ? "http://"
-                       : "https://",
-                       s5r->domain);
-      hdr_val = new_location;
-    }
-    GNUNET_free (leho_host);
-  }
 
   /* MHD does not allow certain characters in values, remove those */
-  if (NULL != (tok = strchr (hdr_val, '\n')))
+  if (NULL != (tok = strchr(hdr_val, '\n')))
     *tok = '\0';
-  if (NULL != (tok = strchr (hdr_val, '\r')))
+  if (NULL != (tok = strchr(hdr_val, '\r')))
     *tok = '\0';
-  if (NULL != (tok = strchr (hdr_val, '\t')))
+  if (NULL != (tok = strchr(hdr_val, '\t')))
     *tok = '\0';
-  if (0 != strlen (hdr_val)) /* Rely in MHD to set those */
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Adding header %s: %s to MHD response\n",
-                hdr_type,
-                hdr_val);
-    header = GNUNET_new (struct HttpResponseHeader);
-    header->type = GNUNET_strdup (hdr_type);
-    header->value = GNUNET_strdup (hdr_val);
-    GNUNET_CONTAINER_DLL_insert (s5r->header_head,
-                                 s5r->header_tail,
-                                 header);
-  }
- cleanup:
-  GNUNET_free (ndup);
-  GNUNET_free_non_null (new_cookie_hdr);
-  GNUNET_free_non_null (new_location);
+  if (0 != strlen(hdr_val))  /* Rely in MHD to set those */
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Adding header %s: %s to MHD response\n",
+                 hdr_type,
+                 hdr_val);
+      header = GNUNET_new(struct HttpResponseHeader);
+      header->type = GNUNET_strdup(hdr_type);
+      header->value = GNUNET_strdup(hdr_val);
+      GNUNET_CONTAINER_DLL_insert(s5r->header_head,
+                                  s5r->header_tail,
+                                  header);
+    }
+cleanup:
+  GNUNET_free(ndup);
+  GNUNET_free_non_null(new_cookie_hdr);
+  GNUNET_free_non_null(new_location);
   return bytes;
 }
 
@@ -1330,73 +1312,73 @@ curl_check_hdr (void *buffer,
  *         already initialized before
  */
 static int
-create_mhd_response_from_s5r (struct Socks5Request *s5r)
+create_mhd_response_from_s5r(struct Socks5Request *s5r)
 {
   long resp_code;
   double content_length;
 
   if (NULL != s5r->response)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Response already set!\n");
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Response already set!\n");
+      return GNUNET_SYSERR;
+    }
 
-  GNUNET_break (CURLE_OK ==
-                curl_easy_getinfo (s5r->curl,
-                                   CURLINFO_RESPONSE_CODE,
-                                   &resp_code));
-  GNUNET_break (CURLE_OK ==
-                curl_easy_getinfo (s5r->curl,
-                                   CURLINFO_CONTENT_LENGTH_DOWNLOAD,
-                                   &content_length));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Creating MHD response with code %d and size %d for %s%s\n",
-              (int) resp_code,
-              (int) content_length,
-              s5r->domain,
-              s5r->url);
+  GNUNET_break(CURLE_OK ==
+               curl_easy_getinfo(s5r->curl,
+                                 CURLINFO_RESPONSE_CODE,
+                                 &resp_code));
+  GNUNET_break(CURLE_OK ==
+               curl_easy_getinfo(s5r->curl,
+                                 CURLINFO_CONTENT_LENGTH_DOWNLOAD,
+                                 &content_length));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Creating MHD response with code %d and size %d for %s%s\n",
+             (int)resp_code,
+             (int)content_length,
+             s5r->domain,
+             s5r->url);
   s5r->response_code = resp_code;
-  s5r->response = MHD_create_response_from_callback ((-1 == content_length)
-                                                     ? MHD_SIZE_UNKNOWN
-                                                     : content_length,
-                                                     IO_BUFFERSIZE,
-                                                     &mhd_content_cb,
-                                                     s5r,
-                                                     NULL);
+  s5r->response = MHD_create_response_from_callback((-1 == content_length)
+                                                    ? MHD_SIZE_UNKNOWN
+                                                    : content_length,
+                                                    IO_BUFFERSIZE,
+                                                    &mhd_content_cb,
+                                                    s5r,
+                                                    NULL);
   for (struct HttpResponseHeader *header = s5r->header_head;
        NULL != header;
        header = header->next)
-  {
-    if (0 == strcasecmp (header->type,
-                         MHD_HTTP_HEADER_CONTENT_LENGTH))
-      continue; /* MHD won't let us mess with those, for good reason */
-    if ( (0 == strcasecmp (header->type,
+    {
+      if (0 == strcasecmp(header->type,
+                          MHD_HTTP_HEADER_CONTENT_LENGTH))
+        continue; /* MHD won't let us mess with those, for good reason */
+      if ((0 == strcasecmp(header->type,
                            MHD_HTTP_HEADER_TRANSFER_ENCODING)) &&
-         ( (0 == strcasecmp (header->value,
-                             "identity")) ||
-           (0 == strcasecmp (header->value,
-                             "chunked")) ) )
-      continue; /* MHD won't let us mess with those, for good reason */
-    if (MHD_YES !=
-        MHD_add_response_header (s5r->response,
-                                 header->type,
-                                 header->value))
-    {
-      GNUNET_break (0);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Failed to add header `%s:%s'\n",
-                  header->type,
-                  header->value);
+          ((0 == strcasecmp(header->value,
+                            "identity")) ||
+           (0 == strcasecmp(header->value,
+                            "chunked"))))
+        continue; /* MHD won't let us mess with those, for good reason */
+      if (MHD_YES !=
+          MHD_add_response_header(s5r->response,
+                                  header->type,
+                                  header->value))
+        {
+          GNUNET_break(0);
+          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                     "Failed to add header `%s:%s'\n",
+                     header->type,
+                     header->value);
+        }
     }
-  }
   /* force connection to be closed after each request, as we
      do not support HTTP pipelining (yet, FIXME!) */
   /*GNUNET_break (MHD_YES ==
-    MHD_add_response_header (s5r->response,
-    MHD_HTTP_HEADER_CONNECTION,
-    "close"));*/
-  MHD_resume_connection (s5r->con);
+     MHD_add_response_header (s5r->response,
+     MHD_HTTP_HEADER_CONNECTION,
+     "close"));*/
+  MHD_resume_connection(s5r->con);
   s5r->suspended = GNUNET_NO;
   return GNUNET_OK;
 }
@@ -1413,70 +1395,70 @@ create_mhd_response_from_s5r (struct Socks5Request *s5r)
  * @return number of bytes handled
  */
 static size_t
-curl_download_cb (void *ptr,
-                  size_t size,
-                  size_t nmemb,
-                  void* ctx)
+curl_download_cb(void *ptr,
+                 size_t size,
+                 size_t nmemb,
+                 void* ctx)
 {
   struct Socks5Request *s5r = ctx;
   size_t total = size * nmemb;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving %ux%u bytes for `%s%s' from cURL to download\n",
-              (unsigned int) size,
-              (unsigned int) nmemb,
-              s5r->domain,
-              s5r->url);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving %ux%u bytes for `%s%s' from cURL to download\n",
+             (unsigned int)size,
+             (unsigned int)nmemb,
+             s5r->domain,
+             s5r->url);
   if (NULL == s5r->response)
-    GNUNET_assert (GNUNET_OK ==
-                   create_mhd_response_from_s5r (s5r));
-  if ( (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) &&
-       (0 == s5r->io_len))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Previous upload finished... starting DOWNLOAD.\n");
-    s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-  }
-  if ( (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
-       (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
-  {
-    /* we're still not done with the upload, do not yet
-       start the download, the IO buffer is still full
-       with upload data. */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Pausing CURL download `%s%s', waiting for UPLOAD to finish\n",
-                s5r->domain,
-                s5r->url);
-    s5r->curl_paused = GNUNET_YES;
-    return CURL_WRITEFUNC_PAUSE; /* not yet ready for data download */
-  }
-  if (sizeof (s5r->io_buf) - s5r->io_len < total)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Pausing CURL `%s%s' download, not enough space %llu %llu %llu\n",
-                s5r->domain,
-                s5r->url,
-                (unsigned long long) sizeof (s5r->io_buf),
-                (unsigned long long) s5r->io_len,
-                (unsigned long long) total);
-    s5r->curl_paused = GNUNET_YES;
-    return CURL_WRITEFUNC_PAUSE; /* not enough space */
-  }
-  GNUNET_memcpy (&s5r->io_buf[s5r->io_len],
-                 ptr,
-                 total);
+    GNUNET_assert(GNUNET_OK ==
+                  create_mhd_response_from_s5r(s5r));
+  if ((SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) &&
+      (0 == s5r->io_len))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Previous upload finished... starting DOWNLOAD.\n");
+      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+    }
+  if ((SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
+      (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state))
+    {
+      /* we're still not done with the upload, do not yet
+         start the download, the IO buffer is still full
+         with upload data. */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Pausing CURL download `%s%s', waiting for UPLOAD to finish\n",
+                 s5r->domain,
+                 s5r->url);
+      s5r->curl_paused = GNUNET_YES;
+      return CURL_WRITEFUNC_PAUSE; /* not yet ready for data download */
+    }
+  if (sizeof(s5r->io_buf) - s5r->io_len < total)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Pausing CURL `%s%s' download, not enough space %llu %llu %llu\n",
+                 s5r->domain,
+                 s5r->url,
+                 (unsigned long long)sizeof(s5r->io_buf),
+                 (unsigned long long)s5r->io_len,
+                 (unsigned long long)total);
+      s5r->curl_paused = GNUNET_YES;
+      return CURL_WRITEFUNC_PAUSE; /* not enough space */
+    }
+  GNUNET_memcpy(&s5r->io_buf[s5r->io_len],
+                ptr,
+                total);
   s5r->io_len += total;
   if (GNUNET_YES == s5r->suspended)
-  {
-    MHD_resume_connection (s5r->con);
-    s5r->suspended = GNUNET_NO;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %llu bytes of payload via cURL from %s\n",
-              (unsigned long long) total,
-              s5r->domain);
+    {
+      MHD_resume_connection(s5r->con);
+      s5r->suspended = GNUNET_NO;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received %llu bytes of payload via cURL from %s\n",
+             (unsigned long long)total,
+             s5r->domain);
   if (s5r->io_len == total)
-    run_mhd_now (s5r->hd);
+    run_mhd_now(s5r->hd);
   return total;
 }
 
@@ -1492,64 +1474,64 @@ curl_download_cb (void *ptr,
  * @return number of bytes copied to @a buf
  */
 static size_t
-curl_upload_cb (void *buf,
-                size_t size,
-                size_t nmemb,
-                void *cls)
+curl_upload_cb(void *buf,
+               size_t size,
+               size_t nmemb,
+               void *cls)
 {
   struct Socks5Request *s5r = cls;
   size_t len = size * nmemb;
   size_t to_copy;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving %ux%u bytes for `%s%s' from cURL to upload\n",
-              (unsigned int) size,
-              (unsigned int) nmemb,
-              s5r->domain,
-              s5r->url);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving %ux%u bytes for `%s%s' from cURL to upload\n",
+             (unsigned int)size,
+             (unsigned int)nmemb,
+             s5r->domain,
+             s5r->url);
 
-  if ( (0 == s5r->io_len) &&
-       (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Pausing CURL UPLOAD %s%s, need more data\n",
-                s5r->domain,
-                s5r->url);
-    return CURL_READFUNC_PAUSE;
-  }
-  if ( (0 == s5r->io_len) &&
-       (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
-  {
-    s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-    if (GNUNET_YES == s5r->curl_paused)
+  if ((0 == s5r->io_len) &&
+      (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state))
     {
-      s5r->curl_paused = GNUNET_NO;
-      curl_easy_pause (s5r->curl,
-                       CURLPAUSE_CONT);
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Completed CURL UPLOAD %s%s\n",
-                s5r->domain,
-                s5r->url);
-    return 0; /* upload finished, can now download */
-  }
-  if ( (SOCKS5_SOCKET_UPLOAD_STARTED != s5r->state) &&
-       (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state) )
-  {
-    GNUNET_break (0);
-    return CURL_READFUNC_ABORT;
-  }
-  to_copy = GNUNET_MIN (s5r->io_len,
-                        len);
-  GNUNET_memcpy (buf,
-                 s5r->io_buf,
-                 to_copy);
-  memmove (s5r->io_buf,
-           &s5r->io_buf[to_copy],
-           s5r->io_len - to_copy);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Pausing CURL UPLOAD %s%s, need more data\n",
+                 s5r->domain,
+                 s5r->url);
+      return CURL_READFUNC_PAUSE;
+    }
+  if ((0 == s5r->io_len) &&
+      (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state))
+    {
+      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+      if (GNUNET_YES == s5r->curl_paused)
+        {
+          s5r->curl_paused = GNUNET_NO;
+          curl_easy_pause(s5r->curl,
+                          CURLPAUSE_CONT);
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Completed CURL UPLOAD %s%s\n",
+                 s5r->domain,
+                 s5r->url);
+      return 0; /* upload finished, can now download */
+    }
+  if ((SOCKS5_SOCKET_UPLOAD_STARTED != s5r->state) &&
+      (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state))
+    {
+      GNUNET_break(0);
+      return CURL_READFUNC_ABORT;
+    }
+  to_copy = GNUNET_MIN(s5r->io_len,
+                       len);
+  GNUNET_memcpy(buf,
+                s5r->io_buf,
+                to_copy);
+  memmove(s5r->io_buf,
+          &s5r->io_buf[to_copy],
+          s5r->io_len - to_copy);
   s5r->io_len -= to_copy;
-  if (s5r->io_len + to_copy == sizeof (s5r->io_buf))
-    run_mhd_now (s5r->hd); /* got more space for upload now */
+  if (s5r->io_len + to_copy == sizeof(s5r->io_buf))
+    run_mhd_now(s5r->hd);  /* got more space for upload now */
   return to_copy;
 }
 
@@ -1564,14 +1546,14 @@ curl_upload_cb (void *buf,
  * @param cls closure
  */
 static void
-curl_task_download (void *cls);
+curl_task_download(void *cls);
 
 
 /**
  * Ask cURL for the select() sets and schedule cURL operations.
  */
 static void
-curl_download_prepare ()
+curl_download_prepare()
 {
   CURLMcode mret;
   fd_set rs;
@@ -1583,63 +1565,63 @@ curl_download_prepare ()
   long to;
   struct GNUNET_TIME_Relative rtime;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Scheduling CURL interaction\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Scheduling CURL interaction\n");
   if (NULL != curl_download_task)
-  {
-    GNUNET_SCHEDULER_cancel (curl_download_task);
-    curl_download_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(curl_download_task);
+      curl_download_task = NULL;
+    }
   max = -1;
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
-  if (CURLM_OK != (mret = curl_multi_fdset (curl_multi,
-                                            &rs,
-                                            &ws,
-                                            &es,
-                                            &max)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s failed at %s:%d: `%s'\n",
-                "curl_multi_fdset", __FILE__, __LINE__,
-                curl_multi_strerror (mret));
-    return;
-  }
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
+  if (CURLM_OK != (mret = curl_multi_fdset(curl_multi,
+                                           &rs,
+                                           &ws,
+                                           &es,
+                                           &max)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "%s failed at %s:%d: `%s'\n",
+                 "curl_multi_fdset", __FILE__, __LINE__,
+                 curl_multi_strerror(mret));
+      return;
+    }
   to = -1;
-  GNUNET_break (CURLM_OK ==
-                curl_multi_timeout (curl_multi,
-                                    &to));
+  GNUNET_break(CURLM_OK ==
+               curl_multi_timeout(curl_multi,
+                                  &to));
   if (-1 == to)
     rtime = GNUNET_TIME_UNIT_FOREVER_REL;
   else
-    rtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                           to);
+    rtime = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
+                                          to);
   if (-1 != max)
-  {
-    grs = GNUNET_NETWORK_fdset_create ();
-    gws = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy_native (grs,
-                                      &rs,
-                                      max + 1);
-    GNUNET_NETWORK_fdset_copy_native (gws,
-                                      &ws,
-                                      max + 1);
-    curl_download_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                      rtime,
-                                                      grs,
-                                                      gws,
-                                                      &curl_task_download,
-                                                      curl_multi);
-    GNUNET_NETWORK_fdset_destroy (gws);
-    GNUNET_NETWORK_fdset_destroy (grs);
-  }
-  else
-  {
-    curl_download_task = GNUNET_SCHEDULER_add_delayed (rtime,
+    {
+      grs = GNUNET_NETWORK_fdset_create();
+      gws = GNUNET_NETWORK_fdset_create();
+      GNUNET_NETWORK_fdset_copy_native(grs,
+                                       &rs,
+                                       max + 1);
+      GNUNET_NETWORK_fdset_copy_native(gws,
+                                       &ws,
+                                       max + 1);
+      curl_download_task = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                       rtime,
+                                                       grs,
+                                                       gws,
                                                        &curl_task_download,
                                                        curl_multi);
-  }
+      GNUNET_NETWORK_fdset_destroy(gws);
+      GNUNET_NETWORK_fdset_destroy(grs);
+    }
+  else
+    {
+      curl_download_task = GNUNET_SCHEDULER_add_delayed(rtime,
+                                                        &curl_task_download,
+                                                        curl_multi);
+    }
 }
 
 
@@ -1649,7 +1631,7 @@ curl_download_prepare ()
  * @param cls closure, NULL
  */
 static void
-curl_task_download (void *cls)
+curl_task_download(void *cls)
 {
   int running;
   int msgnum;
@@ -1658,103 +1640,109 @@ curl_task_download (void *cls)
   struct Socks5Request *s5r;
 
   curl_download_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Running CURL interaction\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Running CURL interaction\n");
   do
-  {
-    running = 0;
-    mret = curl_multi_perform (curl_multi,
-                               &running);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Checking CURL multi status: %d\n",
-                mret);
-    while (NULL != (msg = curl_multi_info_read (curl_multi,
-                                                &msgnum)))
-    {
-      GNUNET_break (CURLE_OK ==
-                    curl_easy_getinfo (msg->easy_handle,
-                                       CURLINFO_PRIVATE,
-                                       (char **) &s5r ));
-      if (NULL == s5r)
-      {
-        GNUNET_break (0);
-        continue;
-      }
-      switch (msg->msg)
-      {
-        case CURLMSG_NONE:
-          /* documentation says this is not used */
-          GNUNET_break (0);
-          break;
-        case CURLMSG_DONE:
-          switch (msg->data.result)
-          {
-            case CURLE_OK:
-            case CURLE_GOT_NOTHING:
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "CURL download %s%s completed.\n",
-                          s5r->domain,
-                          s5r->url);
+    {
+      running = 0;
+      mret = curl_multi_perform(curl_multi,
+                                &running);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Checking CURL multi status: %d\n",
+                 mret);
+      while (NULL != (msg = curl_multi_info_read(curl_multi,
+                                                 &msgnum)))
+        {
+          GNUNET_break(CURLE_OK ==
+                       curl_easy_getinfo(msg->easy_handle,
+                                         CURLINFO_PRIVATE,
+                                         (char **)&s5r));
+          if (NULL == s5r)
+            {
+              GNUNET_break(0);
+              continue;
+            }
+          switch (msg->msg)
+            {
+            case CURLMSG_NONE:
+              /* documentation says this is not used */
+              GNUNET_break(0);
+              break;
+
+            case CURLMSG_DONE:
+              switch (msg->data.result)
+                {
+                case CURLE_OK:
+                case CURLE_GOT_NOTHING:
+                  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                             "CURL download %s%s completed.\n",
+                             s5r->domain,
+                             s5r->url);
+                  if (NULL == s5r->response)
+                    {
+                      GNUNET_assert(GNUNET_OK ==
+                                    create_mhd_response_from_s5r(s5r));
+                    }
+                  s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
+                  if (GNUNET_YES == s5r->suspended)
+                    {
+                      MHD_resume_connection(s5r->con);
+                      s5r->suspended = GNUNET_NO;
+                    }
+                  run_mhd_now(s5r->hd);
+                  break;
+
+                default:
+                  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                             "Download curl %s%s failed: %s\n",
+                             s5r->domain,
+                             s5r->url,
+                             curl_easy_strerror(msg->data.result));
+                  /* FIXME: indicate error somehow? close MHD connection badly as well? */
+                  s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
+                  if (GNUNET_YES == s5r->suspended)
+                    {
+                      MHD_resume_connection(s5r->con);
+                      s5r->suspended = GNUNET_NO;
+                    }
+                  run_mhd_now(s5r->hd);
+                  break;
+                }
               if (NULL == s5r->response)
-              {
-                GNUNET_assert (GNUNET_OK ==
-                               create_mhd_response_from_s5r (s5r));
-              }
-              s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
-              if (GNUNET_YES == s5r->suspended)
-              {
-                MHD_resume_connection (s5r->con);
-                s5r->suspended = GNUNET_NO;
-              }
-              run_mhd_now (s5r->hd);
+                s5r->response = curl_failure_response;
               break;
+
+            case CURLMSG_LAST:
+              /* documentation says this is not used */
+              GNUNET_break(0);
+              break;
+
             default:
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                          "Download curl %s%s failed: %s\n",
-                          s5r->domain,
-                          s5r->url,
-                          curl_easy_strerror (msg->data.result));
-              /* FIXME: indicate error somehow? close MHD connection badly as well? */
-              s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
-              if (GNUNET_YES == s5r->suspended)
-              {
-                MHD_resume_connection (s5r->con);
-                s5r->suspended = GNUNET_NO;
-              }
-              run_mhd_now (s5r->hd);
+              /* unexpected status code */
+              GNUNET_break(0);
               break;
-          }
-          if (NULL == s5r->response)
-            s5r->response = curl_failure_response;
-          break;
-        case CURLMSG_LAST:
-          /* documentation says this is not used */
-          GNUNET_break (0);
-          break;
-        default:
-          /* unexpected status code */
-          GNUNET_break (0);
-          break;
-      }
-    };
-  } while (mret == CURLM_CALL_MULTI_PERFORM);
+            }
+        }
+      ;
+    }
+  while (mret == CURLM_CALL_MULTI_PERFORM);
   if (CURLM_OK != mret)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s failed at %s:%d: `%s'\n",
-                "curl_multi_perform", __FILE__, __LINE__,
-                curl_multi_strerror (mret));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "%s failed at %s:%d: `%s'\n",
+               "curl_multi_perform", __FILE__, __LINE__,
+               curl_multi_strerror(mret));
   if (0 == running)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Suspending cURL multi loop, no more events pending\n");
-    if (NULL != curl_download_task)
     {
-      GNUNET_SCHEDULER_cancel (curl_download_task);
-      curl_download_task = NULL;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Suspending cURL multi loop, no more events pending\n");
+      if (NULL != curl_download_task)
+        {
+          GNUNET_SCHEDULER_cancel(curl_download_task);
+          curl_download_task = NULL;
+        }
+      return; /* nothing more in progress */
     }
-    return; /* nothing more in progress */
-  }
-  curl_download_prepare ();
+  curl_download_prepare();
 }
 
 
@@ -1775,28 +1763,28 @@ curl_task_download (void *cls)
  * @return #MHD_YES to continue to iterate
  */
 static int
-con_val_iter (void *cls,
-              enum MHD_ValueKind kind,
-              const char *key,
-              const char *value)
+con_val_iter(void *cls,
+             enum MHD_ValueKind kind,
+             const char *key,
+             const char *value)
 {
   struct Socks5Request *s5r = cls;
   char *hdr;
 
-  if ( (0 == strcasecmp (MHD_HTTP_HEADER_HOST,
-                         key)) &&
-       (NULL != s5r->leho) )
+  if ((0 == strcasecmp(MHD_HTTP_HEADER_HOST,
+                       key)) &&
+      (NULL != s5r->leho))
     value = s5r->leho;
-  GNUNET_asprintf (&hdr,
-                   "%s: %s",
-                   key,
-                   value);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding HEADER `%s' to HTTP request\n",
-              hdr);
-  s5r->headers = curl_slist_append (s5r->headers,
-                                    hdr);
-  GNUNET_free (hdr);
+  GNUNET_asprintf(&hdr,
+                  "%s: %s",
+                  key,
+                  value);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Adding HEADER `%s' to HTTP request\n",
+             hdr);
+  s5r->headers = curl_slist_append(s5r->headers,
+                                   hdr);
+  GNUNET_free(hdr);
   return MHD_YES;
 }
 
@@ -1825,14 +1813,14 @@ con_val_iter (void *cls,
  *         error while handling the request
  */
 static int
-create_response (void *cls,
-                 struct MHD_Connection *con,
-                 const char *url,
-                 const char *meth,
-                 const char *ver,
-                 const char *upload_data,
-                 size_t *upload_data_size,
-                 void **con_cls)
+create_response(void *cls,
+                struct MHD_Connection *con,
+                const char *url,
+                const char *meth,
+                const char *ver,
+                const char *upload_data,
+                size_t *upload_data_size,
+                void **con_cls)
 {
   struct Socks5Request *s5r = *con_cls;
   char *curlurl;
@@ -1845,412 +1833,415 @@ create_response (void *cls,
   size_t left;
 
   if (NULL == s5r)
-  {
-    GNUNET_break (0);
-    return MHD_NO;
-  }
+    {
+      GNUNET_break(0);
+      return MHD_NO;
+    }
   s5r->con = con;
   /* Fresh connection. */
   if (SOCKS5_SOCKET_WITH_MHD == s5r->state)
-  {
-    /* first time here, initialize curl handle */
-    if (s5r->is_gns)
     {
-      sa = (const struct sockaddr *) &s5r->destination_address;
-      switch (sa->sa_family)
-      {
-      case AF_INET:
-        s4 = (const struct sockaddr_in *) &s5r->destination_address;
-        if (NULL == inet_ntop (AF_INET,
-                               &s4->sin_addr,
-                               ipstring,
-                               sizeof (ipstring)))
+      /* first time here, initialize curl handle */
+      if (s5r->is_gns)
         {
-          GNUNET_break (0);
-          return MHD_NO;
+          sa = (const struct sockaddr *)&s5r->destination_address;
+          switch (sa->sa_family)
+            {
+            case AF_INET:
+              s4 = (const struct sockaddr_in *)&s5r->destination_address;
+              if (NULL == inet_ntop(AF_INET,
+                                    &s4->sin_addr,
+                                    ipstring,
+                                    sizeof(ipstring)))
+                {
+                  GNUNET_break(0);
+                  return MHD_NO;
+                }
+              GNUNET_snprintf(ipaddr,
+                              sizeof(ipaddr),
+                              "%s",
+                              ipstring);
+              port = ntohs(s4->sin_port);
+              break;
+
+            case AF_INET6:
+              s6 = (const struct sockaddr_in6 *)&s5r->destination_address;
+              if (NULL == inet_ntop(AF_INET6,
+                                    &s6->sin6_addr,
+                                    ipstring,
+                                    sizeof(ipstring)))
+                {
+                  GNUNET_break(0);
+                  return MHD_NO;
+                }
+              GNUNET_snprintf(ipaddr,
+                              sizeof(ipaddr),
+                              "%s",
+                              ipstring);
+              port = ntohs(s6->sin6_port);
+              break;
+
+            default:
+              GNUNET_break(0);
+              return MHD_NO;
+            }
         }
-        GNUNET_snprintf (ipaddr,
-                         sizeof (ipaddr),
-                         "%s",
-                         ipstring);
-        port = ntohs (s4->sin_port);
-        break;
-      case AF_INET6:
-        s6 = (const struct sockaddr_in6 *) &s5r->destination_address;
-        if (NULL == inet_ntop (AF_INET6,
-                               &s6->sin6_addr,
-                               ipstring,
-                               sizeof (ipstring)))
+      else
         {
-          GNUNET_break (0);
-          return MHD_NO;
+          port = s5r->port;
         }
-        GNUNET_snprintf (ipaddr,
-                         sizeof (ipaddr),
-                         "%s",
-                         ipstring);
-        port = ntohs (s6->sin6_port);
-        break;
-      default:
-        GNUNET_break (0);
-        return MHD_NO;
-      }
-    }
-    else
-    {
-      port = s5r->port;
-    }
-    if (NULL == s5r->curl)
-      s5r->curl = curl_easy_init ();
-    if (NULL == s5r->curl)
-      return MHD_queue_response (con,
-                                 MHD_HTTP_INTERNAL_SERVER_ERROR,
-                                 curl_failure_response);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_HEADERFUNCTION,
-                      &curl_check_hdr);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_HEADERDATA,
-                      s5r);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_FOLLOWLOCATION,
-                      0);
-    if (s5r->is_gns)
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_IPRESOLVE,
-                        CURL_IPRESOLVE_V4);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_CONNECTTIMEOUT,
-                      600L);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_TIMEOUT,
-                      600L);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_NOSIGNAL,
-                      1L);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_HTTP_CONTENT_DECODING,
-                      0);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_NOSIGNAL,
-                      1L);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_PRIVATE,
-                      s5r);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_VERBOSE,
-                      0L);
-    /**
-     * Pre-populate cache to resolve Hostname.
-     * This is necessary as the DNS name in the CURLOPT_URL is used
-     * for SNI http://de.wikipedia.org/wiki/Server_Name_Indication
-     */
-    if (NULL != s5r->leho)
-    {
-      char *curl_hosts;
-
-      GNUNET_asprintf (&curl_hosts,
-                       "%s:%d:%s",
-                       s5r->leho,
-                       port,
-                       ipaddr);
-      s5r->hosts = curl_slist_append (NULL,
-                                      curl_hosts);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_RESOLVE,
-                        s5r->hosts);
-      GNUNET_free (curl_hosts);
-    }
-    if (s5r->is_gns)
-    {
-      GNUNET_asprintf (&curlurl,
-                       (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                       ? "http://%s:%d%s"
-                       : "https://%s:%d%s",
-                       (NULL != s5r->leho)
-                       ? s5r->leho
-                       : ipaddr,
-                       port,
-                       s5r->url);
-    }
-    else
-    {
-      GNUNET_asprintf (&curlurl,
-                       (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
-                       ? "http://%s:%d%s"
-                       : "https://%s:%d%s",
-                       s5r->domain,
-                       port,
-                       s5r->url);
-    }
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_URL,
-                      curlurl);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Launching %s CURL interaction, fetching `%s'\n",
-                (s5r->is_gns) ? "GNS" : "DNS",
-                curlurl);
-    GNUNET_free (curlurl);
-    if (0 == strcasecmp (meth,
-                         MHD_HTTP_METHOD_PUT))
-    {
-      s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_UPLOAD,
-                        1L);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEFUNCTION,
-                        &curl_download_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEDATA,
-                        s5r);
-      GNUNET_assert (CURLE_OK ==
-                     curl_easy_setopt (s5r->curl,
-                                       CURLOPT_READFUNCTION,
-                                       &curl_upload_cb));
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_READDATA,
-                        s5r);
-      {
-        const char *us;
-        long upload_size = 0;
-
-        us = MHD_lookup_connection_value (con,
-                                          MHD_HEADER_KIND,
-                                          MHD_HTTP_HEADER_CONTENT_LENGTH);
-        if ( (1 == sscanf (us,
-                           "%ld",
-                           &upload_size)) &&
-             (upload_size >= 0) )
+      if (NULL == s5r->curl)
+        s5r->curl = curl_easy_init();
+      if (NULL == s5r->curl)
+        return MHD_queue_response(con,
+                                  MHD_HTTP_INTERNAL_SERVER_ERROR,
+                                  curl_failure_response);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_HEADERFUNCTION,
+                       &curl_check_hdr);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_HEADERDATA,
+                       s5r);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_FOLLOWLOCATION,
+                       0);
+      if (s5r->is_gns)
+        curl_easy_setopt(s5r->curl,
+                         CURLOPT_IPRESOLVE,
+                         CURL_IPRESOLVE_V4);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_CONNECTTIMEOUT,
+                       600L);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_TIMEOUT,
+                       600L);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_NOSIGNAL,
+                       1L);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_HTTP_CONTENT_DECODING,
+                       0);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_NOSIGNAL,
+                       1L);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_PRIVATE,
+                       s5r);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_VERBOSE,
+                       0L);
+      /**
+       * Pre-populate cache to resolve Hostname.
+       * This is necessary as the DNS name in the CURLOPT_URL is used
+       * for SNI http://de.wikipedia.org/wiki/Server_Name_Indication
+       */
+      if (NULL != s5r->leho)
         {
-          curl_easy_setopt (s5r->curl,
-                            CURLOPT_INFILESIZE,
-                            upload_size);
+          char *curl_hosts;
+
+          GNUNET_asprintf(&curl_hosts,
+                          "%s:%d:%s",
+                          s5r->leho,
+                          port,
+                          ipaddr);
+          s5r->hosts = curl_slist_append(NULL,
+                                         curl_hosts);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_RESOLVE,
+                           s5r->hosts);
+          GNUNET_free(curl_hosts);
         }
-      }
-    }
-    else if (0 == strcasecmp (meth, MHD_HTTP_METHOD_POST))
-    {
-      s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_POST,
-                        1L);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEFUNCTION,
-                        &curl_download_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEDATA,
-                        s5r);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_READFUNCTION,
-                        &curl_upload_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_READDATA,
-                        s5r);
-      {
-        const char *us;
-        long upload_size;
-
-        upload_size = 0;
-        us = MHD_lookup_connection_value (con,
-                                          MHD_HEADER_KIND,
-                                          MHD_HTTP_HEADER_CONTENT_LENGTH);
-        if ( (NULL != us) &&
-             (1 == sscanf (us,
-                           "%ld",
-                           &upload_size)) &&
-             (upload_size >= 0) )
+      if (s5r->is_gns)
         {
-          curl_easy_setopt (s5r->curl,
-                            CURLOPT_INFILESIZE,
-                            upload_size);
-        } else {
-          curl_easy_setopt (s5r->curl,
-                            CURLOPT_INFILESIZE,
-                            upload_size);
+          GNUNET_asprintf(&curlurl,
+                          (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                          ? "http://%s:%d%s"
+                          : "https://%s:%d%s",
+                          (NULL != s5r->leho)
+                          ? s5r->leho
+                          : ipaddr,
+                          port,
+                          s5r->url);
+        }
+      else
+        {
+          GNUNET_asprintf(&curlurl,
+                          (GNUNET_YES != s5r->is_tls) //(HTTPS_PORT != s5r->port)
+                          ? "http://%s:%d%s"
+                          : "https://%s:%d%s",
+                          s5r->domain,
+                          port,
+                          s5r->url);
+        }
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_URL,
+                       curlurl);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Launching %s CURL interaction, fetching `%s'\n",
+                 (s5r->is_gns) ? "GNS" : "DNS",
+                 curlurl);
+      GNUNET_free(curlurl);
+      if (0 == strcasecmp(meth,
+                          MHD_HTTP_METHOD_PUT))
+        {
+          s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_UPLOAD,
+                           1L);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEFUNCTION,
+                           &curl_download_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEDATA,
+                           s5r);
+          GNUNET_assert(CURLE_OK ==
+                        curl_easy_setopt(s5r->curl,
+                                         CURLOPT_READFUNCTION,
+                                         &curl_upload_cb));
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_READDATA,
+                           s5r);
+          {
+            const char *us;
+            long upload_size = 0;
+
+            us = MHD_lookup_connection_value(con,
+                                             MHD_HEADER_KIND,
+                                             MHD_HTTP_HEADER_CONTENT_LENGTH);
+            if ((1 == sscanf(us,
+                             "%ld",
+                             &upload_size)) &&
+                (upload_size >= 0))
+              {
+                curl_easy_setopt(s5r->curl,
+                                 CURLOPT_INFILESIZE,
+                                 upload_size);
+              }
+          }
+        }
+      else if (0 == strcasecmp(meth, MHD_HTTP_METHOD_POST))
+        {
+          s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_POST,
+                           1L);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEFUNCTION,
+                           &curl_download_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEDATA,
+                           s5r);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_READFUNCTION,
+                           &curl_upload_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_READDATA,
+                           s5r);
+          {
+            const char *us;
+            long upload_size;
+
+            upload_size = 0;
+            us = MHD_lookup_connection_value(con,
+                                             MHD_HEADER_KIND,
+                                             MHD_HTTP_HEADER_CONTENT_LENGTH);
+            if ((NULL != us) &&
+                (1 == sscanf(us,
+                             "%ld",
+                             &upload_size)) &&
+                (upload_size >= 0))
+              {
+                curl_easy_setopt(s5r->curl,
+                                 CURLOPT_INFILESIZE,
+                                 upload_size);
+              }
+            else
+              {
+                curl_easy_setopt(s5r->curl,
+                                 CURLOPT_INFILESIZE,
+                                 upload_size);
+              }
+          }
+        }
+      else if (0 == strcasecmp(meth,
+                               MHD_HTTP_METHOD_HEAD))
+        {
+          s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_NOBODY,
+                           1L);
+        }
+      else if (0 == strcasecmp(meth,
+                               MHD_HTTP_METHOD_OPTIONS))
+        {
+          s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_CUSTOMREQUEST,
+                           "OPTIONS");
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEFUNCTION,
+                           &curl_download_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEDATA,
+                           s5r);
+        }
+      else if (0 == strcasecmp(meth,
+                               MHD_HTTP_METHOD_GET))
+        {
+          s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_HTTPGET,
+                           1L);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEFUNCTION,
+                           &curl_download_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEDATA,
+                           s5r);
+        }
+      else if (0 == strcasecmp(meth,
+                               MHD_HTTP_METHOD_DELETE))
+        {
+          s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_CUSTOMREQUEST,
+                           "DELETE");
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEFUNCTION,
+                           &curl_download_cb);
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_WRITEDATA,
+                           s5r);
+        }
+      else
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Unsupported HTTP method `%s'\n"),
+                     meth);
+          curl_easy_cleanup(s5r->curl);
+          s5r->curl = NULL;
+          return MHD_NO;
         }
-      }
-    }
-    else if (0 == strcasecmp (meth,
-                              MHD_HTTP_METHOD_HEAD))
-    {
-      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_NOBODY,
-                        1L);
-    }
-    else if (0 == strcasecmp (meth,
-                              MHD_HTTP_METHOD_OPTIONS))
-    {
-      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_CUSTOMREQUEST,
-                        "OPTIONS");
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEFUNCTION,
-                        &curl_download_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEDATA,
-                        s5r);
-
-    }
-    else if (0 == strcasecmp (meth,
-                              MHD_HTTP_METHOD_GET))
-    {
-      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_HTTPGET,
-                        1L);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEFUNCTION,
-                        &curl_download_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEDATA,
-                        s5r);
-    }
-    else if (0 == strcasecmp (meth,
-                              MHD_HTTP_METHOD_DELETE))
-    {
-      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_CUSTOMREQUEST,
-                        "DELETE");
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEFUNCTION,
-                        &curl_download_cb);
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_WRITEDATA,
-                        s5r);
-    }
-    else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Unsupported HTTP method `%s'\n"),
-                  meth);
-      curl_easy_cleanup (s5r->curl);
-      s5r->curl = NULL;
-      return MHD_NO;
-    }
 
-    if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_0))
-    {
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_HTTP_VERSION,
-                        CURL_HTTP_VERSION_1_0);
-    }
-    else if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_1))
-    {
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_HTTP_VERSION,
-                        CURL_HTTP_VERSION_1_1);
-    }
-    else
-    {
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_HTTP_VERSION,
-                        CURL_HTTP_VERSION_NONE);
-    }
+      if (0 == strcasecmp(ver, MHD_HTTP_VERSION_1_0))
+        {
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_HTTP_VERSION,
+                           CURL_HTTP_VERSION_1_0);
+        }
+      else if (0 == strcasecmp(ver, MHD_HTTP_VERSION_1_1))
+        {
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_HTTP_VERSION,
+                           CURL_HTTP_VERSION_1_1);
+        }
+      else
+        {
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_HTTP_VERSION,
+                           CURL_HTTP_VERSION_NONE);
+        }
 
-    if (GNUNET_YES == s5r->is_tls) //(HTTPS_PORT == s5r->port)
-    {
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_USE_SSL,
-                        CURLUSESSL_ALL);
-      if (0 < s5r->num_danes)
-        curl_easy_setopt (s5r->curl,
-                          CURLOPT_SSL_VERIFYPEER,
-                          0L);
+      if (GNUNET_YES == s5r->is_tls) //(HTTPS_PORT == s5r->port)
+        {
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_USE_SSL,
+                           CURLUSESSL_ALL);
+          if (0 < s5r->num_danes)
+            curl_easy_setopt(s5r->curl,
+                             CURLOPT_SSL_VERIFYPEER,
+                             0L);
+          else
+            curl_easy_setopt(s5r->curl,
+                             CURLOPT_SSL_VERIFYPEER,
+                             1L);
+          /* Disable cURL checking the hostname, as we will check ourselves
+             as only we have the domain name or the LEHO or the DANE record */
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_SSL_VERIFYHOST,
+                           0L);
+        }
       else
-        curl_easy_setopt (s5r->curl,
-                          CURLOPT_SSL_VERIFYPEER,
-                          1L);
-      /* Disable cURL checking the hostname, as we will check ourselves
-         as only we have the domain name or the LEHO or the DANE record */
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_SSL_VERIFYHOST,
-                        0L);
-    }
-    else
-    {
-      curl_easy_setopt (s5r->curl,
-                        CURLOPT_USE_SSL,
-                        CURLUSESSL_NONE);
-    }
+        {
+          curl_easy_setopt(s5r->curl,
+                           CURLOPT_USE_SSL,
+                           CURLUSESSL_NONE);
+        }
 
-    if (CURLM_OK !=
-        curl_multi_add_handle (curl_multi,
-                               s5r->curl))
-    {
-      GNUNET_break (0);
-      curl_easy_cleanup (s5r->curl);
-      s5r->curl = NULL;
-      return MHD_NO;
+      if (CURLM_OK !=
+          curl_multi_add_handle(curl_multi,
+                                s5r->curl))
+        {
+          GNUNET_break(0);
+          curl_easy_cleanup(s5r->curl);
+          s5r->curl = NULL;
+          return MHD_NO;
+        }
+      MHD_get_connection_values(con,
+                                MHD_HEADER_KIND,
+                                (MHD_KeyValueIterator) & con_val_iter,
+                                s5r);
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_HTTPHEADER,
+                       s5r->headers);
+      curl_download_prepare();
+      return MHD_YES;
     }
-    MHD_get_connection_values (con,
-                               MHD_HEADER_KIND,
-                               (MHD_KeyValueIterator) &con_val_iter,
-                               s5r);
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_HTTPHEADER,
-                      s5r->headers);
-    curl_download_prepare ();
-    return MHD_YES;
-  }
 
   /* continuing to process request */
   if (0 != *upload_data_size)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Processing %u bytes UPLOAD\n",
-                (unsigned int) *upload_data_size);
-
-    /* FIXME: This must be set or a header with Transfer-Encoding: chunked. Else
-     * upload callback is not called!
-     */
-    curl_easy_setopt (s5r->curl,
-                      CURLOPT_POSTFIELDSIZE,
-                      *upload_data_size);
-
-    left = GNUNET_MIN (*upload_data_size,
-                       sizeof (s5r->io_buf) - s5r->io_len);
-    GNUNET_memcpy (&s5r->io_buf[s5r->io_len],
-                   upload_data,
-                   left);
-    s5r->io_len += left;
-    *upload_data_size -= left;
-    GNUNET_assert (NULL != s5r->curl);
-    if (GNUNET_YES == s5r->curl_paused)
     {
-      s5r->curl_paused = GNUNET_NO;
-      curl_easy_pause (s5r->curl,
-                       CURLPAUSE_CONT);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Processing %u bytes UPLOAD\n",
+                 (unsigned int)*upload_data_size);
+
+      /* FIXME: This must be set or a header with Transfer-Encoding: chunked. Else
+       * upload callback is not called!
+       */
+      curl_easy_setopt(s5r->curl,
+                       CURLOPT_POSTFIELDSIZE,
+                       *upload_data_size);
+
+      left = GNUNET_MIN(*upload_data_size,
+                        sizeof(s5r->io_buf) - s5r->io_len);
+      GNUNET_memcpy(&s5r->io_buf[s5r->io_len],
+                    upload_data,
+                    left);
+      s5r->io_len += left;
+      *upload_data_size -= left;
+      GNUNET_assert(NULL != s5r->curl);
+      if (GNUNET_YES == s5r->curl_paused)
+        {
+          s5r->curl_paused = GNUNET_NO;
+          curl_easy_pause(s5r->curl,
+                          CURLPAUSE_CONT);
+        }
+      return MHD_YES;
     }
-    return MHD_YES;
-  }
   if (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Finished processing UPLOAD\n");
-    s5r->state = SOCKS5_SOCKET_UPLOAD_DONE;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Finished processing UPLOAD\n");
+      s5r->state = SOCKS5_SOCKET_UPLOAD_DONE;
+    }
   if (NULL == s5r->response)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Waiting for HTTP response for %s%s...\n",
-                s5r->domain,
-                s5r->url);
-    MHD_suspend_connection (con);
-    s5r->suspended = GNUNET_YES;
-    return MHD_YES;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Queueing response for %s%s with MHD\n",
-              s5r->domain,
-              s5r->url);
-  run_mhd_now (s5r->hd);
-  return MHD_queue_response (con,
-                             s5r->response_code,
-                             s5r->response);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Waiting for HTTP response for %s%s...\n",
+                 s5r->domain,
+                 s5r->url);
+      MHD_suspend_connection(con);
+      s5r->suspended = GNUNET_YES;
+      return MHD_YES;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Queueing response for %s%s with MHD\n",
+             s5r->domain,
+             s5r->url);
+  run_mhd_now(s5r->hd);
+  return MHD_queue_response(con,
+                            s5r->response_code,
+                            s5r->response);
 }
 
 
@@ -2267,51 +2258,51 @@ create_response (void *cls,
  * @param toe reason for request termination (ignored)
  */
 static void
-mhd_completed_cb (void *cls,
-                  struct MHD_Connection *connection,
-                  void **con_cls,
-                  enum MHD_RequestTerminationCode toe)
+mhd_completed_cb(void *cls,
+                 struct MHD_Connection *connection,
+                 void **con_cls,
+                 enum MHD_RequestTerminationCode toe)
 {
   struct Socks5Request *s5r = *con_cls;
 
   if (NULL == s5r)
     return;
   if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "MHD encountered error handling request: %d\n",
-                toe);
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+               "MHD encountered error handling request: %d\n",
+               toe);
   if (NULL != s5r->curl)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Removing cURL handle (MHD interaction complete)\n");
-    curl_multi_remove_handle (curl_multi,
-                              s5r->curl);
-    curl_slist_free_all (s5r->headers);
-    s5r->headers = NULL;
-    curl_easy_reset (s5r->curl);
-    s5r->rbuf_len = 0;
-    s5r->wbuf_len = 0;
-    s5r->io_len = 0;
-    curl_download_prepare ();
-  }
-  if ( (NULL != s5r->response) &&
-       (curl_failure_response != s5r->response) )
-    MHD_destroy_response (s5r->response);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Removing cURL handle (MHD interaction complete)\n");
+      curl_multi_remove_handle(curl_multi,
+                               s5r->curl);
+      curl_slist_free_all(s5r->headers);
+      s5r->headers = NULL;
+      curl_easy_reset(s5r->curl);
+      s5r->rbuf_len = 0;
+      s5r->wbuf_len = 0;
+      s5r->io_len = 0;
+      curl_download_prepare();
+    }
+  if ((NULL != s5r->response) &&
+      (curl_failure_response != s5r->response))
+    MHD_destroy_response(s5r->response);
   for (struct HttpResponseHeader *header = s5r->header_head;
        NULL != header;
        header = s5r->header_head)
-  {
-    GNUNET_CONTAINER_DLL_remove (s5r->header_head,
-                                 s5r->header_tail,
-                                 header);
-    GNUNET_free (header->type);
-    GNUNET_free (header->value);
-    GNUNET_free (header);
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Finished request for %s\n",
-              s5r->url);
-  GNUNET_free (s5r->url);
+    {
+      GNUNET_CONTAINER_DLL_remove(s5r->header_head,
+                                  s5r->header_tail,
+                                  header);
+      GNUNET_free(header->type);
+      GNUNET_free(header->value);
+      GNUNET_free(header);
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Finished request for %s\n",
+             s5r->url);
+  GNUNET_free(s5r->url);
   s5r->state = SOCKS5_SOCKET_WITH_MHD;
   s5r->url = NULL;
   s5r->response = NULL;
@@ -2329,56 +2320,58 @@ mhd_completed_cb (void *cls,
  * @param toe connection notification type
  */
 static void
-mhd_connection_cb (void *cls,
-                   struct MHD_Connection *connection,
-                   void **con_cls,
-                   enum MHD_ConnectionNotificationCode cnc)
+mhd_connection_cb(void *cls,
+                  struct MHD_Connection *connection,
+                  void **con_cls,
+                  enum MHD_ConnectionNotificationCode cnc)
 {
   struct Socks5Request *s5r;
   const union MHD_ConnectionInfo *ci;
   int sock;
 
   switch (cnc)
-  {
+    {
     case MHD_CONNECTION_NOTIFY_STARTED:
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection started...\n");
-      ci = MHD_get_connection_info (connection,
-                                    MHD_CONNECTION_INFO_CONNECTION_FD);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connection started...\n");
+      ci = MHD_get_connection_info(connection,
+                                   MHD_CONNECTION_INFO_CONNECTION_FD);
       if (NULL == ci)
-      {
-        GNUNET_break (0);
-        return;
-      }
+        {
+          GNUNET_break(0);
+          return;
+        }
       sock = ci->connect_fd;
       for (s5r = s5r_head; NULL != s5r; s5r = s5r->next)
-      {
-        if (GNUNET_NETWORK_get_fd (s5r->sock) == sock)
         {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Context set...\n");
-          s5r->ssl_checked = GNUNET_NO;
-          *con_cls = s5r;
-          break;
+          if (GNUNET_NETWORK_get_fd(s5r->sock) == sock)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                         "Context set...\n");
+              s5r->ssl_checked = GNUNET_NO;
+              *con_cls = s5r;
+              break;
+            }
         }
-      }
       break;
+
     case MHD_CONNECTION_NOTIFY_CLOSED:
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Connection closed... cleaning up\n");
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Connection closed... cleaning up\n");
       s5r = *con_cls;
       if (NULL == s5r)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Connection stale!\n");
-        return;
-      }
-      cleanup_s5r (s5r);
-      curl_download_prepare ();
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Connection stale!\n");
+          return;
+        }
+      cleanup_s5r(s5r);
+      curl_download_prepare();
       *con_cls = NULL;
       break;
+
     default:
-      GNUNET_break (0);
-  }
+      GNUNET_break(0);
+    }
 }
 
 /**
@@ -2395,34 +2388,34 @@ mhd_connection_cb (void *cls,
  * @return the `struct Socks5Request` that this @a connection is for
  */
 static void *
-mhd_log_callback (void *cls,
-                  const char *url,
-                  struct MHD_Connection *connection)
+mhd_log_callback(void *cls,
+                 const char *url,
+                 struct MHD_Connection *connection)
 {
   struct Socks5Request *s5r;
   const union MHD_ConnectionInfo *ci;
 
-  ci = MHD_get_connection_info (connection,
-                                MHD_CONNECTION_INFO_SOCKET_CONTEXT);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing %s\n", url);
+  ci = MHD_get_connection_info(connection,
+                               MHD_CONNECTION_INFO_SOCKET_CONTEXT);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Processing %s\n", url);
   if (NULL == ci)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
   s5r = ci->socket_context;
   if (NULL != s5r->url)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  s5r->url = GNUNET_strdup (url);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  s5r->url = GNUNET_strdup(url);
   if (NULL != s5r->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (s5r->timeout_task);
-    s5r->timeout_task = NULL;
-  }
-  GNUNET_assert (s5r->state == SOCKS5_SOCKET_WITH_MHD);
+    {
+      GNUNET_SCHEDULER_cancel(s5r->timeout_task);
+      s5r->timeout_task = NULL;
+    }
+  GNUNET_assert(s5r->state == SOCKS5_SOCKET_WITH_MHD);
   return s5r;
 }
 
@@ -2433,22 +2426,22 @@ mhd_log_callback (void *cls,
  * @param hd daemon to stop
  */
 static void
-kill_httpd (struct MhdHttpList *hd)
+kill_httpd(struct MhdHttpList *hd)
 {
-  GNUNET_CONTAINER_DLL_remove (mhd_httpd_head,
-                               mhd_httpd_tail,
-                               hd);
-  GNUNET_free_non_null (hd->domain);
-  MHD_stop_daemon (hd->daemon);
+  GNUNET_CONTAINER_DLL_remove(mhd_httpd_head,
+                              mhd_httpd_tail,
+                              hd);
+  GNUNET_free_non_null(hd->domain);
+  MHD_stop_daemon(hd->daemon);
   if (NULL != hd->httpd_task)
-  {
-    GNUNET_SCHEDULER_cancel (hd->httpd_task);
-    hd->httpd_task = NULL;
-  }
-  GNUNET_free_non_null (hd->proxy_cert);
+    {
+      GNUNET_SCHEDULER_cancel(hd->httpd_task);
+      hd->httpd_task = NULL;
+    }
+  GNUNET_free_non_null(hd->proxy_cert);
   if (hd == httpd)
     httpd = NULL;
-  GNUNET_free (hd);
+  GNUNET_free(hd);
 }
 
 
@@ -2458,12 +2451,12 @@ kill_httpd (struct MhdHttpList *hd)
  * @param cls the `struct MhdHttpList *`
  */
 static void
-kill_httpd_task (void *cls)
+kill_httpd_task(void *cls)
 {
   struct MhdHttpList *hd = cls;
 
   hd->httpd_task = NULL;
-  kill_httpd (hd);
+  kill_httpd(hd);
 }
 
 
@@ -2473,7 +2466,7 @@ kill_httpd_task (void *cls)
  * @param cls the `struct MhdHttpList *` of the daemon that is being run
  */
 static void
-do_httpd (void *cls);
+do_httpd(void *cls);
 
 
 /**
@@ -2484,7 +2477,7 @@ do_httpd (void *cls);
  * @param hd the daemon to schedule
  */
 static void
-schedule_httpd (struct MhdHttpList *hd)
+schedule_httpd(struct MhdHttpList *hd)
 {
   fd_set rs;
   fd_set ws;
@@ -2496,63 +2489,63 @@ schedule_httpd (struct MhdHttpList *hd)
   MHD_UNSIGNED_LONG_LONG timeout;
   struct GNUNET_TIME_Relative tv;
 
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
   max = -1;
   if (MHD_YES !=
-      MHD_get_fdset (hd->daemon,
-                     &rs,
-                     &ws,
-                     &es,
-                     &max))
-  {
-    kill_httpd (hd);
-    return;
-  }
-  haveto = MHD_get_timeout (hd->daemon,
-                            &timeout);
+      MHD_get_fdset(hd->daemon,
+                    &rs,
+                    &ws,
+                    &es,
+                    &max))
+    {
+      kill_httpd(hd);
+      return;
+    }
+  haveto = MHD_get_timeout(hd->daemon,
+                           &timeout);
   if (MHD_YES == haveto)
-    tv.rel_value_us = (uint64_t) timeout * 1000LL;
+    tv.rel_value_us = (uint64_t)timeout * 1000LL;
   else
     tv = GNUNET_TIME_UNIT_FOREVER_REL;
   if (-1 != max)
-  {
-    wrs = GNUNET_NETWORK_fdset_create ();
-    wws = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
-    GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
-  }
+    {
+      wrs = GNUNET_NETWORK_fdset_create();
+      wws = GNUNET_NETWORK_fdset_create();
+      GNUNET_NETWORK_fdset_copy_native(wrs, &rs, max + 1);
+      GNUNET_NETWORK_fdset_copy_native(wws, &ws, max + 1);
+    }
   else
-  {
-    wrs = NULL;
-    wws = NULL;
-  }
+    {
+      wrs = NULL;
+      wws = NULL;
+    }
   if (NULL != hd->httpd_task)
-  {
-    GNUNET_SCHEDULER_cancel (hd->httpd_task);
-    hd->httpd_task = NULL;
-  }
-  if ( (MHD_YES != haveto) &&
-       (-1 == max) &&
-       (hd != httpd) )
-  {
-    /* daemon is idle, kill after timeout */
-    hd->httpd_task = GNUNET_SCHEDULER_add_delayed (MHD_CACHE_TIMEOUT,
-                                                   &kill_httpd_task,
-                                                   hd);
-  }
+    {
+      GNUNET_SCHEDULER_cancel(hd->httpd_task);
+      hd->httpd_task = NULL;
+    }
+  if ((MHD_YES != haveto) &&
+      (-1 == max) &&
+      (hd != httpd))
+    {
+      /* daemon is idle, kill after timeout */
+      hd->httpd_task = GNUNET_SCHEDULER_add_delayed(MHD_CACHE_TIMEOUT,
+                                                    &kill_httpd_task,
+                                                    hd);
+    }
   else
-  {
-    hd->httpd_task =
-      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                   tv, wrs, wws,
-                                   &do_httpd, hd);
-  }
+    {
+      hd->httpd_task =
+        GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                    tv, wrs, wws,
+                                    &do_httpd, hd);
+    }
   if (NULL != wrs)
-    GNUNET_NETWORK_fdset_destroy (wrs);
+    GNUNET_NETWORK_fdset_destroy(wrs);
   if (NULL != wws)
-    GNUNET_NETWORK_fdset_destroy (wws);
+    GNUNET_NETWORK_fdset_destroy(wws);
 }
 
 
@@ -2562,13 +2555,13 @@ schedule_httpd (struct MhdHttpList *hd)
  * @param cls the `struct MhdHttpList` of the daemon that is being run
  */
 static void
-do_httpd (void *cls)
+do_httpd(void *cls)
 {
   struct MhdHttpList *hd = cls;
 
   hd->httpd_task = NULL;
-  MHD_run (hd->daemon);
-  schedule_httpd (hd);
+  MHD_run(hd->daemon);
+  schedule_httpd(hd);
 }
 
 
@@ -2578,12 +2571,12 @@ do_httpd (void *cls)
  * @param hd the daemon to run now.
  */
 static void
-run_mhd_now (struct MhdHttpList *hd)
+run_mhd_now(struct MhdHttpList *hd)
 {
   if (NULL != hd->httpd_task)
-    GNUNET_SCHEDULER_cancel (hd->httpd_task);
-  hd->httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
-                                             hd);
+    GNUNET_SCHEDULER_cancel(hd->httpd_task);
+  hd->httpd_task = GNUNET_SCHEDULER_add_now(&do_httpd,
+                                            hd);
 }
 
 
@@ -2595,30 +2588,30 @@ run_mhd_now (struct MhdHttpList *hd)
  * @return NULL on error
  */
 static void*
-load_file (const char* filename,
-           unsigned int* size)
+load_file(const char* filename,
+          unsigned int* size)
 {
   void *buffer;
   uint64_t fsize;
 
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size (filename,
-                             &fsize,
-                             GNUNET_YES,
-                             GNUNET_YES))
+      GNUNET_DISK_file_size(filename,
+                            &fsize,
+                            GNUNET_YES,
+                            GNUNET_YES))
     return NULL;
   if (fsize > MAX_PEM_SIZE)
     return NULL;
-  *size = (unsigned int) fsize;
-  buffer = GNUNET_malloc (*size);
+  *size = (unsigned int)fsize;
+  buffer = GNUNET_malloc(*size);
   if (fsize !=
-      GNUNET_DISK_fn_read (filename,
-                           buffer,
-                           (size_t) fsize))
-  {
-    GNUNET_free (buffer);
-    return NULL;
-  }
+      GNUNET_DISK_fn_read(filename,
+                          buffer,
+                          (size_t)fsize))
+    {
+      GNUNET_free(buffer);
+      return NULL;
+    }
   return buffer;
 }
 
@@ -2631,25 +2624,25 @@ load_file (const char* filename,
  * @return #GNUNET_OK on success
  */
 static int
-load_key_from_file (gnutls_x509_privkey_t key,
-                    const char* keyfile)
+load_key_from_file(gnutls_x509_privkey_t key,
+                   const char* keyfile)
 {
   gnutls_datum_t key_data;
   int ret;
 
-  key_data.data = load_file (keyfile,
-                             &key_data.size);
+  key_data.data = load_file(keyfile,
+                            &key_data.size);
   if (NULL == key_data.data)
     return GNUNET_SYSERR;
-  ret = gnutls_x509_privkey_import (key, &key_data,
-                                    GNUTLS_X509_FMT_PEM);
+  ret = gnutls_x509_privkey_import(key, &key_data,
+                                   GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unable to import private key from file `%s'\n"),
-                keyfile);
-  }
-  GNUNET_free_non_null (key_data.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to import private key from file `%s'\n"),
+                 keyfile);
+    }
+  GNUNET_free_non_null(key_data.data);
   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
 }
 
@@ -2662,26 +2655,26 @@ load_key_from_file (gnutls_x509_privkey_t key,
  * @return #GNUNET_OK on success
  */
 static int
-load_cert_from_file (gnutls_x509_crt_t crt,
-                     const char* certfile)
+load_cert_from_file(gnutls_x509_crt_t crt,
+                    const char* certfile)
 {
   gnutls_datum_t cert_data;
   int ret;
 
-  cert_data.data = load_file (certfile,
-                              &cert_data.size);
+  cert_data.data = load_file(certfile,
+                             &cert_data.size);
   if (NULL == cert_data.data)
     return GNUNET_SYSERR;
-  ret = gnutls_x509_crt_import (crt,
-                                &cert_data,
-                                GNUTLS_X509_FMT_PEM);
+  ret = gnutls_x509_crt_import(crt,
+                               &cert_data,
+                               GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unable to import certificate from `%s'\n"),
-                certfile);
-  }
-  GNUNET_free_non_null (cert_data.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to import certificate from `%s'\n"),
+                 certfile);
+    }
+  GNUNET_free_non_null(cert_data.data);
   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
 }
 
@@ -2693,7 +2686,7 @@ load_cert_from_file (gnutls_x509_crt_t crt,
  * @return a struct holding the PEM data, NULL on error
  */
 static struct ProxyGNSCertificate *
-generate_gns_certificate (const char *name)
+generate_gns_certificate(const char *name)
 {
   unsigned int serial;
   size_t key_buf_size;
@@ -2703,65 +2696,65 @@ generate_gns_certificate (const char *name)
   struct tm *tm_data;
   struct ProxyGNSCertificate *pgc;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Generating x.509 certificate for `%s'\n",
-              name);
-  GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_init (&request));
-  GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_set_key (request, proxy_ca.key));
-  pgc = GNUNET_new (struct ProxyGNSCertificate);
-  gnutls_x509_crt_set_dn_by_oid (request,
-                                 GNUTLS_OID_X520_COUNTRY_NAME,
-                                 0,
-                                 "ZZ",
-                                 strlen ("ZZ"));
-  gnutls_x509_crt_set_dn_by_oid (request,
-                                 GNUTLS_OID_X520_ORGANIZATION_NAME,
-                                 0,
-                                 "GNU Name System",
-                                 strlen ("GNU Name System"));
-  gnutls_x509_crt_set_dn_by_oid (request,
-                                 GNUTLS_OID_X520_COMMON_NAME,
-                                 0,
-                                 name,
-                                 strlen (name));
-  gnutls_x509_crt_set_subject_alternative_name (request,
-                                        GNUTLS_SAN_DNSNAME,
-                                        name);
-  GNUNET_break (GNUTLS_E_SUCCESS ==
-                gnutls_x509_crt_set_version (request,
-                                             3));
-  gnutls_rnd (GNUTLS_RND_NONCE,
-              &serial,
-              sizeof (serial));
-  gnutls_x509_crt_set_serial (request,
-                              &serial,
-                              sizeof (serial));
-  etime = time (NULL);
-  tm_data = localtime (&etime);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Generating x.509 certificate for `%s'\n",
+             name);
+  GNUNET_break(GNUTLS_E_SUCCESS == gnutls_x509_crt_init(&request));
+  GNUNET_break(GNUTLS_E_SUCCESS == gnutls_x509_crt_set_key(request, proxy_ca.key));
+  pgc = GNUNET_new(struct ProxyGNSCertificate);
+  gnutls_x509_crt_set_dn_by_oid(request,
+                                GNUTLS_OID_X520_COUNTRY_NAME,
+                                0,
+                                "ZZ",
+                                strlen("ZZ"));
+  gnutls_x509_crt_set_dn_by_oid(request,
+                                GNUTLS_OID_X520_ORGANIZATION_NAME,
+                                0,
+                                "GNU Name System",
+                                strlen("GNU Name System"));
+  gnutls_x509_crt_set_dn_by_oid(request,
+                                GNUTLS_OID_X520_COMMON_NAME,
+                                0,
+                                name,
+                                strlen(name));
+  gnutls_x509_crt_set_subject_alternative_name(request,
+                                               GNUTLS_SAN_DNSNAME,
+                                               name);
+  GNUNET_break(GNUTLS_E_SUCCESS ==
+               gnutls_x509_crt_set_version(request,
+                                           3));
+  gnutls_rnd(GNUTLS_RND_NONCE,
+             &serial,
+             sizeof(serial));
+  gnutls_x509_crt_set_serial(request,
+                             &serial,
+                             sizeof(serial));
+  etime = time(NULL);
+  tm_data = localtime(&etime);
   tm_data->tm_hour--;
   etime = mktime(tm_data);
-  gnutls_x509_crt_set_activation_time (request,
-                                       etime);
+  gnutls_x509_crt_set_activation_time(request,
+                                      etime);
   tm_data->tm_year++;
-  etime = mktime (tm_data);
-  gnutls_x509_crt_set_expiration_time (request,
-                                       etime);
-  gnutls_x509_crt_sign2 (request,
-                         proxy_ca.cert,
-                         proxy_ca.key,
-                         GNUTLS_DIG_SHA512,
-                         0);
-  key_buf_size = sizeof (pgc->key);
-  cert_buf_size = sizeof (pgc->cert);
-  gnutls_x509_crt_export (request,
-                          GNUTLS_X509_FMT_PEM,
-                          pgc->cert,
-                          &cert_buf_size);
-  gnutls_x509_privkey_export (proxy_ca.key,
-                              GNUTLS_X509_FMT_PEM,
-                              pgc->key,
-                              &key_buf_size);
-  gnutls_x509_crt_deinit (request);
+  etime = mktime(tm_data);
+  gnutls_x509_crt_set_expiration_time(request,
+                                      etime);
+  gnutls_x509_crt_sign2(request,
+                        proxy_ca.cert,
+                        proxy_ca.key,
+                        GNUTLS_DIG_SHA512,
+                        0);
+  key_buf_size = sizeof(pgc->key);
+  cert_buf_size = sizeof(pgc->cert);
+  gnutls_x509_crt_export(request,
+                         GNUTLS_X509_FMT_PEM,
+                         pgc->cert,
+                         &cert_buf_size);
+  gnutls_x509_privkey_export(proxy_ca.key,
+                             GNUTLS_X509_FMT_PEM,
+                             pgc->key,
+                             &key_buf_size);
+  gnutls_x509_crt_deinit(request);
   return pgc;
 }
 
@@ -2774,9 +2767,9 @@ generate_gns_certificate (const char *name)
  * @param ap arguments to @a fm
  */
 static void
-mhd_error_log_callback (void *cls,
-                        const char *fm,
-                        va_list ap)
+mhd_error_log_callback(void *cls,
+                       const char *fm,
+                       va_list ap)
 {
   /* do nothing */
 }
@@ -2789,49 +2782,49 @@ mhd_error_log_callback (void *cls,
  * @return NULL on error
  */
 static struct MhdHttpList *
-lookup_ssl_httpd (const char* domain)
+lookup_ssl_httpd(const char* domain)
 {
   struct MhdHttpList *hd;
   struct ProxyGNSCertificate *pgc;
 
   if (NULL == domain)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
   for (hd = mhd_httpd_head; NULL != hd; hd = hd->next)
-    if ( (NULL != hd->domain) &&
-         (0 == strcmp (hd->domain, domain)) )
+    if ((NULL != hd->domain) &&
+        (0 == strcmp(hd->domain, domain)))
       return hd;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting fresh MHD HTTPS instance for domain `%s'\n",
-              domain);
-  pgc = generate_gns_certificate (domain);
-  hd = GNUNET_new (struct MhdHttpList);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting fresh MHD HTTPS instance for domain `%s'\n",
+             domain);
+  pgc = generate_gns_certificate(domain);
+  hd = GNUNET_new(struct MhdHttpList);
   hd->is_ssl = GNUNET_YES;
-  hd->domain = GNUNET_strdup (domain);
+  hd->domain = GNUNET_strdup(domain);
   hd->proxy_cert = pgc;
-  hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
-                                 0,
-                                 NULL, NULL,
-                                 &create_response, hd,
-                                 MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-                                 MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
-                                 MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
-                                 MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
-                                 MHD_OPTION_EXTERNAL_LOGGER, &mhd_error_log_callback, NULL,
-                                 MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
-                                 MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
-                                 MHD_OPTION_END);
+  hd->daemon = MHD_start_daemon(MHD_USE_DEBUG | MHD_USE_SSL | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
+                                0,
+                                NULL, NULL,
+                                &create_response, hd,
+                                MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int)16,
+                                MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
+                                MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
+                                MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
+                                MHD_OPTION_EXTERNAL_LOGGER, &mhd_error_log_callback, NULL,
+                                MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
+                                MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
+                                MHD_OPTION_END);
   if (NULL == hd->daemon)
-  {
-    GNUNET_free (pgc);
-    GNUNET_free (hd);
-    return NULL;
-  }
-  GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
-                               mhd_httpd_tail,
-                               hd);
+    {
+      GNUNET_free(pgc);
+      GNUNET_free(hd);
+      return NULL;
+    }
+  GNUNET_CONTAINER_DLL_insert(mhd_httpd_head,
+                              mhd_httpd_tail,
+                              hd);
   return hd;
 }
 
@@ -2844,12 +2837,12 @@ lookup_ssl_httpd (const char* domain)
  * @param cls the `struct Socks5Request *`
  */
 static void
-timeout_s5r_handshake (void *cls)
+timeout_s5r_handshake(void *cls)
 {
   struct Socks5Request *s5r = cls;
 
   s5r->timeout_task = NULL;
-  cleanup_s5r (s5r);
+  cleanup_s5r(s5r);
 }
 
 
@@ -2862,7 +2855,7 @@ timeout_s5r_handshake (void *cls)
  * @param s5r socks request that has reached the final stage
  */
 static void
-setup_data_transfer (struct Socks5Request *s5r)
+setup_data_transfer(struct Socks5Request *s5r)
 {
   struct MhdHttpList *hd;
   int fd;
@@ -2871,47 +2864,49 @@ setup_data_transfer (struct Socks5Request *s5r)
   char *domain;
 
   if (GNUNET_YES == s5r->is_tls)
-  {
-    GNUNET_asprintf (&domain,
-                     "%s",
+    {
+      GNUNET_asprintf(&domain,
+                      "%s",
+                      s5r->domain);
+      hd = lookup_ssl_httpd(domain);
+      if (NULL == hd)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Failed to start HTTPS server for `%s'\n"),
                      s5r->domain);
-    hd = lookup_ssl_httpd (domain);
-    if (NULL == hd)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to start HTTPS server for `%s'\n"),
-                  s5r->domain);
-      cleanup_s5r (s5r);
-      GNUNET_free (domain);
-      return;
+          cleanup_s5r(s5r);
+          GNUNET_free(domain);
+          return;
+        }
     }
-  } else {
+  else
+    {
       domain = NULL;
-      GNUNET_assert (NULL != httpd);
+      GNUNET_assert(NULL != httpd);
       hd = httpd;
-  }
-  fd = GNUNET_NETWORK_get_fd (s5r->sock);
-  addr = GNUNET_NETWORK_get_addr (s5r->sock);
-  len = GNUNET_NETWORK_get_addrlen (s5r->sock);
+    }
+  fd = GNUNET_NETWORK_get_fd(s5r->sock);
+  addr = GNUNET_NETWORK_get_addr(s5r->sock);
+  len = GNUNET_NETWORK_get_addrlen(s5r->sock);
   s5r->state = SOCKS5_SOCKET_WITH_MHD;
   if (MHD_YES !=
-      MHD_add_connection (hd->daemon,
-                          fd,
-                          addr,
-                          len))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to pass client to MHD\n"));
-    cleanup_s5r (s5r);
-    GNUNET_free_non_null (domain);
-    return;
-  }
+      MHD_add_connection(hd->daemon,
+                         fd,
+                         addr,
+                         len))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to pass client to MHD\n"));
+      cleanup_s5r(s5r);
+      GNUNET_free_non_null(domain);
+      return;
+    }
   s5r->hd = hd;
-  schedule_httpd (hd);
-  s5r->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_HANDSHAKE_TIMEOUT,
-                                                    &timeout_s5r_handshake,
-                                                    s5r);
-  GNUNET_free_non_null (domain);
+  schedule_httpd(hd);
+  s5r->timeout_task = GNUNET_SCHEDULER_add_delayed(HTTP_HANDSHAKE_TIMEOUT,
+                                                   &timeout_s5r_handshake,
+                                                   s5r);
+  GNUNET_free_non_null(domain);
 }
 
 
@@ -2924,57 +2919,61 @@ setup_data_transfer (struct Socks5Request *s5r)
  * @param cls the closure with the `struct Socks5Request`
  */
 static void
-do_write (void *cls)
+do_write(void *cls)
 {
   struct Socks5Request *s5r = cls;
   ssize_t len;
 
   s5r->wtask = NULL;
-  len = GNUNET_NETWORK_socket_send (s5r->sock,
-                                    s5r->wbuf,
-                                    s5r->wbuf_len);
+  len = GNUNET_NETWORK_socket_send(s5r->sock,
+                                   s5r->wbuf,
+                                   s5r->wbuf_len);
   if (len <= 0)
-  {
-    /* write error: connection closed, shutdown, etc.; just clean up */
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Write Error\n");
-    cleanup_s5r (s5r);
-    return;
-  }
-  memmove (s5r->wbuf,
-           &s5r->wbuf[len],
-           s5r->wbuf_len - len);
+    {
+      /* write error: connection closed, shutdown, etc.; just clean up */
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Write Error\n");
+      cleanup_s5r(s5r);
+      return;
+    }
+  memmove(s5r->wbuf,
+          &s5r->wbuf[len],
+          s5r->wbuf_len - len);
   s5r->wbuf_len -= len;
   if (s5r->wbuf_len > 0)
-  {
-    /* not done writing */
-    s5r->wtask =
-      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      s5r->sock,
-                                      &do_write, s5r);
-    return;
-  }
+    {
+      /* not done writing */
+      s5r->wtask =
+        GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       s5r->sock,
+                                       &do_write, s5r);
+      return;
+    }
 
   /* we're done writing, continue with state machine! */
 
   switch (s5r->state)
-  {
+    {
     case SOCKS5_INIT:
-      GNUNET_assert (0);
+      GNUNET_assert(0);
       break;
+
     case SOCKS5_REQUEST:
-      GNUNET_assert (NULL != s5r->rtask);
+      GNUNET_assert(NULL != s5r->rtask);
       break;
+
     case SOCKS5_DATA_TRANSFER:
-      setup_data_transfer (s5r);
+      setup_data_transfer(s5r);
       return;
+
     case SOCKS5_WRITE_THEN_CLEANUP:
-      cleanup_s5r (s5r);
+      cleanup_s5r(s5r);
       return;
+
     default:
-      GNUNET_break (0);
+      GNUNET_break(0);
       break;
-  }
+    }
 }
 
 
@@ -2985,21 +2984,21 @@ do_write (void *cls)
  * @param sc status code to return
  */
 static void
-signal_socks_failure (struct Socks5Request *s5r,
-                      enum Socks5StatusCode sc)
+signal_socks_failure(struct Socks5Request *s5r,
+                     enum Socks5StatusCode sc)
 {
   struct Socks5ServerResponseMessage *s_resp;
 
-  s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
-  memset (s_resp, 0, sizeof (struct Socks5ServerResponseMessage));
+  s_resp = (struct Socks5ServerResponseMessage *)&s5r->wbuf[s5r->wbuf_len];
+  memset(s_resp, 0, sizeof(struct Socks5ServerResponseMessage));
   s_resp->version = SOCKS_VERSION_5;
   s_resp->reply = sc;
   s5r->state = SOCKS5_WRITE_THEN_CLEANUP;
   if (NULL != s5r->wtask)
     s5r->wtask =
-      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      s5r->sock,
-                                      &do_write, s5r);
+      GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                     s5r->sock,
+                                     &do_write, s5r);
 }
 
 
@@ -3009,26 +3008,26 @@ signal_socks_failure (struct Socks5Request *s5r,
  * @param s5r request to return success status message for
  */
 static void
-signal_socks_success (struct Socks5Request *s5r)
+signal_socks_success(struct Socks5Request *s5r)
 {
   struct Socks5ServerResponseMessage *s_resp;
 
-  s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
+  s_resp = (struct Socks5ServerResponseMessage *)&s5r->wbuf[s5r->wbuf_len];
   s_resp->version = SOCKS_VERSION_5;
   s_resp->reply = SOCKS5_STATUS_REQUEST_GRANTED;
   s_resp->reserved = 0;
   s_resp->addr_type = SOCKS5_AT_IPV4;
   /* zero out IPv4 address and port */
-  memset (&s_resp[1],
-          0,
-          sizeof (struct in_addr) + sizeof (uint16_t));
-  s5r->wbuf_len += sizeof (struct Socks5ServerResponseMessage) +
-    sizeof (struct in_addr) + sizeof (uint16_t);
+  memset(&s_resp[1],
+         0,
+         sizeof(struct in_addr) + sizeof(uint16_t));
+  s5r->wbuf_len += sizeof(struct Socks5ServerResponseMessage) +
+                   sizeof(struct in_addr) + sizeof(uint16_t);
   if (NULL == s5r->wtask)
     s5r->wtask =
-      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      s5r->sock,
-                                      &do_write, s5r);
+      GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                     s5r->sock,
+                                     &do_write, s5r);
 }
 
 
@@ -3041,10 +3040,10 @@ signal_socks_success (struct Socks5Request *s5r)
  * @param rd record data
  */
 static void
-handle_gns_result (void *cls,
-                   int tld,
-                   uint32_t rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns_result(void *cls,
+                  int tld,
+                  uint32_t rd_count,
+                  const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Socks5Request *s5r = cls;
   const struct GNUNET_GNSRECORD_Data *r;
@@ -3053,118 +3052,123 @@ handle_gns_result (void *cls,
   s5r->gns_lookup = NULL;
   s5r->is_gns = tld;
   got_ip = GNUNET_NO;
-  for (uint32_t i=0;i<rd_count;i++)
-  {
-    r = &rd[i];
-    switch (r->record_type)
+  for (uint32_t i = 0; i < rd_count; i++)
     {
-      case GNUNET_DNSPARSER_TYPE_A:
+      r = &rd[i];
+      switch (r->record_type)
+        {
+        case GNUNET_DNSPARSER_TYPE_A:
         {
           struct sockaddr_in *in;
 
-          if (sizeof (struct in_addr) != r->data_size)
-          {
-            GNUNET_break_op (0);
-            break;
-          }
+          if (sizeof(struct in_addr) != r->data_size)
+            {
+              GNUNET_break_op(0);
+              break;
+            }
           if (GNUNET_YES == got_ip)
             break;
           if (GNUNET_OK !=
-              GNUNET_NETWORK_test_pf (PF_INET))
+              GNUNET_NETWORK_test_pf(PF_INET))
             break;
           got_ip = GNUNET_YES;
-          in = (struct sockaddr_in *) &s5r->destination_address;
+          in = (struct sockaddr_in *)&s5r->destination_address;
           in->sin_family = AF_INET;
-          GNUNET_memcpy (&in->sin_addr,
-                         r->data,
-                         r->data_size);
-          in->sin_port = htons (s5r->port);
+          GNUNET_memcpy(&in->sin_addr,
+                        r->data,
+                        r->data_size);
+          in->sin_port = htons(s5r->port);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          in->sin_len = sizeof (*in);
+          in->sin_len = sizeof(*in);
 #endif
         }
         break;
-      case GNUNET_DNSPARSER_TYPE_AAAA:
+
+        case GNUNET_DNSPARSER_TYPE_AAAA:
         {
           struct sockaddr_in6 *in;
 
-          if (sizeof (struct in6_addr) != r->data_size)
-          {
-            GNUNET_break_op (0);
-            break;
-          }
+          if (sizeof(struct in6_addr) != r->data_size)
+            {
+              GNUNET_break_op(0);
+              break;
+            }
           if (GNUNET_YES == got_ip)
             break;
           if (GNUNET_YES == disable_v6)
             break;
           if (GNUNET_OK !=
-              GNUNET_NETWORK_test_pf (PF_INET6))
+              GNUNET_NETWORK_test_pf(PF_INET6))
             break;
           /* FIXME: allow user to disable IPv6 per configuration option... */
           got_ip = GNUNET_YES;
-          in = (struct sockaddr_in6 *) &s5r->destination_address;
+          in = (struct sockaddr_in6 *)&s5r->destination_address;
           in->sin6_family = AF_INET6;
-          GNUNET_memcpy (&in->sin6_addr,
-                         r->data,
-                         r->data_size);
-          in->sin6_port = htons (s5r->port);
+          GNUNET_memcpy(&in->sin6_addr,
+                        r->data,
+                        r->data_size);
+          in->sin6_port = htons(s5r->port);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          in->sin6_len = sizeof (*in);
+          in->sin6_len = sizeof(*in);
 #endif
         }
         break;
-      case GNUNET_GNSRECORD_TYPE_VPN:
-        GNUNET_break (0); /* should have been translated within GNS */
-        break;
-      case GNUNET_GNSRECORD_TYPE_LEHO:
-        GNUNET_free_non_null (s5r->leho);
-        s5r->leho = GNUNET_strndup (r->data,
-                                    r->data_size);
-        break;
-      case GNUNET_GNSRECORD_TYPE_BOX:
+
+        case GNUNET_GNSRECORD_TYPE_VPN:
+          GNUNET_break(0); /* should have been translated within GNS */
+          break;
+
+        case GNUNET_GNSRECORD_TYPE_LEHO:
+          GNUNET_free_non_null(s5r->leho);
+          s5r->leho = GNUNET_strndup(r->data,
+                                     r->data_size);
+          break;
+
+        case GNUNET_GNSRECORD_TYPE_BOX:
         {
           const struct GNUNET_GNSRECORD_BoxRecord *box;
 
-          if (r->data_size < sizeof (struct GNUNET_GNSRECORD_BoxRecord))
-          {
-            GNUNET_break_op (0);
-            break;
-          }
+          if (r->data_size < sizeof(struct GNUNET_GNSRECORD_BoxRecord))
+            {
+              GNUNET_break_op(0);
+              break;
+            }
           box = r->data;
-          if ( (ntohl (box->record_type) != GNUNET_DNSPARSER_TYPE_TLSA) ||
-               (ntohs (box->protocol) != IPPROTO_TCP) ||
-               (ntohs (box->service) != s5r->port) )
+          if ((ntohl(box->record_type) != GNUNET_DNSPARSER_TYPE_TLSA) ||
+              (ntohs(box->protocol) != IPPROTO_TCP) ||
+              (ntohs(box->service) != s5r->port))
             break; /* BOX record does not apply */
-          if (s5r->num_danes >= MAX_DANES)
-            {
-              GNUNET_break (0); /* MAX_DANES too small */
-              break;
-            }
+          if (s5r->num_danes >= MAX_DANES)
+            {
+              GNUNET_break(0);  /* MAX_DANES too small */
+              break;
+            }
           s5r->is_tls = GNUNET_YES; /* This should be TLS */
           s5r->dane_data_len[s5r->num_danes]
-            = r->data_size - sizeof (struct GNUNET_GNSRECORD_BoxRecord);
+            = r->data_size - sizeof(struct GNUNET_GNSRECORD_BoxRecord);
           s5r->dane_data[s5r->num_danes]
-            = GNUNET_memdup (&box[1],
-                             s5r->dane_data_len[s5r->num_danes]);
-          s5r->num_danes++;
+            = GNUNET_memdup(&box[1],
+                            s5r->dane_data_len[s5r->num_danes]);
+          s5r->num_danes++;
+          break;
+        }
+
+        default:
+          /* don't care */
           break;
         }
-      default:
-        /* don't care */
-        break;
     }
-  }
-  if ( (GNUNET_YES != got_ip) &&
-       (GNUNET_YES == tld) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Name resolution failed to yield useful IP address.\n");
-    signal_socks_failure (s5r,
-                          SOCKS5_STATUS_GENERAL_FAILURE);
-    return;
-  }
+  if ((GNUNET_YES != got_ip) &&
+      (GNUNET_YES == tld))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Name resolution failed to yield useful IP address.\n");
+      signal_socks_failure(s5r,
+                           SOCKS5_STATUS_GENERAL_FAILURE);
+      return;
+    }
   s5r->state = SOCKS5_DATA_TRANSFER;
-  signal_socks_success (s5r);
+  signal_socks_success(s5r);
 }
 
 
@@ -3175,13 +3179,13 @@ handle_gns_result (void *cls,
  * @param len number of bytes in read buffer to advance
  */
 static void
-clear_from_s5r_rbuf (struct Socks5Request *s5r,
-                     size_t len)
+clear_from_s5r_rbuf(struct Socks5Request *s5r,
+                    size_t len)
 {
-  GNUNET_assert (len <= s5r->rbuf_len);
-  memmove (s5r->rbuf,
-           &s5r->rbuf[len],
-           s5r->rbuf_len - len);
+  GNUNET_assert(len <= s5r->rbuf_len);
+  memmove(s5r->rbuf,
+          &s5r->rbuf[len],
+          s5r->rbuf_len - len);
   s5r->rbuf_len -= len;
 }
 
@@ -3192,7 +3196,7 @@ clear_from_s5r_rbuf (struct Socks5Request *s5r,
  * @param cls the closure with the `struct Socks5Request`
  */
 static void
-do_s5r_read (void *cls)
+do_s5r_read(void *cls)
 {
   struct Socks5Request *s5r = cls;
   const struct Socks5ClientHelloMessage *c_hello;
@@ -3203,188 +3207,196 @@ do_s5r_read (void *cls)
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   s5r->rtask = NULL;
-  tc = GNUNET_SCHEDULER_get_task_context ();
-  if ( (NULL != tc->read_ready) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
-                                    s5r->sock)) )
-  {
-    rlen = GNUNET_NETWORK_socket_recv (s5r->sock,
-                                       &s5r->rbuf[s5r->rbuf_len],
-                                       sizeof (s5r->rbuf) - s5r->rbuf_len);
-    if (rlen <= 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "socks5 client disconnected.\n");
-      cleanup_s5r (s5r);
-      return;
+  tc = GNUNET_SCHEDULER_get_task_context();
+  if ((NULL != tc->read_ready) &&
+      (GNUNET_NETWORK_fdset_isset(tc->read_ready,
+                                  s5r->sock)))
+    {
+      rlen = GNUNET_NETWORK_socket_recv(s5r->sock,
+                                        &s5r->rbuf[s5r->rbuf_len],
+                                        sizeof(s5r->rbuf) - s5r->rbuf_len);
+      if (rlen <= 0)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "socks5 client disconnected.\n");
+          cleanup_s5r(s5r);
+          return;
+        }
+      s5r->rbuf_len += rlen;
     }
-    s5r->rbuf_len += rlen;
-  }
-  s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              s5r->sock,
-                                              &do_s5r_read, s5r);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Processing %zu bytes of socks data in state %d\n",
-              s5r->rbuf_len,
-              s5r->state);
+  s5r->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                             s5r->sock,
+                                             &do_s5r_read, s5r);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Processing %zu bytes of socks data in state %d\n",
+             s5r->rbuf_len,
+             s5r->state);
   switch (s5r->state)
-  {
+    {
     case SOCKS5_INIT:
-      c_hello = (const struct Socks5ClientHelloMessage*) &s5r->rbuf;
-      if ( (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage)) ||
-           (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods) )
+      c_hello = (const struct Socks5ClientHelloMessage*)&s5r->rbuf;
+      if ((s5r->rbuf_len < sizeof(struct Socks5ClientHelloMessage)) ||
+          (s5r->rbuf_len < sizeof(struct Socks5ClientHelloMessage) + c_hello->num_auth_methods))
         return; /* need more data */
       if (SOCKS_VERSION_5 != c_hello->version)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _("Unsupported socks version %d\n"),
-                    (int) c_hello->version);
-        cleanup_s5r (s5r);
-        return;
-      }
-      clear_from_s5r_rbuf (s5r,
-                           sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods);
-      GNUNET_assert (0 == s5r->wbuf_len);
-      s_hello = (struct Socks5ServerHelloMessage *) &s5r->wbuf;
-      s5r->wbuf_len = sizeof (struct Socks5ServerHelloMessage);
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unsupported socks version %d\n"),
+                     (int)c_hello->version);
+          cleanup_s5r(s5r);
+          return;
+        }
+      clear_from_s5r_rbuf(s5r,
+                          sizeof(struct Socks5ClientHelloMessage) + c_hello->num_auth_methods);
+      GNUNET_assert(0 == s5r->wbuf_len);
+      s_hello = (struct Socks5ServerHelloMessage *)&s5r->wbuf;
+      s5r->wbuf_len = sizeof(struct Socks5ServerHelloMessage);
       s_hello->version = SOCKS_VERSION_5;
       s_hello->auth_method = SOCKS_AUTH_NONE;
-      GNUNET_assert (NULL == s5r->wtask);
-      s5r->wtask = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                   s5r->sock,
-                                                   &do_write, s5r);
+      GNUNET_assert(NULL == s5r->wtask);
+      s5r->wtask = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  s5r->sock,
+                                                  &do_write, s5r);
       s5r->state = SOCKS5_REQUEST;
       return;
+
     case SOCKS5_REQUEST:
-      c_req = (const struct Socks5ClientRequestMessage *) &s5r->rbuf;
-      if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage))
+      c_req = (const struct Socks5ClientRequestMessage *)&s5r->rbuf;
+      if (s5r->rbuf_len < sizeof(struct Socks5ClientRequestMessage))
         return;
       switch (c_req->command)
-      {
+        {
         case SOCKS5_CMD_TCP_STREAM:
           /* handled below */
           break;
+
         default:
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Unsupported socks command %d\n"),
-                      (int) c_req->command);
-          signal_socks_failure (s5r,
-                                SOCKS5_STATUS_COMMAND_NOT_SUPPORTED);
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unsupported socks command %d\n"),
+                     (int)c_req->command);
+          signal_socks_failure(s5r,
+                               SOCKS5_STATUS_COMMAND_NOT_SUPPORTED);
           return;
-      }
+        }
       switch (c_req->addr_type)
-      {
+        {
         case SOCKS5_AT_IPV4:
-          {
-            const struct in_addr *v4 = (const struct in_addr *) &c_req[1];
-            const uint16_t *port = (const uint16_t *) &v4[1];
-            struct sockaddr_in *in;
-
-            s5r->port = ntohs (*port);
-            alen = sizeof (struct in_addr);
-            if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
-                alen + sizeof (uint16_t))
-              return; /* need more data */
-            in = (struct sockaddr_in *) &s5r->destination_address;
-            in->sin_family = AF_INET;
-            in->sin_addr = *v4;
-            in->sin_port = *port;
+        {
+          const struct in_addr *v4 = (const struct in_addr *)&c_req[1];
+          const uint16_t *port = (const uint16_t *)&v4[1];
+          struct sockaddr_in *in;
+
+          s5r->port = ntohs(*port);
+          alen = sizeof(struct in_addr);
+          if (s5r->rbuf_len < sizeof(struct Socks5ClientRequestMessage) +
+              alen + sizeof(uint16_t))
+            return;   /* need more data */
+          in = (struct sockaddr_in *)&s5r->destination_address;
+          in->sin_family = AF_INET;
+          in->sin_addr = *v4;
+          in->sin_port = *port;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-            in->sin_len = sizeof (*in);
+          in->sin_len = sizeof(*in);
 #endif
-            s5r->state = SOCKS5_DATA_TRANSFER;
-          }
-          break;
+          s5r->state = SOCKS5_DATA_TRANSFER;
+        }
+        break;
+
         case SOCKS5_AT_IPV6:
-          {
-            const struct in6_addr *v6 = (const struct in6_addr *) &c_req[1];
-            const uint16_t *port = (const uint16_t *) &v6[1];
-            struct sockaddr_in6 *in;
-
-            s5r->port = ntohs (*port);
-            alen = sizeof (struct in6_addr);
-            if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
-                alen + sizeof (uint16_t))
-              return; /* need more data */
-            in = (struct sockaddr_in6 *) &s5r->destination_address;
-            in->sin6_family = AF_INET6;
-            in->sin6_addr = *v6;
-            in->sin6_port = *port;
+        {
+          const struct in6_addr *v6 = (const struct in6_addr *)&c_req[1];
+          const uint16_t *port = (const uint16_t *)&v6[1];
+          struct sockaddr_in6 *in;
+
+          s5r->port = ntohs(*port);
+          alen = sizeof(struct in6_addr);
+          if (s5r->rbuf_len < sizeof(struct Socks5ClientRequestMessage) +
+              alen + sizeof(uint16_t))
+            return;   /* need more data */
+          in = (struct sockaddr_in6 *)&s5r->destination_address;
+          in->sin6_family = AF_INET6;
+          in->sin6_addr = *v6;
+          in->sin6_port = *port;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-            in->sin6_len = sizeof (*in);
+          in->sin6_len = sizeof(*in);
 #endif
-            s5r->state = SOCKS5_DATA_TRANSFER;
-          }
-          break;
+          s5r->state = SOCKS5_DATA_TRANSFER;
+        }
+        break;
+
         case SOCKS5_AT_DOMAINNAME:
-          {
-            const uint8_t *dom_len;
-            const char *dom_name;
-            const uint16_t *port;
-
-            dom_len = (const uint8_t *) &c_req[1];
-            alen = *dom_len + 1;
-            if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
-                alen + sizeof (uint16_t))
-              return; /* need more data */
-            dom_name = (const char *) &dom_len[1];
-            port = (const uint16_t*) &dom_name[*dom_len];
-            s5r->domain = GNUNET_strndup (dom_name,
-                                          *dom_len);
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "Requested connection is to %s:%d\n",
-                        //(HTTPS_PORT == s5r->port) ? "s" : "",
-                        s5r->domain,
-                        ntohs (*port));
-            s5r->state = SOCKS5_RESOLVING;
-            s5r->port = ntohs (*port);
-            s5r->is_tls = (HTTPS_PORT == s5r->port) ? GNUNET_YES : GNUNET_NO;
-            s5r->gns_lookup = GNUNET_GNS_lookup_with_tld (gns_handle,
-                                                          s5r->domain,
-                                                          GNUNET_DNSPARSER_TYPE_A,
-                                                          GNUNET_NO /* only cached */,
-                                                          &handle_gns_result,
-                                                          s5r);
-            break;
-          }
+        {
+          const uint8_t *dom_len;
+          const char *dom_name;
+          const uint16_t *port;
+
+          dom_len = (const uint8_t *)&c_req[1];
+          alen = *dom_len + 1;
+          if (s5r->rbuf_len < sizeof(struct Socks5ClientRequestMessage) +
+              alen + sizeof(uint16_t))
+            return;   /* need more data */
+          dom_name = (const char *)&dom_len[1];
+          port = (const uint16_t*)&dom_name[*dom_len];
+          s5r->domain = GNUNET_strndup(dom_name,
+                                       *dom_len);
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Requested connection is to %s:%d\n",
+                     //(HTTPS_PORT == s5r->port) ? "s" : "",
+                     s5r->domain,
+                     ntohs(*port));
+          s5r->state = SOCKS5_RESOLVING;
+          s5r->port = ntohs(*port);
+          s5r->is_tls = (HTTPS_PORT == s5r->port) ? GNUNET_YES : GNUNET_NO;
+          s5r->gns_lookup = GNUNET_GNS_lookup_with_tld(gns_handle,
+                                                       s5r->domain,
+                                                       GNUNET_DNSPARSER_TYPE_A,
+                                                       GNUNET_NO /* only cached */,
+                                                       &handle_gns_result,
+                                                       s5r);
+          break;
+        }
+
         default:
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Unsupported socks address type %d\n"),
-                      (int) c_req->addr_type);
-          signal_socks_failure (s5r,
-                                SOCKS5_STATUS_ADDRESS_TYPE_NOT_SUPPORTED);
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unsupported socks address type %d\n"),
+                     (int)c_req->addr_type);
+          signal_socks_failure(s5r,
+                               SOCKS5_STATUS_ADDRESS_TYPE_NOT_SUPPORTED);
           return;
-      }
-      clear_from_s5r_rbuf (s5r,
-                           sizeof (struct Socks5ClientRequestMessage) +
-                           alen + sizeof (uint16_t));
+        }
+      clear_from_s5r_rbuf(s5r,
+                          sizeof(struct Socks5ClientRequestMessage) +
+                          alen + sizeof(uint16_t));
       if (0 != s5r->rbuf_len)
-      {
-        /* read more bytes than healthy, why did the client send more!? */
-        GNUNET_break_op (0);
-        signal_socks_failure (s5r,
-                              SOCKS5_STATUS_GENERAL_FAILURE);
-        return;
-      }
+        {
+          /* read more bytes than healthy, why did the client send more!? */
+          GNUNET_break_op(0);
+          signal_socks_failure(s5r,
+                               SOCKS5_STATUS_GENERAL_FAILURE);
+          return;
+        }
       if (SOCKS5_DATA_TRANSFER == s5r->state)
-      {
-        /* if we are not waiting for GNS resolution, signal success */
-        signal_socks_success (s5r);
-      }
+        {
+          /* if we are not waiting for GNS resolution, signal success */
+          signal_socks_success(s5r);
+        }
       /* We are done reading right now */
-      GNUNET_SCHEDULER_cancel (s5r->rtask);
+      GNUNET_SCHEDULER_cancel(s5r->rtask);
       s5r->rtask = NULL;
       return;
+
     case SOCKS5_RESOLVING:
-      GNUNET_assert (0);
+      GNUNET_assert(0);
       return;
+
     case SOCKS5_DATA_TRANSFER:
-      GNUNET_assert (0);
+      GNUNET_assert(0);
       return;
+
     default:
-      GNUNET_assert (0);
+      GNUNET_assert(0);
       return;
-  }
+    }
 }
 
 
@@ -3395,46 +3407,46 @@ do_s5r_read (void *cls)
  * @param tc the scheduler context
  */
 static void
-do_accept (void *cls)
+do_accept(void *cls)
 {
   struct GNUNET_NETWORK_Handle *lsock = cls;
   struct GNUNET_NETWORK_Handle *s;
   struct Socks5Request *s5r;
 
-  GNUNET_assert (NULL != lsock);
+  GNUNET_assert(NULL != lsock);
   if (lsock == lsock4)
-    ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                            lsock,
-                                            &do_accept,
-                                            lsock);
+    ltask4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                           lsock,
+                                           &do_accept,
+                                           lsock);
   else if (lsock == lsock6)
-    ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                            lsock,
-                                            &do_accept,
-                                            lsock);
+    ltask6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                           lsock,
+                                           &do_accept,
+                                           lsock);
   else
-    GNUNET_assert (0);
-  s = GNUNET_NETWORK_socket_accept (lsock,
-                                    NULL,
-                                    NULL);
+    GNUNET_assert(0);
+  s = GNUNET_NETWORK_socket_accept(lsock,
+                                   NULL,
+                                   NULL);
   if (NULL == s)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "accept");
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got an inbound connection, waiting for data\n");
-  s5r = GNUNET_new (struct Socks5Request);
-  GNUNET_CONTAINER_DLL_insert (s5r_head,
-                               s5r_tail,
-                               s5r);
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                          "accept");
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got an inbound connection, waiting for data\n");
+  s5r = GNUNET_new(struct Socks5Request);
+  GNUNET_CONTAINER_DLL_insert(s5r_head,
+                              s5r_tail,
+                              s5r);
   s5r->sock = s;
   s5r->state = SOCKS5_INIT;
-  s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              s5r->sock,
-                                              &do_s5r_read,
-                                              s5r);
+  s5r->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                             s5r->sock,
+                                             &do_s5r_read,
+                                             s5r);
 }
 
 
@@ -3447,63 +3459,63 @@ do_accept (void *cls)
  * @param cls closure
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Shutting down...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Shutting down...\n");
   /* MHD requires resuming before destroying the daemons */
   for (struct Socks5Request *s5r = s5r_head;
        NULL != s5r;
        s5r = s5r->next)
-  {
-    if (s5r->suspended)
     {
-      s5r->suspended = GNUNET_NO;
-      MHD_resume_connection (s5r->con);
+      if (s5r->suspended)
+        {
+          s5r->suspended = GNUNET_NO;
+          MHD_resume_connection(s5r->con);
+        }
     }
-  }
   while (NULL != mhd_httpd_head)
-    kill_httpd (mhd_httpd_head);
+    kill_httpd(mhd_httpd_head);
   while (NULL != s5r_head)
-    cleanup_s5r (s5r_head);
+    cleanup_s5r(s5r_head);
   if (NULL != lsock4)
-  {
-    GNUNET_NETWORK_socket_close (lsock4);
-    lsock4 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(lsock4);
+      lsock4 = NULL;
+    }
   if (NULL != lsock6)
-  {
-    GNUNET_NETWORK_socket_close (lsock6);
-    lsock6 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(lsock6);
+      lsock6 = NULL;
+    }
   if (NULL != curl_multi)
-  {
-    curl_multi_cleanup (curl_multi);
-    curl_multi = NULL;
-  }
+    {
+      curl_multi_cleanup(curl_multi);
+      curl_multi = NULL;
+    }
   if (NULL != gns_handle)
-  {
-    GNUNET_GNS_disconnect (gns_handle);
-    gns_handle = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(gns_handle);
+      gns_handle = NULL;
+    }
   if (NULL != curl_download_task)
-  {
-    GNUNET_SCHEDULER_cancel (curl_download_task);
-    curl_download_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(curl_download_task);
+      curl_download_task = NULL;
+    }
   if (NULL != ltask4)
-  {
-    GNUNET_SCHEDULER_cancel (ltask4);
-    ltask4 = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(ltask4);
+      ltask4 = NULL;
+    }
   if (NULL != ltask6)
-  {
-    GNUNET_SCHEDULER_cancel (ltask6);
-    ltask6 = NULL;
-  }
-  gnutls_x509_crt_deinit (proxy_ca.cert);
-  gnutls_x509_privkey_deinit (proxy_ca.key);
-  gnutls_global_deinit ();
+    {
+      GNUNET_SCHEDULER_cancel(ltask6);
+      ltask6 = NULL;
+    }
+  gnutls_x509_crt_deinit(proxy_ca.cert);
+  gnutls_x509_privkey_deinit(proxy_ca.key);
+  gnutls_global_deinit();
 }
 
 
@@ -3513,34 +3525,34 @@ do_shutdown (void *cls)
  * @return NULL on error
  */
 static struct GNUNET_NETWORK_Handle *
-bind_v4 ()
+bind_v4()
 {
   struct GNUNET_NETWORK_Handle *ls;
   struct sockaddr_in sa4;
   int eno;
 
-  memset (&sa4, 0, sizeof (sa4));
+  memset(&sa4, 0, sizeof(sa4));
   sa4.sin_family = AF_INET;
-  sa4.sin_port = htons (port);
+  sa4.sin_port = htons(port);
   sa4.sin_addr.s_addr = address;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa4.sin_len = sizeof (sa4);
+  sa4.sin_len = sizeof(sa4);
 #endif
-  ls = GNUNET_NETWORK_socket_create (AF_INET,
-                                     SOCK_STREAM,
-                                     0);
+  ls = GNUNET_NETWORK_socket_create(AF_INET,
+                                    SOCK_STREAM,
+                                    0);
   if (NULL == ls)
     return NULL;
   if (GNUNET_OK !=
-      GNUNET_NETWORK_socket_bind (ls,
-                                  (const struct sockaddr *) &sa4,
-                                  sizeof (sa4)))
-  {
-    eno = errno;
-    GNUNET_NETWORK_socket_close (ls);
-    errno = eno;
-    return NULL;
-  }
+      GNUNET_NETWORK_socket_bind(ls,
+                                 (const struct sockaddr *)&sa4,
+                                 sizeof(sa4)))
+    {
+      eno = errno;
+      GNUNET_NETWORK_socket_close(ls);
+      errno = eno;
+      return NULL;
+    }
   return ls;
 }
 
@@ -3551,34 +3563,34 @@ bind_v4 ()
  * @return NULL on error
  */
 static struct GNUNET_NETWORK_Handle *
-bind_v6 ()
+bind_v6()
 {
   struct GNUNET_NETWORK_Handle *ls;
   struct sockaddr_in6 sa6;
   int eno;
 
-  memset (&sa6, 0, sizeof (sa6));
+  memset(&sa6, 0, sizeof(sa6));
   sa6.sin6_family = AF_INET6;
-  sa6.sin6_port = htons (port);
+  sa6.sin6_port = htons(port);
   sa6.sin6_addr = address6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa6.sin6_len = sizeof (sa6);
+  sa6.sin6_len = sizeof(sa6);
 #endif
-  ls = GNUNET_NETWORK_socket_create (AF_INET6,
-                                     SOCK_STREAM,
-                                     0);
+  ls = GNUNET_NETWORK_socket_create(AF_INET6,
+                                    SOCK_STREAM,
+                                    0);
   if (NULL == ls)
     return NULL;
   if (GNUNET_OK !=
-      GNUNET_NETWORK_socket_bind (ls,
-                                  (const struct sockaddr *) &sa6,
-                                  sizeof (sa6)))
-  {
-    eno = errno;
-    GNUNET_NETWORK_socket_close (ls);
-    errno = eno;
-    return NULL;
-  }
+      GNUNET_NETWORK_socket_bind(ls,
+                                 (const struct sockaddr *)&sa6,
+                                 sizeof(sa6)))
+    {
+      eno = errno;
+      GNUNET_NETWORK_socket_close(ls);
+      errno = eno;
+      return NULL;
+    }
   return ls;
 }
 
@@ -3592,10 +3604,10 @@ bind_v6 ()
  * @param c configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
   char* cafile_cfg = NULL;
   char* cafile;
@@ -3605,198 +3617,198 @@ run (void *cls,
   cfg = c;
 
   /* Get address to bind to */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "gns-proxy",
-                                                          "BIND_TO",
-                                                          &addr_str))
-  {
-    //No address specified
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Don't know what to bind to...\n");
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (1 != inet_pton (AF_INET, addr_str, &address))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse address %s\n",
-                addr_str);
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_free (addr_str);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "gns-proxy",
+                                                         "BIND_TO",
+                                                         &addr_str))
+    {
+      //No address specified
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Don't know what to bind to...\n");
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (1 != inet_pton(AF_INET, addr_str, &address))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to parse address %s\n",
+                 addr_str);
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_free(addr_str);
   /* Get address to bind to */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "gns-proxy",
-                                                          "BIND_TO6",
-                                                          &addr_str))
-  {
-    //No address specified
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Don't know what to bind6 to...\n");
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (1 != inet_pton (AF_INET6, addr_str, &address6))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse IPv6 address %s\n",
-                addr_str);
-    GNUNET_free (addr_str);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_free (addr_str);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "gns-proxy",
+                                                         "BIND_TO6",
+                                                         &addr_str))
+    {
+      //No address specified
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Don't know what to bind6 to...\n");
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (1 != inet_pton(AF_INET6, addr_str, &address6))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to parse IPv6 address %s\n",
+                 addr_str);
+      GNUNET_free(addr_str);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_free(addr_str);
 
-  if (NULL == (curl_multi = curl_multi_init ()))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create cURL multi handle!\n");
-    return;
-  }
+  if (NULL == (curl_multi = curl_multi_init()))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create cURL multi handle!\n");
+      return;
+    }
   cafile = cafile_opt;
   if (NULL == cafile)
-  {
-    if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                 "gns-proxy",
-                                                 "PROXY_CACERT",
-                                                 &cafile_cfg))
-    {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                                 "gns-proxy",
-                                 "PROXY_CACERT");
+    {
+      if (GNUNET_OK !=
+          GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                  "gns-proxy",
+                                                  "PROXY_CACERT",
+                                                  &cafile_cfg))
+        {
+          GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+                                    "gns-proxy",
+                                    "PROXY_CACERT");
+          return;
+        }
+      cafile = cafile_cfg;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using `%s' as CA\n",
+             cafile);
+
+  gnutls_global_init();
+  gnutls_x509_crt_init(&proxy_ca.cert);
+  gnutls_x509_privkey_init(&proxy_ca.key);
+
+  if ((GNUNET_OK !=
+       load_cert_from_file(proxy_ca.cert,
+                           cafile)) ||
+      (GNUNET_OK !=
+       load_key_from_file(proxy_ca.key,
+                          cafile)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to load X.509 key and certificate from `%s'\n"),
+                 cafile);
+      gnutls_x509_crt_deinit(proxy_ca.cert);
+      gnutls_x509_privkey_deinit(proxy_ca.key);
+      gnutls_global_deinit();
+      GNUNET_free_non_null(cafile_cfg);
       return;
     }
-    cafile = cafile_cfg;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using `%s' as CA\n",
-              cafile);
-
-  gnutls_global_init ();
-  gnutls_x509_crt_init (&proxy_ca.cert);
-  gnutls_x509_privkey_init (&proxy_ca.key);
-
-  if ( (GNUNET_OK !=
-        load_cert_from_file (proxy_ca.cert,
-                             cafile)) ||
-       (GNUNET_OK !=
-        load_key_from_file (proxy_ca.key,
-                            cafile)) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to load X.509 key and certificate from `%s'\n"),
-                cafile);
-    gnutls_x509_crt_deinit (proxy_ca.cert);
-    gnutls_x509_privkey_deinit (proxy_ca.key);
-    gnutls_global_deinit ();
-    GNUNET_free_non_null (cafile_cfg);
-    return;
-  }
-  GNUNET_free_non_null (cafile_cfg);
-  if (NULL == (gns_handle = GNUNET_GNS_connect (cfg)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to connect to GNS!\n");
-    gnutls_x509_crt_deinit (proxy_ca.cert);
-    gnutls_x509_privkey_deinit (proxy_ca.key);
-    gnutls_global_deinit ();
-    return;
-  }
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
+  GNUNET_free_non_null(cafile_cfg);
+  if (NULL == (gns_handle = GNUNET_GNS_connect(cfg)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to connect to GNS!\n");
+      gnutls_x509_crt_deinit(proxy_ca.cert);
+      gnutls_x509_privkey_deinit(proxy_ca.key);
+      gnutls_global_deinit();
+      return;
+    }
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
 
   /* Open listen socket for socks proxy */
-  lsock6 = bind_v6 ();
+  lsock6 = bind_v6();
   if (NULL == lsock6)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "bind");
-  }
-  else
-  {
-    if (GNUNET_OK !=
-        GNUNET_NETWORK_socket_listen (lsock6,
-                                      5))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                           "listen");
-      GNUNET_NETWORK_socket_close (lsock6);
-      lsock6 = NULL;
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                          "bind");
     }
-    else
+  else
     {
-      ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              lsock6,
-                                              &do_accept,
-                                              lsock6);
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_listen(lsock6,
+                                       5))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                              "listen");
+          GNUNET_NETWORK_socket_close(lsock6);
+          lsock6 = NULL;
+        }
+      else
+        {
+          ltask6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 lsock6,
+                                                 &do_accept,
+                                                 lsock6);
+        }
     }
-  }
-  lsock4 = bind_v4 ();
+  lsock4 = bind_v4();
   if (NULL == lsock4)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "bind");
-  }
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                          "bind");
+    }
   else
-  {
-    if (GNUNET_OK !=
-        GNUNET_NETWORK_socket_listen (lsock4,
-                                      5))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                           "listen");
-      GNUNET_NETWORK_socket_close (lsock4);
-      lsock4 = NULL;
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_listen(lsock4,
+                                       5))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                              "listen");
+          GNUNET_NETWORK_socket_close(lsock4);
+          lsock4 = NULL;
+        }
+      else
+        {
+          ltask4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 lsock4,
+                                                 &do_accept,
+                                                 lsock4);
+        }
     }
-    else
+  if ((NULL == lsock4) &&
+      (NULL == lsock6))
     {
-      ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              lsock4,
-                                              &do_accept,
-                                              lsock4);
+      GNUNET_SCHEDULER_shutdown();
+      return;
     }
-  }
-  if ( (NULL == lsock4) &&
-       (NULL == lsock6) )
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (0 != curl_global_init (CURL_GLOBAL_WIN32))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "cURL global init failed!\n");
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Proxy listens on port %u\n",
-              (unsigned int) port);
+  if (0 != curl_global_init(CURL_GLOBAL_WIN32))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "cURL global init failed!\n");
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Proxy listens on port %u\n",
+             (unsigned int)port);
 
   /* start MHD daemon for HTTP */
-  hd = GNUNET_new (struct MhdHttpList);
-  hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
-                                 0,
-                                 NULL, NULL,
-                                 &create_response, hd,
-                                 MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-                                 MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
-                                 MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
-                                 MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
-                                 MHD_OPTION_END);
+  hd = GNUNET_new(struct MhdHttpList);
+  hd->daemon = MHD_start_daemon(MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
+                                0,
+                                NULL, NULL,
+                                &create_response, hd,
+                                MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int)16,
+                                MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
+                                MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
+                                MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
+                                MHD_OPTION_END);
   if (NULL == hd->daemon)
-  {
-    GNUNET_free (hd);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_free(hd);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   httpd = hd;
-  GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
-                               mhd_httpd_tail,
-                               hd);
+  GNUNET_CONTAINER_DLL_insert(mhd_httpd_head,
+                              mhd_httpd_tail,
+                              hd);
 }
 
 
@@ -3808,24 +3820,24 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc,
-      char *const *argv)
+main(int argc,
+     char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint16 ('p',
-                                 "port",
-                                 NULL,
-                                 gettext_noop ("listen on specified port (default: 7777)"),
-                                 &port),
-    GNUNET_GETOPT_option_string ('a',
-                                 "authority",
-                                 NULL,
-                                 gettext_noop ("pem file to use as CA"),
-                                 &cafile_opt),
-    GNUNET_GETOPT_option_flag ('6',
-                               "disable-ivp6",
-                               gettext_noop ("disable use of IPv6"),
-                               &disable_v6),
+    GNUNET_GETOPT_option_uint16('p',
+                                "port",
+                                NULL,
+                                gettext_noop("listen on specified port (default: 7777)"),
+                                &port),
+    GNUNET_GETOPT_option_string('a',
+                                "authority",
+                                NULL,
+                                gettext_noop("pem file to use as CA"),
+                                &cafile_opt),
+    GNUNET_GETOPT_option_flag('6',
+                              "disable-ivp6",
+                              gettext_noop("disable use of IPv6"),
+                              &disable_v6),
 
     GNUNET_GETOPT_OPTION_END
   };
@@ -3835,26 +3847,26 @@ main (int argc,
   int ret;
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_get_utf8_args (argc, argv,
-                                    &argc, &argv))
+      GNUNET_STRINGS_get_utf8_args(argc, argv,
+                                   &argc, &argv))
     return 2;
-  GNUNET_log_setup ("gnunet-gns-proxy",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("gnunet-gns-proxy",
+                   "WARNING",
+                   NULL);
   curl_failure_response
-    = MHD_create_response_from_buffer (strlen (page),
-                                       (void *) page,
-                                       MHD_RESPMEM_PERSISTENT);
+    = MHD_create_response_from_buffer(strlen(page),
+                                      (void *)page,
+                                      MHD_RESPMEM_PERSISTENT);
 
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run (argc, argv,
-                         "gnunet-gns-proxy",
-                         _("GNUnet GNS proxy"),
-                         options,
-                         &run, NULL)) ? 0 : 1;
-  MHD_destroy_response (curl_failure_response);
-  GNUNET_free_non_null ((char *) argv);
+     GNUNET_PROGRAM_run(argc, argv,
+                        "gnunet-gns-proxy",
+                        _("GNUnet GNS proxy"),
+                        options,
+                        &run, NULL)) ? 0 : 1;
+  MHD_destroy_response(curl_failure_response);
+  GNUNET_free_non_null((char *)argv);
   return ret;
 }
 
diff --git a/src/gns/gnunet-gns.c b/src/gns/gnunet-gns.c
index d795f89fc..352ccce04 100644
--- a/src/gns/gnunet-gns.c
+++ b/src/gns/gnunet-gns.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gnunet-gns.c
  * @brief command line tool to access distributed GNS
@@ -90,24 +90,24 @@ static int global_ret;
  * @param cls unused
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != to_task)
-  {
-    GNUNET_SCHEDULER_cancel (to_task);
-    to_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(to_task);
+      to_task = NULL;
+    }
   if (NULL != lr)
-  {
-    GNUNET_GNS_lookup_with_tld_cancel (lr);
-    lr = NULL;
-  }
+    {
+      GNUNET_GNS_lookup_with_tld_cancel(lr);
+      lr = NULL;
+    }
   if (NULL != gns)
-  {
-    GNUNET_GNS_disconnect (gns);
-    gns = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(gns);
+      gns = NULL;
+    }
 }
 
 /**
@@ -116,11 +116,11 @@ do_shutdown (void *cls)
  * @param cls unused
  */
 static void
-do_timeout (void* cls)
+do_timeout(void* cls)
 {
   to_task = NULL;
   global_ret = 3; //Timeout
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 /**
@@ -132,10 +132,10 @@ do_timeout (void* cls)
  * @param rd array of @a rd_count records with the results
  */
 static void
-process_lookup_result (void *cls,
-                       int was_gns,
-                       uint32_t rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+process_lookup_result(void *cls,
+                      int was_gns,
+                      uint32_t rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
   const char *name = cls;
   const char *typename;
@@ -143,41 +143,41 @@ process_lookup_result (void *cls,
 
   lr = NULL;
   if (GNUNET_NO == was_gns)
-  {
-    global_ret = 4; /* not for GNS */
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (! raw)
-  {
-    if (0 == rd_count)
-      printf ("No results.\n");
-    else
-      printf ("%s:\n", name);
-  }
+    {
+      global_ret = 4; /* not for GNS */
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (!raw)
+    {
+      if (0 == rd_count)
+        printf("No results.\n");
+      else
+        printf("%s:\n", name);
+    }
   for (uint32_t i = 0; i < rd_count; i++)
-  {
-    if ((rd[i].record_type != rtype) && (GNUNET_GNSRECORD_TYPE_ANY != rtype))
-      continue;
-    typename = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
-    string_val = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
-                                                   rd[i].data,
-                                                   rd[i].data_size);
-    if (NULL == string_val)
     {
-      fprintf (stderr,
-               "Record %u of type %d malformed, skipping\n",
-               (unsigned int) i,
-               (int) rd[i].record_type);
-      continue;
+      if ((rd[i].record_type != rtype) && (GNUNET_GNSRECORD_TYPE_ANY != rtype))
+        continue;
+      typename = GNUNET_GNSRECORD_number_to_typename(rd[i].record_type);
+      string_val = GNUNET_GNSRECORD_value_to_string(rd[i].record_type,
+                                                    rd[i].data,
+                                                    rd[i].data_size);
+      if (NULL == string_val)
+        {
+          fprintf(stderr,
+                  "Record %u of type %d malformed, skipping\n",
+                  (unsigned int)i,
+                  (int)rd[i].record_type);
+          continue;
+        }
+      if (raw)
+        printf("%s\n", string_val);
+      else
+        printf("Got `%s' record: %s\n", typename, string_val);
+      GNUNET_free(string_val);
     }
-    if (raw)
-      printf ("%s\n", string_val);
-    else
-      printf ("Got `%s' record: %s\n", typename, string_val);
-    GNUNET_free (string_val);
-  }
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -190,53 +190,53 @@ process_lookup_result (void *cls,
  * @param c configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
 
   cfg = c;
   to_task = NULL;
-  if (GNUNET_OK != GNUNET_DNSPARSER_check_name (lookup_name))
-  {
-    fprintf (stderr, _ ("`%s' is not a valid domain name\n"), lookup_name);
-    global_ret = 3;
-    return;
-  }
-  to_task = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, NULL);
-  gns = GNUNET_GNS_connect (cfg);
+  if (GNUNET_OK != GNUNET_DNSPARSER_check_name(lookup_name))
+    {
+      fprintf(stderr, _("`%s' is not a valid domain name\n"), lookup_name);
+      global_ret = 3;
+      return;
+    }
+  to_task = GNUNET_SCHEDULER_add_delayed(timeout, &do_timeout, NULL);
+  gns = GNUNET_GNS_connect(cfg);
   if (NULL == gns)
-  {
-    fprintf (stderr, _ ("Failed to connect to GNS\n"));
-    global_ret = 2;
-    return;
-  }
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+    {
+      fprintf(stderr, _("Failed to connect to GNS\n"));
+      global_ret = 2;
+      return;
+    }
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
   if (NULL != lookup_type)
-    rtype = GNUNET_GNSRECORD_typename_to_number (lookup_type);
+    rtype = GNUNET_GNSRECORD_typename_to_number(lookup_type);
   else
     rtype = GNUNET_DNSPARSER_TYPE_A;
   if (UINT32_MAX == rtype)
-  {
-    fprintf (stderr, _ ("Invalid typename specified, assuming `ANY'\n"));
-    rtype = GNUNET_GNSRECORD_TYPE_ANY;
-  }
-  lr = GNUNET_GNS_lookup_with_tld (gns,
-                                   lookup_name,
-                                   rtype,
-                                   GNUNET_GNS_LO_DEFAULT,
-                                   &process_lookup_result,
-                                   lookup_name);
+    {
+      fprintf(stderr, _("Invalid typename specified, assuming `ANY'\n"));
+      rtype = GNUNET_GNSRECORD_TYPE_ANY;
+    }
+  lr = GNUNET_GNS_lookup_with_tld(gns,
+                                  lookup_name,
+                                  rtype,
+                                  GNUNET_GNS_LO_DEFAULT,
+                                  &process_lookup_result,
+                                  lookup_name);
   if (NULL == lr)
-  {
-    global_ret = 2;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      global_ret = 2;
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
 }
 
 
@@ -248,48 +248,48 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   timeout = GNUNET_TIME_UNIT_FOREVER_REL;
   struct GNUNET_GETOPT_CommandLineOption options[] =
-    {GNUNET_GETOPT_option_mandatory (
-       GNUNET_GETOPT_option_string ('u',
-                                    "lookup",
-                                    "NAME",
-                                    gettext_noop (
-                                      "Lookup a record for the given name"),
-                                    &lookup_name)),
-     GNUNET_GETOPT_option_string ('t',
-                                  "type",
-                                  "TYPE",
-                                  gettext_noop (
-                                    "Specify the type of the record to lookup"),
-                                  &lookup_type),
-     GNUNET_GETOPT_option_relative_time ('T',
-                                         "timeout",
-                                         "TIMEOUT",
-                                         gettext_noop (
-                                           "Specify a timeout for the lookup"),
-                                         &timeout),
-     GNUNET_GETOPT_option_flag ('r',
-                                "raw",
-                                gettext_noop ("No unneeded output"),
-                                &raw),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_mandatory(
+      GNUNET_GETOPT_option_string('u',
+                                  "lookup",
+                                  "NAME",
+                                  gettext_noop(
+                                    "Lookup a record for the given name"),
+                                  &lookup_name)),
+    GNUNET_GETOPT_option_string('t',
+                                "type",
+                                "TYPE",
+                                gettext_noop(
+                                  "Specify the type of the record to lookup"),
+                                &lookup_type),
+    GNUNET_GETOPT_option_relative_time('T',
+                                       "timeout",
+                                       "TIMEOUT",
+                                       gettext_noop(
+                                         "Specify a timeout for the lookup"),
+                                       &timeout),
+    GNUNET_GETOPT_option_flag('r',
+                              "raw",
+                              gettext_noop("No unneeded output"),
+                              &raw),
+    GNUNET_GETOPT_OPTION_END };
   int ret;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
     return 2;
 
-  GNUNET_log_setup ("gnunet-gns", "WARNING", NULL);
-  ret = GNUNET_PROGRAM_run (argc,
-                            argv,
-                            "gnunet-gns",
-                            _ ("GNUnet GNS resolver tool"),
-                            options,
-                            &run,
-                            NULL);
-  GNUNET_free ((void *) argv);
+  GNUNET_log_setup("gnunet-gns", "WARNING", NULL);
+  ret = GNUNET_PROGRAM_run(argc,
+                           argv,
+                           "gnunet-gns",
+                           _("GNUnet GNS resolver tool"),
+                           options,
+                           &run,
+                           NULL);
+  GNUNET_free((void *)argv);
   if (GNUNET_OK != ret)
     return 1;
   return global_ret;
diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 65c232f93..5bfaf4859 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gnunet-service-gns.c
  * @brief GNU Name System (main service)
@@ -46,9 +46,7 @@ struct GnsClient;
 /**
  * Handle to a lookup operation from client via API.
  */
-struct ClientLookupHandle
-{
-
+struct ClientLookupHandle {
   /**
    * We keep these in a DLL.
    */
@@ -73,15 +71,13 @@ struct ClientLookupHandle
    * request id
    */
   uint32_t request_id;
-
 };
 
 
 /**
  * Information we track per connected client.
  */
-struct GnsClient
-{
+struct GnsClient {
   /**
    * The client
    */
@@ -108,9 +104,7 @@ struct GnsClient
  * Representation of a TLD, mapping the respective TLD string
  * (i.e. ".gnu") to the respective public key of the zone.
  */
-struct GNS_TopLevelDomain
-{
-
+struct GNS_TopLevelDomain {
   /**
    * Kept in a DLL, as there are unlikely enough of these to
    * warrant a hash map.
@@ -132,7 +126,6 @@ struct GNS_TopLevelDomain
    * Top-level domain as a string, including leading ".".
    */
   char *tld;
-
 };
 
 
@@ -180,25 +173,25 @@ static struct GNS_TopLevelDomain *tld_tail;
  * @return #GNUNET_YES if @a tld was found #GNUNET_NO if not
  */
 int
-GNS_find_tld (const char *tld_str,
-              struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
+GNS_find_tld(const char *tld_str,
+             struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 {
   if ('\0' == *tld_str)
     return GNUNET_NO;
   for (struct GNS_TopLevelDomain *tld = tld_head;
        NULL != tld;
        tld = tld->next)
-  {
-    if (0 == strcasecmp (tld_str,
-                         tld->tld))
     {
-      *pkey = tld->pkey;
-      return GNUNET_YES;
+      if (0 == strcasecmp(tld_str,
+                          tld->tld))
+        {
+          *pkey = tld->pkey;
+          return GNUNET_YES;
+        }
     }
-  }
   if (GNUNET_OK ==
-      GNUNET_GNSRECORD_zkey_to_pkey (tld_str + 1,
-                                     pkey))
+      GNUNET_GNSRECORD_zkey_to_pkey(tld_str + 1,
+                                    pkey))
     return GNUNET_YES; /* TLD string *was* the public key */
   return GNUNET_NO;
 }
@@ -212,12 +205,12 @@ GNS_find_tld (const char *tld_str,
  *         or @a name if @a name does not contain a "."
  */
 const char *
-GNS_get_tld (const char *name)
+GNS_get_tld(const char *name)
 {
   const char *tld;
 
-  tld = strrchr (name,
-                 (unsigned char) '.');
+  tld = strrchr(name,
+                (unsigned char)'.');
   if (NULL == tld)
     tld = name;
   else
@@ -232,39 +225,39 @@ GNS_get_tld (const char *name)
  * @param cls unused, NULL
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
   struct GNS_TopLevelDomain *tld;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Shutting down!\n");
-  GNS_interceptor_done ();
-  GNS_resolver_done ();
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Shutting down!\n");
+  GNS_interceptor_done();
+  GNS_resolver_done();
   if (NULL != statistics)
-  {
-    GNUNET_STATISTICS_destroy (statistics,
-                               GNUNET_NO);
-    statistics = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(statistics,
+                                GNUNET_NO);
+      statistics = NULL;
+    }
   if (NULL != namecache_handle)
-  {
-    GNUNET_NAMECACHE_disconnect (namecache_handle);
-    namecache_handle = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_disconnect(namecache_handle);
+      namecache_handle = NULL;
+    }
   if (NULL != dht_handle)
-  {
-    GNUNET_DHT_disconnect (dht_handle);
-    dht_handle = NULL;
-  }
+    {
+      GNUNET_DHT_disconnect(dht_handle);
+      dht_handle = NULL;
+    }
   while (NULL != (tld = tld_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (tld_head,
-                                 tld_tail,
-                                 tld);
-    GNUNET_free (tld->tld);
-    GNUNET_free (tld);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(tld_head,
+                                  tld_tail,
+                                  tld);
+      GNUNET_free(tld->tld);
+      GNUNET_free(tld);
+    }
 }
 
 
@@ -276,27 +269,27 @@ shutdown_task (void *cls)
  * @param app_ctx @a client
  */
 static void
-client_disconnect_cb (void *cls,
-                      struct GNUNET_SERVICE_Client *client,
-                      void *app_ctx)
+client_disconnect_cb(void *cls,
+                     struct GNUNET_SERVICE_Client *client,
+                     void *app_ctx)
 {
   struct ClientLookupHandle *clh;
   struct GnsClient *gc = app_ctx;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client %p disconnected\n",
-              client);
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Client %p disconnected\n",
+             client);
   while (NULL != (clh = gc->clh_head))
-  {
-    if (NULL != clh->lookup)
-      GNS_resolver_lookup_cancel (clh->lookup);
-    GNUNET_CONTAINER_DLL_remove (gc->clh_head,
-                                 gc->clh_tail,
-                                 clh);
-    GNUNET_free (clh);
-  }
-  GNUNET_free (gc);
+    {
+      if (NULL != clh->lookup)
+        GNS_resolver_lookup_cancel(clh->lookup);
+      GNUNET_CONTAINER_DLL_remove(gc->clh_head,
+                                  gc->clh_tail,
+                                  clh);
+      GNUNET_free(clh);
+    }
+  GNUNET_free(gc);
 }
 
 
@@ -309,17 +302,17 @@ client_disconnect_cb (void *cls,
  * @return internal namestore client structure for this client
  */
 static void *
-client_connect_cb (void *cls,
-                   struct GNUNET_SERVICE_Client *client,
-                   struct GNUNET_MQ_Handle *mq)
+client_connect_cb(void *cls,
+                  struct GNUNET_SERVICE_Client *client,
+                  struct GNUNET_MQ_Handle *mq)
 {
   struct GnsClient *gc;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client %p connected\n",
-              client);
-  gc = GNUNET_new (struct GnsClient);
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Client %p connected\n",
+             client);
+  gc = GNUNET_new(struct GnsClient);
   gc->client = client;
   gc->mq = mq;
   return gc;
@@ -334,9 +327,9 @@ client_connect_cb (void *cls,
  * @param rd the record data
  */
 static void
-send_lookup_response (void *cls,
-                      uint32_t rd_count,
-                      const struct GNUNET_GNSRECORD_Data *rd)
+send_lookup_response(void *cls,
+                     uint32_t rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ClientLookupHandle *clh = cls;
   struct GnsClient *gc = clh->gc;
@@ -344,46 +337,46 @@ send_lookup_response (void *cls,
   struct LookupResultMessage *rmsg;
   ssize_t len;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending LOOKUP_RESULT message with %u results\n",
-              (unsigned int) rd_count);
-  len = GNUNET_GNSRECORD_records_get_size (rd_count,
-                                           rd);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending LOOKUP_RESULT message with %u results\n",
+             (unsigned int)rd_count);
+  len = GNUNET_GNSRECORD_records_get_size(rd_count,
+                                          rd);
   if (len < 0)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (gc->client);
-    return;
-  }
-  if (len > UINT16_MAX - sizeof (*rmsg))
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (gc->client);
-    return;
-  }
-  env = GNUNET_MQ_msg_extra (rmsg,
-                             len,
-                             GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(gc->client);
+      return;
+    }
+  if (len > UINT16_MAX - sizeof(*rmsg))
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(gc->client);
+      return;
+    }
+  env = GNUNET_MQ_msg_extra(rmsg,
+                            len,
+                            GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
   rmsg->id = clh->request_id;
-  rmsg->rd_count = htonl (rd_count);
-  GNUNET_assert (len ==
-                 GNUNET_GNSRECORD_records_serialize (rd_count,
-                                                     rd,
-                                                     len,
-                                                     (char*) &rmsg[1]));
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (gc->client),
-                  env);
-  GNUNET_CONTAINER_DLL_remove (gc->clh_head,
-                               gc->clh_tail,
-                               clh);
-  GNUNET_free (clh);
-  GNUNET_STATISTICS_update (statistics,
-                            "Completed lookups", 1,
-                            GNUNET_NO);
-  GNUNET_STATISTICS_update (statistics,
-                            "Records resolved",
-                            rd_count,
-                            GNUNET_NO);
+  rmsg->rd_count = htonl(rd_count);
+  GNUNET_assert(len ==
+                GNUNET_GNSRECORD_records_serialize(rd_count,
+                                                   rd,
+                                                   len,
+                                                   (char*)&rmsg[1]));
+  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(gc->client),
+                 env);
+  GNUNET_CONTAINER_DLL_remove(gc->clh_head,
+                              gc->clh_tail,
+                              clh);
+  GNUNET_free(clh);
+  GNUNET_STATISTICS_update(statistics,
+                           "Completed lookups", 1,
+                           GNUNET_NO);
+  GNUNET_STATISTICS_update(statistics,
+                           "Records resolved",
+                           rd_count,
+                           GNUNET_NO);
 }
 
 
@@ -395,19 +388,19 @@ send_lookup_response (void *cls,
  * @return #GNUNET_OK if @a l_msg is well-formed
  */
 static int
-check_lookup (void *cls,
-              const struct LookupMessage *l_msg)
+check_lookup(void *cls,
+             const struct LookupMessage *l_msg)
 {
   size_t nlen;
 
-  (void) cls;
-  GNUNET_MQ_check_zero_termination (l_msg);
-  nlen = ntohs (l_msg->header.size) - sizeof (struct LookupMessage);
+  (void)cls;
+  GNUNET_MQ_check_zero_termination(l_msg);
+  nlen = ntohs(l_msg->header.size) - sizeof(struct LookupMessage);
   if (nlen > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -420,8 +413,8 @@ check_lookup (void *cls,
  * @param message the message
  */
 static void
-handle_lookup (void *cls,
-               const struct LookupMessage *sh_msg)
+handle_lookup(void *cls,
+              const struct LookupMessage *sh_msg)
 {
   struct GnsClient *gc = cls;
   char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 1];
@@ -429,47 +422,47 @@ handle_lookup (void *cls,
   char *nameptr = name;
   const char *utf_in;
 
-  GNUNET_SERVICE_client_continue (gc->client);
-  utf_in = (const char *) &sh_msg[1];
-  GNUNET_STRINGS_utf8_tolower (utf_in,
-                               nameptr);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received LOOKUP `%s' message\n",
-              name);
-  clh = GNUNET_new (struct ClientLookupHandle);
-  GNUNET_CONTAINER_DLL_insert (gc->clh_head,
-                               gc->clh_tail,
-                               clh);
+  GNUNET_SERVICE_client_continue(gc->client);
+  utf_in = (const char *)&sh_msg[1];
+  GNUNET_STRINGS_utf8_tolower(utf_in,
+                              nameptr);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received LOOKUP `%s' message\n",
+             name);
+  clh = GNUNET_new(struct ClientLookupHandle);
+  GNUNET_CONTAINER_DLL_insert(gc->clh_head,
+                              gc->clh_tail,
+                              clh);
   clh->gc = gc;
   clh->request_id = sh_msg->id;
-  if ( (GNUNET_DNSPARSER_TYPE_A == ntohl (sh_msg->type)) &&
-       (GNUNET_OK != v4_enabled) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "LOOKUP: Query for A record but AF_INET not supported!");
-    send_lookup_response (clh,
-                          0,
-                          NULL);
-    return;
-  }
-  if ( (GNUNET_DNSPARSER_TYPE_AAAA == ntohl (sh_msg->type)) &&
-       (GNUNET_OK != v6_enabled) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
-    send_lookup_response (clh,
-                          0,
-                          NULL);
-    return;
-  }
-  clh->lookup = GNS_resolver_lookup (&sh_msg->zone,
-                                     ntohl (sh_msg->type),
-                                     name,
-                                     (enum GNUNET_GNS_LocalOptions) ntohs (sh_msg->options),
-                                     &send_lookup_response, clh);
-  GNUNET_STATISTICS_update (statistics,
-                            "Lookup attempts",
-                            1, GNUNET_NO);
+  if ((GNUNET_DNSPARSER_TYPE_A == ntohl(sh_msg->type)) &&
+      (GNUNET_OK != v4_enabled))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "LOOKUP: Query for A record but AF_INET not supported!");
+      send_lookup_response(clh,
+                           0,
+                           NULL);
+      return;
+    }
+  if ((GNUNET_DNSPARSER_TYPE_AAAA == ntohl(sh_msg->type)) &&
+      (GNUNET_OK != v6_enabled))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
+      send_lookup_response(clh,
+                           0,
+                           NULL);
+      return;
+    }
+  clh->lookup = GNS_resolver_lookup(&sh_msg->zone,
+                                    ntohl(sh_msg->type),
+                                    name,
+                                    (enum GNUNET_GNS_LocalOptions)ntohs(sh_msg->options),
+                                    &send_lookup_response, clh);
+  GNUNET_STATISTICS_update(statistics,
+                           "Lookup attempts",
+                           1, GNUNET_NO);
 }
 
 
@@ -482,36 +475,36 @@ handle_lookup (void *cls,
  * @param value value for the option, public key for TLDs
  */
 static void
-read_service_conf (void *cls,
-                   const char *section,
-                   const char *option,
-                   const char *value)
+read_service_conf(void *cls,
+                  const char *section,
+                  const char *option,
+                  const char *value)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
   struct GNS_TopLevelDomain *tld;
 
-  (void) cls;
-  (void) section;
+  (void)cls;
+  (void)section;
   if (option[0] != '.')
     return;
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (value,
-                                     strlen (value),
-                                     &pk,
-                                     sizeof (pk)))
-  {
-    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                               section,
-                               option,
-                               _("Properly base32-encoded public key required"));
-    return;
-  }
-  tld = GNUNET_new (struct GNS_TopLevelDomain);
-  tld->tld = GNUNET_strdup (&option[1]);
+      GNUNET_STRINGS_string_to_data(value,
+                                    strlen(value),
+                                    &pk,
+                                    sizeof(pk)))
+    {
+      GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
+                                section,
+                                option,
+                                _("Properly base32-encoded public key required"));
+      return;
+    }
+  tld = GNUNET_new(struct GNS_TopLevelDomain);
+  tld->tld = GNUNET_strdup(&option[1]);
   tld->pkey = pk;
-  GNUNET_CONTAINER_DLL_insert (tld_head,
-                               tld_tail,
-                               tld);
+  GNUNET_CONTAINER_DLL_insert(tld_head,
+                              tld_tail,
+                              tld);
 }
 
 
@@ -523,66 +516,66 @@ read_service_conf (void *cls,
  * @param c configuration to use
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *c,
-     struct GNUNET_SERVICE_Handle *service)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *c,
+    struct GNUNET_SERVICE_Handle *service)
 {
   unsigned long long max_parallel_bg_queries = 16;
 
-  GNUNET_CONFIGURATION_iterate_section_values (c,
-                                               "gns",
-                                               &read_service_conf,
-                                               NULL);
-  v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
-  v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
-  namecache_handle = GNUNET_NAMECACHE_connect (c);
+  GNUNET_CONFIGURATION_iterate_section_values(c,
+                                              "gns",
+                                              &read_service_conf,
+                                              NULL);
+  v6_enabled = GNUNET_NETWORK_test_pf(PF_INET6);
+  v4_enabled = GNUNET_NETWORK_test_pf(PF_INET);
+  namecache_handle = GNUNET_NAMECACHE_connect(c);
   if (NULL == namecache_handle)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to connect to the namecache!\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to the namecache!\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number (c,
-                                             "gns",
-                                             "MAX_PARALLEL_BACKGROUND_QUERIES",
-                                             &max_parallel_bg_queries))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Number of allowed parallel background queries: %llu\n",
-                max_parallel_bg_queries);
-  }
-  dht_handle = GNUNET_DHT_connect (c,
-                                   (unsigned int) max_parallel_bg_queries);
+      GNUNET_CONFIGURATION_get_value_number(c,
+                                            "gns",
+                                            "MAX_PARALLEL_BACKGROUND_QUERIES",
+                                            &max_parallel_bg_queries))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Number of allowed parallel background queries: %llu\n",
+                 max_parallel_bg_queries);
+    }
+  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_SCHEDULER_add_now (&shutdown_task,
-                              NULL);
-    return;
-  }
-  GNS_resolver_init (namecache_handle,
-                     dht_handle,
-                     c,
-                     max_parallel_bg_queries);
-  if ( (GNUNET_YES ==
-        GNUNET_CONFIGURATION_get_value_yesno (c,
-                                              "gns",
-                                              "INTERCEPT_DNS")) &&
-       (GNUNET_SYSERR ==
-        GNS_interceptor_init (c)) )
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_add_now (&shutdown_task,
-                              NULL);
-    return;
-  }
-  statistics = GNUNET_STATISTICS_create ("gns",
-                                         c);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 NULL);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not connect to DHT!\n"));
+      GNUNET_SCHEDULER_add_now(&shutdown_task,
+                               NULL);
+      return;
+    }
+  GNS_resolver_init(namecache_handle,
+                    dht_handle,
+                    c,
+                    max_parallel_bg_queries);
+  if ((GNUNET_YES ==
+       GNUNET_CONFIGURATION_get_value_yesno(c,
+                                            "gns",
+                                            "INTERCEPT_DNS")) &&
+      (GNUNET_SYSERR ==
+       GNS_interceptor_init(c)))
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_add_now(&shutdown_task,
+                               NULL);
+      return;
+    }
+  statistics = GNUNET_STATISTICS_create("gns",
+                                        c);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+                                NULL);
 }
 
 
@@ -590,17 +583,17 @@ run (void *cls,
  * Define "main" method using service macro.
  */
 GNUNET_SERVICE_MAIN
-("gns",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_var_size (lookup,
+  ("gns",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size(lookup,
                         GNUNET_MESSAGE_TYPE_GNS_LOOKUP,
                         struct LookupMessage,
                         NULL),
- GNUNET_MQ_handler_end());
+  GNUNET_MQ_handler_end());
 
 
 /* end of gnunet-service-gns.c */
diff --git a/src/gns/gnunet-service-gns.h b/src/gns/gnunet-service-gns.h
index d9309e985..2c17ca72a 100644
--- a/src/gns/gnunet-service-gns.h
+++ b/src/gns/gnunet-service-gns.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gnunet-service-gns.h
  * @brief GNU Name System (main service)
@@ -35,8 +35,8 @@
  * @return #GNUNET_YES if @a tld was found #GNUNET_NO if not
  */
 int
-GNS_find_tld (const char *tld_str,
-              struct GNUNET_CRYPTO_EcdsaPublicKey *pkey);
+GNS_find_tld(const char *tld_str,
+             struct GNUNET_CRYPTO_EcdsaPublicKey *pkey);
 
 
 /**
@@ -47,7 +47,7 @@ GNS_find_tld (const char *tld_str,
  *         or @a name if @a name does not contain a "."
  */
 const char *
-GNS_get_tld (const char *name);
+GNS_get_tld(const char *name);
 
 
 #endif
diff --git a/src/gns/gnunet-service-gns_interceptor.c b/src/gns/gnunet-service-gns_interceptor.c
index d5a84f6a0..e56aaef47 100644
--- a/src/gns/gnunet-service-gns_interceptor.c
+++ b/src/gns/gnunet-service-gns_interceptor.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gnunet-service-gns_interceptor.c
  * @brief GNUnet GNS interceptor logic
@@ -37,9 +37,7 @@
  * Handle to a DNS intercepted
  * reslution request
  */
-struct InterceptLookupHandle
-{
-
+struct InterceptLookupHandle {
   /**
    * We keep these in a DLL.
    */
@@ -64,7 +62,6 @@ struct InterceptLookupHandle
    * Handle for the lookup operation.
    */
   struct GNS_ResolverHandle *lookup;
-
 };
 
 
@@ -92,8 +89,8 @@ static struct InterceptLookupHandle *ilh_tail;
  * @param rd the record data
  */
 static void
-reply_to_dns (void *cls, uint32_t rd_count,
-              const struct GNUNET_GNSRECORD_Data *rd)
+reply_to_dns(void *cls, uint32_t rd_count,
+             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct InterceptLookupHandle *ilh = cls;
   struct GNUNET_DNSPARSER_Packet *packet = ilh->packet;
@@ -109,7 +106,7 @@ reply_to_dns (void *cls, uint32_t rd_count,
 
   /* Put records in the DNS packet */
   num_answers = 0;
-  for (i=0; i < rd_count; i++)
+  for (i = 0; i < rd_count; i++)
     if (rd[i].record_type == query->type)
       num_answers++;
   skip_answers = 0;
@@ -124,123 +121,131 @@ reply_to_dns (void *cls, uint32_t rd_count,
     /* FIXME: need to handle #GNUNET_GNSRECORD_RF_SHADOW_RECORD option
        (by ignoring records where this flag is set if there is any
        other record of that type in the result set) */
-    for (i=0; i < rd_count; i++)
-    {
-      if (rd[i].record_type == query->type)
+    for (i = 0; i < rd_count; i++)
       {
-        answer_records[i - skip_answers].name = query->name;
-        answer_records[i - skip_answers].type = rd[i].record_type;
-        switch(rd[i].record_type)
-        {
-        case GNUNET_DNSPARSER_TYPE_NS:
-        case GNUNET_DNSPARSER_TYPE_CNAME:
-        case GNUNET_DNSPARSER_TYPE_PTR:
-          answer_records[i - skip_answers].data.hostname
-            = GNUNET_DNSPARSER_parse_name (rd[i].data,
-                                           rd[i].data_size,
-                                           &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == answer_records[i].data.hostname) )
-          {
-            GNUNET_break_op (0);
-            skip_answers++;
-          }
-          break;
-        case GNUNET_DNSPARSER_TYPE_SOA:
-          answer_records[i - skip_answers].data.soa
-            = GNUNET_DNSPARSER_parse_soa (rd[i].data,
-                                          rd[i].data_size,
-                                          &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == answer_records[i].data.soa) )
-          {
-            GNUNET_break_op (0);
-            skip_answers++;
-          }
-          break;
-        case GNUNET_DNSPARSER_TYPE_SRV:
-          /* FIXME: SRV is not yet supported */
-          skip_answers++;
-          break;
-        case GNUNET_DNSPARSER_TYPE_MX:
-          answer_records[i - skip_answers].data.mx
-            = GNUNET_DNSPARSER_parse_mx (rd[i].data,
-                                         rd[i].data_size,
-                                         &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == answer_records[i].data.hostname) )
-          {
-            GNUNET_break_op (0);
-            skip_answers++;
-          }
-          break;
-        default:
-          answer_records[i - skip_answers].data.raw.data_len = rd[i].data_size;
-          answer_records[i - skip_answers].data.raw.data = (char*)rd[i].data;
-          break;
-        }
-        GNUNET_break (0 == (rd[i - skip_answers].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
-        answer_records[i - skip_answers].expiration_time.abs_value_us = rd[i].expiration_time;
-        answer_records[i - skip_answers].dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-      }
-      else
-      {
-        additional_records[i - skip_additional].name = query->name;
-        additional_records[i - skip_additional].type = rd[i].record_type;
-        switch(rd[i].record_type)
-        {
-        case GNUNET_DNSPARSER_TYPE_NS:
-        case GNUNET_DNSPARSER_TYPE_CNAME:
-        case GNUNET_DNSPARSER_TYPE_PTR:
-          additional_records[i - skip_additional].data.hostname
-            = GNUNET_DNSPARSER_parse_name (rd[i].data,
-                                           rd[i].data_size,
-                                           &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == additional_records[i].data.hostname) )
-          {
-            GNUNET_break_op (0);
-            skip_additional++;
-          }
-          break;
-        case GNUNET_DNSPARSER_TYPE_SOA:
-          additional_records[i - skip_additional].data.soa
-            = GNUNET_DNSPARSER_parse_soa (rd[i].data,
-                                          rd[i].data_size,
-                                          &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == additional_records[i].data.hostname) )
-          {
-            GNUNET_break_op (0);
-            skip_additional++;
-          }
-          break;
-        case GNUNET_DNSPARSER_TYPE_MX:
-          additional_records[i - skip_additional].data.mx
-            = GNUNET_DNSPARSER_parse_mx (rd[i].data,
-                                         rd[i].data_size,
-                                         &off);
-          if ( (off != rd[i].data_size) ||
-               (NULL == additional_records[i].data.hostname) )
-          {
-            GNUNET_break_op (0);
-            skip_additional++;
-          }
-          break;
-        case GNUNET_DNSPARSER_TYPE_SRV:
-          /* FIXME: SRV is not yet supported */
-          skip_answers++;
-          break;
-        default:
-          additional_records[i - skip_additional].data.raw.data_len = rd[i].data_size;
-          additional_records[i - skip_additional].data.raw.data = (char*)rd[i].data;
-          break;
-        }
-        GNUNET_break (0 == (rd[i - skip_additional].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
-        additional_records[i - skip_additional].expiration_time.abs_value_us = rd[i].expiration_time;
-        additional_records[i - skip_additional].dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+        if (rd[i].record_type == query->type)
+          {
+            answer_records[i - skip_answers].name = query->name;
+            answer_records[i - skip_answers].type = rd[i].record_type;
+            switch (rd[i].record_type)
+              {
+              case GNUNET_DNSPARSER_TYPE_NS:
+              case GNUNET_DNSPARSER_TYPE_CNAME:
+              case GNUNET_DNSPARSER_TYPE_PTR:
+                answer_records[i - skip_answers].data.hostname
+                  = GNUNET_DNSPARSER_parse_name(rd[i].data,
+                                                rd[i].data_size,
+                                                &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == answer_records[i].data.hostname))
+                  {
+                    GNUNET_break_op(0);
+                    skip_answers++;
+                  }
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_SOA:
+                answer_records[i - skip_answers].data.soa
+                  = GNUNET_DNSPARSER_parse_soa(rd[i].data,
+                                               rd[i].data_size,
+                                               &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == answer_records[i].data.soa))
+                  {
+                    GNUNET_break_op(0);
+                    skip_answers++;
+                  }
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_SRV:
+                /* FIXME: SRV is not yet supported */
+                skip_answers++;
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_MX:
+                answer_records[i - skip_answers].data.mx
+                  = GNUNET_DNSPARSER_parse_mx(rd[i].data,
+                                              rd[i].data_size,
+                                              &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == answer_records[i].data.hostname))
+                  {
+                    GNUNET_break_op(0);
+                    skip_answers++;
+                  }
+                break;
+
+              default:
+                answer_records[i - skip_answers].data.raw.data_len = rd[i].data_size;
+                answer_records[i - skip_answers].data.raw.data = (char*)rd[i].data;
+                break;
+              }
+            GNUNET_break(0 == (rd[i - skip_answers].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
+            answer_records[i - skip_answers].expiration_time.abs_value_us = rd[i].expiration_time;
+            answer_records[i - skip_answers].dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+          }
+        else
+          {
+            additional_records[i - skip_additional].name = query->name;
+            additional_records[i - skip_additional].type = rd[i].record_type;
+            switch (rd[i].record_type)
+              {
+              case GNUNET_DNSPARSER_TYPE_NS:
+              case GNUNET_DNSPARSER_TYPE_CNAME:
+              case GNUNET_DNSPARSER_TYPE_PTR:
+                additional_records[i - skip_additional].data.hostname
+                  = GNUNET_DNSPARSER_parse_name(rd[i].data,
+                                                rd[i].data_size,
+                                                &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == additional_records[i].data.hostname))
+                  {
+                    GNUNET_break_op(0);
+                    skip_additional++;
+                  }
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_SOA:
+                additional_records[i - skip_additional].data.soa
+                  = GNUNET_DNSPARSER_parse_soa(rd[i].data,
+                                               rd[i].data_size,
+                                               &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == additional_records[i].data.hostname))
+                  {
+                    GNUNET_break_op(0);
+                    skip_additional++;
+                  }
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_MX:
+                additional_records[i - skip_additional].data.mx
+                  = GNUNET_DNSPARSER_parse_mx(rd[i].data,
+                                              rd[i].data_size,
+                                              &off);
+                if ((off != rd[i].data_size) ||
+                    (NULL == additional_records[i].data.hostname))
+                  {
+                    GNUNET_break_op(0);
+                    skip_additional++;
+                  }
+                break;
+
+              case GNUNET_DNSPARSER_TYPE_SRV:
+                /* FIXME: SRV is not yet supported */
+                skip_answers++;
+                break;
+
+              default:
+                additional_records[i - skip_additional].data.raw.data_len = rd[i].data_size;
+                additional_records[i - skip_additional].data.raw.data = (char*)rd[i].data;
+                break;
+              }
+            GNUNET_break(0 == (rd[i - skip_additional].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
+            additional_records[i - skip_additional].expiration_time.abs_value_us = rd[i].expiration_time;
+            additional_records[i - skip_additional].dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
+          }
       }
-    }
     packet->num_answers = num_answers - skip_answers;
     packet->num_additional_records = rd_count - num_answers - skip_additional;
     packet->flags.authoritative_answer = 1;
@@ -249,32 +254,32 @@ reply_to_dns (void *cls, uint32_t rd_count,
     else
       packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR;
     packet->flags.query_or_response = 1;
-    ret = GNUNET_DNSPARSER_pack (packet,
-                                 1024, /* maximum allowed size for DNS reply */
-                                 &buf,
-                                 &len);
+    ret = GNUNET_DNSPARSER_pack(packet,
+                                1024,  /* maximum allowed size for DNS reply */
+                                &buf,
+                                &len);
     if (GNUNET_OK != ret)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Error converting GNS response to DNS response!\n"));
-      if (GNUNET_NO == ret)
-        GNUNET_free (buf);
-    }
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                   _("Error converting GNS response to DNS response!\n"));
+        if (GNUNET_NO == ret)
+          GNUNET_free(buf);
+      }
     else
-    {
-      GNUNET_DNS_request_answer (ilh->request_handle,
-                                 len,
-                                 buf);
-      GNUNET_free (buf);
-    }
+      {
+        GNUNET_DNS_request_answer(ilh->request_handle,
+                                  len,
+                                  buf);
+        GNUNET_free(buf);
+      }
     packet->num_answers = 0;
     packet->answers = NULL;
     packet->num_additional_records = 0;
     packet->additional_records = NULL;
-    GNUNET_DNSPARSER_free_packet (packet);
+    GNUNET_DNSPARSER_free_packet(packet);
   }
-  GNUNET_CONTAINER_DLL_remove (ilh_head, ilh_tail, ilh);
-  GNUNET_free (ilh);
+  GNUNET_CONTAINER_DLL_remove(ilh_head, ilh_tail, ilh);
+  GNUNET_free(ilh);
 }
 
 
@@ -287,61 +292,61 @@ reply_to_dns (void *cls, uint32_t rd_count,
  * @param request UDP payload of the DNS request
  */
 static void
-handle_dns_request (void *cls,
-                    struct GNUNET_DNS_RequestHandle *rh,
-                    size_t request_length,
-                    const char *request)
+handle_dns_request(void *cls,
+                   struct GNUNET_DNS_RequestHandle *rh,
+                   size_t request_length,
+                   const char *request)
 {
   struct GNUNET_DNSPARSER_Packet *p;
   struct InterceptLookupHandle *ilh;
   struct GNUNET_CRYPTO_EcdsaPublicKey zone;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Hijacked a DNS request. Processing.\n");
-  if (NULL == (p = GNUNET_DNSPARSER_parse (request, request_length)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Received malformed DNS packet, leaving it untouched.\n");
-    GNUNET_DNS_request_forward (rh);
-    GNUNET_DNSPARSER_free_packet (p);
-    return;
-  }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Hijacked a DNS request. Processing.\n");
+  if (NULL == (p = GNUNET_DNSPARSER_parse(request, request_length)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Received malformed DNS packet, leaving it untouched.\n");
+      GNUNET_DNS_request_forward(rh);
+      GNUNET_DNSPARSER_free_packet(p);
+      return;
+    }
 
   /* Check TLD and decide if we or legacy dns is responsible */
   if (1 != p->num_queries)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Not exactly one query in DNS packet. Forwarding untouched.\n");
-    GNUNET_DNS_request_forward (rh);
-    GNUNET_DNSPARSER_free_packet(p);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Not exactly one query in DNS packet. Forwarding untouched.\n");
+      GNUNET_DNS_request_forward(rh);
+      GNUNET_DNSPARSER_free_packet(p);
+      return;
+    }
 
   /* Check for GNS TLDs. */
   if (GNUNET_YES ==
-      GNS_find_tld (GNS_get_tld (p->queries[0].name),
-                    &zone))
-  {
-    /* Start resolution in GNS */
-    ilh = GNUNET_new (struct InterceptLookupHandle);
-    GNUNET_CONTAINER_DLL_insert (ilh_head,
-                                 ilh_tail,
-                                 ilh);
-    ilh->packet = p;
-    ilh->request_handle = rh;
-    ilh->lookup = GNS_resolver_lookup (&zone,
-                                       p->queries[0].type,
-                                       p->queries[0].name,
-                                       GNUNET_NO,
-                                       &reply_to_dns, ilh);
-    return;
-  }
+      GNS_find_tld(GNS_get_tld(p->queries[0].name),
+                   &zone))
+    {
+      /* Start resolution in GNS */
+      ilh = GNUNET_new(struct InterceptLookupHandle);
+      GNUNET_CONTAINER_DLL_insert(ilh_head,
+                                  ilh_tail,
+                                  ilh);
+      ilh->packet = p;
+      ilh->request_handle = rh;
+      ilh->lookup = GNS_resolver_lookup(&zone,
+                                        p->queries[0].type,
+                                        p->queries[0].name,
+                                        GNUNET_NO,
+                                        &reply_to_dns, ilh);
+      return;
+    }
   /* This request does not concern us. Forward to real DNS. */
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Request for `%s' is forwarded to DNS untouched.\n",
-              p->queries[0].name);
-  GNUNET_DNS_request_forward (rh);
-  GNUNET_DNSPARSER_free_packet (p);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Request for `%s' is forwarded to DNS untouched.\n",
+             p->queries[0].name);
+  GNUNET_DNS_request_forward(rh);
+  GNUNET_DNSPARSER_free_packet(p);
 }
 
 
@@ -352,20 +357,20 @@ handle_dns_request (void *cls,
  * @return #GNUNET_OK on success
  */
 int
-GNS_interceptor_init (const struct GNUNET_CONFIGURATION_Handle *c)
+GNS_interceptor_init(const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "DNS hijacking enabled. Connecting to DNS service.\n");
-  dns_handle = GNUNET_DNS_connect (c,
-                                   GNUNET_DNS_FLAG_PRE_RESOLUTION,
-                                   &handle_dns_request,
-                                   NULL);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "DNS hijacking enabled. Connecting to DNS service.\n");
+  dns_handle = GNUNET_DNS_connect(c,
+                                  GNUNET_DNS_FLAG_PRE_RESOLUTION,
+                                  &handle_dns_request,
+                                  NULL);
   if (NULL == dns_handle)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to connect to the DNS service!\n"));
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to the DNS service!\n"));
+      return GNUNET_SYSERR;
+    }
   return GNUNET_YES;
 }
 
@@ -374,25 +379,25 @@ GNS_interceptor_init (const struct GNUNET_CONFIGURATION_Handle *c)
  * Disconnect from interceptor
  */
 void
-GNS_interceptor_done ()
+GNS_interceptor_done()
 {
   struct InterceptLookupHandle *ilh;
 
   while (NULL != (ilh = ilh_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (ilh_head,
-                                 ilh_tail,
-                                 ilh);
-    GNS_resolver_lookup_cancel (ilh->lookup);
-    GNUNET_DNS_request_drop (ilh->request_handle);
-    GNUNET_DNSPARSER_free_packet (ilh->packet);
-    GNUNET_free (ilh);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(ilh_head,
+                                  ilh_tail,
+                                  ilh);
+      GNS_resolver_lookup_cancel(ilh->lookup);
+      GNUNET_DNS_request_drop(ilh->request_handle);
+      GNUNET_DNSPARSER_free_packet(ilh->packet);
+      GNUNET_free(ilh);
+    }
   if (NULL != dns_handle)
-  {
-    GNUNET_DNS_disconnect (dns_handle);
-    dns_handle = NULL;
-  }
+    {
+      GNUNET_DNS_disconnect(dns_handle);
+      dns_handle = NULL;
+    }
 }
 
 /* end of gnunet-service-gns_interceptor.c */
diff --git a/src/gns/gnunet-service-gns_interceptor.h b/src/gns/gnunet-service-gns_interceptor.h
index 095448db2..10e1acab6 100644
--- a/src/gns/gnunet-service-gns_interceptor.h
+++ b/src/gns/gnunet-service-gns_interceptor.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gnunet-service-gns_interceptor.h
  * @brief GNUnet GNS service
@@ -35,12 +35,12 @@
  * @return #GNUNET_YES on success #GNUNET_SYSERR on error
  */
 int
-GNS_interceptor_init (const struct GNUNET_CONFIGURATION_Handle *c);
+GNS_interceptor_init(const struct GNUNET_CONFIGURATION_Handle *c);
 
 /**
  * Stops the interceptor
  */
 void
-GNS_interceptor_done (void);
+GNS_interceptor_done(void);
 
 #endif
diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c
index 703a0f652..da54f3dd5 100644
--- a/src/gns/gnunet-service-gns_resolver.c
+++ b/src/gns/gnunet-service-gns_resolver.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file gns/gnunet-service-gns_resolver.c
@@ -45,17 +45,17 @@
 /**
  * Default DHT timeout for lookups.
  */
-#define DHT_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
+#define DHT_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * Default timeout for DNS lookups.
  */
-#define DNS_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
+#define DNS_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15)
 
 /**
  * Default timeout for VPN redirections.
  */
-#define VPN_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
+#define VPN_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
 
 /**
  * DHT replication level
@@ -80,9 +80,7 @@ struct AuthorityChain;
  * responsible DNS server hostname in a GNS2DNS recursive
  * resolution.
  */
-struct Gns2DnsPending
-{
-
+struct Gns2DnsPending {
   /**
    * Kept in a DLL.
    */
@@ -128,8 +126,7 @@ struct GNS_ResolverHandle;
  * DLL to hold the authority chain we had to pass in the resolution
  * process.
  */
-struct AuthorityChain
-{
+struct AuthorityChain {
   /**
    * This is a DLL.
    */
@@ -159,16 +156,13 @@ struct AuthorityChain
   /**
    * Information about the resolver authority for this label.
    */
-  union
-  {
-
+  union {
     /**
      * The zone of the GNS authority
      */
     struct GNUNET_CRYPTO_EcdsaPublicKey gns_authority;
 
-    struct
-    {
+    struct {
       /**
        * Domain of the DNS resolver that is the authority.
        * (appended to construct the DNS name to resolve;
@@ -203,20 +197,15 @@ struct AuthorityChain
        * Did we start the recursive resolution via DNS?
        */
       int launched;
-
     } dns_authority;
-
   } authority_info;
-
 };
 
 
 /**
  * A result we got from DNS.
  */
-struct DnsResult
-{
-
+struct DnsResult {
   /**
    * Kept in DLL.
    */
@@ -247,16 +236,13 @@ struct DnsResult
    * Type of the GNS/DNS record.
    */
   uint32_t record_type;
-
 };
 
 
 /**
  * Closure for #vpn_allocation_cb.
  */
-struct VpnContext
-{
-
+struct VpnContext {
   /**
    * Which resolution process are we processing.
    */
@@ -288,9 +274,7 @@ struct VpnContext
  * Handle to a currenty pending resolution.  On result (positive or
  * negative) the #GNS_ResultProcessor is called.
  */
-struct GNS_ResolverHandle
-{
-
+struct GNS_ResolverHandle {
   /**
    * DLL
    */
@@ -426,16 +410,13 @@ struct GNS_ResolverHandle
    * 16 bit random ID we used in the @e dns_request.
    */
   uint16_t original_dns_id;
-
 };
 
 
 /**
  * Active namestore caching operations.
  */
-struct CacheOps
-{
-
+struct CacheOps {
   /**
    * Organized in a DLL.
    */
@@ -450,7 +431,6 @@ struct CacheOps
    * Pending Namestore caching task.
    */
   struct GNUNET_NAMECACHE_QueueEntry *namecache_qe_cache;
-
 };
 
 
@@ -526,19 +506,19 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
  * @return #GNUNET_YES if canonical
  */
 /* dead, but keep for now */ int
-is_canonical (const char *name)
+is_canonical(const char *name)
 {
   const char *pos;
   const char *dot;
 
-  if (NULL == strchr (name,
-                      (unsigned char) '.'))
+  if (NULL == strchr(name,
+                     (unsigned char)'.'))
     return GNUNET_YES;
   if ('_' != name[0])
     return GNUNET_NO;
   pos = &name[1];
-  while (NULL != (dot = strchr (pos,
-                                (unsigned char) '.')))
+  while (NULL != (dot = strchr(pos,
+                               (unsigned char)'.')))
     if ('_' != dot[1])
       return GNUNET_NO;
     else
@@ -556,22 +536,22 @@ is_canonical (const char *name)
  * @return updated name
  */
 static char *
-translate_dot_plus (struct GNS_ResolverHandle *rh,
-                    char *name)
+translate_dot_plus(struct GNS_ResolverHandle *rh,
+                   char *name)
 {
   char *ret;
-  size_t s_len = strlen (name);
+  size_t s_len = strlen(name);
 
-  if (0 != strcmp (&name[s_len - 2],
-                   ".+"))
+  if (0 != strcmp(&name[s_len - 2],
+                  ".+"))
     return name; /* did not end in ".+" */
-  GNUNET_assert (GNUNET_YES == rh->ac_tail->gns_authority);
-  GNUNET_asprintf (&ret,
-                   "%.*s.%s",
-                   (int) (s_len - 2),
-                   name,
-                   GNUNET_GNSRECORD_pkey_to_zkey (&rh->ac_tail->authority_info.gns_authority));
-  GNUNET_free (name);
+  GNUNET_assert(GNUNET_YES == rh->ac_tail->gns_authority);
+  GNUNET_asprintf(&ret,
+                  "%.*s.%s",
+                  (int)(s_len - 2),
+                  name,
+                  GNUNET_GNSRECORD_pkey_to_zkey(&rh->ac_tail->authority_info.gns_authority));
+  GNUNET_free(name);
   return ret;
 }
 
@@ -583,12 +563,12 @@ translate_dot_plus (struct GNS_ResolverHandle *rh,
  * @param cls the `struct GNS_ResolverHandle`
  */
 static void
-GNS_resolver_lookup_cancel_ (void *cls)
+GNS_resolver_lookup_cancel_(void *cls)
 {
   struct GNS_ResolverHandle *rh = cls;
 
   rh->task_id = NULL;
-  GNS_resolver_lookup_cancel (rh);
+  GNS_resolver_lookup_cancel(rh);
 }
 
 
@@ -598,14 +578,14 @@ GNS_resolver_lookup_cancel_ (void *cls)
  * @param rh the resolution to fail
  */
 static void
-fail_resolution (struct GNS_ResolverHandle *rh)
+fail_resolution(struct GNS_ResolverHandle *rh)
 {
-  rh->proc (rh->proc_cls,
-            0,
-            NULL);
-  GNUNET_assert (NULL == rh->task_id);
-  rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                          rh);
+  rh->proc(rh->proc_cls,
+           0,
+           NULL);
+  GNUNET_assert(NULL == rh->task_id);
+  rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                         rh);
 }
 
 
@@ -615,12 +595,12 @@ fail_resolution (struct GNS_ResolverHandle *rh)
  * @param cls the `struct GNS_ResolverHandle`
  */
 static void
-timeout_resolution (void *cls)
+timeout_resolution(void *cls)
 {
   struct GNS_ResolverHandle *rh = cls;
 
   rh->task_id = NULL;
-  fail_resolution (rh);
+  fail_resolution(rh);
 }
 
 
@@ -642,7 +622,7 @@ timeout_resolution (void *cls)
  * @return NULL if there are no more labels
  */
 static char *
-resolver_lookup_get_next_label (struct GNS_ResolverHandle *rh)
+resolver_lookup_get_next_label(struct GNS_ResolverHandle *rh)
 {
   const char *rp;
   const char *dot;
@@ -655,71 +635,71 @@ resolver_lookup_get_next_label (struct GNS_ResolverHandle *rh)
 
   if (0 == rh->name_resolution_pos)
     return NULL;
-  dot = memrchr (rh->name,
-                 (int) '.',
-                 rh->name_resolution_pos);
+  dot = memrchr(rh->name,
+                (int)'.',
+                rh->name_resolution_pos);
   if (NULL == dot)
-  {
-    /* done, this was the last one */
-    len = rh->name_resolution_pos;
-    rp = rh->name;
-    rh->name_resolution_pos = 0;
-  }
+    {
+      /* done, this was the last one */
+      len = rh->name_resolution_pos;
+      rp = rh->name;
+      rh->name_resolution_pos = 0;
+    }
   else
-  {
-    /* advance by one label */
-    len = rh->name_resolution_pos - (dot - rh->name) - 1;
-    rp = dot + 1;
-    rh->name_resolution_pos = dot - rh->name;
-  }
+    {
+      /* advance by one label */
+      len = rh->name_resolution_pos - (dot - rh->name) - 1;
+      rp = dot + 1;
+      rh->name_resolution_pos = dot - rh->name;
+    }
   rh->protocol = 0;
   rh->service = 0;
-  ret = GNUNET_strndup (rp, len);
+  ret = GNUNET_strndup(rp, len);
   /* If we have labels starting with underscore with label on
    * the right (SRV/DANE/BOX case), determine port/protocol;
    * The format of `rh->name` must be "_PORT._PROTOCOL".
    */
-  if ( ('_' == rh->name[0]) &&
-       (NULL != (dot = memrchr (rh->name,
-                                (int) '.',
-                                rh->name_resolution_pos))) &&
-       ('_' == dot[1]) &&
-       (NULL == memrchr (rh->name,
-                         (int) '.',
-                         dot - rh->name)) )
-  {
-    srv_name = GNUNET_strndup (&rh->name[1],
-                               (dot - rh->name) - 1);
-    proto_name = GNUNET_strndup (&dot[2],
-                                 rh->name_resolution_pos - (dot - rh->name) - 1);
-    rh->name_resolution_pos = 0;
-    pe = getprotobyname (proto_name);
-    if (NULL == pe)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Protocol `%s' unknown, skipping labels.\n"),
-                  proto_name);
-      GNUNET_free (proto_name);
-      GNUNET_free (srv_name);
-      return ret;
-    }
-    se = getservbyname (srv_name,
-                        proto_name);
-    if (NULL == se)
+  if (('_' == rh->name[0]) &&
+      (NULL != (dot = memrchr(rh->name,
+                              (int)'.',
+                              rh->name_resolution_pos))) &&
+      ('_' == dot[1]) &&
+      (NULL == memrchr(rh->name,
+                       (int)'.',
+                       dot - rh->name)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Service `%s' unknown for protocol `%s', skipping labels.\n"),
-                  srv_name,
-                  proto_name);
-      GNUNET_free (proto_name);
-      GNUNET_free (srv_name);
-      return ret;
+      srv_name = GNUNET_strndup(&rh->name[1],
+                                (dot - rh->name) - 1);
+      proto_name = GNUNET_strndup(&dot[2],
+                                  rh->name_resolution_pos - (dot - rh->name) - 1);
+      rh->name_resolution_pos = 0;
+      pe = getprotobyname(proto_name);
+      if (NULL == pe)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Protocol `%s' unknown, skipping labels.\n"),
+                     proto_name);
+          GNUNET_free(proto_name);
+          GNUNET_free(srv_name);
+          return ret;
+        }
+      se = getservbyname(srv_name,
+                         proto_name);
+      if (NULL == se)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     _("Service `%s' unknown for protocol `%s', skipping labels.\n"),
+                     srv_name,
+                     proto_name);
+          GNUNET_free(proto_name);
+          GNUNET_free(srv_name);
+          return ret;
+        }
+      rh->protocol = pe->p_proto;
+      rh->service = se->s_port;
+      GNUNET_free(proto_name);
+      GNUNET_free(srv_name);
     }
-    rh->protocol = pe->p_proto;
-    rh->service = se->s_port;
-    GNUNET_free (proto_name);
-    GNUNET_free (srv_name);
-  }
   return ret;
 }
 
@@ -730,7 +710,7 @@ resolver_lookup_get_next_label (struct GNS_ResolverHandle *rh)
  * @param rh resolution process that has culminated in a result
  */
 static void
-transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
+transmit_lookup_dns_result(struct GNS_ResolverHandle *rh)
 {
   struct DnsResult *pos;
   unsigned int n;
@@ -744,31 +724,31 @@ transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
 
     i = 0;
     for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
-    {
-      rd[i].data = pos->data;
-      rd[i].data_size = pos->data_size;
-      rd[i].record_type = pos->record_type;
-      if (0 == pos->expiration_time)
       {
-        rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-        rd[i].expiration_time = 0;
-      }
-      else
-      {
-        rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
-        rd[i].expiration_time = pos->expiration_time;
+        rd[i].data = pos->data;
+        rd[i].data_size = pos->data_size;
+        rd[i].record_type = pos->record_type;
+        if (0 == pos->expiration_time)
+          {
+            rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+            rd[i].expiration_time = 0;
+          }
+        else
+          {
+            rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
+            rd[i].expiration_time = pos->expiration_time;
+          }
+        i++;
       }
-      i++;
-    }
-    GNUNET_assert (i == n);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Transmitting standard DNS result with %u records\n",
-                n);
-    rh->proc (rh->proc_cls,
-              n,
-              rd);
+    GNUNET_assert(i == n);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Transmitting standard DNS result with %u records\n",
+               n);
+    rh->proc(rh->proc_cls,
+             n,
+             rd);
   }
-  GNS_resolver_lookup_cancel (rh);
+  GNS_resolver_lookup_cancel(rh);
 }
 
 
@@ -782,25 +762,25 @@ transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
  * @param data binary data to return in DNS record
  */
 static void
-add_dns_result (struct GNS_ResolverHandle *rh,
-                uint64_t expiration_time,
-                uint32_t record_type,
-                size_t data_size,
-                const void *data)
+add_dns_result(struct GNS_ResolverHandle *rh,
+               uint64_t expiration_time,
+               uint32_t record_type,
+               size_t data_size,
+               const void *data)
 {
   struct DnsResult *res;
 
-  res = GNUNET_malloc (sizeof (struct DnsResult) + data_size);
+  res = GNUNET_malloc(sizeof(struct DnsResult) + data_size);
   res->expiration_time = expiration_time;
   res->data_size = data_size;
   res->record_type = record_type;
   res->data = &res[1];
-  GNUNET_memcpy (&res[1],
-                 data,
-                 data_size);
-  GNUNET_CONTAINER_DLL_insert (rh->dns_result_head,
-                               rh->dns_result_tail,
-                               res);
+  GNUNET_memcpy(&res[1],
+                data,
+                data_size);
+  GNUNET_CONTAINER_DLL_insert(rh->dns_result_head,
+                              rh->dns_result_tail,
+                              res);
 }
 
 
@@ -813,45 +793,47 @@ add_dns_result (struct GNS_ResolverHandle *rh,
  * @param addrlen length of the address
  */
 static void
-handle_dns_result (void *cls,
-                   const struct sockaddr *addr,
-                   socklen_t addrlen)
+handle_dns_result(void *cls,
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
 {
   struct GNS_ResolverHandle *rh = cls;
   const struct sockaddr_in *sa4;
   const struct sockaddr_in6 *sa6;
 
   if (NULL == addr)
-  {
-    rh->std_resolve = NULL;
-    transmit_lookup_dns_result (rh);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %u bytes of DNS IP data\n",
-              addrlen);
+    {
+      rh->std_resolve = NULL;
+      transmit_lookup_dns_result(rh);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received %u bytes of DNS IP data\n",
+             addrlen);
   switch (addr->sa_family)
-  {
-  case AF_INET:
-    sa4 = (const struct sockaddr_in *) addr;
-    add_dns_result (rh,
-                    0 /* expiration time is unknown */,
-                    GNUNET_DNSPARSER_TYPE_A,
-                    sizeof (struct in_addr),
-                    &sa4->sin_addr);
-    break;
-  case AF_INET6:
-    sa6 = (const struct sockaddr_in6 *) addr;
-    add_dns_result (rh,
-                    0 /* expiration time is unknown */,
-                    GNUNET_DNSPARSER_TYPE_AAAA,
-                    sizeof (struct in6_addr),
-                    &sa6->sin6_addr);
-    break;
-  default:
-    GNUNET_break (0);
-    break;
-  }
+    {
+    case AF_INET:
+      sa4 = (const struct sockaddr_in *)addr;
+      add_dns_result(rh,
+                     0 /* expiration time is unknown */,
+                     GNUNET_DNSPARSER_TYPE_A,
+                     sizeof(struct in_addr),
+                     &sa4->sin_addr);
+      break;
+
+    case AF_INET6:
+      sa6 = (const struct sockaddr_in6 *)addr;
+      add_dns_result(rh,
+                     0 /* expiration time is unknown */,
+                     GNUNET_DNSPARSER_TYPE_AAAA,
+                     sizeof(struct in6_addr),
+                     &sa6->sin6_addr);
+      break;
+
+    default:
+      GNUNET_break(0);
+      break;
+    }
 }
 
 
@@ -862,7 +844,7 @@ handle_dns_result (void *cls,
  * @param tc task context
  */
 static void
-recursive_resolution (void *cls);
+recursive_resolution(void *cls);
 
 
 /**
@@ -872,7 +854,7 @@ recursive_resolution (void *cls);
  * @param cls closure with `struct GNS_ResolverHandle *rh`
  */
 static void
-start_resolver_lookup (void *cls);
+start_resolver_lookup(void *cls);
 
 
 /**
@@ -884,9 +866,9 @@ start_resolver_lookup (void *cls);
  * @param dns_len number of bytes in @a dns
  */
 static void
-dns_result_parser (void *cls,
-                   const struct GNUNET_TUN_DnsHeader *dns,
-                   size_t dns_len)
+dns_result_parser(void *cls,
+                  const struct GNUNET_TUN_DnsHeader *dns,
+                  size_t dns_len)
 {
   struct GNS_ResolverHandle *rh = cls;
   struct GNUNET_DNSPARSER_Packet *p;
@@ -894,80 +876,82 @@ dns_result_parser (void *cls,
   unsigned int rd_count;
 
   if (NULL == dns)
-  {
-    rh->dns_request = NULL;
-    GNUNET_SCHEDULER_cancel (rh->task_id);
-    rh->task_id = NULL;
-    fail_resolution (rh);
-    return;
-  }
+    {
+      rh->dns_request = NULL;
+      GNUNET_SCHEDULER_cancel(rh->task_id);
+      rh->task_id = NULL;
+      fail_resolution(rh);
+      return;
+    }
   if (rh->original_dns_id != dns->id)
-  {
-    /* DNS answer, but for another query */
-    return;
-  }
-  p = GNUNET_DNSPARSER_parse ((const char *) dns,
-                              dns_len);
+    {
+      /* DNS answer, but for another query */
+      return;
+    }
+  p = GNUNET_DNSPARSER_parse((const char *)dns,
+                             dns_len);
   if (NULL == p)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to parse DNS response\n"));
-    return;
-  }
-
-  /* We got a result from DNS */
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received DNS response for `%s' with %u answers\n",
-              rh->ac_tail->label,
-              (unsigned int) p->num_answers);
-  if ( (p->num_answers > 0) &&
-       (GNUNET_DNSPARSER_TYPE_CNAME == p->answers[0].type) &&
-       (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type) )
-  {
-    int af;
-
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Got CNAME `%s' from DNS for `%s'\n",
-                p->answers[0].data.hostname,
-                rh->name);
-    if (NULL != rh->std_resolve)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Multiple CNAME results from DNS resolving `%s'! Not really allowed...\n",
-                  rh->name);
-      GNUNET_RESOLVER_request_cancel (rh->std_resolve);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to parse DNS response\n"));
+      return;
     }
-    GNUNET_free (rh->name);
-    rh->name = GNUNET_strdup (p->answers[0].data.hostname);
-    rh->name_resolution_pos = strlen (rh->name);
-    switch (rh->record_type)
+
+  /* We got a result from DNS */
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received DNS response for `%s' with %u answers\n",
+             rh->ac_tail->label,
+             (unsigned int)p->num_answers);
+  if ((p->num_answers > 0) &&
+      (GNUNET_DNSPARSER_TYPE_CNAME == p->answers[0].type) &&
+      (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type))
     {
-    case GNUNET_DNSPARSER_TYPE_A:
-      af = AF_INET;
-      break;
-    case GNUNET_DNSPARSER_TYPE_AAAA:
-      af = AF_INET6;
-      break;
-    default:
-      af = AF_UNSPEC;
-      break;
+      int af;
+
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Got CNAME `%s' from DNS for `%s'\n",
+                 p->answers[0].data.hostname,
+                 rh->name);
+      if (NULL != rh->std_resolve)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Multiple CNAME results from DNS resolving `%s'! Not really allowed...\n",
+                     rh->name);
+          GNUNET_RESOLVER_request_cancel(rh->std_resolve);
+        }
+      GNUNET_free(rh->name);
+      rh->name = GNUNET_strdup(p->answers[0].data.hostname);
+      rh->name_resolution_pos = strlen(rh->name);
+      switch (rh->record_type)
+        {
+        case GNUNET_DNSPARSER_TYPE_A:
+          af = AF_INET;
+          break;
+
+        case GNUNET_DNSPARSER_TYPE_AAAA:
+          af = AF_INET6;
+          break;
+
+        default:
+          af = AF_UNSPEC;
+          break;
+        }
+      if (NULL != rh->leho)
+        add_dns_result(rh,
+                       GNUNET_TIME_UNIT_HOURS.rel_value_us,
+                       GNUNET_GNSRECORD_TYPE_LEHO,
+                       strlen(rh->leho),
+                       rh->leho);
+      rh->std_resolve = GNUNET_RESOLVER_ip_get(rh->name,
+                                               af,
+                                               DNS_LOOKUP_TIMEOUT,
+                                               &handle_dns_result,
+                                               rh);
+      GNUNET_DNSPARSER_free_packet(p);
+      GNUNET_DNSSTUB_resolve_cancel(rh->dns_request);
+      rh->dns_request = NULL;
+      return;
     }
-    if (NULL != rh->leho)
-      add_dns_result (rh,
-                      GNUNET_TIME_UNIT_HOURS.rel_value_us,
-                      GNUNET_GNSRECORD_TYPE_LEHO,
-                      strlen (rh->leho),
-                      rh->leho);
-    rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
-                                              af,
-                                              DNS_LOOKUP_TIMEOUT,
-                                              &handle_dns_result,
-                                              rh);
-    GNUNET_DNSPARSER_free_packet (p);
-    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
-    rh->dns_request = NULL;
-    return;
-  }
 
   /* convert from (parsed) DNS to (binary) GNS format! */
   rd_count = p->num_answers + p->num_authority_records + p->num_additional_records;
@@ -980,151 +964,157 @@ dns_result_parser (void *cls,
 
     buf_off = 0;
     skip = 0;
-    memset (rd,
-            0,
-            sizeof (rd));
-    for (unsigned int i=0;i<rd_count;i++)
-    {
-      if (i < p->num_answers)
-        rec = &p->answers[i];
-      else if (i < p->num_answers + p->num_authority_records)
-        rec = &p->authority_records[i - p->num_answers];
-      else
-        rec = &p->additional_records[i - p->num_answers - p->num_authority_records];
-      /* As we copied the full DNS name to 'rh->ac_tail->label', this
-         should be the correct check to see if this record is actually
-         a record for our label... */
-      if (0 != strcmp (rec->name,
-                       rh->ac_tail->label))
+    memset(rd,
+           0,
+           sizeof(rd));
+    for (unsigned int i = 0; i < rd_count; i++)
       {
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Dropping record `%s', does not match desired name `%s'\n",
-                    rec->name,
-                    rh->ac_tail->label);
-        skip++;
-        continue;
-      }
-      rd[i - skip].record_type = rec->type;
-      rd[i - skip].expiration_time = rec->expiration_time.abs_value_us;
-      switch (rec->type)
+        if (i < p->num_answers)
+          rec = &p->answers[i];
+        else if (i < p->num_answers + p->num_authority_records)
+          rec = &p->authority_records[i - p->num_answers];
+        else
+          rec = &p->additional_records[i - p->num_answers - p->num_authority_records];
+        /* As we copied the full DNS name to 'rh->ac_tail->label', this
+           should be the correct check to see if this record is actually
+           a record for our label... */
+        if (0 != strcmp(rec->name,
+                        rh->ac_tail->label))
+          {
+            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                       "Dropping record `%s', does not match desired name `%s'\n",
+                       rec->name,
+                       rh->ac_tail->label);
+            skip++;
+            continue;
+          }
+        rd[i - skip].record_type = rec->type;
+        rd[i - skip].expiration_time = rec->expiration_time.abs_value_us;
+        switch (rec->type)
+          {
+          case GNUNET_DNSPARSER_TYPE_A:
+            if (rec->data.raw.data_len != sizeof(struct in_addr))
+              {
+                GNUNET_break_op(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = rec->data.raw.data_len;
+            rd[i - skip].data = rec->data.raw.data;
+            break;
+
+          case GNUNET_DNSPARSER_TYPE_AAAA:
+            if (rec->data.raw.data_len != sizeof(struct in6_addr))
+              {
+                GNUNET_break_op(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = rec->data.raw.data_len;
+            rd[i - skip].data = rec->data.raw.data;
+            break;
+
+          case GNUNET_DNSPARSER_TYPE_CNAME:
+          case GNUNET_DNSPARSER_TYPE_PTR:
+          case GNUNET_DNSPARSER_TYPE_NS:
+            buf_start = buf_off;
+            if (GNUNET_OK !=
+                GNUNET_DNSPARSER_builder_add_name(buf,
+                                                  sizeof(buf),
+                                                  &buf_off,
+                                                  rec->data.hostname))
+              {
+                GNUNET_break(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = buf_off - buf_start;
+            rd[i - skip].data = &buf[buf_start];
+            break;
+
+          case GNUNET_DNSPARSER_TYPE_SOA:
+            buf_start = buf_off;
+            if (GNUNET_OK !=
+                GNUNET_DNSPARSER_builder_add_soa(buf,
+                                                 sizeof(buf),
+                                                 &buf_off,
+                                                 rec->data.soa))
+              {
+                GNUNET_break(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = buf_off - buf_start;
+            rd[i - skip].data = &buf[buf_start];
+            break;
+
+          case GNUNET_DNSPARSER_TYPE_MX:
+            buf_start = buf_off;
+            if (GNUNET_OK !=
+                GNUNET_DNSPARSER_builder_add_mx(buf,
+                                                sizeof(buf),
+                                                &buf_off,
+                                                rec->data.mx))
+              {
+                GNUNET_break(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = buf_off - buf_start;
+            rd[i - skip].data = &buf[buf_start];
+            break;
+
+          case GNUNET_DNSPARSER_TYPE_SRV:
+            buf_start = buf_off;
+            if (GNUNET_OK !=
+                GNUNET_DNSPARSER_builder_add_srv(buf,
+                                                 sizeof(buf),
+                                                 &buf_off,
+                                                 rec->data.srv))
+              {
+                GNUNET_break(0);
+                skip++;
+                continue;
+              }
+            rd[i - skip].data_size = buf_off - buf_start;
+            rd[i - skip].data = &buf[buf_start];
+            break;
+
+          default:
+            GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                       _("Skipping record of unsupported type %d\n"),
+                       rec->type);
+            skip++;
+            continue;
+          }
+      } /* end of for all records in answer */
+    if (NULL != rh->leho)
       {
-      case GNUNET_DNSPARSER_TYPE_A:
-        if (rec->data.raw.data_len != sizeof (struct in_addr))
-        {
-          GNUNET_break_op (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = rec->data.raw.data_len;
-        rd[i - skip].data = rec->data.raw.data;
-        break;
-      case GNUNET_DNSPARSER_TYPE_AAAA:
-        if (rec->data.raw.data_len != sizeof (struct in6_addr))
-        {
-          GNUNET_break_op (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = rec->data.raw.data_len;
-        rd[i - skip].data = rec->data.raw.data;
-        break;
-      case GNUNET_DNSPARSER_TYPE_CNAME:
-      case GNUNET_DNSPARSER_TYPE_PTR:
-      case GNUNET_DNSPARSER_TYPE_NS:
-        buf_start = buf_off;
-        if (GNUNET_OK !=
-            GNUNET_DNSPARSER_builder_add_name (buf,
-                                               sizeof (buf),
-                                               &buf_off,
-                                               rec->data.hostname))
-        {
-          GNUNET_break (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = buf_off - buf_start;
-        rd[i - skip].data = &buf[buf_start];
-        break;
-      case GNUNET_DNSPARSER_TYPE_SOA:
-        buf_start = buf_off;
-        if (GNUNET_OK !=
-            GNUNET_DNSPARSER_builder_add_soa (buf,
-                                              sizeof (buf),
-                                              &buf_off,
-                                              rec->data.soa))
-        {
-          GNUNET_break (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = buf_off - buf_start;
-        rd[i - skip].data = &buf[buf_start];
-        break;
-      case GNUNET_DNSPARSER_TYPE_MX:
-        buf_start = buf_off;
-        if (GNUNET_OK !=
-            GNUNET_DNSPARSER_builder_add_mx (buf,
-                                             sizeof (buf),
-                                             &buf_off,
-                                             rec->data.mx))
-        {
-          GNUNET_break (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = buf_off - buf_start;
-        rd[i - skip].data = &buf[buf_start];
-        break;
-      case GNUNET_DNSPARSER_TYPE_SRV:
-        buf_start = buf_off;
-        if (GNUNET_OK !=
-            GNUNET_DNSPARSER_builder_add_srv (buf,
-                                              sizeof (buf),
-                                              &buf_off,
-                                              rec->data.srv))
-        {
-          GNUNET_break (0);
-          skip++;
-          continue;
-        }
-        rd[i - skip].data_size = buf_off - buf_start;
-        rd[i - skip].data = &buf[buf_start];
-        break;
-      default:
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    _("Skipping record of unsupported type %d\n"),
-                    rec->type);
-        skip++;
-        continue;
+        rd[rd_count - skip].record_type = GNUNET_GNSRECORD_TYPE_LEHO;
+        rd[rd_count - skip].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+        rd[rd_count - skip].expiration_time = GNUNET_TIME_UNIT_HOURS.rel_value_us;
+        rd[rd_count - skip].data = rh->leho;
+        rd[rd_count - skip].data_size = strlen(rh->leho);
+        skip--; /* skip one LESS */
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Adding LEHO %s\n",
+                   rh->leho);
       }
-    } /* end of for all records in answer */
-    if (NULL != rh->leho)
-    {
-      rd[rd_count - skip].record_type = GNUNET_GNSRECORD_TYPE_LEHO;
-      rd[rd_count - skip].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-      rd[rd_count - skip].expiration_time = GNUNET_TIME_UNIT_HOURS.rel_value_us;
-      rd[rd_count - skip].data = rh->leho;
-      rd[rd_count - skip].data_size = strlen (rh->leho);
-      skip--; /* skip one LESS */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Adding LEHO %s\n",
-                  rh->leho);
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Returning DNS response for `%s' with %u answers\n",
-                rh->ac_tail->label,
-                (unsigned int) (rd_count - skip));
-    rh->proc (rh->proc_cls,
-              rd_count - skip,
-              rd);
-    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Returning DNS response for `%s' with %u answers\n",
+               rh->ac_tail->label,
+               (unsigned int)(rd_count - skip));
+    rh->proc(rh->proc_cls,
+             rd_count - skip,
+             rd);
+    GNUNET_DNSSTUB_resolve_cancel(rh->dns_request);
     rh->dns_request = NULL;
   }
-  GNUNET_DNSPARSER_free_packet (p);
+  GNUNET_DNSPARSER_free_packet(p);
   if (NULL != rh->task_id)
-    GNUNET_SCHEDULER_cancel (rh->task_id); /* should be timeout task */
-  rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                          rh);
+    GNUNET_SCHEDULER_cancel(rh->task_id);  /* should be timeout task */
+  rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                         rh);
 }
 
 
@@ -1137,7 +1127,7 @@ dns_result_parser (void *cls,
  * @param rh resolution information
  */
 static void
-recursive_dns_resolution (struct GNS_ResolverHandle *rh)
+recursive_dns_resolution(struct GNS_ResolverHandle *rh)
 {
   struct AuthorityChain *ac;
   struct GNUNET_DNSPARSER_Query *query;
@@ -1147,54 +1137,54 @@ recursive_dns_resolution (struct GNS_ResolverHandle *rh)
   int ret;
 
   ac = rh->ac_tail;
-  GNUNET_assert (NULL != ac);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting DNS lookup for `%s'\n",
-              ac->label);
-  GNUNET_assert (GNUNET_NO == ac->gns_authority);
-  query = GNUNET_new (struct GNUNET_DNSPARSER_Query);
-  query->name = GNUNET_strdup (ac->label);
+  GNUNET_assert(NULL != ac);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting DNS lookup for `%s'\n",
+             ac->label);
+  GNUNET_assert(GNUNET_NO == ac->gns_authority);
+  query = GNUNET_new(struct GNUNET_DNSPARSER_Query);
+  query->name = GNUNET_strdup(ac->label);
   query->type = rh->record_type;
   query->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-  p = GNUNET_new (struct GNUNET_DNSPARSER_Packet);
+  p = GNUNET_new(struct GNUNET_DNSPARSER_Packet);
   p->queries = query;
   p->num_queries = 1;
-  p->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                               UINT16_MAX);
+  p->id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
+                                             UINT16_MAX);
   p->flags.opcode = GNUNET_TUN_DNS_OPCODE_QUERY;
   p->flags.recursion_desired = 1;
-  ret = GNUNET_DNSPARSER_pack (p,
-                               1024,
-                               &dns_request,
-                               &dns_request_length);
+  ret = GNUNET_DNSPARSER_pack(p,
+                              1024,
+                              &dns_request,
+                              &dns_request_length);
   if (GNUNET_OK != ret)
-  {
-    GNUNET_break (0);
-    rh->proc (rh->proc_cls,
-              0,
-              NULL);
-    GNUNET_assert (NULL == rh->task_id);
-    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                            rh);
-  }
+    {
+      GNUNET_break(0);
+      rh->proc(rh->proc_cls,
+               0,
+               NULL);
+      GNUNET_assert(NULL == rh->task_id);
+      rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                             rh);
+    }
   else
-  {
-    rh->original_dns_id = p->id;
-    GNUNET_assert (NULL != ac->authority_info.dns_authority.dns_handle);
-    GNUNET_assert (NULL == rh->dns_request);
-    rh->leho = GNUNET_strdup (ac->label);
-    rh->dns_request = GNUNET_DNSSTUB_resolve (ac->authority_info.dns_authority.dns_handle,
-                                              dns_request,
-                                              dns_request_length,
-                                              &dns_result_parser,
-                                              rh);
-    rh->task_id = GNUNET_SCHEDULER_add_delayed (DNS_LOOKUP_TIMEOUT,
-                                                &timeout_resolution,
-                                                rh);
-  }
+    {
+      rh->original_dns_id = p->id;
+      GNUNET_assert(NULL != ac->authority_info.dns_authority.dns_handle);
+      GNUNET_assert(NULL == rh->dns_request);
+      rh->leho = GNUNET_strdup(ac->label);
+      rh->dns_request = GNUNET_DNSSTUB_resolve(ac->authority_info.dns_authority.dns_handle,
+                                               dns_request,
+                                               dns_request_length,
+                                               &dns_result_parser,
+                                               rh);
+      rh->task_id = GNUNET_SCHEDULER_add_delayed(DNS_LOOKUP_TIMEOUT,
+                                                 &timeout_resolution,
+                                                 rh);
+    }
   if (GNUNET_SYSERR != ret)
-    GNUNET_free (dns_request);
-  GNUNET_DNSPARSER_free_packet (p);
+    GNUNET_free(dns_request);
+  GNUNET_DNSPARSER_free_packet(p);
 }
 
 
@@ -1207,85 +1197,87 @@ recursive_dns_resolution (struct GNS_ResolverHandle *rh)
  *        authority chain tail
  */
 static void
-handle_gns_cname_result (struct GNS_ResolverHandle *rh,
-                         const char *cname)
+handle_gns_cname_result(struct GNS_ResolverHandle *rh,
+                        const char *cname)
 {
   size_t nlen;
   char *res;
   struct AuthorityChain *ac;
   int af;
 
-  nlen = strlen (cname);
-  if ( (nlen > 2) &&
-       (0 == strcmp (".+",
-                     &cname[nlen - 2])) )
-  {
-    /* CNAME resolution continues relative to current domain */
-    if (0 == rh->name_resolution_pos)
+  nlen = strlen(cname);
+  if ((nlen > 2) &&
+      (0 == strcmp(".+",
+                   &cname[nlen - 2])))
     {
-      res = GNUNET_strndup (cname, nlen - 2);
-      rh->name_resolution_pos = nlen - 2;
+      /* CNAME resolution continues relative to current domain */
+      if (0 == rh->name_resolution_pos)
+        {
+          res = GNUNET_strndup(cname, nlen - 2);
+          rh->name_resolution_pos = nlen - 2;
+        }
+      else
+        {
+          GNUNET_asprintf(&res,
+                          "%.*s.%.*s",
+                          (int)rh->name_resolution_pos,
+                          rh->name,
+                          (int)(nlen - 2),
+                          cname);
+          rh->name_resolution_pos = strlen(res);
+        }
+      GNUNET_free(rh->name);
+      rh->name = res;
+      ac = GNUNET_new(struct AuthorityChain);
+      ac->rh = rh;
+      ac->gns_authority = GNUNET_YES;
+      ac->authority_info.gns_authority = rh->ac_tail->authority_info.gns_authority;
+      ac->label = resolver_lookup_get_next_label(rh);
+      /* add AC to tail */
+      GNUNET_CONTAINER_DLL_insert_tail(rh->ac_head,
+                                       rh->ac_tail,
+                                       ac);
+      rh->task_id = GNUNET_SCHEDULER_add_now(&recursive_resolution,
+                                             rh);
+      return;
     }
-    else
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Got CNAME `%s' from GNS for `%s'\n",
+             cname,
+             rh->name);
+  if (NULL != rh->std_resolve)
     {
-      GNUNET_asprintf (&res,
-                       "%.*s.%.*s",
-                       (int) rh->name_resolution_pos,
-                       rh->name,
-                       (int) (nlen - 2),
-                       cname);
-      rh->name_resolution_pos = strlen (res);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Multiple CNAME results from GNS resolving `%s'! Not really allowed...\n",
+                 rh->name);
+      GNUNET_RESOLVER_request_cancel(rh->std_resolve);
     }
-    GNUNET_free (rh->name);
-    rh->name = res;
-    ac = GNUNET_new (struct AuthorityChain);
-    ac->rh = rh;
-    ac->gns_authority = GNUNET_YES;
-    ac->authority_info.gns_authority = rh->ac_tail->authority_info.gns_authority;
-    ac->label = resolver_lookup_get_next_label (rh);
-    /* add AC to tail */
-    GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
-                                      rh->ac_tail,
-                                      ac);
-    rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
-                                            rh);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Got CNAME `%s' from GNS for `%s'\n",
-              cname,
-              rh->name);
-  if (NULL != rh->std_resolve)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Multiple CNAME results from GNS resolving `%s'! Not really allowed...\n",
-                rh->name);
-    GNUNET_RESOLVER_request_cancel (rh->std_resolve);
-  }
   /* name is absolute, go to DNS */
-  GNUNET_free (rh->name);
-  rh->name = GNUNET_strdup (cname);
-  rh->name_resolution_pos = strlen (rh->name);
+  GNUNET_free(rh->name);
+  rh->name = GNUNET_strdup(cname);
+  rh->name_resolution_pos = strlen(rh->name);
   switch (rh->record_type)
-  {
-  case GNUNET_DNSPARSER_TYPE_A:
-    af = AF_INET;
-    break;
-  case GNUNET_DNSPARSER_TYPE_AAAA:
-    af = AF_INET6;
-    break;
-  default:
-    af = AF_UNSPEC;
-    break;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Doing standard DNS lookup for `%s'\n",
-              rh->name);
-  rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
-                                            af,
-                                            DNS_LOOKUP_TIMEOUT,
-                                            &handle_dns_result,
-                                            rh);
+    {
+    case GNUNET_DNSPARSER_TYPE_A:
+      af = AF_INET;
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_AAAA:
+      af = AF_INET6;
+      break;
+
+    default:
+      af = AF_UNSPEC;
+      break;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Doing standard DNS lookup for `%s'\n",
+             rh->name);
+  rh->std_resolve = GNUNET_RESOLVER_ip_get(rh->name,
+                                           af,
+                                           DNS_LOOKUP_TIMEOUT,
+                                           &handle_dns_result,
+                                           rh);
 }
 
 
@@ -1297,9 +1289,9 @@ handle_gns_cname_result (struct GNS_ResolverHandle *rh,
  * @param rd array of records with data to store
  */
 static void
-handle_gns_resolution_result (void *cls,
-                              unsigned int rd_count,
-                              const struct GNUNET_GNSRECORD_Data *rd);
+handle_gns_resolution_result(void *cls,
+                             unsigned int rd_count,
+                             const struct GNUNET_GNSRECORD_Data *rd);
 
 
 /**
@@ -1317,9 +1309,9 @@ handle_gns_resolution_result (void *cls,
  *                specified target peer; NULL on error
  */
 static void
-vpn_allocation_cb (void *cls,
-                   int af,
-                   const void *address)
+vpn_allocation_cb(void *cls,
+                  int af,
+                  const void *address)
 {
   struct VpnContext *vpn_ctx = cls;
   struct GNS_ResolverHandle *rh = vpn_ctx->rh;
@@ -1328,47 +1320,49 @@ vpn_allocation_cb (void *cls,
 
   vpn_ctx->vpn_request = NULL;
   rh->vpn_ctx = NULL;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_GNSRECORD_records_deserialize ((size_t) vpn_ctx->rd_data_size,
-                                                       vpn_ctx->rd_data,
-                                                       vpn_ctx->rd_count,
-                                                       rd));
-  for (i=0;i<vpn_ctx->rd_count;i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_VPN == rd[i].record_type)
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_GNSRECORD_records_deserialize((size_t)vpn_ctx->rd_data_size,
+                                                     vpn_ctx->rd_data,
+                                                     vpn_ctx->rd_count,
+                                                     rd));
+  for (i = 0; i < vpn_ctx->rd_count; i++)
     {
-      switch (af)
-      {
-      case AF_INET:
-        rd[i].record_type = GNUNET_DNSPARSER_TYPE_A;
-        rd[i].data_size = sizeof (struct in_addr);
-        rd[i].expiration_time = GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT).abs_value_us;
-        rd[i].flags = 0;
-        rd[i].data = address;
-        break;
-      case AF_INET6:
-        rd[i].record_type = GNUNET_DNSPARSER_TYPE_AAAA;
-        rd[i].expiration_time = GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT).abs_value_us;
-        rd[i].flags = 0;
-        rd[i].data = address;
-        rd[i].data_size = sizeof (struct in6_addr);
-        break;
-      default:
-        GNUNET_assert (0);
-      }
-      break;
+      if (GNUNET_GNSRECORD_TYPE_VPN == rd[i].record_type)
+        {
+          switch (af)
+            {
+            case AF_INET:
+              rd[i].record_type = GNUNET_DNSPARSER_TYPE_A;
+              rd[i].data_size = sizeof(struct in_addr);
+              rd[i].expiration_time = GNUNET_TIME_relative_to_absolute(VPN_TIMEOUT).abs_value_us;
+              rd[i].flags = 0;
+              rd[i].data = address;
+              break;
+
+            case AF_INET6:
+              rd[i].record_type = GNUNET_DNSPARSER_TYPE_AAAA;
+              rd[i].expiration_time = GNUNET_TIME_relative_to_absolute(VPN_TIMEOUT).abs_value_us;
+              rd[i].flags = 0;
+              rd[i].data = address;
+              rd[i].data_size = sizeof(struct in6_addr);
+              break;
+
+            default:
+              GNUNET_assert(0);
+            }
+          break;
+        }
     }
-  }
-  GNUNET_assert (i < vpn_ctx->rd_count);
+  GNUNET_assert(i < vpn_ctx->rd_count);
   if (0 == vpn_ctx->rd_count)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("VPN returned empty result for `%s'\n"),
-                rh->name);
-  handle_gns_resolution_result (rh,
-                                vpn_ctx->rd_count,
-                                rd);
-  GNUNET_free (vpn_ctx->rd_data);
-  GNUNET_free (vpn_ctx);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("VPN returned empty result for `%s'\n"),
+               rh->name);
+  handle_gns_resolution_result(rh,
+                               vpn_ctx->rd_count,
+                               rd);
+  GNUNET_free(vpn_ctx->rd_data);
+  GNUNET_free(vpn_ctx);
 }
 
 
@@ -1380,32 +1374,31 @@ vpn_allocation_cb (void *cls,
  * @param ac context for GNS2DNS resolution
  */
 static void
-continue_with_gns2dns (struct AuthorityChain *ac)
+continue_with_gns2dns(struct AuthorityChain *ac)
 {
   struct GNS_ResolverHandle *rh = ac->rh;
 
-  if ( (NULL != ac->authority_info.dns_authority.gp_head) &&
-       (GNUNET_NO == ac->authority_info.dns_authority.found) )
+  if ((NULL != ac->authority_info.dns_authority.gp_head) &&
+      (GNUNET_NO == ac->authority_info.dns_authority.found))
     return; /* more pending and none found yet */
   if (GNUNET_NO == ac->authority_info.dns_authority.found)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Failed to resolve DNS server for `%s' in GNS2DNS resolution\n",
-                ac->authority_info.dns_authority.name);
-    fail_resolution (rh);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Failed to resolve DNS server for `%s' in GNS2DNS resolution\n",
+                 ac->authority_info.dns_authority.name);
+      fail_resolution(rh);
+      return;
+    }
   if (GNUNET_NO != ac->authority_info.dns_authority.launched)
     return; /* already running, do not launch again! */
   /* recurse */
   ac->authority_info.dns_authority.launched = GNUNET_YES;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Will continue resolution using DNS to resolve `%s'\n",
-              ac->label);
-  GNUNET_assert (NULL == rh->task_id);
-  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
-                                          rh);
-
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Will continue resolution using DNS to resolve `%s'\n",
+             ac->label);
+  GNUNET_assert(NULL == rh->task_id);
+  rh->task_id = GNUNET_SCHEDULER_add_now(&recursive_resolution,
+                                         rh);
 }
 
 
@@ -1418,93 +1411,95 @@ continue_with_gns2dns (struct AuthorityChain *ac)
  * @param rd addresses for the DNS resolver  (presumably)
  */
 static void
-handle_gns2dns_result (void *cls,
-                       unsigned int rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns2dns_result(void *cls,
+                      unsigned int rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Gns2DnsPending *gp = cls;
   struct AuthorityChain *ac = gp->ac;
 
-  GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
-                               ac->authority_info.dns_authority.gp_tail,
-                               gp);
+  GNUNET_CONTAINER_DLL_remove(ac->authority_info.dns_authority.gp_head,
+                              ac->authority_info.dns_authority.gp_tail,
+                              gp);
   /* enable cleanup of 'rh' handle that automatically comes after we return,
      and which expects 'rh' to be in the #rlh_head DLL. */
   if (NULL != gp->rh)
-  {
-    GNUNET_CONTAINER_DLL_insert (rlh_head,
-                                 rlh_tail,
-                                 gp->rh);
-    gp->rh = NULL;
-  }
-  GNUNET_free (gp);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %u results for IP address of DNS server for GNS2DNS transition\n",
-              rd_count);
+    {
+      GNUNET_CONTAINER_DLL_insert(rlh_head,
+                                  rlh_tail,
+                                  gp->rh);
+      gp->rh = NULL;
+    }
+  GNUNET_free(gp);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received %u results for IP address of DNS server for GNS2DNS transition\n",
+             rd_count);
   /* find suitable A/AAAA record */
-  for (unsigned int j=0;j<rd_count;j++)
-  {
-    switch (rd[j].record_type)
+  for (unsigned int j = 0; j < rd_count; j++)
     {
-    case GNUNET_DNSPARSER_TYPE_A:
-      {
-        struct sockaddr_in v4;
-
-        if (sizeof (struct in_addr) != rd[j].data_size)
+      switch (rd[j].record_type)
         {
-          GNUNET_break_op (0);
-          continue;
-        }
-        memset (&v4,
-                0,
-                sizeof (v4));
-        v4.sin_family = AF_INET;
-        v4.sin_port = htons (53);
+        case GNUNET_DNSPARSER_TYPE_A:
+        {
+          struct sockaddr_in v4;
+
+          if (sizeof(struct in_addr) != rd[j].data_size)
+            {
+              GNUNET_break_op(0);
+              continue;
+            }
+          memset(&v4,
+                 0,
+                 sizeof(v4));
+          v4.sin_family = AF_INET;
+          v4.sin_port = htons(53);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-        v4.sin_len = (u_char) sizeof (v4);
+          v4.sin_len = (u_char)sizeof(v4);
 #endif
-        GNUNET_memcpy (&v4.sin_addr,
-                       rd[j].data,
-                       sizeof (struct in_addr));
-        if (GNUNET_OK ==
-            GNUNET_DNSSTUB_add_dns_sa (ac->authority_info.dns_authority.dns_handle,
-                                       (const struct sockaddr *) &v4))
-          ac->authority_info.dns_authority.found = GNUNET_YES;
-        break;
-      }
-    case GNUNET_DNSPARSER_TYPE_AAAA:
-      {
-        struct sockaddr_in6 v6;
+          GNUNET_memcpy(&v4.sin_addr,
+                        rd[j].data,
+                        sizeof(struct in_addr));
+          if (GNUNET_OK ==
+              GNUNET_DNSSTUB_add_dns_sa(ac->authority_info.dns_authority.dns_handle,
+                                        (const struct sockaddr *)&v4))
+            ac->authority_info.dns_authority.found = GNUNET_YES;
+          break;
+        }
 
-        if (sizeof (struct in6_addr) != rd[j].data_size)
+        case GNUNET_DNSPARSER_TYPE_AAAA:
         {
-          GNUNET_break_op (0);
-          continue;
-        }
-        /* FIXME: might want to check if we support IPv6 here,
-           and otherwise skip this one and hope we find another */
-        memset (&v6,
-                0,
-                sizeof (v6));
-        v6.sin6_family = AF_INET6;
-        v6.sin6_port = htons (53);
+          struct sockaddr_in6 v6;
+
+          if (sizeof(struct in6_addr) != rd[j].data_size)
+            {
+              GNUNET_break_op(0);
+              continue;
+            }
+          /* FIXME: might want to check if we support IPv6 here,
+             and otherwise skip this one and hope we find another */
+          memset(&v6,
+                 0,
+                 sizeof(v6));
+          v6.sin6_family = AF_INET6;
+          v6.sin6_port = htons(53);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-        v6.sin6_len = (u_char) sizeof (v6);
+          v6.sin6_len = (u_char)sizeof(v6);
 #endif
-        GNUNET_memcpy (&v6.sin6_addr,
-                       rd[j].data,
-                       sizeof (struct in6_addr));
-        if (GNUNET_OK ==
-            GNUNET_DNSSTUB_add_dns_sa (ac->authority_info.dns_authority.dns_handle,
-                                       (const struct sockaddr *) &v6))
-          ac->authority_info.dns_authority.found = GNUNET_YES;
-        break;
-      }
-    default:
-      break;
+          GNUNET_memcpy(&v6.sin6_addr,
+                        rd[j].data,
+                        sizeof(struct in6_addr));
+          if (GNUNET_OK ==
+              GNUNET_DNSSTUB_add_dns_sa(ac->authority_info.dns_authority.dns_handle,
+                                        (const struct sockaddr *)&v6))
+            ac->authority_info.dns_authority.found = GNUNET_YES;
+          break;
+        }
+
+        default:
+          break;
+        }
     }
-  }
-  continue_with_gns2dns (ac);
+  continue_with_gns2dns(ac);
 }
 
 
@@ -1516,9 +1511,9 @@ handle_gns2dns_result (void *cls,
  * @param addrlen length of @a addr
  */
 static void
-handle_gns2dns_ip (void *cls,
-                   const struct sockaddr *addr,
-                   socklen_t addrlen)
+handle_gns2dns_ip(void *cls,
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
 {
   struct Gns2DnsPending *gp = cls;
   struct AuthorityChain *ac = gp->ac;
@@ -1527,42 +1522,44 @@ handle_gns2dns_ip (void *cls,
   struct sockaddr_in6 *v6;
 
   if (NULL == addr)
-  {
-    /* DNS resolution finished */
-    if (0 == gp->num_results)
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Failed to use DNS to resolve name of DNS resolver\n");
-    GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
-                                 ac->authority_info.dns_authority.gp_tail,
-                                 gp);
-    GNUNET_free (gp);
-    continue_with_gns2dns (ac);
-    return;
-  }
-  GNUNET_memcpy (&ss,
-                 addr,
-                 addrlen);
+    {
+      /* DNS resolution finished */
+      if (0 == gp->num_results)
+        GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                   "Failed to use DNS to resolve name of DNS resolver\n");
+      GNUNET_CONTAINER_DLL_remove(ac->authority_info.dns_authority.gp_head,
+                                  ac->authority_info.dns_authority.gp_tail,
+                                  gp);
+      GNUNET_free(gp);
+      continue_with_gns2dns(ac);
+      return;
+    }
+  GNUNET_memcpy(&ss,
+                addr,
+                addrlen);
   switch (ss.ss_family)
-  {
-  case AF_INET:
-    v4 = (struct sockaddr_in *) &ss;
-    v4->sin_port = htons (53);
-    gp->num_results++;
-    break;
-  case AF_INET6:
-    v6 = (struct sockaddr_in6 *) &ss;
-    v6->sin6_port = htons (53);
-    gp->num_results++;
-    break;
-  default:
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unsupported AF %d\n",
-                ss.ss_family);
-    return;
-  }
+    {
+    case AF_INET:
+      v4 = (struct sockaddr_in *)&ss;
+      v4->sin_port = htons(53);
+      gp->num_results++;
+      break;
+
+    case AF_INET6:
+      v6 = (struct sockaddr_in6 *)&ss;
+      v6->sin6_port = htons(53);
+      gp->num_results++;
+      break;
+
+    default:
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unsupported AF %d\n",
+                 ss.ss_family);
+      return;
+    }
   if (GNUNET_OK ==
-      GNUNET_DNSSTUB_add_dns_sa (ac->authority_info.dns_authority.dns_handle,
-                                 (struct sockaddr *) &ss))
+      GNUNET_DNSSTUB_add_dns_sa(ac->authority_info.dns_authority.dns_handle,
+                                (struct sockaddr *)&ss))
     ac->authority_info.dns_authority.found = GNUNET_YES;
 }
 
@@ -1574,27 +1571,27 @@ handle_gns2dns_ip (void *cls,
  * @param rd record with CNAME to resolve recursively
  */
 static void
-recursive_cname_resolution (struct GNS_ResolverHandle *rh,
-                            const struct GNUNET_GNSRECORD_Data *rd)
+recursive_cname_resolution(struct GNS_ResolverHandle *rh,
+                           const struct GNUNET_GNSRECORD_Data *rd)
 {
   char *cname;
   size_t off;
 
   off = 0;
-  cname = GNUNET_DNSPARSER_parse_name (rd->data,
-                                       rd->data_size,
-                                       &off);
-  if ( (NULL == cname) ||
-       (off != rd->data_size) )
-  {
-    GNUNET_break_op (0); /* record not well-formed */
-    GNUNET_free_non_null (cname);
-    fail_resolution (rh);
-    return;
-  }
-  handle_gns_cname_result (rh,
-                           cname);
-  GNUNET_free (cname);
+  cname = GNUNET_DNSPARSER_parse_name(rd->data,
+                                      rd->data_size,
+                                      &off);
+  if ((NULL == cname) ||
+      (off != rd->data_size))
+    {
+      GNUNET_break_op(0); /* record not well-formed */
+      GNUNET_free_non_null(cname);
+      fail_resolution(rh);
+      return;
+    }
+  handle_gns_cname_result(rh,
+                          cname);
+  GNUNET_free(cname);
 }
 
 
@@ -1605,34 +1602,34 @@ recursive_cname_resolution (struct GNS_ResolverHandle *rh,
  * @param rd record with PKEY to resolve recursively
  */
 static void
-recursive_pkey_resolution (struct GNS_ResolverHandle *rh,
-                           const struct GNUNET_GNSRECORD_Data *rd)
+recursive_pkey_resolution(struct GNS_ResolverHandle *rh,
+                          const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct AuthorityChain *ac;
 
   /* delegation to another zone */
-  if (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) !=
+  if (sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) !=
       rd->data_size)
-  {
-    GNUNET_break_op (0);
-    fail_resolution (rh);
-    return;
-  }
+    {
+      GNUNET_break_op(0);
+      fail_resolution(rh);
+      return;
+    }
   /* expand authority chain */
-  ac = GNUNET_new (struct AuthorityChain);
+  ac = GNUNET_new(struct AuthorityChain);
   ac->rh = rh;
   ac->gns_authority = GNUNET_YES;
-  GNUNET_memcpy (&ac->authority_info.gns_authority,
-                 rd->data,
-                 sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
-  ac->label = resolver_lookup_get_next_label (rh);
+  GNUNET_memcpy(&ac->authority_info.gns_authority,
+                rd->data,
+                sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey));
+  ac->label = resolver_lookup_get_next_label(rh);
   /* add AC to tail */
-  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
-                                    rh->ac_tail,
-                                    ac);
+  GNUNET_CONTAINER_DLL_insert_tail(rh->ac_head,
+                                   rh->ac_tail,
+                                   ac);
   /* recurse */
-  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
-                                          rh);
+  rh->task_id = GNUNET_SCHEDULER_add_now(&recursive_resolution,
+                                         rh);
 }
 
 
@@ -1647,9 +1644,9 @@ recursive_pkey_resolution (struct GNS_ResolverHandle *rh,
  * @return #GNUNET_OK if this worked, #GNUNET_SYSERR if no GNS2DNS records were in @a rd
  */
 static int
-recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
-                              unsigned int rd_count,
-                              const struct GNUNET_GNSRECORD_Data *rd)
+recursive_gns2dns_resolution(struct GNS_ResolverHandle *rh,
+                             unsigned int rd_count,
+                             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct AuthorityChain *ac;
   const char *tld;
@@ -1657,157 +1654,157 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
 
   ns = NULL;
   /* expand authority chain */
-  ac = GNUNET_new (struct AuthorityChain);
+  ac = GNUNET_new(struct AuthorityChain);
   ac->rh = rh;
-  ac->authority_info.dns_authority.dns_handle = GNUNET_DNSSTUB_start (4);
+  ac->authority_info.dns_authority.dns_handle = GNUNET_DNSSTUB_start(4);
 
-  for (unsigned int i=0;i<rd_count;i++)
-  {
-    char *ip;
-    char *n;
-    size_t off;
-    struct Gns2DnsPending *gp;
-    struct GNUNET_CRYPTO_EcdsaPublicKey zone;
-    struct sockaddr_in v4;
-    struct sockaddr_in6 v6;
-
-    if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
-      continue;
-    off = 0;
-    n = GNUNET_DNSPARSER_parse_name (rd[i].data,
-                                     rd[i].data_size,
-                                     &off);
-    ip = GNUNET_DNSPARSER_parse_name (rd[i].data,
-                                      rd[i].data_size,
-                                      &off);
-    if ( (NULL == n) ||
-         (NULL == ip) ||
-         (off != rd[i].data_size) )
+  for (unsigned int i = 0; i < rd_count; i++)
     {
-      GNUNET_break_op (0);
-      GNUNET_free_non_null (n);
-      GNUNET_free_non_null (ip);
-      continue;
-    }
-    /* resolve 'ip' to determine the IP(s) of the DNS
-       resolver to use for lookup of 'ns' */
-    if (NULL != ns)
-    {
-      if (0 != strcasecmp (ns,
-                           n))
-      {
-        /* NS values must all be the same for all GNS2DNS records,
-           anything else leads to insanity */
-        GNUNET_break_op (0);
-        GNUNET_free (n);
-        GNUNET_free (ip);
+      char *ip;
+      char *n;
+      size_t off;
+      struct Gns2DnsPending *gp;
+      struct GNUNET_CRYPTO_EcdsaPublicKey zone;
+      struct sockaddr_in v4;
+      struct sockaddr_in6 v6;
+
+      if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
         continue;
-      }
-      GNUNET_free (n);
-    }
-    else
-    {
-      ns = n;
-    }
+      off = 0;
+      n = GNUNET_DNSPARSER_parse_name(rd[i].data,
+                                      rd[i].data_size,
+                                      &off);
+      ip = GNUNET_DNSPARSER_parse_name(rd[i].data,
+                                       rd[i].data_size,
+                                       &off);
+      if ((NULL == n) ||
+          (NULL == ip) ||
+          (off != rd[i].data_size))
+        {
+          GNUNET_break_op(0);
+          GNUNET_free_non_null(n);
+          GNUNET_free_non_null(ip);
+          continue;
+        }
+      /* resolve 'ip' to determine the IP(s) of the DNS
+         resolver to use for lookup of 'ns' */
+      if (NULL != ns)
+        {
+          if (0 != strcasecmp(ns,
+                              n))
+            {
+              /* NS values must all be the same for all GNS2DNS records,
+                 anything else leads to insanity */
+              GNUNET_break_op(0);
+              GNUNET_free(n);
+              GNUNET_free(ip);
+              continue;
+            }
+          GNUNET_free(n);
+        }
+      else
+        {
+          ns = n;
+        }
 
-    /* check if 'ip' is already an IPv4/IPv6 address */
-    if ( (1 == inet_pton (AF_INET,
+      /* check if 'ip' is already an IPv4/IPv6 address */
+      if ((1 == inet_pton(AF_INET,
                           ip,
                           &v4)) ||
-         (1 == inet_pton (AF_INET6,
+          (1 == inet_pton(AF_INET6,
                           ip,
-                          &v6)) )
-    {
-      GNUNET_break (GNUNET_OK ==
-                    GNUNET_DNSSTUB_add_dns_ip (ac->authority_info.dns_authority.dns_handle,
-                                               ip));
-      ac->authority_info.dns_authority.found = GNUNET_YES;
-      GNUNET_free (ip);
-      continue;
-    }
-    tld = GNS_get_tld (ip);
-    if (0 != strcmp (tld,
-                     "+"))
-    {
-      /* 'ip' is a DNS name */
-      gp = GNUNET_new (struct Gns2DnsPending);
+                          &v6)))
+        {
+          GNUNET_break(GNUNET_OK ==
+                       GNUNET_DNSSTUB_add_dns_ip(ac->authority_info.dns_authority.dns_handle,
+                                                 ip));
+          ac->authority_info.dns_authority.found = GNUNET_YES;
+          GNUNET_free(ip);
+          continue;
+        }
+      tld = GNS_get_tld(ip);
+      if (0 != strcmp(tld,
+                      "+"))
+        {
+          /* 'ip' is a DNS name */
+          gp = GNUNET_new(struct Gns2DnsPending);
+          gp->ac = ac;
+          GNUNET_CONTAINER_DLL_insert(ac->authority_info.dns_authority.gp_head,
+                                      ac->authority_info.dns_authority.gp_tail,
+                                      gp);
+          gp->dns_rh = GNUNET_RESOLVER_ip_get(ip,
+                                              AF_UNSPEC,
+                                              GNUNET_TIME_UNIT_FOREVER_REL,
+                                              &handle_gns2dns_ip,
+                                              gp);
+          GNUNET_free(ip);
+          continue;
+        }
+      /* 'ip' should be a GNS name */
+      gp = GNUNET_new(struct Gns2DnsPending);
       gp->ac = ac;
-      GNUNET_CONTAINER_DLL_insert (ac->authority_info.dns_authority.gp_head,
-                                   ac->authority_info.dns_authority.gp_tail,
-                                   gp);
-      gp->dns_rh = GNUNET_RESOLVER_ip_get (ip,
-                                           AF_UNSPEC,
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           &handle_gns2dns_ip,
-                                           gp);
-      GNUNET_free (ip);
-      continue;
-    }
-    /* 'ip' should be a GNS name */
-    gp = GNUNET_new (struct Gns2DnsPending);
-    gp->ac = ac;
-    GNUNET_CONTAINER_DLL_insert (ac->authority_info.dns_authority.gp_head,
-                                 ac->authority_info.dns_authority.gp_tail,
-                                 gp);
-    gp->rh = GNUNET_new (struct GNS_ResolverHandle);
-    ip = translate_dot_plus (rh,
-                             ip);
-    tld = GNS_get_tld (ip);
-    if (GNUNET_OK !=
-        GNUNET_GNSRECORD_zkey_to_pkey (tld,
-                                       &zone))
-    {
-      GNUNET_break_op (0);
-      GNUNET_free (ip);
-      continue;
-    }
-    gp->rh->authority_zone = zone;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Resolving `%s' to determine IP address of DNS server for GNS2DNS transition for `%s'\n",
-                ip,
-                ns);
-    gp->rh->name = ip;
-    gp->rh->name_resolution_pos = strlen (ip) - strlen (tld) - 1;
-    gp->rh->proc = &handle_gns2dns_result;
-    gp->rh->proc_cls = gp;
-    gp->rh->record_type = GNUNET_GNSRECORD_TYPE_ANY;
-    gp->rh->options = GNUNET_GNS_LO_DEFAULT;
-    gp->rh->loop_limiter = rh->loop_limiter + 1;
-    gp->rh->task_id
-      = GNUNET_SCHEDULER_add_now (&start_resolver_lookup,
-                                  gp->rh);
-  } /* end 'for all records' */
+      GNUNET_CONTAINER_DLL_insert(ac->authority_info.dns_authority.gp_head,
+                                  ac->authority_info.dns_authority.gp_tail,
+                                  gp);
+      gp->rh = GNUNET_new(struct GNS_ResolverHandle);
+      ip = translate_dot_plus(rh,
+                              ip);
+      tld = GNS_get_tld(ip);
+      if (GNUNET_OK !=
+          GNUNET_GNSRECORD_zkey_to_pkey(tld,
+                                        &zone))
+        {
+          GNUNET_break_op(0);
+          GNUNET_free(ip);
+          continue;
+        }
+      gp->rh->authority_zone = zone;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Resolving `%s' to determine IP address of DNS server for GNS2DNS transition for `%s'\n",
+                 ip,
+                 ns);
+      gp->rh->name = ip;
+      gp->rh->name_resolution_pos = strlen(ip) - strlen(tld) - 1;
+      gp->rh->proc = &handle_gns2dns_result;
+      gp->rh->proc_cls = gp;
+      gp->rh->record_type = GNUNET_GNSRECORD_TYPE_ANY;
+      gp->rh->options = GNUNET_GNS_LO_DEFAULT;
+      gp->rh->loop_limiter = rh->loop_limiter + 1;
+      gp->rh->task_id
+        = GNUNET_SCHEDULER_add_now(&start_resolver_lookup,
+                                   gp->rh);
+    } /* end 'for all records' */
 
   if (NULL == ns)
-  {
-    /* not a single GNS2DNS record found */
-    GNUNET_free (ac);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_assert (strlen (ns) <= GNUNET_DNSPARSER_MAX_NAME_LENGTH);
-  strcpy (ac->authority_info.dns_authority.name,
-          ns);
+    {
+      /* not a single GNS2DNS record found */
+      GNUNET_free(ac);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_assert(strlen(ns) <= GNUNET_DNSPARSER_MAX_NAME_LENGTH);
+  strcpy(ac->authority_info.dns_authority.name,
+         ns);
   /* for DNS recursion, the label is the full DNS name,
      created from the remainder of the GNS name and the
      name in the NS record */
-  GNUNET_asprintf (&ac->label,
-                   "%.*s%s%s",
-                   (int) rh->name_resolution_pos,
-                   rh->name,
-                   (0 != rh->name_resolution_pos) ? "." : "",
-                   ns);
-  GNUNET_free (ns);
-  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
-                                    rh->ac_tail,
-                                    ac);
-  if (strlen (ac->label) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("GNS lookup resulted in DNS name that is too long (`%s')\n"),
-                ac->label);
-    return GNUNET_SYSERR;
-  }
-  continue_with_gns2dns (ac);
+  GNUNET_asprintf(&ac->label,
+                  "%.*s%s%s",
+                  (int)rh->name_resolution_pos,
+                  rh->name,
+                  (0 != rh->name_resolution_pos) ? "." : "",
+                  ns);
+  GNUNET_free(ns);
+  GNUNET_CONTAINER_DLL_insert_tail(rh->ac_head,
+                                   rh->ac_tail,
+                                   ac);
+  if (strlen(ac->label) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("GNS lookup resulted in DNS name that is too long (`%s')\n"),
+                 ac->label);
+      return GNUNET_SYSERR;
+    }
+  continue_with_gns2dns(ac);
   return GNUNET_OK;
 }
 
@@ -1820,9 +1817,9 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
  * @param rd array of records with data to store
  */
 static void
-handle_gns_resolution_result (void *cls,
-                              unsigned int rd_count,
-                              const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns_resolution_result(void *cls,
+                             unsigned int rd_count,
+                             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNS_ResolverHandle *rh = cls;
   char *cname;
@@ -1838,431 +1835,442 @@ handle_gns_resolution_result (void *cls,
   struct GNUNET_GNSRECORD_Data rd_new[rd_count];
   unsigned int rd_off;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Resolution succeeded for `%s' in zone %s, got %u records\n",
-              rh->ac_tail->label,
-              GNUNET_GNSRECORD_z2s (&rh->ac_tail->authority_info.gns_authority),
-              rd_count);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Resolution succeeded for `%s' in zone %s, got %u records\n",
+             rh->ac_tail->label,
+             GNUNET_GNSRECORD_z2s(&rh->ac_tail->authority_info.gns_authority),
+             rd_count);
   if (0 == rd_count)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("GNS lookup failed (zero records found for `%s')\n"),
-                rh->name);
-    fail_resolution (rh);
-    return;
-  }
-
-  if (0 == rh->name_resolution_pos)
-  {
-    /* top-level match, are we done yet? */
-    if ( (rd_count > 0) &&
-         (GNUNET_DNSPARSER_TYPE_CNAME == rd[0].record_type) &&
-         (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type) )
     {
-      off = 0;
-      cname = GNUNET_DNSPARSER_parse_name (rd[0].data,
-                                           rd[0].data_size,
-                                           &off);
-      if ( (NULL == cname) ||
-           (off != rd[0].data_size) )
-      {
-        GNUNET_break_op (0);
-        GNUNET_free_non_null (cname);
-        fail_resolution (rh);
-        return;
-      }
-      handle_gns_cname_result (rh,
-                               cname);
-      GNUNET_free (cname);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("GNS lookup failed (zero records found for `%s')\n"),
+                 rh->name);
+      fail_resolution(rh);
       return;
     }
-    /* If A/AAAA was requested, but we got a VPN
-       record, we convert it to A/AAAA using GNUnet VPN */
-    if ( (GNUNET_DNSPARSER_TYPE_A == rh->record_type) ||
-         (GNUNET_DNSPARSER_TYPE_AAAA == rh->record_type) )
+
+  if (0 == rh->name_resolution_pos)
     {
-      for (unsigned int i=0;i<rd_count;i++)
-      {
-        switch (rd[i].record_type)
-        {
-        case GNUNET_GNSRECORD_TYPE_VPN:
-          {
-            af = (GNUNET_DNSPARSER_TYPE_A == rh->record_type) ? AF_INET : AF_INET6;
-            if (sizeof (struct GNUNET_TUN_GnsVpnRecord) >
-                rd[i].data_size)
-            {
-              GNUNET_break_op (0);
-              fail_resolution (rh);
-              return;
-            }
-            vpn = (const struct GNUNET_TUN_GnsVpnRecord *) rd[i].data;
-            vname = (const char *) &vpn[1];
-            if ('\0' != vname[rd[i].data_size - 1 - sizeof (struct GNUNET_TUN_GnsVpnRecord)])
-            {
-              GNUNET_break_op (0);
-              fail_resolution (rh);
-              return;
-            }
-            GNUNET_TUN_service_name_to_hash (vname,
-                                             &vhash);
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "Attempting VPN allocation for %s-%s (AF: %d, proto %d)\n",
-                        GNUNET_i2s (&vpn->peer),
-                        vname,
-                        (int) af,
-                        (int) ntohs (vpn->proto));
-            vpn_ctx = GNUNET_new (struct VpnContext);
-            rh->vpn_ctx = vpn_ctx;
-            vpn_ctx->rh = rh;
-            vpn_ctx->rd_data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
-                                                                       rd);
-            if (vpn_ctx->rd_data_size < 0)
+      /* top-level match, are we done yet? */
+      if ((rd_count > 0) &&
+          (GNUNET_DNSPARSER_TYPE_CNAME == rd[0].record_type) &&
+          (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type))
+        {
+          off = 0;
+          cname = GNUNET_DNSPARSER_parse_name(rd[0].data,
+                                              rd[0].data_size,
+                                              &off);
+          if ((NULL == cname) ||
+              (off != rd[0].data_size))
             {
-              GNUNET_break_op (0);
-              GNUNET_free (vpn_ctx);
-              fail_resolution (rh);
-              return;
-            }
-            vpn_ctx->rd_data = GNUNET_malloc ((size_t) vpn_ctx->rd_data_size);
-            vpn_ctx->rd_count = rd_count;
-            GNUNET_assert (vpn_ctx->rd_data_size ==
-                           GNUNET_GNSRECORD_records_serialize (rd_count,
-                                                               rd,
-                                                               (size_t) vpn_ctx->rd_data_size,
-                                                               vpn_ctx->rd_data));
-            vpn_ctx->vpn_request = GNUNET_VPN_redirect_to_peer (vpn_handle,
-                                                                af,
-                                                                ntohs (vpn->proto),
-                                                                &vpn->peer,
-                                                                &vhash,
-                                                                GNUNET_TIME_relative_to_absolute (VPN_TIMEOUT),
-                                                                &vpn_allocation_cb,
-                                                                vpn_ctx);
-            return;
-          }
-        case GNUNET_GNSRECORD_TYPE_GNS2DNS:
-          {
-            /* delegation to DNS */
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                        "Found GNS2DNS record, delegating to DNS!\n");
-            if (GNUNET_OK ==
-                recursive_gns2dns_resolution (rh,
-                                              rd_count,
-                                              rd))
+              GNUNET_break_op(0);
+              GNUNET_free_non_null(cname);
+              fail_resolution(rh);
               return;
-            else
-              goto fail;
-          }
-        default:
-          break;
-        } /* end: switch */
-      } /* end: for rd */
-    } /* end: name_resolution_pos */
-    /* convert relative names in record values to absolute names,
-       using 'scratch' array for memory allocations */
-    scratch_off = 0;
-    rd_off = 0;
-    for (unsigned int i=0;i<rd_count;i++)
-    {
-      GNUNET_assert (rd_off <= i);
-      if ( (0 != rh->protocol) &&
-           (0 != rh->service) &&
-           (GNUNET_GNSRECORD_TYPE_BOX != rd[i].record_type) )
-        continue; /* we _only_ care about boxed records */
-
-      GNUNET_assert (rd_off < rd_count);
-      rd_new[rd_off] = rd[i];
-      /* Check if the embedded name(s) end in "+", and if so,
-         replace the "+" with the zone at "ac_tail", changing the name
-         to a ".ZONEKEY".  The name is allocated on the 'scratch' array,
-         so we can free it afterwards. */
-      switch (rd[i].record_type)
-      {
-      case GNUNET_DNSPARSER_TYPE_CNAME:
-        {
-          char *cname;
-
-          off = 0;
-          cname = GNUNET_DNSPARSER_parse_name (rd[i].data,
-                                               rd[i].data_size,
-                                               &off);
-          if ( (NULL == cname) ||
-               (off != rd[i].data_size) )
-          {
-            GNUNET_break_op (0); /* record not well-formed */
-          }
-          else
-          {
-            cname = translate_dot_plus (rh, cname);
-            GNUNET_break (NULL != cname);
-            scratch_start = scratch_off;
-            if (GNUNET_OK !=
-                GNUNET_DNSPARSER_builder_add_name (scratch,
-                                                   sizeof (scratch),
-                                                   &scratch_off,
-                                                   cname))
-            {
-              GNUNET_break (0);
-            }
-            else
-            {
-              GNUNET_assert (rd_off < rd_count);
-              rd_new[rd_off].data = &scratch[scratch_start];
-              rd_new[rd_off].data_size = scratch_off - scratch_start;
-              rd_off++;
-            }
-          }
-          GNUNET_free_non_null (cname);
-        }
-        break;
-      case GNUNET_DNSPARSER_TYPE_SOA:
-        {
-          struct GNUNET_DNSPARSER_SoaRecord *soa;
-
-          off = 0;
-          soa = GNUNET_DNSPARSER_parse_soa (rd[i].data,
-                                            rd[i].data_size,
-                                            &off);
-          if ( (NULL == soa) ||
-               (off != rd[i].data_size) )
-          {
-            GNUNET_break_op (0); /* record not well-formed */
-          }
-          else
-          {
-            soa->mname = translate_dot_plus (rh, soa->mname);
-            soa->rname = translate_dot_plus (rh, soa->rname);
-            scratch_start = scratch_off;
-            if (GNUNET_OK !=
-                GNUNET_DNSPARSER_builder_add_soa (scratch,
-                                                  sizeof (scratch),
-                                                  &scratch_off,
-                                                  soa))
-            {
-              GNUNET_break (0);
-            }
-            else
-            {
-              GNUNET_assert (rd_off < rd_count);
-              rd_new[rd_off].data = &scratch[scratch_start];
-              rd_new[rd_off].data_size = scratch_off - scratch_start;
-              rd_off++;
-            }
-          }
-          if (NULL != soa)
-            GNUNET_DNSPARSER_free_soa (soa);
-        }
-        break;
-      case GNUNET_DNSPARSER_TYPE_MX:
-        {
-          struct GNUNET_DNSPARSER_MxRecord *mx;
-
-          off = 0;
-          mx = GNUNET_DNSPARSER_parse_mx (rd[i].data,
-                                          rd[i].data_size,
-                                          &off);
-          if ( (NULL == mx) ||
-               (off != rd[i].data_size) )
-          {
-            GNUNET_break_op (0); /* record not well-formed */
-          }
-          else
-          {
-            mx->mxhost = translate_dot_plus (rh, mx->mxhost);
-            scratch_start = scratch_off;
-            if (GNUNET_OK !=
-                GNUNET_DNSPARSER_builder_add_mx (scratch,
-                                                 sizeof (scratch),
-                                                 &scratch_off,
-                                                 mx))
-            {
-              GNUNET_break (0);
-            }
-            else
-            {
-              GNUNET_assert (rd_off < rd_count);
-              rd_new[rd_off].data = &scratch[scratch_start];
-              rd_new[rd_off].data_size = scratch_off - scratch_start;
-              rd_off++;
-            }
-          }
-          if (NULL != mx)
-            GNUNET_DNSPARSER_free_mx (mx);
-        }
-        break;
-      case GNUNET_DNSPARSER_TYPE_SRV:
-        {
-          struct GNUNET_DNSPARSER_SrvRecord *srv;
-
-          off = 0;
-          srv = GNUNET_DNSPARSER_parse_srv (rd[i].data,
-                                            rd[i].data_size,
-                                            &off);
-          if ( (NULL == srv) ||
-               (off != rd[i].data_size) )
-          {
-            GNUNET_break_op (0); /* record not well-formed */
-          }
-          else
-          {
-            srv->target = translate_dot_plus (rh, srv->target);
-            scratch_start = scratch_off;
-            if (GNUNET_OK !=
-                GNUNET_DNSPARSER_builder_add_srv (scratch,
-                                                  sizeof (scratch),
-                                                  &scratch_off,
-                                                  srv))
-            {
-              GNUNET_break (0);
-            }
-            else
-            {
-              GNUNET_assert (rd_off < rd_count);
-              rd_new[rd_off].data = &scratch[scratch_start];
-              rd_new[rd_off].data_size = scratch_off - scratch_start;
-              rd_off++;
-            }
-          }
-          if (NULL != srv)
-            GNUNET_DNSPARSER_free_srv (srv);
-        }
-        break;
-
-      case GNUNET_GNSRECORD_TYPE_NICK:
-        {
-          const char *nick;
-
-          nick = rd[i].data;
-          if ((rd[i].data_size > 0) &&
-              (nick[rd[i].data_size -1] != '\0'))
-          {
-            GNUNET_break_op (0);
-            break;
-          }
-          break;
-        }
-      case GNUNET_GNSRECORD_TYPE_PKEY:
-        {
-          struct GNUNET_CRYPTO_EcdsaPublicKey pub;
-
-          if (rd[i].data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
-          {
-            GNUNET_break_op (0);
-            break;
-          }
-          GNUNET_memcpy (&pub,
-                         rd[i].data,
-                         rd[i].data_size);
-          rd_off++;
-          if (GNUNET_GNSRECORD_TYPE_PKEY != rh->record_type)
-          {
-            /* try to resolve "@" */
-            struct AuthorityChain *ac;
-
-            ac = GNUNET_new (struct AuthorityChain);
-            ac->rh = rh;
-            ac->gns_authority = GNUNET_YES;
-            ac->authority_info.gns_authority = pub;
-            ac->label = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
-            GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
-                                              rh->ac_tail,
-                                              ac);
-            rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
-                                                    rh);
-            return;
-          }
+            }
+          handle_gns_cname_result(rh,
+                                  cname);
+          GNUNET_free(cname);
+          return;
         }
-        break;
-      case GNUNET_GNSRECORD_TYPE_GNS2DNS:
+      /* If A/AAAA was requested, but we got a VPN
+         record, we convert it to A/AAAA using GNUnet VPN */
+      if ((GNUNET_DNSPARSER_TYPE_A == rh->record_type) ||
+          (GNUNET_DNSPARSER_TYPE_AAAA == rh->record_type))
         {
-          /* delegation to DNS */
-          if (GNUNET_GNSRECORD_TYPE_GNS2DNS == rh->record_type)
-          {
-            rd_off++;
-            break; /* do not follow to DNS, we wanted the GNS2DNS record! */
-          }
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Found GNS2DNS record, delegating to DNS!\n");
-          if (GNUNET_OK ==
-              recursive_gns2dns_resolution (rh,
-                                            rd_count,
-                                            rd))
-            return;
-          else
-            goto fail;
-        }
-      case GNUNET_GNSRECORD_TYPE_BOX:
+          for (unsigned int i = 0; i < rd_count; i++)
+            {
+              switch (rd[i].record_type)
+                {
+                case GNUNET_GNSRECORD_TYPE_VPN:
+                {
+                  af = (GNUNET_DNSPARSER_TYPE_A == rh->record_type) ? AF_INET : AF_INET6;
+                  if (sizeof(struct GNUNET_TUN_GnsVpnRecord) >
+                      rd[i].data_size)
+                    {
+                      GNUNET_break_op(0);
+                      fail_resolution(rh);
+                      return;
+                    }
+                  vpn = (const struct GNUNET_TUN_GnsVpnRecord *)rd[i].data;
+                  vname = (const char *)&vpn[1];
+                  if ('\0' != vname[rd[i].data_size - 1 - sizeof(struct GNUNET_TUN_GnsVpnRecord)])
+                    {
+                      GNUNET_break_op(0);
+                      fail_resolution(rh);
+                      return;
+                    }
+                  GNUNET_TUN_service_name_to_hash(vname,
+                                                  &vhash);
+                  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                             "Attempting VPN allocation for %s-%s (AF: %d, proto %d)\n",
+                             GNUNET_i2s(&vpn->peer),
+                             vname,
+                             (int)af,
+                             (int)ntohs(vpn->proto));
+                  vpn_ctx = GNUNET_new(struct VpnContext);
+                  rh->vpn_ctx = vpn_ctx;
+                  vpn_ctx->rh = rh;
+                  vpn_ctx->rd_data_size = GNUNET_GNSRECORD_records_get_size(rd_count,
+                                                                            rd);
+                  if (vpn_ctx->rd_data_size < 0)
+                    {
+                      GNUNET_break_op(0);
+                      GNUNET_free(vpn_ctx);
+                      fail_resolution(rh);
+                      return;
+                    }
+                  vpn_ctx->rd_data = GNUNET_malloc((size_t)vpn_ctx->rd_data_size);
+                  vpn_ctx->rd_count = rd_count;
+                  GNUNET_assert(vpn_ctx->rd_data_size ==
+                                GNUNET_GNSRECORD_records_serialize(rd_count,
+                                                                   rd,
+                                                                   (size_t)vpn_ctx->rd_data_size,
+                                                                   vpn_ctx->rd_data));
+                  vpn_ctx->vpn_request = GNUNET_VPN_redirect_to_peer(vpn_handle,
+                                                                     af,
+                                                                     ntohs(vpn->proto),
+                                                                     &vpn->peer,
+                                                                     &vhash,
+                                                                     GNUNET_TIME_relative_to_absolute(VPN_TIMEOUT),
+                                                                     &vpn_allocation_cb,
+                                                                     vpn_ctx);
+                  return;
+                }
+
+                case GNUNET_GNSRECORD_TYPE_GNS2DNS:
+                {
+                  /* delegation to DNS */
+                  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                             "Found GNS2DNS record, delegating to DNS!\n");
+                  if (GNUNET_OK ==
+                      recursive_gns2dns_resolution(rh,
+                                                   rd_count,
+                                                   rd))
+                    return;
+                  else
+                    goto fail;
+                }
+
+                default:
+                  break;
+                } /* end: switch */
+            } /* end: for rd */
+        } /* end: name_resolution_pos */
+      /* convert relative names in record values to absolute names,
+         using 'scratch' array for memory allocations */
+      scratch_off = 0;
+      rd_off = 0;
+      for (unsigned int i = 0; i < rd_count; i++)
         {
-          /* unbox SRV/TLSA records if a specific one was requested */
-          if ( (0 != rh->protocol) &&
-               (0 != rh->service) &&
-               (rd[i].data_size >= sizeof (struct GNUNET_GNSRECORD_BoxRecord)) )
-          {
-            const struct GNUNET_GNSRECORD_BoxRecord *box;
+          GNUNET_assert(rd_off <= i);
+          if ((0 != rh->protocol) &&
+              (0 != rh->service) &&
+              (GNUNET_GNSRECORD_TYPE_BOX != rd[i].record_type))
+            continue; /* we _only_ care about boxed records */
+
+          GNUNET_assert(rd_off < rd_count);
+          rd_new[rd_off] = rd[i];
+          /* Check if the embedded name(s) end in "+", and if so,
+             replace the "+" with the zone at "ac_tail", changing the name
+             to a ".ZONEKEY".  The name is allocated on the 'scratch' array,
+             so we can free it afterwards. */
+          switch (rd[i].record_type)
+            {
+            case GNUNET_DNSPARSER_TYPE_CNAME:
+            {
+              char *cname;
+
+              off = 0;
+              cname = GNUNET_DNSPARSER_parse_name(rd[i].data,
+                                                  rd[i].data_size,
+                                                  &off);
+              if ((NULL == cname) ||
+                  (off != rd[i].data_size))
+                {
+                  GNUNET_break_op(0); /* record not well-formed */
+                }
+              else
+                {
+                  cname = translate_dot_plus(rh, cname);
+                  GNUNET_break(NULL != cname);
+                  scratch_start = scratch_off;
+                  if (GNUNET_OK !=
+                      GNUNET_DNSPARSER_builder_add_name(scratch,
+                                                        sizeof(scratch),
+                                                        &scratch_off,
+                                                        cname))
+                    {
+                      GNUNET_break(0);
+                    }
+                  else
+                    {
+                      GNUNET_assert(rd_off < rd_count);
+                      rd_new[rd_off].data = &scratch[scratch_start];
+                      rd_new[rd_off].data_size = scratch_off - scratch_start;
+                      rd_off++;
+                    }
+                }
+              GNUNET_free_non_null(cname);
+            }
+            break;
+
+            case GNUNET_DNSPARSER_TYPE_SOA:
+            {
+              struct GNUNET_DNSPARSER_SoaRecord *soa;
+
+              off = 0;
+              soa = GNUNET_DNSPARSER_parse_soa(rd[i].data,
+                                               rd[i].data_size,
+                                               &off);
+              if ((NULL == soa) ||
+                  (off != rd[i].data_size))
+                {
+                  GNUNET_break_op(0); /* record not well-formed */
+                }
+              else
+                {
+                  soa->mname = translate_dot_plus(rh, soa->mname);
+                  soa->rname = translate_dot_plus(rh, soa->rname);
+                  scratch_start = scratch_off;
+                  if (GNUNET_OK !=
+                      GNUNET_DNSPARSER_builder_add_soa(scratch,
+                                                       sizeof(scratch),
+                                                       &scratch_off,
+                                                       soa))
+                    {
+                      GNUNET_break(0);
+                    }
+                  else
+                    {
+                      GNUNET_assert(rd_off < rd_count);
+                      rd_new[rd_off].data = &scratch[scratch_start];
+                      rd_new[rd_off].data_size = scratch_off - scratch_start;
+                      rd_off++;
+                    }
+                }
+              if (NULL != soa)
+                GNUNET_DNSPARSER_free_soa(soa);
+            }
+            break;
+
+            case GNUNET_DNSPARSER_TYPE_MX:
+            {
+              struct GNUNET_DNSPARSER_MxRecord *mx;
+
+              off = 0;
+              mx = GNUNET_DNSPARSER_parse_mx(rd[i].data,
+                                             rd[i].data_size,
+                                             &off);
+              if ((NULL == mx) ||
+                  (off != rd[i].data_size))
+                {
+                  GNUNET_break_op(0); /* record not well-formed */
+                }
+              else
+                {
+                  mx->mxhost = translate_dot_plus(rh, mx->mxhost);
+                  scratch_start = scratch_off;
+                  if (GNUNET_OK !=
+                      GNUNET_DNSPARSER_builder_add_mx(scratch,
+                                                      sizeof(scratch),
+                                                      &scratch_off,
+                                                      mx))
+                    {
+                      GNUNET_break(0);
+                    }
+                  else
+                    {
+                      GNUNET_assert(rd_off < rd_count);
+                      rd_new[rd_off].data = &scratch[scratch_start];
+                      rd_new[rd_off].data_size = scratch_off - scratch_start;
+                      rd_off++;
+                    }
+                }
+              if (NULL != mx)
+                GNUNET_DNSPARSER_free_mx(mx);
+            }
+            break;
+
+            case GNUNET_DNSPARSER_TYPE_SRV:
+            {
+              struct GNUNET_DNSPARSER_SrvRecord *srv;
+
+              off = 0;
+              srv = GNUNET_DNSPARSER_parse_srv(rd[i].data,
+                                               rd[i].data_size,
+                                               &off);
+              if ((NULL == srv) ||
+                  (off != rd[i].data_size))
+                {
+                  GNUNET_break_op(0); /* record not well-formed */
+                }
+              else
+                {
+                  srv->target = translate_dot_plus(rh, srv->target);
+                  scratch_start = scratch_off;
+                  if (GNUNET_OK !=
+                      GNUNET_DNSPARSER_builder_add_srv(scratch,
+                                                       sizeof(scratch),
+                                                       &scratch_off,
+                                                       srv))
+                    {
+                      GNUNET_break(0);
+                    }
+                  else
+                    {
+                      GNUNET_assert(rd_off < rd_count);
+                      rd_new[rd_off].data = &scratch[scratch_start];
+                      rd_new[rd_off].data_size = scratch_off - scratch_start;
+                      rd_off++;
+                    }
+                }
+              if (NULL != srv)
+                GNUNET_DNSPARSER_free_srv(srv);
+            }
+            break;
+
+            case GNUNET_GNSRECORD_TYPE_NICK:
+            {
+              const char *nick;
+
+              nick = rd[i].data;
+              if ((rd[i].data_size > 0) &&
+                  (nick[rd[i].data_size - 1] != '\0'))
+                {
+                  GNUNET_break_op(0);
+                  break;
+                }
+              break;
+            }
 
-            box = rd[i].data;
-            if ( (ntohs (box->protocol) == rh->protocol) &&
-                 (ntohs (box->service) == rh->service) )
+            case GNUNET_GNSRECORD_TYPE_PKEY:
             {
-              /* Box matches, unbox! */
-              GNUNET_assert (rd_off < rd_count);
-              rd_new[rd_off].record_type = ntohl (box->record_type);
-              rd_new[rd_off].data_size -= sizeof (struct GNUNET_GNSRECORD_BoxRecord);
-              rd_new[rd_off].data = &box[1];
+              struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+
+              if (rd[i].data_size != sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))
+                {
+                  GNUNET_break_op(0);
+                  break;
+                }
+              GNUNET_memcpy(&pub,
+                            rd[i].data,
+                            rd[i].data_size);
               rd_off++;
+              if (GNUNET_GNSRECORD_TYPE_PKEY != rh->record_type)
+                {
+                  /* try to resolve "@" */
+                  struct AuthorityChain *ac;
+
+                  ac = GNUNET_new(struct AuthorityChain);
+                  ac->rh = rh;
+                  ac->gns_authority = GNUNET_YES;
+                  ac->authority_info.gns_authority = pub;
+                  ac->label = GNUNET_strdup(GNUNET_GNS_EMPTY_LABEL_AT);
+                  GNUNET_CONTAINER_DLL_insert_tail(rh->ac_head,
+                                                   rh->ac_tail,
+                                                   ac);
+                  rh->task_id = GNUNET_SCHEDULER_add_now(&recursive_resolution,
+                                                         rh);
+                  return;
+                }
             }
-          }
-          else
-          {
-            /* no specific protocol/service specified, preserve all BOX
-               records (for modern, GNS-enabled applications) */
-            rd_off++;
-          }
-          break;
-        }
-      default:
-        rd_off++;
-        break;
-      } /* end: switch */
-    } /* end: for rd_count */
-
-    /* yes, we are done, return result */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Returning GNS response for `%s' with %u answers\n",
-                rh->ac_tail->label,
-                rd_off);
-    rh->proc (rh->proc_cls,
-              rd_off,
-              rd_new);
-    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                            rh);
-    return;
-  }
+            break;
+
+            case GNUNET_GNSRECORD_TYPE_GNS2DNS:
+            {
+              /* delegation to DNS */
+              if (GNUNET_GNSRECORD_TYPE_GNS2DNS == rh->record_type)
+                {
+                  rd_off++;
+                  break; /* do not follow to DNS, we wanted the GNS2DNS record! */
+                }
+              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                         "Found GNS2DNS record, delegating to DNS!\n");
+              if (GNUNET_OK ==
+                  recursive_gns2dns_resolution(rh,
+                                               rd_count,
+                                               rd))
+                return;
+              else
+                goto fail;
+            }
+
+            case GNUNET_GNSRECORD_TYPE_BOX:
+            {
+              /* unbox SRV/TLSA records if a specific one was requested */
+              if ((0 != rh->protocol) &&
+                  (0 != rh->service) &&
+                  (rd[i].data_size >= sizeof(struct GNUNET_GNSRECORD_BoxRecord)))
+                {
+                  const struct GNUNET_GNSRECORD_BoxRecord *box;
+
+                  box = rd[i].data;
+                  if ((ntohs(box->protocol) == rh->protocol) &&
+                      (ntohs(box->service) == rh->service))
+                    {
+                      /* Box matches, unbox! */
+                      GNUNET_assert(rd_off < rd_count);
+                      rd_new[rd_off].record_type = ntohl(box->record_type);
+                      rd_new[rd_off].data_size -= sizeof(struct GNUNET_GNSRECORD_BoxRecord);
+                      rd_new[rd_off].data = &box[1];
+                      rd_off++;
+                    }
+                }
+              else
+                {
+                  /* no specific protocol/service specified, preserve all BOX
+                     records (for modern, GNS-enabled applications) */
+                  rd_off++;
+                }
+              break;
+            }
+
+            default:
+              rd_off++;
+              break;
+            } /* end: switch */
+        } /* end: for rd_count */
+
+      /* yes, we are done, return result */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Returning GNS response for `%s' with %u answers\n",
+                 rh->ac_tail->label,
+                 rd_off);
+      rh->proc(rh->proc_cls,
+               rd_off,
+               rd_new);
+      rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                             rh);
+      return;
+    }
 
   switch (rd[0].record_type)
-  {
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-    GNUNET_break_op (1 == rd_count); /* CNAME should be unique */
-    recursive_cname_resolution (rh,
+    {
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+      GNUNET_break_op(1 == rd_count); /* CNAME should be unique */
+      recursive_cname_resolution(rh,
+                                 &rd[0]);
+      return;
+
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      GNUNET_break_op(1 == rd_count); /* PKEY should be unique */
+      recursive_pkey_resolution(rh,
                                 &rd[0]);
-    return;
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    GNUNET_break_op (1 == rd_count); /* PKEY should be unique */
-    recursive_pkey_resolution (rh,
-                               &rd[0]);
-    return;
-  default:
-    if (GNUNET_OK ==
-        recursive_gns2dns_resolution (rh,
-                                      rd_count,
-                                      rd))
       return;
-    break;
-  }
- fail:
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _("GNS lookup recursion failed (no delegation record found)\n"));
-  fail_resolution (rh);
+
+    default:
+      if (GNUNET_OK ==
+          recursive_gns2dns_resolution(rh,
+                                       rd_count,
+                                       rd))
+        return;
+      break;
+    }
+fail:
+  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+             _("GNS lookup recursion failed (no delegation record found)\n"));
+  fail_resolution(rh);
 }
 
 
@@ -2275,21 +2283,21 @@ handle_gns_resolution_result (void *cls,
  * @param emsg error message
  */
 static void
-namecache_cache_continuation (void *cls,
-                              int32_t success,
-                              const char *emsg)
+namecache_cache_continuation(void *cls,
+                             int32_t success,
+                             const char *emsg)
 {
   struct CacheOps *co = cls;
 
   co->namecache_qe_cache = NULL;
   if (GNUNET_OK != success)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to cache GNS resolution: %s\n"),
-                emsg);
-  GNUNET_CONTAINER_DLL_remove (co_head,
-                               co_tail,
-                               co);
-  GNUNET_free (co);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("Failed to cache GNS resolution: %s\n"),
+               emsg);
+  GNUNET_CONTAINER_DLL_remove(co_head,
+                              co_tail,
+                              co);
+  GNUNET_free(co);
 }
 
 
@@ -2311,88 +2319,88 @@ namecache_cache_continuation (void *cls,
  * @param data pointer to the result data
  */
 static void
-handle_dht_response (void *cls,
-                     struct GNUNET_TIME_Absolute exp,
-                     const struct GNUNET_HashCode *key,
-                     const struct GNUNET_PeerIdentity *get_path,
-                     unsigned int get_path_length,
-                     const struct GNUNET_PeerIdentity *put_path,
-                     unsigned int put_path_length,
-                     enum GNUNET_BLOCK_Type type,
-                     size_t size,
-                     const void *data)
+handle_dht_response(void *cls,
+                    struct GNUNET_TIME_Absolute exp,
+                    const struct GNUNET_HashCode *key,
+                    const struct GNUNET_PeerIdentity *get_path,
+                    unsigned int get_path_length,
+                    const struct GNUNET_PeerIdentity *put_path,
+                    unsigned int put_path_length,
+                    enum GNUNET_BLOCK_Type type,
+                    size_t size,
+                    const void *data)
 {
   struct GNS_ResolverHandle *rh = cls;
   struct AuthorityChain *ac = rh->ac_tail;
   const struct GNUNET_GNSRECORD_Block *block;
   struct CacheOps *co;
 
-  (void) exp;
-  (void) key;
-  (void) get_path;
-  (void) get_path_length;
-  (void) put_path;
-  (void) put_path_length;
-  (void) type;
-  GNUNET_DHT_get_stop (rh->get_handle);
+  (void)exp;
+  (void)key;
+  (void)get_path;
+  (void)get_path_length;
+  (void)put_path;
+  (void)put_path_length;
+  (void)type;
+  GNUNET_DHT_get_stop(rh->get_handle);
   rh->get_handle = NULL;
-  GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
+  GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
   rh->dht_heap_node = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Handling response from the DHT\n");
-  if (size < sizeof (struct GNUNET_GNSRECORD_Block))
-  {
-    /* how did this pass DHT block validation!? */
-    GNUNET_break (0);
-    fail_resolution (rh);
-    return;
-  }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Handling response from the DHT\n");
+  if (size < sizeof(struct GNUNET_GNSRECORD_Block))
+    {
+      /* how did this pass DHT block validation!? */
+      GNUNET_break(0);
+      fail_resolution(rh);
+      return;
+    }
   block = data;
   if (size !=
-      ntohl (block->purpose.size) +
-      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
-      sizeof (struct GNUNET_CRYPTO_EcdsaSignature))
-  {
-    /* how did this pass DHT block validation!? */
-    GNUNET_break (0);
-    fail_resolution (rh);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Decrypting DHT block of size %u for `%s', expires %s\n",
-              ntohl (block->purpose.size),
-              rh->name,
-              GNUNET_STRINGS_absolute_time_to_string (exp));
+      ntohl(block->purpose.size) +
+      sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) +
+      sizeof(struct GNUNET_CRYPTO_EcdsaSignature))
+    {
+      /* how did this pass DHT block validation!? */
+      GNUNET_break(0);
+      fail_resolution(rh);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Decrypting DHT block of size %u for `%s', expires %s\n",
+             ntohl(block->purpose.size),
+             rh->name,
+             GNUNET_STRINGS_absolute_time_to_string(exp));
   if (GNUNET_OK !=
-      GNUNET_GNSRECORD_block_decrypt (block,
-                                      &ac->authority_info.gns_authority,
-                                      ac->label,
-                                      &handle_gns_resolution_result,
-                                      rh))
-  {
-    GNUNET_break_op (0); /* block was ill-formed */
-    fail_resolution (rh);
-    return;
-  }
-  if (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (block->expiration_time)).rel_value_us)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received expired block from the DHT, will not cache it.\n");
-    return;
-  }
+      GNUNET_GNSRECORD_block_decrypt(block,
+                                     &ac->authority_info.gns_authority,
+                                     ac->label,
+                                     &handle_gns_resolution_result,
+                                     rh))
+    {
+      GNUNET_break_op(0); /* block was ill-formed */
+      fail_resolution(rh);
+      return;
+    }
+  if (0 == GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_ntoh(block->expiration_time)).rel_value_us)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received expired block from the DHT, will not cache it.\n");
+      return;
+    }
   if (GNUNET_YES == disable_cache)
     return;
   /* Cache well-formed blocks */
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Caching response from the DHT in namecache\n");
-  co = GNUNET_new (struct CacheOps);
-  co->namecache_qe_cache = GNUNET_NAMECACHE_block_cache (namecache_handle,
-                                                         block,
-                                                         &namecache_cache_continuation,
-                                                         co);
-  GNUNET_CONTAINER_DLL_insert (co_head,
-                               co_tail,
-                               co);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Caching response from the DHT in namecache\n");
+  co = GNUNET_new(struct CacheOps);
+  co->namecache_qe_cache = GNUNET_NAMECACHE_block_cache(namecache_handle,
+                                                        block,
+                                                        &namecache_cache_continuation,
+                                                        co);
+  GNUNET_CONTAINER_DLL_insert(co_head,
+                              co_tail,
+                              co);
 }
 
 
@@ -2403,30 +2411,30 @@ handle_dht_response (void *cls,
  * @param query key to use in the DHT lookup
  */
 static void
-start_dht_request (struct GNS_ResolverHandle *rh,
-                   const struct GNUNET_HashCode *query)
+start_dht_request(struct GNS_ResolverHandle *rh,
+                  const struct GNUNET_HashCode *query)
 {
   struct GNS_ResolverHandle *rx;
 
-  GNUNET_assert (NULL == rh->get_handle);
-  rh->get_handle = GNUNET_DHT_get_start (dht_handle,
-                                         GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
-                                         query,
-                                         DHT_GNS_REPLICATION_LEVEL,
-                                         GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                                         NULL, 0,
-                                         &handle_dht_response, rh);
-  rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
-                                                    rh,
-                                                    GNUNET_TIME_absolute_get ().abs_value_us);
-  if (GNUNET_CONTAINER_heap_get_size (dht_lookup_heap) > max_allowed_background_queries)
-  {
-    /* fail longest-standing DHT request */
-    rx = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap);
-    rx->dht_heap_node = NULL;
-    GNUNET_assert (NULL != rx);
-    fail_resolution (rx);
-  }
+  GNUNET_assert(NULL == rh->get_handle);
+  rh->get_handle = GNUNET_DHT_get_start(dht_handle,
+                                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
+                                        query,
+                                        DHT_GNS_REPLICATION_LEVEL,
+                                        GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                        NULL, 0,
+                                        &handle_dht_response, rh);
+  rh->dht_heap_node = GNUNET_CONTAINER_heap_insert(dht_lookup_heap,
+                                                   rh,
+                                                   GNUNET_TIME_absolute_get().abs_value_us);
+  if (GNUNET_CONTAINER_heap_get_size(dht_lookup_heap) > max_allowed_background_queries)
+    {
+      /* fail longest-standing DHT request */
+      rx = GNUNET_CONTAINER_heap_remove_root(dht_lookup_heap);
+      rx->dht_heap_node = NULL;
+      GNUNET_assert(NULL != rx);
+      fail_resolution(rx);
+    }
 }
 
 
@@ -2439,19 +2447,19 @@ start_dht_request (struct GNS_ResolverHandle *rh,
  * @param rd array of records with data to store
  */
 static void
-handle_gns_namecache_resolution_result (void *cls,
-                                        unsigned int rd_count,
-                                        const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns_namecache_resolution_result(void *cls,
+                                       unsigned int rd_count,
+                                       const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNS_ResolverHandle *rh = cls;
 
   if (0 == rd_count)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("GNS namecache returned empty result for `%s'\n"),
-                rh->name);
-  handle_gns_resolution_result (rh,
-                                rd_count,
-                                rd);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("GNS namecache returned empty result for `%s'\n"),
+               rh->name);
+  handle_gns_resolution_result(rh,
+                               rd_count,
+                               rd);
 }
 
 
@@ -2462,8 +2470,8 @@ handle_gns_namecache_resolution_result (void *cls,
  * @param block block that was stored in the namecache
  */
 static void
-handle_namecache_block_response (void *cls,
-                                 const struct GNUNET_GNSRECORD_Block *block)
+handle_namecache_block_response(void *cls,
+                                const struct GNUNET_GNSRECORD_Block *block)
 {
   struct GNS_ResolverHandle *rh = cls;
   struct AuthorityChain *ac = rh->ac_tail;
@@ -2471,62 +2479,62 @@ handle_namecache_block_response (void *cls,
   const struct GNUNET_CRYPTO_EcdsaPublicKey *auth = &ac->authority_info.gns_authority;
   struct GNUNET_HashCode query;
 
-  GNUNET_assert (NULL != rh->namecache_qe);
+  GNUNET_assert(NULL != rh->namecache_qe);
   rh->namecache_qe = NULL;
-  if ( ( (GNUNET_GNS_LO_DEFAULT == rh->options) ||
-         ( (GNUNET_GNS_LO_LOCAL_MASTER == rh->options) &&
-           (ac != rh->ac_head) ) ) &&
-       ( (NULL == block) ||
-         (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (block->expiration_time)).rel_value_us) ) )
-  {
-    /* namecache knows nothing; try DHT lookup */
-    GNUNET_GNSRECORD_query_from_public_key (auth,
-                                            label,
-                                            &query);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
-                ac->label,
-                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority),
-                GNUNET_h2s (&query));
-    start_dht_request (rh, &query);
-    return;
-  }
+  if (((GNUNET_GNS_LO_DEFAULT == rh->options) ||
+       ((GNUNET_GNS_LO_LOCAL_MASTER == rh->options) &&
+        (ac != rh->ac_head))) &&
+      ((NULL == block) ||
+       (0 == GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_ntoh(block->expiration_time)).rel_value_us)))
+    {
+      /* namecache knows nothing; try DHT lookup */
+      GNUNET_GNSRECORD_query_from_public_key(auth,
+                                             label,
+                                             &query);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
+                 ac->label,
+                 GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority),
+                 GNUNET_h2s(&query));
+      start_dht_request(rh, &query);
+      return;
+    }
 
-  if ( (NULL == block) ||
-       (0 == GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (block->expiration_time)).rel_value_us) )
-  {
-    /* DHT not permitted and no local result, fail */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Resolution failed for `%s' in zone %s (DHT lookup not permitted by configuration)\n",
-                ac->label,
-                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
-    fail_resolution (rh);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received result from namecache for label `%s'\n",
-              ac->label);
+  if ((NULL == block) ||
+      (0 == GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_ntoh(block->expiration_time)).rel_value_us))
+    {
+      /* DHT not permitted and no local result, fail */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Resolution failed for `%s' in zone %s (DHT lookup not permitted by configuration)\n",
+                 ac->label,
+                 GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority));
+      fail_resolution(rh);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received result from namecache for label `%s'\n",
+             ac->label);
 
   if (GNUNET_OK !=
-      GNUNET_GNSRECORD_block_decrypt (block,
-                                      auth,
-                                      label,
-                                      &handle_gns_namecache_resolution_result,
-                                      rh))
-  {
-    GNUNET_break_op (0); /* block was ill-formed */
-    /* try DHT instead */
-    GNUNET_GNSRECORD_query_from_public_key (auth,
-                                            label,
-                                            &query);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
-                ac->label,
-                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority),
-                GNUNET_h2s (&query));
-    start_dht_request (rh, &query);
-    return;
-  }
+      GNUNET_GNSRECORD_block_decrypt(block,
+                                     auth,
+                                     label,
+                                     &handle_gns_namecache_resolution_result,
+                                     rh))
+    {
+      GNUNET_break_op(0); /* block was ill-formed */
+      /* try DHT instead */
+      GNUNET_GNSRECORD_query_from_public_key(auth,
+                                             label,
+                                             &query);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
+                 ac->label,
+                 GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority),
+                 GNUNET_h2s(&query));
+      start_dht_request(rh, &query);
+      return;
+    }
 }
 
 
@@ -2536,32 +2544,32 @@ handle_namecache_block_response (void *cls,
  * @param rh query we are processing
  */
 static void
-recursive_gns_resolution_namecache (struct GNS_ResolverHandle *rh)
+recursive_gns_resolution_namecache(struct GNS_ResolverHandle *rh)
 {
   struct AuthorityChain *ac = rh->ac_tail;
   struct GNUNET_HashCode query;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting GNS resolution for `%s' in zone %s\n",
-              ac->label,
-              GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
-  GNUNET_GNSRECORD_query_from_public_key (&ac->authority_info.gns_authority,
-                                          ac->label,
-                                          &query);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting GNS resolution for `%s' in zone %s\n",
+             ac->label,
+             GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority));
+  GNUNET_GNSRECORD_query_from_public_key(&ac->authority_info.gns_authority,
+                                         ac->label,
+                                         &query);
   if (GNUNET_YES != disable_cache)
-  {
-    rh->namecache_qe
-      = GNUNET_NAMECACHE_lookup_block (namecache_handle,
-                                       &query,
-                                       &handle_namecache_block_response,
-                                       rh);
-    GNUNET_assert (NULL != rh->namecache_qe);
-  }
+    {
+      rh->namecache_qe
+        = GNUNET_NAMECACHE_lookup_block(namecache_handle,
+                                        &query,
+                                        &handle_namecache_block_response,
+                                        rh);
+      GNUNET_assert(NULL != rh->namecache_qe);
+    }
   else
-  {
-    start_dht_request (rh,
-                       &query);
-  }
+    {
+      start_dht_request(rh,
+                        &query);
+    }
 }
 
 
@@ -2572,22 +2580,22 @@ recursive_gns_resolution_namecache (struct GNS_ResolverHandle *rh)
  * @param is_valid #GNUNET_YES if the zone was not yet revoked
  */
 static void
-handle_revocation_result (void *cls,
-                          int is_valid)
+handle_revocation_result(void *cls,
+                         int is_valid)
 {
   struct GNS_ResolverHandle *rh = cls;
   struct AuthorityChain *ac = rh->ac_tail;
 
   rh->rev_check = NULL;
   if (GNUNET_YES != is_valid)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Zone %s was revoked, resolution fails\n"),
-                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
-    fail_resolution (rh);
-    return;
-  }
-  recursive_gns_resolution_namecache (rh);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Zone %s was revoked, resolution fails\n"),
+                 GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority));
+      fail_resolution(rh);
+      return;
+    }
+  recursive_gns_resolution_namecache(rh);
 }
 
 
@@ -2597,18 +2605,18 @@ handle_revocation_result (void *cls,
  * @param rh query we are processing
  */
 static void
-recursive_gns_resolution_revocation (struct GNS_ResolverHandle *rh)
+recursive_gns_resolution_revocation(struct GNS_ResolverHandle *rh)
 {
   struct AuthorityChain *ac = rh->ac_tail;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting revocation check for zone %s\n",
-              GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
-  rh->rev_check = GNUNET_REVOCATION_query (cfg,
-                                           &ac->authority_info.gns_authority,
-                                           &handle_revocation_result,
-                                           rh);
-  GNUNET_assert (NULL != rh->rev_check);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting revocation check for zone %s\n",
+             GNUNET_GNSRECORD_z2s(&ac->authority_info.gns_authority));
+  rh->rev_check = GNUNET_REVOCATION_query(cfg,
+                                          &ac->authority_info.gns_authority,
+                                          &handle_revocation_result,
+                                          rh);
+  GNUNET_assert(NULL != rh->rev_check);
 }
 
 
@@ -2618,23 +2626,23 @@ recursive_gns_resolution_revocation (struct GNS_ResolverHandle *rh)
  * @param cls the `struct GNS_ResolverHandle` of the resolution
  */
 static void
-recursive_resolution (void *cls)
+recursive_resolution(void *cls)
 {
   struct GNS_ResolverHandle *rh = cls;
 
   rh->task_id = NULL;
   if (MAX_RECURSION < rh->loop_limiter++)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Encountered unbounded recursion resolving `%s'\n",
-                rh->name);
-    fail_resolution (rh);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Encountered unbounded recursion resolving `%s'\n",
+                 rh->name);
+      fail_resolution(rh);
+      return;
+    }
   if (GNUNET_YES == rh->ac_tail->gns_authority)
-    recursive_gns_resolution_revocation (rh);
+    recursive_gns_resolution_revocation(rh);
   else
-    recursive_dns_resolution (rh);
+    recursive_dns_resolution(rh);
 }
 
 
@@ -2645,7 +2653,7 @@ recursive_resolution (void *cls)
  * @param cls the `struct GNS_ResolverHandle`
  */
 static void
-start_resolver_lookup (void *cls)
+start_resolver_lookup(void *cls)
 {
   struct GNS_ResolverHandle *rh = cls;
   struct AuthorityChain *ac;
@@ -2653,61 +2661,61 @@ start_resolver_lookup (void *cls)
   struct in6_addr v6;
 
   rh->task_id = NULL;
-  if (1 == inet_pton (AF_INET,
-                      rh->name,
-                      &v4))
-  {
-    /* name is IPv4 address, pretend it's an A record */
-    struct GNUNET_GNSRECORD_Data rd;
-
-    rd.data = &v4;
-    rd.data_size = sizeof (v4);
-    rd.expiration_time = UINT64_MAX;
-    rd.record_type = GNUNET_DNSPARSER_TYPE_A;
-    rd.flags = 0;
-    rh->proc (rh->proc_cls,
-              1,
-              &rd);
-    GNUNET_assert (NULL == rh->task_id);
-    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                            rh);
-    return;
-  }
-  if (1 == inet_pton (AF_INET6,
-                      rh->name,
-                      &v6))
-  {
-    /* name is IPv6 address, pretend it's an AAAA record */
-    struct GNUNET_GNSRECORD_Data rd;
-
-    rd.data = &v6;
-    rd.data_size = sizeof (v6);
-    rd.expiration_time = UINT64_MAX;
-    rd.record_type = GNUNET_DNSPARSER_TYPE_AAAA;
-    rd.flags = 0;
-    rh->proc (rh->proc_cls,
-              1,
-              &rd);
-    GNUNET_assert (NULL == rh->task_id);
-    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                            rh);
-    return;
-  }
+  if (1 == inet_pton(AF_INET,
+                     rh->name,
+                     &v4))
+    {
+      /* name is IPv4 address, pretend it's an A record */
+      struct GNUNET_GNSRECORD_Data rd;
+
+      rd.data = &v4;
+      rd.data_size = sizeof(v4);
+      rd.expiration_time = UINT64_MAX;
+      rd.record_type = GNUNET_DNSPARSER_TYPE_A;
+      rd.flags = 0;
+      rh->proc(rh->proc_cls,
+               1,
+               &rd);
+      GNUNET_assert(NULL == rh->task_id);
+      rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                             rh);
+      return;
+    }
+  if (1 == inet_pton(AF_INET6,
+                     rh->name,
+                     &v6))
+    {
+      /* name is IPv6 address, pretend it's an AAAA record */
+      struct GNUNET_GNSRECORD_Data rd;
+
+      rd.data = &v6;
+      rd.data_size = sizeof(v6);
+      rd.expiration_time = UINT64_MAX;
+      rd.record_type = GNUNET_DNSPARSER_TYPE_AAAA;
+      rd.flags = 0;
+      rh->proc(rh->proc_cls,
+               1,
+               &rd);
+      GNUNET_assert(NULL == rh->task_id);
+      rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                             rh);
+      return;
+    }
 
-  ac = GNUNET_new (struct AuthorityChain);
+  ac = GNUNET_new(struct AuthorityChain);
   ac->rh = rh;
-  ac->label = resolver_lookup_get_next_label (rh);
+  ac->label = resolver_lookup_get_next_label(rh);
   if (NULL == ac->label)
     /* name was just the "TLD", so we default to label
-       #GNUNET_GNS_EMPTY_LABEL_AT */
-    ac->label = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
+     #GNUNET_GNS_EMPTY_LABEL_AT */
+    ac->label = GNUNET_strdup(GNUNET_GNS_EMPTY_LABEL_AT);
   ac->gns_authority = GNUNET_YES;
   ac->authority_info.gns_authority = rh->authority_zone;
-  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
-                                    rh->ac_tail,
-                                    ac);
-  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
-                                          rh);
+  GNUNET_CONTAINER_DLL_insert_tail(rh->ac_head,
+                                   rh->ac_tail,
+                                   ac);
+  rh->task_id = GNUNET_SCHEDULER_add_now(&recursive_resolution,
+                                         rh);
 }
 
 
@@ -2724,31 +2732,31 @@ start_resolver_lookup (void *cls)
  * @return handle to cancel operation
  */
 struct GNS_ResolverHandle *
-GNS_resolver_lookup (const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
-                     uint32_t record_type,
-                     const char *name,
-                     enum GNUNET_GNS_LocalOptions options,
-                     GNS_ResultProcessor proc,
-                     void *proc_cls)
+GNS_resolver_lookup(const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
+                    uint32_t record_type,
+                    const char *name,
+                    enum GNUNET_GNS_LocalOptions options,
+                    GNS_ResultProcessor proc,
+                    void *proc_cls)
 {
   struct GNS_ResolverHandle *rh;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting lookup for `%s'\n",
-              name);
-  rh = GNUNET_new (struct GNS_ResolverHandle);
-  GNUNET_CONTAINER_DLL_insert (rlh_head,
-                               rlh_tail,
-                               rh);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting lookup for `%s'\n",
+             name);
+  rh = GNUNET_new(struct GNS_ResolverHandle);
+  GNUNET_CONTAINER_DLL_insert(rlh_head,
+                              rlh_tail,
+                              rh);
   rh->authority_zone = *zone;
   rh->proc = proc;
   rh->proc_cls = proc_cls;
   rh->options = options;
   rh->record_type = record_type;
-  rh->name = GNUNET_strdup (name);
-  rh->name_resolution_pos = strlen (name);
-  rh->task_id = GNUNET_SCHEDULER_add_now (&start_resolver_lookup,
-                                          rh);
+  rh->name = GNUNET_strdup(name);
+  rh->name_resolution_pos = strlen(name);
+  rh->task_id = GNUNET_SCHEDULER_add_now(&start_resolver_lookup,
+                                         rh);
   return rh;
 }
 
@@ -2759,107 +2767,107 @@ GNS_resolver_lookup (const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
  * @param rh resolution to abort
  */
 void
-GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh)
+GNS_resolver_lookup_cancel(struct GNS_ResolverHandle *rh)
 {
   struct DnsResult *dr;
   struct AuthorityChain *ac;
   struct VpnContext *vpn_ctx;
 
-  GNUNET_CONTAINER_DLL_remove (rlh_head,
-                               rlh_tail,
-                               rh);
+  GNUNET_CONTAINER_DLL_remove(rlh_head,
+                              rlh_tail,
+                              rh);
   if (NULL != rh->dns_request)
-  {
-    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
-    rh->dns_request = NULL;
-  }
+    {
+      GNUNET_DNSSTUB_resolve_cancel(rh->dns_request);
+      rh->dns_request = NULL;
+    }
   while (NULL != (ac = rh->ac_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rh->ac_head,
-                                 rh->ac_tail,
-                                 ac);
-    if (GNUNET_NO == ac->gns_authority)
     {
-      struct Gns2DnsPending *gp;
-
-      while (NULL != (gp = ac->authority_info.dns_authority.gp_head))
-      {
-        GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
-                                     ac->authority_info.dns_authority.gp_tail,
-                                     gp);
-        if (NULL != gp->rh)
-        {
-          /* rh->g2dc->rh is NOT in the DLL yet, so to enable us
-             using GNS_resolver_lookup_cancel here, we need to
-             add it first... */
-          GNUNET_CONTAINER_DLL_insert (rlh_head,
-                                       rlh_tail,
-                                       gp->rh);
-          GNUNET_assert (NULL == gp->rh->task_id);
-          gp->rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
-                                                      gp->rh);
-          gp->rh = NULL;
-        }
-        if (NULL != gp->dns_rh)
+      GNUNET_CONTAINER_DLL_remove(rh->ac_head,
+                                  rh->ac_tail,
+                                  ac);
+      if (GNUNET_NO == ac->gns_authority)
         {
-          GNUNET_RESOLVER_request_cancel (gp->dns_rh);
-          gp->dns_rh = NULL;
+          struct Gns2DnsPending *gp;
+
+          while (NULL != (gp = ac->authority_info.dns_authority.gp_head))
+            {
+              GNUNET_CONTAINER_DLL_remove(ac->authority_info.dns_authority.gp_head,
+                                          ac->authority_info.dns_authority.gp_tail,
+                                          gp);
+              if (NULL != gp->rh)
+                {
+                  /* rh->g2dc->rh is NOT in the DLL yet, so to enable us
+                     using GNS_resolver_lookup_cancel here, we need to
+                     add it first... */
+                  GNUNET_CONTAINER_DLL_insert(rlh_head,
+                                              rlh_tail,
+                                              gp->rh);
+                  GNUNET_assert(NULL == gp->rh->task_id);
+                  gp->rh->task_id = GNUNET_SCHEDULER_add_now(&GNS_resolver_lookup_cancel_,
+                                                             gp->rh);
+                  gp->rh = NULL;
+                }
+              if (NULL != gp->dns_rh)
+                {
+                  GNUNET_RESOLVER_request_cancel(gp->dns_rh);
+                  gp->dns_rh = NULL;
+                }
+              GNUNET_free(gp);
+            }
+          GNUNET_DNSSTUB_stop(ac->authority_info.dns_authority.dns_handle);
         }
-        GNUNET_free (gp);
-      }
-      GNUNET_DNSSTUB_stop (ac->authority_info.dns_authority.dns_handle);
+      GNUNET_free(ac->label);
+      GNUNET_free(ac);
     }
-    GNUNET_free (ac->label);
-    GNUNET_free (ac);
-  }
   if (NULL != rh->task_id)
-  {
-    GNUNET_SCHEDULER_cancel (rh->task_id);
-    rh->task_id = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rh->task_id);
+      rh->task_id = NULL;
+    }
   if (NULL != rh->get_handle)
-  {
-    GNUNET_DHT_get_stop (rh->get_handle);
-    rh->get_handle = NULL;
-  }
+    {
+      GNUNET_DHT_get_stop(rh->get_handle);
+      rh->get_handle = NULL;
+    }
   if (NULL != rh->dht_heap_node)
-  {
-    GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
-    rh->dht_heap_node = NULL;
-  }
+    {
+      GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
+      rh->dht_heap_node = NULL;
+    }
   if (NULL != (vpn_ctx = rh->vpn_ctx))
-  {
-    GNUNET_VPN_cancel_request (vpn_ctx->vpn_request);
-    GNUNET_free (vpn_ctx->rd_data);
-    GNUNET_free (vpn_ctx);
-  }
+    {
+      GNUNET_VPN_cancel_request(vpn_ctx->vpn_request);
+      GNUNET_free(vpn_ctx->rd_data);
+      GNUNET_free(vpn_ctx);
+    }
   if (NULL != rh->namecache_qe)
-  {
-    GNUNET_NAMECACHE_cancel (rh->namecache_qe);
-    rh->namecache_qe = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_cancel(rh->namecache_qe);
+      rh->namecache_qe = NULL;
+    }
   if (NULL != rh->rev_check)
-  {
-    GNUNET_REVOCATION_query_cancel (rh->rev_check);
-    rh->rev_check = NULL;
-  }
+    {
+      GNUNET_REVOCATION_query_cancel(rh->rev_check);
+      rh->rev_check = NULL;
+    }
   if (NULL != rh->std_resolve)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Canceling standard DNS resolution\n");
-    GNUNET_RESOLVER_request_cancel (rh->std_resolve);
-    rh->std_resolve = NULL;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Canceling standard DNS resolution\n");
+      GNUNET_RESOLVER_request_cancel(rh->std_resolve);
+      rh->std_resolve = NULL;
+    }
   while (NULL != (dr = rh->dns_result_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rh->dns_result_head,
-                                 rh->dns_result_tail,
-                                 dr);
-    GNUNET_free (dr);
-  }
-  GNUNET_free_non_null (rh->leho);
-  GNUNET_free (rh->name);
-  GNUNET_free (rh);
+    {
+      GNUNET_CONTAINER_DLL_remove(rh->dns_result_head,
+                                  rh->dns_result_tail,
+                                  dr);
+      GNUNET_free(dr);
+    }
+  GNUNET_free_non_null(rh->leho);
+  GNUNET_free(rh->name);
+  GNUNET_free(rh);
 }
 
 
@@ -2875,24 +2883,24 @@ GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh)
  * @param max_bg_queries maximum number of parallel background queries in dht
  */
 void
-GNS_resolver_init (struct GNUNET_NAMECACHE_Handle *nc,
-                   struct GNUNET_DHT_Handle *dht,
-                   const struct GNUNET_CONFIGURATION_Handle *c,
-                   unsigned long long max_bg_queries)
+GNS_resolver_init(struct GNUNET_NAMECACHE_Handle *nc,
+                  struct GNUNET_DHT_Handle *dht,
+                  const struct GNUNET_CONFIGURATION_Handle *c,
+                  unsigned long long max_bg_queries)
 {
   cfg = c;
   namecache_handle = nc;
   dht_handle = dht;
   dht_lookup_heap =
-    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+    GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
   max_allowed_background_queries = max_bg_queries;
-  disable_cache = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                        "namecache",
-                                                        "DISABLE");
+  disable_cache = GNUNET_CONFIGURATION_get_value_yesno(cfg,
+                                                       "namecache",
+                                                       "DISABLE");
   if (GNUNET_YES == disable_cache)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Namecache disabled\n");
-  vpn_handle = GNUNET_VPN_connect (cfg);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               "Namecache disabled\n");
+  vpn_handle = GNUNET_VPN_connect(cfg);
 }
 
 
@@ -2900,30 +2908,30 @@ GNS_resolver_init (struct GNUNET_NAMECACHE_Handle *nc,
  * Shutdown resolver
  */
 void
-GNS_resolver_done ()
+GNS_resolver_done()
 {
   struct GNS_ResolverHandle *rh;
   struct CacheOps *co;
 
   /* abort active resolutions */
   while (NULL != (rh = rlh_head))
-  {
-    rh->proc (rh->proc_cls,
-              0,
-              NULL);
-    GNS_resolver_lookup_cancel (rh);
-  }
+    {
+      rh->proc(rh->proc_cls,
+               0,
+               NULL);
+      GNS_resolver_lookup_cancel(rh);
+    }
   while (NULL != (co = co_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (co_head,
-                                 co_tail,
-                                 co);
-    GNUNET_NAMECACHE_cancel (co->namecache_qe_cache);
-    GNUNET_free (co);
-  }
-  GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
+    {
+      GNUNET_CONTAINER_DLL_remove(co_head,
+                                  co_tail,
+                                  co);
+      GNUNET_NAMECACHE_cancel(co->namecache_qe_cache);
+      GNUNET_free(co);
+    }
+  GNUNET_CONTAINER_heap_destroy(dht_lookup_heap);
   dht_lookup_heap = NULL;
-  GNUNET_VPN_disconnect (vpn_handle);
+  GNUNET_VPN_disconnect(vpn_handle);
   vpn_handle = NULL;
   dht_handle = NULL;
   namecache_handle = NULL;
diff --git a/src/gns/gnunet-service-gns_resolver.h b/src/gns/gnunet-service-gns_resolver.h
index 240747931..8865f3c95 100644
--- a/src/gns/gnunet-service-gns_resolver.h
+++ b/src/gns/gnunet-service-gns_resolver.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/gnunet-service-gns_resolver.h
  * @brief GNUnet GNS service
@@ -39,17 +39,17 @@
  * @param max_bg_queries maximum amount of background queries
  */
 void
-GNS_resolver_init (struct GNUNET_NAMECACHE_Handle *nc,
-                   struct GNUNET_DHT_Handle *dht,
-                   const struct GNUNET_CONFIGURATION_Handle *c,
-                   unsigned long long max_bg_queries);
+GNS_resolver_init(struct GNUNET_NAMECACHE_Handle *nc,
+                  struct GNUNET_DHT_Handle *dht,
+                  const struct GNUNET_CONFIGURATION_Handle *c,
+                  unsigned long long max_bg_queries);
 
 
 /**
  * Cleanup resolver: Terminate pending lookups
  */
 void
-GNS_resolver_done (void);
+GNS_resolver_done(void);
 
 
 /**
@@ -84,12 +84,12 @@ typedef void
  * @return handle to cancel operation
  */
 struct GNS_ResolverHandle *
-GNS_resolver_lookup (const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
-                     uint32_t record_type,
-                     const char *name,
-                     enum GNUNET_GNS_LocalOptions options,
-                     GNS_ResultProcessor proc,
-                     void *proc_cls);
+GNS_resolver_lookup(const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
+                    uint32_t record_type,
+                    const char *name,
+                    enum GNUNET_GNS_LocalOptions options,
+                    GNS_ResultProcessor proc,
+                    void *proc_cls);
 
 
 /**
@@ -98,6 +98,6 @@ GNS_resolver_lookup (const struct GNUNET_CRYPTO_EcdsaPublicKey *zone,
  * @param rh resolution to abort
  */
 void
-GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh);
+GNS_resolver_lookup_cancel(struct GNS_ResolverHandle *rh);
 
 #endif
diff --git a/src/gns/gnunet_w32nsp_lib.h b/src/gns/gnunet_w32nsp_lib.h
index 1c17efefe..0316245ff 100644
--- a/src/gns/gnunet_w32nsp_lib.h
+++ b/src/gns/gnunet_w32nsp_lib.h
@@ -4,6 +4,6 @@
 #include <basetyps.h>
 
 /* E0D24085-622C-4A93-9A0018-034469DE28DA */
-DEFINE_GUID (GNUNET_NAMESPACE_PROVIDER_DNS, 0xE0D24085L, 0x622C, 0x4A93, 0x9A, 0x18, 0x03, 0x44, 0x69, 0xDE, 0x28, 0xDA);
+DEFINE_GUID(GNUNET_NAMESPACE_PROVIDER_DNS, 0xE0D24085L, 0x622C, 0x4A93, 0x9A, 0x18, 0x03, 0x44, 0x69, 0xDE, 0x28, 0xDA);
 
 #endif /* GNUNET_W32NSP_LIB_H */
diff --git a/src/gns/nss/nss_gns.c b/src/gns/nss/nss_gns.c
index d76eac845..43fc030b9 100644
--- a/src/gns/nss/nss_gns.c
+++ b/src/gns/nss/nss_gns.c
@@ -17,7 +17,7 @@
     along with nss-mdns; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
     USA.
-***/
+ ***/
 
 #include <gnunet_config.h>
 #include <unistd.h>
@@ -37,9 +37,9 @@
 
 /** macro to align idx to 32bit boundary */
 #define ALIGN(idx) do { \
-  if (idx % sizeof(void*)) \
-    idx += (sizeof(void*) - idx % sizeof(void*)); /* Align on 32 bit boundary */ \
-} while(0)
+      if (idx % sizeof(void*)) \
+      idx += (sizeof(void*) - idx % sizeof(void*)); /* Align on 32 bit boundary */ \
+  } while (0)
 
 
 /**
@@ -75,7 +75,7 @@ _nss_gns_gethostbyname2_r(const char *name,
 #ifdef NSS_IPV6_ONLY
     af = AF_INET6;
 #else
-  af = AF_INET;
+    af = AF_INET;
 #endif
 
 #ifdef NSS_IPV4_ONLY
@@ -83,70 +83,70 @@ _nss_gns_gethostbyname2_r(const char *name,
 #elif NSS_IPV6_ONLY
   if (af != AF_INET6)
 #else
-  if ( (af != AF_INET) &&
-       (af != AF_INET6) )
+  if ((af != AF_INET) &&
+      (af != AF_INET6))
 #endif
-  {
-    *errnop = EINVAL;
-    *h_errnop = NO_RECOVERY;
+    {
+      *errnop = EINVAL;
+      *h_errnop = NO_RECOVERY;
 
-    goto finish;
-  }
+      goto finish;
+    }
 
   address_length = (af == AF_INET) ? sizeof(ipv4_address_t) : sizeof(ipv6_address_t);
   if (buflen <
       sizeof(char*) +     /* alias names */
-      strlen (name) + 1)
-  {   /* official name */
-    *errnop = ERANGE;
-    *h_errnop = NO_RECOVERY;
-    status = NSS_STATUS_TRYAGAIN;
-
-    goto finish;
-  }
+      strlen(name) + 1)
+    { /* official name */
+      *errnop = ERANGE;
+      *h_errnop = NO_RECOVERY;
+      status = NSS_STATUS_TRYAGAIN;
+
+      goto finish;
+    }
   u.count = 0;
   u.data_len = 0;
-  i = gns_resolve_name (af,
-                        name,
-                        &u);
+  i = gns_resolve_name(af,
+                       name,
+                       &u);
   if (-1 == i)
-  {
-    *errnop = errno;
-    status = NSS_STATUS_UNAVAIL;
-    *h_errnop = NO_RECOVERY;
-    goto finish;
-  }
+    {
+      *errnop = errno;
+      status = NSS_STATUS_UNAVAIL;
+      *h_errnop = NO_RECOVERY;
+      goto finish;
+    }
   if (-2 == i)
-  {
-    *errnop = ENOENT;
-    *h_errnop = NO_RECOVERY;
-    status = NSS_STATUS_UNAVAIL;
-    goto finish;
-  }
+    {
+      *errnop = ENOENT;
+      *h_errnop = NO_RECOVERY;
+      status = NSS_STATUS_UNAVAIL;
+      goto finish;
+    }
   if (-3 == i)
-  {
-    *errnop = ETIMEDOUT;
-    *h_errnop = HOST_NOT_FOUND;
-    status = NSS_STATUS_NOTFOUND;
-    goto finish;
-  }
-  if (0 == u.count) 
-  {
-    *errnop = 0; /* success */ 
-    *h_errnop = NO_DATA; /* success */
-    status = NSS_STATUS_NOTFOUND;
-    goto finish;
-  }
+    {
+      *errnop = ETIMEDOUT;
+      *h_errnop = HOST_NOT_FOUND;
+      status = NSS_STATUS_NOTFOUND;
+      goto finish;
+    }
+  if (0 == u.count)
+    {
+      *errnop = 0; /* success */
+      *h_errnop = NO_DATA; /* success */
+      status = NSS_STATUS_NOTFOUND;
+      goto finish;
+    }
   /* Alias names */
-  *((char**) buffer) = NULL;
-  result->h_aliases = (char**) buffer;
+  *((char**)buffer) = NULL;
+  result->h_aliases = (char**)buffer;
   idx = sizeof(char*);
 
   /* Official name */
-  strcpy (buffer+idx,
-          name);
-  result->h_name = buffer+idx;
-  idx += strlen (name)+1;
+  strcpy(buffer + idx,
+         name);
+  result->h_name = buffer + idx;
+  idx += strlen(name) + 1;
 
   ALIGN(idx);
 
@@ -154,29 +154,29 @@ _nss_gns_gethostbyname2_r(const char *name,
   result->h_length = address_length;
 
   /* Check if there's enough space for the addresses */
-  if (buflen < idx+u.data_len+sizeof(char*)*(u.count+1))
-  {
-    *errnop = ERANGE;
-    *h_errnop = NO_RECOVERY;
-    status = NSS_STATUS_TRYAGAIN;
-    goto finish;
-  }
-    /* Addresses */
+  if (buflen < idx + u.data_len + sizeof(char*) * (u.count + 1))
+    {
+      *errnop = ERANGE;
+      *h_errnop = NO_RECOVERY;
+      status = NSS_STATUS_TRYAGAIN;
+      goto finish;
+    }
+  /* Addresses */
   astart = idx;
-  l = u.count*address_length;
+  l = u.count * address_length;
   if (0 != l)
-    memcpy (buffer+astart,
-            &u.data,
-            l);
+    memcpy(buffer + astart,
+           &u.data,
+           l);
   /* address_length is a multiple of 32bits, so idx is still aligned
    * correctly */
   idx += l;
 
   /* Address array address_length is always a multiple of 32bits */
   for (i = 0; i < u.count; i++)
-    ((char**) (buffer+idx))[i] = buffer+astart+address_length*i;
-  ((char**) (buffer+idx))[i] = NULL;
-  result->h_addr_list = (char**) (buffer+idx);
+    ((char**)(buffer + idx))[i] = buffer + astart + address_length * i;
+  ((char**)(buffer + idx))[i] = NULL;
+  result->h_addr_list = (char**)(buffer + idx);
 
   status = NSS_STATUS_SUCCESS;
 
@@ -197,20 +197,20 @@ finish:
  * @return a nss_status code
  */
 enum nss_status
-_nss_gns_gethostbyname_r (const char *name,
-                          struct hostent *result,
-                          char *buffer,
-                          size_t buflen,
-                          int *errnop,
-                          int *h_errnop)
+_nss_gns_gethostbyname_r(const char *name,
+                         struct hostent *result,
+                         char *buffer,
+                         size_t buflen,
+                         int *errnop,
+                         int *h_errnop)
 {
-  return _nss_gns_gethostbyname2_r (name,
-                                    AF_UNSPEC,
-                                    result,
-                                    buffer,
-                                    buflen,
-                                    errnop,
-                                    h_errnop);
+  return _nss_gns_gethostbyname2_r(name,
+                                   AF_UNSPEC,
+                                   result,
+                                   buffer,
+                                   buflen,
+                                   errnop,
+                                   h_errnop);
 }
 
 
@@ -229,21 +229,21 @@ _nss_gns_gethostbyname_r (const char *name,
  * @return NSS_STATUS_UNAVAIL
  */
 enum nss_status
-_nss_gns_gethostbyaddr_r (const void* addr,
-                          int len,
-                          int af,
-                          struct hostent *result,
-                          char *buffer,
-                          size_t buflen,
-                          int *errnop,
-                          int *h_errnop)
+_nss_gns_gethostbyaddr_r(const void* addr,
+                         int len,
+                         int af,
+                         struct hostent *result,
+                         char *buffer,
+                         size_t buflen,
+                         int *errnop,
+                         int *h_errnop)
 {
-  (void) addr;
-  (void) len;
-  (void) af;
-  (void) result;
-  (void) buffer;
-  (void) buflen;
+  (void)addr;
+  (void)len;
+  (void)af;
+  (void)result;
+  (void)buffer;
+  (void)buflen;
   *errnop = EINVAL;
   *h_errnop = NO_RECOVERY;
   /* NOTE we allow to leak this into DNS so no NOTFOUND */
diff --git a/src/gns/nss/nss_gns_query.c b/src/gns/nss/nss_gns_query.c
index 253bb0f02..8af618618 100644
--- a/src/gns/nss/nss_gns_query.c
+++ b/src/gns/nss/nss_gns_query.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -33,12 +33,12 @@
 #define TIMEOUT "5s"
 
 static void
-kwait (pid_t chld)
+kwait(pid_t chld)
 {
   int ret;
 
-  kill (chld, SIGKILL);
-  waitpid (chld, &ret, 0);
+  kill(chld, SIGKILL);
+  waitpid(chld, &ret, 0);
 }
 
 
@@ -55,7 +55,7 @@ kwait (pid_t chld)
  *          else 0
  */
 int
-gns_resolve_name (int af, const char *name, struct userdata *u)
+gns_resolve_name(int af, const char *name, struct userdata *u)
 {
   FILE *p;
   char line[128];
@@ -63,85 +63,85 @@ gns_resolve_name (int af, const char *name, struct userdata *u)
   int out[2];
   pid_t pid;
 
-  if (0 != pipe (out))
+  if (0 != pipe(out))
     return -1;
-  pid = fork ();
+  pid = fork();
   if (-1 == pid)
     return -1;
   if (0 == pid)
-  {
-    char *argv[] = {"gnunet-gns",
-                    "-r",
-                    "-t",
-                    (AF_INET6 == af) ? "AAAA" : "A",
-                    "-u",
-                    (char *) name,
-                    "-T",
-                    TIMEOUT,
-                    NULL};
+    {
+      char *argv[] = { "gnunet-gns",
+                       "-r",
+                       "-t",
+                       (AF_INET6 == af) ? "AAAA" : "A",
+                       "-u",
+                       (char *)name,
+                       "-T",
+                       TIMEOUT,
+                       NULL };
 
-    (void) close (STDOUT_FILENO);
-    if ((0 != close (out[0])) ||
-        (STDOUT_FILENO != dup2 (out[1], STDOUT_FILENO)))
-      _exit (1);
-    (void) execvp ("gnunet-gns", argv);
-    _exit (1);
-  }
-  (void) close (out[1]);
-  p = fdopen (out[0], "r");
+      (void)close(STDOUT_FILENO);
+      if ((0 != close(out[0])) ||
+          (STDOUT_FILENO != dup2(out[1], STDOUT_FILENO)))
+        _exit(1);
+      (void)execvp("gnunet-gns", argv);
+      _exit(1);
+    }
+  (void)close(out[1]);
+  p = fdopen(out[0], "r");
   if (NULL == p)
-  {
-    kwait (pid);
-    return -1;
-  }
-  while (NULL != fgets (line, sizeof (line), p))
-  {
-    if (u->count >= MAX_ENTRIES)
-      break;
-    if (line[strlen (line) - 1] == '\n')
     {
-      line[strlen (line) - 1] = '\0';
-      if (AF_INET == af)
-      {
-        if (inet_pton (af, line, &u->data.ipv4[u->count]))
-        {
-          u->count++;
-          u->data_len += sizeof (ipv4_address_t);
-        }
-        else
-        {
-          (void) fclose (p);
-          kwait (pid);
-          errno = EINVAL;
-          return -1;
-        }
-      }
-      else if (AF_INET6 == af)
-      {
-        if (inet_pton (af, line, &u->data.ipv6[u->count]))
-        {
-          u->count++;
-          u->data_len += sizeof (ipv6_address_t);
-        }
-        else
+      kwait(pid);
+      return -1;
+    }
+  while (NULL != fgets(line, sizeof(line), p))
+    {
+      if (u->count >= MAX_ENTRIES)
+        break;
+      if (line[strlen(line) - 1] == '\n')
         {
-          (void) fclose (p);
-          kwait (pid);
-          errno = EINVAL;
-          return -1;
+          line[strlen(line) - 1] = '\0';
+          if (AF_INET == af)
+            {
+              if (inet_pton(af, line, &u->data.ipv4[u->count]))
+                {
+                  u->count++;
+                  u->data_len += sizeof(ipv4_address_t);
+                }
+              else
+                {
+                  (void)fclose(p);
+                  kwait(pid);
+                  errno = EINVAL;
+                  return -1;
+                }
+            }
+          else if (AF_INET6 == af)
+            {
+              if (inet_pton(af, line, &u->data.ipv6[u->count]))
+                {
+                  u->count++;
+                  u->data_len += sizeof(ipv6_address_t);
+                }
+              else
+                {
+                  (void)fclose(p);
+                  kwait(pid);
+                  errno = EINVAL;
+                  return -1;
+                }
+            }
         }
-      }
     }
-  }
-  (void) fclose (p);
-  waitpid (pid, &ret, 0);
-  if (! WIFEXITED (ret))
+  (void)fclose(p);
+  waitpid(pid, &ret, 0);
+  if (!WIFEXITED(ret))
     return -1;
-  if (4 == WEXITSTATUS (ret))
+  if (4 == WEXITSTATUS(ret))
     return -2; /* not for GNS */
   if (3 == ret)
     return -3; /* timeout -> not found */
-  if ((2 == WEXITSTATUS (ret)) || (1 == WEXITSTATUS (ret)))
+  if ((2 == WEXITSTATUS(ret)) || (1 == WEXITSTATUS(ret)))
     return -2; /* launch failure -> service unavailable */
   return 0;
 }
diff --git a/src/gns/nss/nss_gns_query.h b/src/gns/nss/nss_gns_query.h
index 30ba76fd9..1901dd6c4 100644
--- a/src/gns/nss/nss_gns_query.h
+++ b/src/gns/nss/nss_gns_query.h
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 #ifndef NSS_GNS_QUERY_H
 #define NSS_GNS_QUERY_H
 
@@ -28,20 +28,17 @@
 /* Maximum number of entries to return */
 #define MAX_ENTRIES 16
 
-typedef struct
-{
+typedef struct {
   uint32_t address;
 } ipv4_address_t;
 
 
-typedef struct
-{
+typedef struct {
   uint8_t address[16];
 } ipv6_address_t;
 
 
-struct userdata
-{
+struct userdata {
   int count;
   int data_len; /* only valid when doing reverse lookup */
   union  {
diff --git a/src/gns/plugin_block_gns.c b/src/gns/plugin_block_gns.c
index 86d45b9fe..71cd78a8e 100644
--- a/src/gns/plugin_block_gns.c
+++ b/src/gns/plugin_block_gns.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file gns/plugin_block_gns.c
@@ -56,37 +56,37 @@
  *         by this @a type of block (this is not an error)
  */
 static struct GNUNET_BLOCK_Group *
-block_plugin_gns_create_group (void *cls,
-                               enum GNUNET_BLOCK_Type type,
-                               uint32_t nonce,
-                               const void *raw_data,
-                               size_t raw_data_size,
-                               va_list va)
+block_plugin_gns_create_group(void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              uint32_t nonce,
+                              const void *raw_data,
+                              size_t raw_data_size,
+                              va_list va)
 {
   unsigned int bf_size;
   const char *guard;
 
-  guard = va_arg (va, const char *);
-  if (0 == strcmp (guard,
-                   "seen-set-size"))
-    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned int),
-                                                           BLOOMFILTER_K);
-  else if (0 == strcmp (guard,
-                        "filter-size"))
-    bf_size = va_arg (va, unsigned int);
+  guard = va_arg(va, const char *);
+  if (0 == strcmp(guard,
+                  "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int),
+                                                          BLOOMFILTER_K);
+  else if (0 == strcmp(guard,
+                       "filter-size"))
+    bf_size = va_arg(va, unsigned int);
   else
-  {
-    GNUNET_break (0);
-    bf_size = GNS_BF_SIZE;
-  }
-  GNUNET_break (NULL == va_arg (va, const char *));
-  return GNUNET_BLOCK_GROUP_bf_create (cls,
-                                       bf_size,
-                                       BLOOMFILTER_K,
-                                       type,
-                                       nonce,
-                                       raw_data,
-                                       raw_data_size);
+    {
+      GNUNET_break(0);
+      bf_size = GNS_BF_SIZE;
+    }
+  GNUNET_break(NULL == va_arg(va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create(cls,
+                                      bf_size,
+                                      BLOOMFILTER_K,
+                                      type,
+                                      nonce,
+                                      raw_data,
+                                      raw_data_size);
 }
 
 
@@ -110,16 +110,16 @@ block_plugin_gns_create_group (void *cls,
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_gns_evaluate (void *cls,
-                           struct GNUNET_BLOCK_Context *ctx,
-                           enum GNUNET_BLOCK_Type type,
-                           struct GNUNET_BLOCK_Group *bg,
-                           enum GNUNET_BLOCK_EvaluationOptions eo,
-                           const struct GNUNET_HashCode *query,
-                           const void *xquery,
-                           size_t xquery_size,
-                           const void *reply_block,
-                           size_t reply_block_size)
+block_plugin_gns_evaluate(void *cls,
+                          struct GNUNET_BLOCK_Context *ctx,
+                          enum GNUNET_BLOCK_Type type,
+                          struct GNUNET_BLOCK_Group *bg,
+                          enum GNUNET_BLOCK_EvaluationOptions eo,
+                          const struct GNUNET_HashCode *query,
+                          const void *xquery,
+                          size_t xquery_size,
+                          const void *reply_block,
+                          size_t reply_block_size)
 {
   const struct GNUNET_GNSRECORD_Block *block;
   struct GNUNET_HashCode h;
@@ -128,48 +128,48 @@ block_plugin_gns_evaluate (void *cls,
   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
   if (NULL == reply_block)
-  {
-    if (0 != xquery_size)
     {
-      GNUNET_break_op (0);
-      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
+      if (0 != xquery_size)
+        {
+          GNUNET_break_op(0);
+          return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
+        }
+      return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
     }
-    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-  }
 
   /* this is a reply */
-  if (reply_block_size < sizeof (struct GNUNET_GNSRECORD_Block))
+  if (reply_block_size < sizeof(struct GNUNET_GNSRECORD_Block))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
   block = reply_block;
-  if (ntohl (block->purpose.size) + sizeof (struct GNUNET_CRYPTO_EcdsaSignature) + sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) !=
+  if (ntohl(block->purpose.size) + sizeof(struct GNUNET_CRYPTO_EcdsaSignature) + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) !=
       reply_block_size)
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
-  GNUNET_CRYPTO_hash (&block->derived_key,
-                      sizeof (block->derived_key),
-                      &h);
-  if (0 != GNUNET_memcmp (&h, query))
+  GNUNET_CRYPTO_hash(&block->derived_key,
+                     sizeof(block->derived_key),
+                     &h);
+  if (0 != GNUNET_memcmp(&h, query))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
   if (GNUNET_OK !=
-      GNUNET_GNSRECORD_block_verify (block))
+      GNUNET_GNSRECORD_block_verify(block))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
-  GNUNET_CRYPTO_hash (reply_block,
-                      reply_block_size,
-                      &chash);
+  GNUNET_CRYPTO_hash(reply_block,
+                     reply_block_size,
+                     &chash);
   if (GNUNET_YES ==
-      GNUNET_BLOCK_GROUP_bf_test_and_set (bg,
-                                          &chash))
+      GNUNET_BLOCK_GROUP_bf_test_and_set(bg,
+                                         &chash))
     return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
   return GNUNET_BLOCK_EVALUATION_OK_MORE;
 }
@@ -187,25 +187,25 @@ block_plugin_gns_evaluate (void *cls,
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
-block_plugin_gns_get_key (void *cls,
-                          enum GNUNET_BLOCK_Type type,
-                          const void *reply_block,
-                          size_t reply_block_size,
-                          struct GNUNET_HashCode *key)
+block_plugin_gns_get_key(void *cls,
+                         enum GNUNET_BLOCK_Type type,
+                         const void *reply_block,
+                         size_t reply_block_size,
+                         struct GNUNET_HashCode *key)
 {
   const struct GNUNET_GNSRECORD_Block *block;
 
   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
     return GNUNET_SYSERR;
-  if (reply_block_size < sizeof (struct GNUNET_GNSRECORD_Block))
+  if (reply_block_size < sizeof(struct GNUNET_GNSRECORD_Block))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
   block = reply_block;
-  GNUNET_CRYPTO_hash (&block->derived_key,
-                      sizeof (block->derived_key),
-                      key);
+  GNUNET_CRYPTO_hash(&block->derived_key,
+                     sizeof(block->derived_key),
+                     key);
   return GNUNET_OK;
 }
 
@@ -214,7 +214,7 @@ block_plugin_gns_get_key (void *cls,
  * Entry point for the plugin.
  */
 void *
-libgnunet_plugin_block_gns_init (void *cls)
+libgnunet_plugin_block_gns_init(void *cls)
 {
   static enum GNUNET_BLOCK_Type types[] =
   {
@@ -223,7 +223,7 @@ libgnunet_plugin_block_gns_init (void *cls)
   };
   struct GNUNET_BLOCK_PluginFunctions *api;
 
-  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions);
   api->evaluate = &block_plugin_gns_evaluate;
   api->get_key = &block_plugin_gns_get_key;
   api->create_group = &block_plugin_gns_create_group;
@@ -236,11 +236,11 @@ libgnunet_plugin_block_gns_init (void *cls)
  * Exit point from the plugin.
  */
 void *
-libgnunet_plugin_block_gns_done (void *cls)
+libgnunet_plugin_block_gns_done(void *cls)
 {
   struct GNUNET_BLOCK_PluginFunctions *api = cls;
 
-  GNUNET_free (api);
+  GNUNET_free(api);
   return NULL;
 }
 
diff --git a/src/gns/plugin_gnsrecord_gns.c b/src/gns/plugin_gnsrecord_gns.c
index 8cb76cffe..094307ea3 100644
--- a/src/gns/plugin_gnsrecord_gns.c
+++ b/src/gns/plugin_gnsrecord_gns.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file gns/plugin_gnsrecord_gns.c
@@ -44,88 +44,94 @@
  * @return NULL on error, otherwise human-readable representation of the value
  */
 static char *
-gns_value_to_string (void *cls,
-                     uint32_t type,
-                     const void *data,
-                     size_t data_size)
+gns_value_to_string(void *cls,
+                    uint32_t type,
+                    const void *data,
+                    size_t data_size)
 {
   const char *cdata;
 
   switch (type)
-  {
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    if (data_size != sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
-      return NULL;
-    return GNUNET_CRYPTO_ecdsa_public_key_to_string (data);
-  case GNUNET_GNSRECORD_TYPE_NICK:
-    return GNUNET_strndup (data, data_size);
-  case GNUNET_GNSRECORD_TYPE_LEHO:
-    return GNUNET_strndup (data, data_size);
-  case GNUNET_GNSRECORD_TYPE_GNS2DNS: {
-    char *ns;
-    char *ip;
-    size_t off;
-    char *nstr;
-
-    off = 0;
-    ns = GNUNET_DNSPARSER_parse_name (data, data_size, &off);
-    ip = GNUNET_DNSPARSER_parse_name (data, data_size, &off);
-    if ((NULL == ns) || (NULL == ip) || (off != data_size))
     {
-      GNUNET_break_op (0);
-      GNUNET_free_non_null (ns);
-      GNUNET_free_non_null (ip);
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      if (data_size != sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))
+        return NULL;
+      return GNUNET_CRYPTO_ecdsa_public_key_to_string(data);
+
+    case GNUNET_GNSRECORD_TYPE_NICK:
+      return GNUNET_strndup(data, data_size);
+
+    case GNUNET_GNSRECORD_TYPE_LEHO:
+      return GNUNET_strndup(data, data_size);
+
+    case GNUNET_GNSRECORD_TYPE_GNS2DNS: {
+      char *ns;
+      char *ip;
+      size_t off;
+      char *nstr;
+
+      off = 0;
+      ns = GNUNET_DNSPARSER_parse_name(data, data_size, &off);
+      ip = GNUNET_DNSPARSER_parse_name(data, data_size, &off);
+      if ((NULL == ns) || (NULL == ip) || (off != data_size))
+        {
+          GNUNET_break_op(0);
+          GNUNET_free_non_null(ns);
+          GNUNET_free_non_null(ip);
+          return NULL;
+        }
+      GNUNET_asprintf(&nstr, "%s@%s", ns, ip);
+      GNUNET_free_non_null(ns);
+      GNUNET_free_non_null(ip);
+      return nstr;
+    }
+
+    case GNUNET_GNSRECORD_TYPE_VPN: {
+      struct GNUNET_TUN_GnsVpnRecord vpn;
+      char *vpn_str;
+
+      cdata = data;
+      if ((data_size <= sizeof(vpn)) || ('\0' != cdata[data_size - 1]))
+        return NULL; /* malformed */
+      /* need to memcpy for alignment */
+      GNUNET_memcpy(&vpn, data, sizeof(vpn));
+      GNUNET_asprintf(&vpn_str,
+                      "%u %s %s",
+                      (unsigned int)ntohs(vpn.proto),
+                      (const char *)GNUNET_i2s_full(&vpn.peer),
+                      (const char *)&cdata[sizeof(vpn)]);
+      return vpn_str;
+    }
+
+    case GNUNET_GNSRECORD_TYPE_BOX: {
+      struct GNUNET_GNSRECORD_BoxRecord box;
+      uint32_t rt;
+      char *box_str;
+      char *ival;
+
+      cdata = data;
+      if (data_size < sizeof(struct GNUNET_GNSRECORD_BoxRecord))
+        return NULL; /* malformed */
+      GNUNET_memcpy(&box, data, sizeof(box));
+      rt = ntohl(box.record_type);
+      ival = GNUNET_GNSRECORD_value_to_string(rt,
+                                              &cdata[sizeof(box)],
+                                              data_size - sizeof(box));
+      if (NULL == ival)
+        return NULL; /* malformed */
+      GNUNET_asprintf(&box_str,
+                      "%u %u %u %s",
+                      (unsigned int)ntohs(box.protocol),
+                      (unsigned int)ntohs(box.service),
+                      (unsigned int)rt,
+                      ival);
+      GNUNET_free(ival);
+      return box_str;
+    }
+
+    default:
       return NULL;
     }
-    GNUNET_asprintf (&nstr, "%s@%s", ns, ip);
-    GNUNET_free_non_null (ns);
-    GNUNET_free_non_null (ip);
-    return nstr;
-  }
-  case GNUNET_GNSRECORD_TYPE_VPN: {
-    struct GNUNET_TUN_GnsVpnRecord vpn;
-    char *vpn_str;
-
-    cdata = data;
-    if ((data_size <= sizeof (vpn)) || ('\0' != cdata[data_size - 1]))
-      return NULL; /* malformed */
-    /* need to memcpy for alignment */
-    GNUNET_memcpy (&vpn, data, sizeof (vpn));
-    GNUNET_asprintf (&vpn_str,
-                     "%u %s %s",
-                     (unsigned int) ntohs (vpn.proto),
-                     (const char *) GNUNET_i2s_full (&vpn.peer),
-                     (const char *) &cdata[sizeof (vpn)]);
-    return vpn_str;
-  }
-  case GNUNET_GNSRECORD_TYPE_BOX: {
-    struct GNUNET_GNSRECORD_BoxRecord box;
-    uint32_t rt;
-    char *box_str;
-    char *ival;
-
-    cdata = data;
-    if (data_size < sizeof (struct GNUNET_GNSRECORD_BoxRecord))
-      return NULL; /* malformed */
-    GNUNET_memcpy (&box, data, sizeof (box));
-    rt = ntohl (box.record_type);
-    ival = GNUNET_GNSRECORD_value_to_string (rt,
-                                             &cdata[sizeof (box)],
-                                             data_size - sizeof (box));
-    if (NULL == ival)
-      return NULL; /* malformed */
-    GNUNET_asprintf (&box_str,
-                     "%u %u %u %s",
-                     (unsigned int) ntohs (box.protocol),
-                     (unsigned int) ntohs (box.service),
-                     (unsigned int) rt,
-                     ival);
-    GNUNET_free (ival);
-    return box_str;
-  }
-  default:
-    return NULL;
-  }
 }
 
 
@@ -141,142 +147,146 @@ gns_value_to_string (void *cls,
  * @return #GNUNET_OK on success
  */
 static int
-gns_string_to_value (void *cls,
-                     uint32_t type,
-                     const char *s,
-                     void **data,
-                     size_t *data_size)
+gns_string_to_value(void *cls,
+                    uint32_t type,
+                    const char *s,
+                    void **data,
+                    size_t *data_size)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 
   if (NULL == s)
     return GNUNET_SYSERR;
   switch (type)
-  {
-
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_ecdsa_public_key_from_string (s, strlen (s), &pkey))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Unable to parse PKEY record `%s'\n"),
-                  s);
-      return GNUNET_SYSERR;
-    }
-    *data = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPublicKey);
-    GNUNET_memcpy (*data, &pkey, sizeof (pkey));
-    *data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
-    return GNUNET_OK;
-
-  case GNUNET_GNSRECORD_TYPE_NICK:
-    *data = GNUNET_strdup (s);
-    *data_size = strlen (s);
-    return GNUNET_OK;
-  case GNUNET_GNSRECORD_TYPE_LEHO:
-    *data = GNUNET_strdup (s);
-    *data_size = strlen (s);
-    return GNUNET_OK;
-  case GNUNET_GNSRECORD_TYPE_GNS2DNS: {
-    char nsbuf[514];
-    char *cpy;
-    char *at;
-    size_t off;
-
-    cpy = GNUNET_strdup (s);
-    at = strchr (cpy, '@');
-    if (NULL == at)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Unable to parse GNS2DNS record `%s'\n"),
-                  s);
-      GNUNET_free (cpy);
-      return GNUNET_SYSERR;
-    }
-    *at = '\0';
-    at++;
-
-    off = 0;
-    if ((GNUNET_OK != GNUNET_DNSPARSER_builder_add_name (nsbuf,
-                                                         sizeof (nsbuf),
-                                                         &off,
-                                                         cpy)) ||
-        (GNUNET_OK !=
-         GNUNET_DNSPARSER_builder_add_name (nsbuf, sizeof (nsbuf), &off, at)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Failed to serialize GNS2DNS record with value `%s'\n"),
-                  s);
-      GNUNET_free (cpy);
-      return GNUNET_SYSERR;
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      if (GNUNET_OK !=
+          GNUNET_CRYPTO_ecdsa_public_key_from_string(s, strlen(s), &pkey))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unable to parse PKEY record `%s'\n"),
+                     s);
+          return GNUNET_SYSERR;
+        }
+      *data = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPublicKey);
+      GNUNET_memcpy(*data, &pkey, sizeof(pkey));
+      *data_size = sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
+      return GNUNET_OK;
+
+    case GNUNET_GNSRECORD_TYPE_NICK:
+      *data = GNUNET_strdup(s);
+      *data_size = strlen(s);
+      return GNUNET_OK;
+
+    case GNUNET_GNSRECORD_TYPE_LEHO:
+      *data = GNUNET_strdup(s);
+      *data_size = strlen(s);
+      return GNUNET_OK;
+
+    case GNUNET_GNSRECORD_TYPE_GNS2DNS: {
+      char nsbuf[514];
+      char *cpy;
+      char *at;
+      size_t off;
+
+      cpy = GNUNET_strdup(s);
+      at = strchr(cpy, '@');
+      if (NULL == at)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unable to parse GNS2DNS record `%s'\n"),
+                     s);
+          GNUNET_free(cpy);
+          return GNUNET_SYSERR;
+        }
+      *at = '\0';
+      at++;
+
+      off = 0;
+      if ((GNUNET_OK != GNUNET_DNSPARSER_builder_add_name(nsbuf,
+                                                          sizeof(nsbuf),
+                                                          &off,
+                                                          cpy)) ||
+          (GNUNET_OK !=
+           GNUNET_DNSPARSER_builder_add_name(nsbuf, sizeof(nsbuf), &off, at)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Failed to serialize GNS2DNS record with value `%s'\n"),
+                     s);
+          GNUNET_free(cpy);
+          return GNUNET_SYSERR;
+        }
+      GNUNET_free(cpy);
+      *data_size = off;
+      *data = GNUNET_malloc(off);
+      GNUNET_memcpy(*data, nsbuf, off);
+      return GNUNET_OK;
     }
-    GNUNET_free (cpy);
-    *data_size = off;
-    *data = GNUNET_malloc (off);
-    GNUNET_memcpy (*data, nsbuf, off);
-    return GNUNET_OK;
-  }
-  case GNUNET_GNSRECORD_TYPE_VPN: {
-    struct GNUNET_TUN_GnsVpnRecord *vpn;
-    char s_peer[103 + 1];
-    char s_serv[253 + 1];
-    unsigned int proto;
-
-    if (3 != sscanf (s, "%u %103s %253s", &proto, s_peer, s_serv))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Unable to parse VPN record string `%s'\n"),
-                  s);
-      return GNUNET_SYSERR;
+
+    case GNUNET_GNSRECORD_TYPE_VPN: {
+      struct GNUNET_TUN_GnsVpnRecord *vpn;
+      char s_peer[103 + 1];
+      char s_serv[253 + 1];
+      unsigned int proto;
+
+      if (3 != sscanf(s, "%u %103s %253s", &proto, s_peer, s_serv))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unable to parse VPN record string `%s'\n"),
+                     s);
+          return GNUNET_SYSERR;
+        }
+      *data_size = sizeof(struct GNUNET_TUN_GnsVpnRecord) + strlen(s_serv) + 1;
+      *data = vpn = GNUNET_malloc(*data_size);
+      if (GNUNET_OK !=
+          GNUNET_CRYPTO_eddsa_public_key_from_string((char *)s_peer,
+                                                     strlen(s_peer),
+                                                     &vpn->peer.public_key))
+        {
+          GNUNET_free(vpn);
+          *data_size = 0;
+          return GNUNET_SYSERR;
+        }
+      vpn->proto = htons((uint16_t)proto);
+      strcpy((char *)&vpn[1], s_serv);
+      return GNUNET_OK;
     }
-    *data_size = sizeof (struct GNUNET_TUN_GnsVpnRecord) + strlen (s_serv) + 1;
-    *data = vpn = GNUNET_malloc (*data_size);
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_eddsa_public_key_from_string ((char *) s_peer,
-                                                    strlen (s_peer),
-                                                    &vpn->peer.public_key))
-    {
-      GNUNET_free (vpn);
-      *data_size = 0;
-      return GNUNET_SYSERR;
+
+    case GNUNET_GNSRECORD_TYPE_BOX: {
+      struct GNUNET_GNSRECORD_BoxRecord *box;
+      size_t rest;
+      unsigned int protocol;
+      unsigned int service;
+      unsigned int record_type;
+      void *bval;
+      size_t bval_size;
+
+      if (3 != sscanf(s, "%u %u %u ", &protocol, &service, &record_type))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unable to parse BOX record string `%s'\n"),
+                     s);
+          return GNUNET_SYSERR;
+        }
+      rest = snprintf(NULL, 0, "%u %u %u ", protocol, service, record_type);
+      if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value(record_type,
+                                                        &s[rest],
+                                                        &bval,
+                                                        &bval_size))
+        return GNUNET_SYSERR;
+      *data_size = sizeof(struct GNUNET_GNSRECORD_BoxRecord) + bval_size;
+      *data = box = GNUNET_malloc(*data_size);
+      box->protocol = htons(protocol);
+      box->service = htons(service);
+      box->record_type = htonl(record_type);
+      GNUNET_memcpy(&box[1], bval, bval_size);
+      GNUNET_free(bval);
+      return GNUNET_OK;
     }
-    vpn->proto = htons ((uint16_t) proto);
-    strcpy ((char *) &vpn[1], s_serv);
-    return GNUNET_OK;
-  }
-  case GNUNET_GNSRECORD_TYPE_BOX: {
-    struct GNUNET_GNSRECORD_BoxRecord *box;
-    size_t rest;
-    unsigned int protocol;
-    unsigned int service;
-    unsigned int record_type;
-    void *bval;
-    size_t bval_size;
-
-    if (3 != sscanf (s, "%u %u %u ", &protocol, &service, &record_type))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Unable to parse BOX record string `%s'\n"),
-                  s);
+
+    default:
       return GNUNET_SYSERR;
     }
-    rest = snprintf (NULL, 0, "%u %u %u ", protocol, service, record_type);
-    if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value (record_type,
-                                                       &s[rest],
-                                                       &bval,
-                                                       &bval_size))
-      return GNUNET_SYSERR;
-    *data_size = sizeof (struct GNUNET_GNSRECORD_BoxRecord) + bval_size;
-    *data = box = GNUNET_malloc (*data_size);
-    box->protocol = htons (protocol);
-    box->service = htons (service);
-    box->record_type = htonl (record_type);
-    GNUNET_memcpy (&box[1], bval, bval_size);
-    GNUNET_free (bval);
-    return GNUNET_OK;
-  }
-  default:
-    return GNUNET_SYSERR;
-  }
 }
 
 
@@ -284,17 +294,16 @@ gns_string_to_value (void *cls,
  * Mapping of record type numbers to human-readable
  * record type names.
  */
-static struct
-{
+static struct {
   const char *name;
   uint32_t number;
-} gns_name_map[] = {{"PKEY", GNUNET_GNSRECORD_TYPE_PKEY},
-                    {"NICK", GNUNET_GNSRECORD_TYPE_NICK},
-                    {"LEHO", GNUNET_GNSRECORD_TYPE_LEHO},
-                    {"VPN", GNUNET_GNSRECORD_TYPE_VPN},
-                    {"GNS2DNS", GNUNET_GNSRECORD_TYPE_GNS2DNS},
-                    {"BOX", GNUNET_GNSRECORD_TYPE_BOX},
-                    {NULL, UINT32_MAX}};
+} gns_name_map[] = { { "PKEY", GNUNET_GNSRECORD_TYPE_PKEY },
+                     { "NICK", GNUNET_GNSRECORD_TYPE_NICK },
+                     { "LEHO", GNUNET_GNSRECORD_TYPE_LEHO },
+                     { "VPN", GNUNET_GNSRECORD_TYPE_VPN },
+                     { "GNS2DNS", GNUNET_GNSRECORD_TYPE_GNS2DNS },
+                     { "BOX", GNUNET_GNSRECORD_TYPE_BOX },
+                     { NULL, UINT32_MAX } };
 
 
 /**
@@ -305,13 +314,13 @@ static struct
  * @return corresponding number, UINT32_MAX on error
  */
 static uint32_t
-gns_typename_to_number (void *cls, const char *gns_typename)
+gns_typename_to_number(void *cls, const char *gns_typename)
 {
   unsigned int i;
 
   i = 0;
   while ((NULL != gns_name_map[i].name) &&
-         (0 != strcasecmp (gns_typename, gns_name_map[i].name)))
+         (0 != strcasecmp(gns_typename, gns_name_map[i].name)))
     i++;
   return gns_name_map[i].number;
 }
@@ -325,7 +334,7 @@ gns_typename_to_number (void *cls, const char *gns_typename)
  * @return corresponding typestring, NULL on error
  */
 static const char *
-gns_number_to_typename (void *cls, uint32_t type)
+gns_number_to_typename(void *cls, uint32_t type)
 {
   unsigned int i;
 
@@ -343,11 +352,11 @@ gns_number_to_typename (void *cls, uint32_t type)
  * @return the exported block API
  */
 void *
-libgnunet_plugin_gnsrecord_gns_init (void *cls)
+libgnunet_plugin_gnsrecord_gns_init(void *cls)
 {
   struct GNUNET_GNSRECORD_PluginFunctions *api;
 
-  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api = GNUNET_new(struct GNUNET_GNSRECORD_PluginFunctions);
   api->value_to_string = &gns_value_to_string;
   api->string_to_value = &gns_string_to_value;
   api->typename_to_number = &gns_typename_to_number;
@@ -363,11 +372,11 @@ libgnunet_plugin_gnsrecord_gns_init (void *cls)
  * @return NULL
  */
 void *
-libgnunet_plugin_gnsrecord_gns_done (void *cls)
+libgnunet_plugin_gnsrecord_gns_done(void *cls)
 {
   struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
 
-  GNUNET_free (api);
+  GNUNET_free(api);
   return NULL;
 }
 
diff --git a/src/gns/plugin_rest_gns.c b/src/gns/plugin_rest_gns.c
index 1ecde12f0..2fc103ef6 100644
--- a/src/gns/plugin_rest_gns.c
+++ b/src/gns/plugin_rest_gns.c
@@ -16,7 +16,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-   */
+ */
 /**
  * @author Philippe Buschmann
  * @file gns/plugin_rest_gns.c
@@ -65,17 +65,14 @@ static char *allow_methods;
 /**
  * @brief struct returned by the initialization function of the plugin
  */
-struct Plugin
-{
+struct Plugin {
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 };
 
 /**
  * The request handle
  */
-struct RequestHandle
-{
-
+struct RequestHandle {
   /**
    * Connection to GNS
    */
@@ -143,35 +140,36 @@ struct RequestHandle
  * @param handle Handle to clean up
  */
 static void
-cleanup_handle (void *cls)
+cleanup_handle(void *cls)
 {
   struct RequestHandle *handle = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
 
   if (NULL != handle->gns_lookup)
-  {
-    GNUNET_GNS_lookup_with_tld_cancel (handle->gns_lookup);
-    handle->gns_lookup = NULL;
-  }
+    {
+      GNUNET_GNS_lookup_with_tld_cancel(handle->gns_lookup);
+      handle->gns_lookup = NULL;
+    }
   if (NULL != handle->gns)
-  {
-    GNUNET_GNS_disconnect (handle->gns);
-    handle->gns = NULL;
-  }
+    {
+      GNUNET_GNS_disconnect(handle->gns);
+      handle->gns = NULL;
+    }
 
   if (NULL != handle->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
-    handle->timeout_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(handle->timeout_task);
+      handle->timeout_task = NULL;
+    }
   if (NULL != handle->url)
-    GNUNET_free (handle->url);
+    GNUNET_free(handle->url);
   if (NULL != handle->name)
-    GNUNET_free (handle->name);
+    GNUNET_free(handle->name);
   if (NULL != handle->emsg)
-    GNUNET_free (handle->emsg);
+    GNUNET_free(handle->emsg);
 
-  GNUNET_free (handle);
+  GNUNET_free(handle);
 }
 
 
@@ -181,39 +179,40 @@ cleanup_handle (void *cls)
  * @param cls the `struct RequestHandle`
  */
 static void
-do_error (void *cls)
+do_error(void *cls)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
-  json_t *json_error = json_object ();
+  json_t *json_error = json_object();
   char *response;
 
   if (NULL != handle->timeout_task)
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
+    GNUNET_SCHEDULER_cancel(handle->timeout_task);
   handle->timeout_task = NULL;
   if (NULL == handle->emsg)
-    handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_ERROR_UNKNOWN);
+    handle->emsg = GNUNET_strdup(GNUNET_REST_GNS_ERROR_UNKNOWN);
 
-  json_object_set_new (json_error, "error", json_string (handle->emsg));
+  json_object_set_new(json_error, "error", json_string(handle->emsg));
 
   if (0 == handle->response_code)
     handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
-  response = json_dumps (json_error, 0);
-  resp = GNUNET_REST_create_response (response);
-  handle->proc (handle->proc_cls, resp, handle->response_code);
-  json_decref (json_error);
-  GNUNET_free (response);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+  response = json_dumps(json_error, 0);
+  resp = GNUNET_REST_create_response(response);
+  handle->proc(handle->proc_cls, resp, handle->response_code);
+  json_decref(json_error);
+  GNUNET_free(response);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
 static void
-do_timeout (void *cls)
+do_timeout(void *cls)
 {
   struct RequestHandle *handle = cls;
+
   handle->timeout_task = NULL;
   handle->response_code = MHD_HTTP_REQUEST_TIMEOUT;
-  do_error (handle);
+  do_error(handle);
 }
 
 
@@ -226,10 +225,10 @@ do_timeout (void *cls)
  * @param rd the records in reply
  */
 static void
-handle_gns_response (void *cls,
-                     int was_gns,
-                     uint32_t rd_count,
-                     const struct GNUNET_GNSRECORD_Data *rd)
+handle_gns_response(void *cls,
+                    int was_gns,
+                    uint32_t rd_count,
+                    const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
@@ -239,22 +238,22 @@ handle_gns_response (void *cls,
   handle->gns_lookup = NULL;
 
   if (GNUNET_NO == was_gns)
-  {
-    handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-
-  result_obj = GNUNET_JSON_from_gnsrecord (handle->name, rd, rd_count);
-
-  result = json_dumps (result_obj, 0);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result);
-  resp = GNUNET_REST_create_response (result);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free (result);
-  json_decref (result_obj);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+    {
+      handle->response_code = MHD_HTTP_NOT_FOUND;
+      handle->emsg = GNUNET_strdup(GNUNET_REST_GNS_NOT_FOUND);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+
+  result_obj = GNUNET_JSON_from_gnsrecord(handle->name, rd, rd_count);
+
+  result = json_dumps(result_obj, 0);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result);
+  resp = GNUNET_REST_create_response(result);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_free(result);
+  json_decref(result_obj);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
@@ -266,9 +265,9 @@ handle_gns_response (void *cls,
  * @param cls the RequestHandle
  */
 void
-get_gns_cont (struct GNUNET_REST_RequestHandle *con_handle,
-              const char *url,
-              void *cls)
+get_gns_cont(struct GNUNET_REST_RequestHandle *con_handle,
+             const char *url,
+             void *cls)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_HashCode key;
@@ -277,50 +276,50 @@ get_gns_cont (struct GNUNET_REST_RequestHandle *con_handle,
 
   name = NULL;
   handle->name = NULL;
-  if (strlen (GNUNET_REST_API_NS_GNS) < strlen (handle->url))
-  {
-    name = &handle->url[strlen (GNUNET_REST_API_NS_GNS) + 1];
-  }
+  if (strlen(GNUNET_REST_API_NS_GNS) < strlen(handle->url))
+    {
+      name = &handle->url[strlen(GNUNET_REST_API_NS_GNS) + 1];
+    }
 
   if (NULL == name)
-  {
-    handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  if (0 >= strlen (name))
-  {
-    handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->name = GNUNET_strdup (name);
+    {
+      handle->response_code = MHD_HTTP_NOT_FOUND;
+      handle->emsg = GNUNET_strdup(GNUNET_REST_GNS_NOT_FOUND);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+  if (0 >= strlen(name))
+    {
+      handle->response_code = MHD_HTTP_NOT_FOUND;
+      handle->emsg = GNUNET_strdup(GNUNET_REST_GNS_NOT_FOUND);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+  handle->name = GNUNET_strdup(name);
 
   handle->record_type = UINT32_MAX;
-  GNUNET_CRYPTO_hash (GNUNET_REST_GNS_PARAM_RECORD_TYPE,
-                      strlen (GNUNET_REST_GNS_PARAM_RECORD_TYPE),
-                      &key);
+  GNUNET_CRYPTO_hash(GNUNET_REST_GNS_PARAM_RECORD_TYPE,
+                     strlen(GNUNET_REST_GNS_PARAM_RECORD_TYPE),
+                     &key);
   if (GNUNET_YES ==
-      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
-  {
-    record_type =
-      GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key);
-    handle->record_type = GNUNET_GNSRECORD_typename_to_number (record_type);
-  }
+      GNUNET_CONTAINER_multihashmap_contains(con_handle->url_param_map, &key))
+    {
+      record_type =
+        GNUNET_CONTAINER_multihashmap_get(con_handle->url_param_map, &key);
+      handle->record_type = GNUNET_GNSRECORD_typename_to_number(record_type);
+    }
 
   if (UINT32_MAX == handle->record_type)
-  {
-    handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
-  }
-
-  handle->gns_lookup = GNUNET_GNS_lookup_with_tld (handle->gns,
-                                                   handle->name,
-                                                   handle->record_type,
-                                                   GNUNET_NO,
-                                                   &handle_gns_response,
-                                                   handle);
+    {
+      handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
+    }
+
+  handle->gns_lookup = GNUNET_GNS_lookup_with_tld(handle->gns,
+                                                  handle->name,
+                                                  handle->record_type,
+                                                  GNUNET_NO,
+                                                  &handle_gns_response,
+                                                  handle);
 }
 
 
@@ -332,18 +331,18 @@ get_gns_cont (struct GNUNET_REST_RequestHandle *con_handle,
  * @param cls the RequestHandle
  */
 static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle,
-              const char *url,
-              void *cls)
+options_cont(struct GNUNET_REST_RequestHandle *con_handle,
+             const char *url,
+             void *cls)
 {
   struct MHD_Response *resp;
   struct RequestHandle *handle = cls;
 
   //independent of path return all options
-  resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+  resp = GNUNET_REST_create_response(NULL);
+  MHD_add_response_header(resp, "Access-Control-Allow-Methods", allow_methods);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
   return;
 }
 
@@ -354,20 +353,20 @@ options_cont (struct GNUNET_REST_RequestHandle *con_handle,
  * @param handle the request handle
  */
 static void
-init_cont (struct RequestHandle *handle)
+init_cont(struct RequestHandle *handle)
 {
   struct GNUNET_REST_RequestHandlerError err;
   static const struct GNUNET_REST_RequestHandler handlers[] =
-    {{MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_GNS, &get_gns_cont},
-     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_GNS, &options_cont},
-     GNUNET_REST_HANDLER_END};
+  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_GNS, &get_gns_cont },
+    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_GNS, &options_cont },
+    GNUNET_REST_HANDLER_END };
 
   if (GNUNET_NO ==
-      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
-  {
-    handle->response_code = err.error_code;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-  }
+      GNUNET_REST_handle_request(handle->rest_handle, handlers, &err, handle))
+    {
+      handle->response_code = err.error_code;
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+    }
 }
 
 
@@ -383,30 +382,30 @@ init_cont (struct RequestHandle *handle)
  * @return GNUNET_OK if request accepted
  */
 static void
-rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
-                      GNUNET_REST_ResultProcessor proc,
-                      void *proc_cls)
+rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
+                     GNUNET_REST_ResultProcessor proc,
+                     void *proc_cls)
 {
-  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
+  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
 
   handle->response_code = 0;
   handle->timeout =
-    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60);
+    GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60);
   handle->proc_cls = proc_cls;
   handle->proc = proc;
   handle->rest_handle = rest_handle;
 
-  handle->url = GNUNET_strdup (rest_handle->url);
-  if (handle->url[strlen (handle->url) - 1] == '/')
-    handle->url[strlen (handle->url) - 1] = '\0';
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
-  handle->gns = GNUNET_GNS_connect (cfg);
-  init_cont (handle);
+  handle->url = GNUNET_strdup(rest_handle->url);
+  if (handle->url[strlen(handle->url) - 1] == '/')
+    handle->url[strlen(handle->url) - 1] = '\0';
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+  handle->gns = GNUNET_GNS_connect(cfg);
+  init_cont(handle);
 
   handle->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_timeout, handle);
+    GNUNET_SCHEDULER_add_delayed(handle->timeout, &do_timeout, handle);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 }
 
 
@@ -417,7 +416,7 @@ rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_rest_gns_init (void *cls)
+libgnunet_plugin_rest_gns_init(void *cls)
 {
   static struct Plugin plugin;
   struct GNUNET_REST_Plugin *api;
@@ -425,21 +424,21 @@ libgnunet_plugin_rest_gns_init (void *cls)
   cfg = cls;
   if (NULL != plugin.cfg)
     return NULL; /* can only initialize once! */
-  memset (&plugin, 0, sizeof (struct Plugin));
+  memset(&plugin, 0, sizeof(struct Plugin));
   plugin.cfg = cfg;
-  api = GNUNET_new (struct GNUNET_REST_Plugin);
+  api = GNUNET_new(struct GNUNET_REST_Plugin);
   api->cls = &plugin;
   api->name = GNUNET_REST_API_NS_GNS;
   api->process_request = &rest_process_request;
-  GNUNET_asprintf (&allow_methods,
-                   "%s, %s, %s, %s, %s",
-                   MHD_HTTP_METHOD_GET,
-                   MHD_HTTP_METHOD_POST,
-                   MHD_HTTP_METHOD_PUT,
-                   MHD_HTTP_METHOD_DELETE,
-                   MHD_HTTP_METHOD_OPTIONS);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Gns REST API initialized\n"));
+  GNUNET_asprintf(&allow_methods,
+                  "%s, %s, %s, %s, %s",
+                  MHD_HTTP_METHOD_GET,
+                  MHD_HTTP_METHOD_POST,
+                  MHD_HTTP_METHOD_PUT,
+                  MHD_HTTP_METHOD_DELETE,
+                  MHD_HTTP_METHOD_OPTIONS);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, _("Gns REST API initialized\n"));
   return api;
 }
 
@@ -451,15 +450,16 @@ libgnunet_plugin_rest_gns_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_rest_gns_done (void *cls)
+libgnunet_plugin_rest_gns_done(void *cls)
 {
   struct GNUNET_REST_Plugin *api = cls;
   struct Plugin *plugin = api->cls;
+
   plugin->cfg = NULL;
 
-  GNUNET_free_non_null (allow_methods);
-  GNUNET_free (api);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Gns REST plugin is finished\n");
+  GNUNET_free_non_null(allow_methods);
+  GNUNET_free(api);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Gns REST plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/gns/test_gns_proxy.c b/src/gns/test_gns_proxy.c
index 053f5f898..2df422731 100644
--- a/src/gns/test_gns_proxy.c
+++ b/src/gns/test_gns_proxy.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file test_gns_proxy.c
@@ -37,7 +37,7 @@
 
 #define TEST_DOMAIN "www.test"
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
 
 /**
  * Return value for 'main'.
@@ -69,8 +69,7 @@ static gnutls_x509_crt_t proxy_cert;
 
 static gnutls_x509_privkey_t proxy_key;
 
-struct CBC
-{
+struct CBC {
   char buf[1024];
   size_t pos;
 };
@@ -85,30 +84,30 @@ static struct CBC cbc;
  * @return NULL on error
  */
 static void*
-load_file (const char* filename,
-           unsigned int* size)
+load_file(const char* filename,
+          unsigned int* size)
 {
   void *buffer;
   uint64_t fsize;
 
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size (filename,
-                             &fsize,
-                             GNUNET_YES,
-                             GNUNET_YES))
+      GNUNET_DISK_file_size(filename,
+                            &fsize,
+                            GNUNET_YES,
+                            GNUNET_YES))
     return NULL;
   if (fsize > MAX_PEM_SIZE)
     return NULL;
-  *size = (unsigned int) fsize;
-  buffer = GNUNET_malloc (*size);
+  *size = (unsigned int)fsize;
+  buffer = GNUNET_malloc(*size);
   if (fsize !=
-      GNUNET_DISK_fn_read (filename,
-                           buffer,
-                           (size_t) fsize))
-  {
-    GNUNET_free (buffer);
-    return NULL;
-  }
+      GNUNET_DISK_fn_read(filename,
+                          buffer,
+                          (size_t)fsize))
+    {
+      GNUNET_free(buffer);
+      return NULL;
+    }
   return buffer;
 }
 
@@ -120,25 +119,25 @@ load_file (const char* filename,
  * @return #GNUNET_OK on success
  */
 static int
-load_key_from_file (gnutls_x509_privkey_t key,
-                    const char* keyfile)
+load_key_from_file(gnutls_x509_privkey_t key,
+                   const char* keyfile)
 {
   gnutls_datum_t key_data;
   int ret;
 
-  key_data.data = load_file (keyfile,
-                             &key_data.size);
+  key_data.data = load_file(keyfile,
+                            &key_data.size);
   if (NULL == key_data.data)
     return GNUNET_SYSERR;
-  ret = gnutls_x509_privkey_import (key, &key_data,
-                                    GNUTLS_X509_FMT_PEM);
+  ret = gnutls_x509_privkey_import(key, &key_data,
+                                   GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unable to import private key from file `%s'\n"),
-                keyfile);
-  }
-  GNUNET_free_non_null (key_data.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to import private key from file `%s'\n"),
+                 keyfile);
+    }
+  GNUNET_free_non_null(key_data.data);
   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
 }
 
@@ -150,107 +149,108 @@ load_key_from_file (gnutls_x509_privkey_t key,
  * @return #GNUNET_OK on success
  */
 static int
-load_cert_from_file (gnutls_x509_crt_t crt,
-                     const char* certfile)
+load_cert_from_file(gnutls_x509_crt_t crt,
+                    const char* certfile)
 {
   gnutls_datum_t cert_data;
   int ret;
 
-  cert_data.data = load_file (certfile,
-                              &cert_data.size);
+  cert_data.data = load_file(certfile,
+                             &cert_data.size);
   if (NULL == cert_data.data)
     return GNUNET_SYSERR;
-  ret = gnutls_x509_crt_import (crt,
-                                &cert_data,
-                                GNUTLS_X509_FMT_PEM);
+  ret = gnutls_x509_crt_import(crt,
+                               &cert_data,
+                               GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unable to import certificate from `%s'\n"),
-                certfile);
-  }
-  GNUNET_free_non_null (cert_data.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to import certificate from `%s'\n"),
+                 certfile);
+    }
+  GNUNET_free_non_null(cert_data.data);
   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
 }
 
 static size_t
-copy_buffer (void *ptr, size_t size, size_t nmemb, void *ctx)
+copy_buffer(void *ptr, size_t size, size_t nmemb, void *ctx)
 {
   struct CBC *cbc = ctx;
 
   if (cbc->pos + size * nmemb > sizeof(cbc->buf))
     return 0;                   /* overflow */
-  GNUNET_memcpy (&cbc->buf[cbc->pos], ptr, size * nmemb);
+  GNUNET_memcpy(&cbc->buf[cbc->pos], ptr, size * nmemb);
   cbc->pos += size * nmemb;
   return size * nmemb;
 }
 
 
 static int
-mhd_ahc (void *cls,
-          struct MHD_Connection *connection,
-          const char *url,
-          const char *method,
-          const char *version,
-          const char *upload_data, size_t *upload_data_size,
-          void **unused)
+mhd_ahc(void *cls,
+        struct MHD_Connection *connection,
+        const char *url,
+        const char *method,
+        const char *version,
+        const char *upload_data, size_t *upload_data_size,
+        void **unused)
 {
   static int ptr;
   struct MHD_Response *response;
   int ret;
 
-  if (0 != strcmp ("GET", method))
+  if (0 != strcmp("GET", method))
     return MHD_NO;              /* unexpected method */
   if (&ptr != *unused)
-  {
-    *unused = &ptr;
-    return MHD_YES;
-  }
+    {
+      *unused = &ptr;
+      return MHD_YES;
+    }
   *unused = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MHD sends respose for request to URL `%s'\n", url);
-  response = MHD_create_response_from_buffer (strlen (url),
-                                              (void *) url,
-                                              MHD_RESPMEM_MUST_COPY);
-  ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
-  MHD_destroy_response (response);
-  if (ret == MHD_NO) {
-    global_ret = 1;
-    abort ();
-  }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MHD sends respose for request to URL `%s'\n", url);
+  response = MHD_create_response_from_buffer(strlen(url),
+                                             (void *)url,
+                                             MHD_RESPMEM_MUST_COPY);
+  ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
+  MHD_destroy_response(response);
+  if (ret == MHD_NO)
+    {
+      global_ret = 1;
+      abort();
+    }
   global_ret = 0;
   return ret;
 }
 
 
 static void
-do_shutdown ()
+do_shutdown()
 {
   if (mhd_task_id != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (mhd_task_id);
-    mhd_task_id = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(mhd_task_id);
+      mhd_task_id = NULL;
+    }
   if (curl_task_id != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (curl_task_id);
-    curl_task_id = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(curl_task_id);
+      curl_task_id = NULL;
+    }
   if (NULL != mhd)
-  {
-    MHD_stop_daemon (mhd);
-    mhd = NULL;
-  }
-  GNUNET_free_non_null (url);
+    {
+      MHD_stop_daemon(mhd);
+      mhd = NULL;
+    }
+  GNUNET_free_non_null(url);
 
   if (NULL != proxy_proc)
     {
-      (void) GNUNET_OS_process_kill (proxy_proc, SIGKILL);
-      GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proxy_proc));
-      GNUNET_OS_process_destroy (proxy_proc);
+      (void)GNUNET_OS_process_kill(proxy_proc, SIGKILL);
+      GNUNET_assert(GNUNET_OK == GNUNET_OS_process_wait(proxy_proc));
+      GNUNET_OS_process_destroy(proxy_proc);
       proxy_proc = NULL;
     }
   url = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -258,19 +258,19 @@ do_shutdown ()
  * Function to run the HTTP client.
  */
 static void
-curl_main (void);
+curl_main(void);
 
 
 static void
-curl_task (void *cls)
+curl_task(void *cls)
 {
   curl_task_id = NULL;
-  curl_main ();
+  curl_main();
 }
 
 
 static void
-curl_main ()
+curl_main()
 {
   fd_set rs;
   fd_set ws;
@@ -284,93 +284,93 @@ curl_main ()
   struct CURLMsg *msg;
 
   max = 0;
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
-  curl_multi_perform (multi, &running);
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
+  curl_multi_perform(multi, &running);
   if (running == 0)
-  {
-    GNUNET_assert (NULL != (msg = curl_multi_info_read (multi, &running)));
-    if (msg->msg == CURLMSG_DONE)
     {
-      if (msg->data.result != CURLE_OK)
-      {
-        fprintf (stderr,
-                 "%s failed at %s:%d: `%s'\n",
-                 "curl_multi_perform",
-                 __FILE__,
-                 __LINE__, curl_easy_strerror (msg->data.result));
-        global_ret = 1;
-      }
+      GNUNET_assert(NULL != (msg = curl_multi_info_read(multi, &running)));
+      if (msg->msg == CURLMSG_DONE)
+        {
+          if (msg->data.result != CURLE_OK)
+            {
+              fprintf(stderr,
+                      "%s failed at %s:%d: `%s'\n",
+                      "curl_multi_perform",
+                      __FILE__,
+                      __LINE__, curl_easy_strerror(msg->data.result));
+              global_ret = 1;
+            }
+        }
+      curl_multi_remove_handle(multi, curl);
+      curl_multi_cleanup(multi);
+      curl_easy_cleanup(curl);
+      curl = NULL;
+      multi = NULL;
+      if (cbc.pos != strlen("/hello_world"))
+        {
+          GNUNET_break(0);
+          global_ret = 2;
+        }
+      if (0 != strncmp("/hello_world", cbc.buf, strlen("/hello_world")))
+        {
+          GNUNET_break(0);
+          global_ret = 3;
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!\n");
+      do_shutdown();
+      return;
     }
-    curl_multi_remove_handle (multi, curl);
-    curl_multi_cleanup (multi);
-    curl_easy_cleanup (curl);
-    curl = NULL;
-    multi = NULL;
-    if (cbc.pos != strlen ("/hello_world"))
-    {
-      GNUNET_break (0);
-      global_ret = 2;
-    }
-    if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
-    {
-      GNUNET_break (0);
-      global_ret = 3;
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!\n");
-    do_shutdown ();
-    return;
-  }
-  GNUNET_assert (CURLM_OK == curl_multi_fdset (multi, &rs, &ws, &es, &max));
-  if ( (CURLM_OK != curl_multi_timeout (multi, &timeout)) ||
-       (-1 == timeout) )
+  GNUNET_assert(CURLM_OK == curl_multi_fdset(multi, &rs, &ws, &es, &max));
+  if ((CURLM_OK != curl_multi_timeout(multi, &timeout)) ||
+      (-1 == timeout))
     delay = GNUNET_TIME_UNIT_SECONDS;
   else
-    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, (unsigned int) timeout);
-  GNUNET_NETWORK_fdset_copy_native (&nrs,
-                                    &rs,
-                                    max + 1);
-  GNUNET_NETWORK_fdset_copy_native (&nws,
-                                    &ws,
-                                    max + 1);
-  curl_task_id = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                              delay,
-                                              &nrs,
-                                              &nws,
-                                              &curl_task,
-                                              NULL);
+    delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, (unsigned int)timeout);
+  GNUNET_NETWORK_fdset_copy_native(&nrs,
+                                   &rs,
+                                   max + 1);
+  GNUNET_NETWORK_fdset_copy_native(&nws,
+                                   &ws,
+                                   max + 1);
+  curl_task_id = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                             delay,
+                                             &nrs,
+                                             &nws,
+                                             &curl_task,
+                                             NULL);
 }
 
 
 static void
-start_curl (void *cls)
+start_curl(void *cls)
 {
   curl_task_id = NULL;
-  GNUNET_asprintf (&url,
-                   "https://%s:%d/hello_world",
-                   TEST_DOMAIN, port);
-  curl = curl_easy_init ();
-  curl_easy_setopt (curl, CURLOPT_URL, url);
+  GNUNET_asprintf(&url,
+                  "https://%s:%d/hello_world",
+                  TEST_DOMAIN, port);
+  curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_URL, url);
   //curl_easy_setopt (curl, CURLOPT_URL, "https://127.0.0.1:8443/hello_world");
-  curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, &copy_buffer);
-  curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbc);
-  curl_easy_setopt (curl, CURLOPT_FAILONERROR, 1);
-  curl_easy_setopt (curl, CURLOPT_TIMEOUT, 150L);
-  curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, 15L);
-  curl_easy_setopt (curl, CURLOPT_NOSIGNAL, 1);
-  curl_easy_setopt (curl, CURLOPT_CAINFO, cafile_opt);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &copy_buffer);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbc);
+  curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT, 150L);
+  curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 15L);
+  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
+  curl_easy_setopt(curl, CURLOPT_CAINFO, cafile_opt);
   //curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0L);
   //curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0L);
-  curl_easy_setopt (curl, CURLOPT_PROXY, "socks5h://127.0.0.1:7777");
-
-  multi = curl_multi_init ();
-  GNUNET_assert (multi != NULL);
-  GNUNET_assert (CURLM_OK == curl_multi_add_handle (multi, curl));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Beginning HTTP download from `%s'\n",
-              url);
-  curl_main ();
+  curl_easy_setopt(curl, CURLOPT_PROXY, "socks5h://127.0.0.1:7777");
+
+  multi = curl_multi_init();
+  GNUNET_assert(multi != NULL);
+  GNUNET_assert(CURLM_OK == curl_multi_add_handle(multi, curl));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Beginning HTTP download from `%s'\n",
+             url);
+  curl_main();
 }
 
 
@@ -387,12 +387,12 @@ start_curl (void *cls)
  *                specified target peer; NULL on error
  */
 static void
-commence_testing (void *cls)
+commence_testing(void *cls)
 {
   curl_task_id =
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                  &start_curl,
-                                  NULL);
+    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
+                                 &start_curl,
+                                 NULL);
 }
 
 
@@ -400,20 +400,20 @@ commence_testing (void *cls)
  * Function to keep the HTTP server running.
  */
 static void
-mhd_main (void);
+mhd_main(void);
 
 
 static void
-mhd_task (void *cls)
+mhd_task(void *cls)
 {
   mhd_task_id = NULL;
-  MHD_run (mhd);
-  mhd_main ();
+  MHD_run(mhd);
+  mhd_main();
 }
 
 
 static void
-mhd_main ()
+mhd_main()
 {
   struct GNUNET_NETWORK_FDSet nrs;
   struct GNUNET_NETWORK_FDSet nws;
@@ -424,30 +424,30 @@ mhd_main ()
   unsigned MHD_LONG_LONG timeout;
   struct GNUNET_TIME_Relative delay;
 
-  GNUNET_assert (NULL == mhd_task_id);
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
+  GNUNET_assert(NULL == mhd_task_id);
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
   max_fd = -1;
-  GNUNET_assert (MHD_YES ==
-                 MHD_get_fdset (mhd, &rs, &ws, &es, &max_fd));
-  if (MHD_YES == MHD_get_timeout (mhd, &timeout))
-    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                           (unsigned int) timeout);
+  GNUNET_assert(MHD_YES ==
+                MHD_get_fdset(mhd, &rs, &ws, &es, &max_fd));
+  if (MHD_YES == MHD_get_timeout(mhd, &timeout))
+    delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
+                                          (unsigned int)timeout);
   else
     delay = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_NETWORK_fdset_copy_native (&nrs,
-                                    &rs,
-                                    max_fd + 1);
-  GNUNET_NETWORK_fdset_copy_native (&nws,
-                                    &ws,
-                                    max_fd + 1);
-  mhd_task_id = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                             delay,
-                                             &nrs,
-                                             &nws,
-                                             &mhd_task,
-                                             NULL);
+  GNUNET_NETWORK_fdset_copy_native(&nrs,
+                                   &rs,
+                                   max_fd + 1);
+  GNUNET_NETWORK_fdset_copy_native(&nws,
+                                   &ws,
+                                   max_fd + 1);
+  mhd_task_id = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                            delay,
+                                            &nrs,
+                                            &nws,
+                                            &mhd_task,
+                                            NULL);
 }
 
 
@@ -460,105 +460,105 @@ mhd_main ()
  * @param c configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using `%s' as CA\n",
-              cafile_srv);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using `%s' as CA\n",
+             cafile_srv);
   char cert[MAX_PEM_SIZE];
   char key[MAX_PEM_SIZE];
   size_t key_buf_size;
   size_t cert_buf_size;
 
-  gnutls_global_init ();
-  gnutls_x509_crt_init (&proxy_cert);
-  gnutls_x509_privkey_init (&proxy_key);
-
-  if ( (GNUNET_OK !=
-        load_cert_from_file (proxy_cert,
-                             cafile_srv)) ||
-       (GNUNET_OK !=
-        load_key_from_file (proxy_key,
-                            cafile_srv)) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to load X.509 key and certificate from `%s'\n"),
-                cafile_srv);
-    gnutls_x509_crt_deinit (proxy_cert);
-    gnutls_x509_privkey_deinit (proxy_key);
-    gnutls_global_deinit ();
-    return;
-  }
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
-  key_buf_size = sizeof (key);
-  cert_buf_size = sizeof (cert);
-  gnutls_x509_crt_export (proxy_cert,
-                          GNUTLS_X509_FMT_PEM,
-                          cert,
-                          &cert_buf_size);
-  gnutls_x509_privkey_export (proxy_key,
-                              GNUTLS_X509_FMT_PEM,
-                              key,
-                              &key_buf_size);
-  mhd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL | MHD_ALLOW_SUSPEND_RESUME, port,
-                          NULL, NULL,
-                          &mhd_ahc, NULL,
-                          MHD_OPTION_HTTPS_MEM_KEY, key,
-                          MHD_OPTION_HTTPS_MEM_CERT, cert,
-                          MHD_OPTION_END);
-  GNUNET_assert (NULL != mhd);
-  mhd_main ();
-
-  GNUNET_SCHEDULER_add_now (&commence_testing,
-                            NULL);
+  gnutls_global_init();
+  gnutls_x509_crt_init(&proxy_cert);
+  gnutls_x509_privkey_init(&proxy_key);
+
+  if ((GNUNET_OK !=
+       load_cert_from_file(proxy_cert,
+                           cafile_srv)) ||
+      (GNUNET_OK !=
+       load_key_from_file(proxy_key,
+                          cafile_srv)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to load X.509 key and certificate from `%s'\n"),
+                 cafile_srv);
+      gnutls_x509_crt_deinit(proxy_cert);
+      gnutls_x509_privkey_deinit(proxy_key);
+      gnutls_global_deinit();
+      return;
+    }
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
+  key_buf_size = sizeof(key);
+  cert_buf_size = sizeof(cert);
+  gnutls_x509_crt_export(proxy_cert,
+                         GNUTLS_X509_FMT_PEM,
+                         cert,
+                         &cert_buf_size);
+  gnutls_x509_privkey_export(proxy_key,
+                             GNUTLS_X509_FMT_PEM,
+                             key,
+                             &key_buf_size);
+  mhd = MHD_start_daemon(MHD_USE_DEBUG | MHD_USE_SSL | MHD_ALLOW_SUSPEND_RESUME, port,
+                         NULL, NULL,
+                         &mhd_ahc, NULL,
+                         MHD_OPTION_HTTPS_MEM_KEY, key,
+                         MHD_OPTION_HTTPS_MEM_CERT, cert,
+                         MHD_OPTION_END);
+  GNUNET_assert(NULL != mhd);
+  mhd_main();
+
+  GNUNET_SCHEDULER_add_now(&commence_testing,
+                           NULL);
 }
 
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint16 ('p',
-                                 "port",
-                                 NULL,
-                                 gettext_noop ("listen on specified port (default: 7777)"),
-                                 &port),
-    GNUNET_GETOPT_option_string ('A',
-                                 "curlcert",
-                                 NULL,
-                                 gettext_noop ("pem file to use as CA"),
-                                 &cafile_opt),
-    GNUNET_GETOPT_option_string ('S',
-                                 "servercert",
-                                 NULL,
-                                 gettext_noop ("pem file to use for the server"),
-                                 &cafile_srv),
+    GNUNET_GETOPT_option_uint16('p',
+                                "port",
+                                NULL,
+                                gettext_noop("listen on specified port (default: 7777)"),
+                                &port),
+    GNUNET_GETOPT_option_string('A',
+                                "curlcert",
+                                NULL,
+                                gettext_noop("pem file to use as CA"),
+                                &cafile_opt),
+    GNUNET_GETOPT_option_string('S',
+                                "servercert",
+                                NULL,
+                                gettext_noop("pem file to use for the server"),
+                                &cafile_srv),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (0 != curl_global_init (CURL_GLOBAL_WIN32))
-  {
-    fprintf (stderr, "failed to initialize curl\n");
-    return 2;
-  }
+  if (0 != curl_global_init(CURL_GLOBAL_WIN32))
+    {
+      fprintf(stderr, "failed to initialize curl\n");
+      return 2;
+    }
   if (GNUNET_OK !=
-      GNUNET_STRINGS_get_utf8_args (argc, argv,
-                                    &argc, &argv))
+      GNUNET_STRINGS_get_utf8_args(argc, argv,
+                                   &argc, &argv))
     return 2;
-  GNUNET_log_setup ("gnunet-gns-proxy-test",
-                    "WARNING",
-                    NULL);
-  if (GNUNET_OK != GNUNET_PROGRAM_run (argc, argv,
-                                       "gnunet-gns-proxy-test",
-                                       _("GNUnet GNS proxy test"),
-                                       options,
-                                       &run, NULL))
+  GNUNET_log_setup("gnunet-gns-proxy-test",
+                   "WARNING",
+                   NULL);
+  if (GNUNET_OK != GNUNET_PROGRAM_run(argc, argv,
+                                      "gnunet-gns-proxy-test",
+                                      _("GNUnet GNS proxy test"),
+                                      options,
+                                      &run, NULL))
     return 1;
-  GNUNET_free_non_null ((char *) argv);
+  GNUNET_free_non_null((char *)argv);
   return global_ret;
 }
 
diff --git a/src/gns/w32nsp-install.c b/src/gns/w32nsp-install.c
index 6c9c44409..2674359fb 100644
--- a/src/gns/w32nsp-install.c
+++ b/src/gns/w32nsp-install.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/w32nsp-install.c
  * @brief W32 integration installer for GNS
@@ -31,7 +31,7 @@
 #include <stdio.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   int ret;
   int r = 1;
@@ -47,97 +47,97 @@ main (int argc, char **argv)
   int p_count;
   int i;
 
-  if (WSAStartup (MAKEWORD (2,2), &wsd) != 0)
-  {
-    fprintf (stderr, "WSAStartup () failed: %lu\n", GetLastError ());
-    return 5;
-  }
+  if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
+    {
+      fprintf(stderr, "WSAStartup () failed: %lu\n", GetLastError());
+      return 5;
+    }
 
   dwBufferLen = dwInitialBufferLen;
-  pi = malloc (dwBufferLen);
+  pi = malloc(dwBufferLen);
   if (NULL == pi)
-  {
-    fprintf (stderr, "malloc (%lu) failed: %d\n", dwBufferLen, errno);
-    WSACleanup ();
-    return 6;
-  }
-  p_count = WSAEnumNameSpaceProviders (&dwBufferLen, pi);
+    {
+      fprintf(stderr, "malloc (%lu) failed: %d\n", dwBufferLen, errno);
+      WSACleanup();
+      return 6;
+    }
+  p_count = WSAEnumNameSpaceProviders(&dwBufferLen, pi);
   if (SOCKET_ERROR == p_count)
-  {
-    DWORD err = GetLastError ();
-    if (WSAEFAULT == err && dwBufferLen != dwInitialBufferLen)
     {
-      free (pi);
+      DWORD err = GetLastError();
+      if (WSAEFAULT == err && dwBufferLen != dwInitialBufferLen)
+        {
+          free(pi);
 
-      pi = malloc (dwBufferLen);
-      if (pi == NULL)
-      {
-        fprintf (stderr, "malloc (%lu) failed: %d\n", dwBufferLen, errno);
-        WSACleanup ();
-        return 6;
-      }
+          pi = malloc(dwBufferLen);
+          if (pi == NULL)
+            {
+              fprintf(stderr, "malloc (%lu) failed: %d\n", dwBufferLen, errno);
+              WSACleanup();
+              return 6;
+            }
 
-      p_count = WSAEnumNameSpaceProviders (&dwBufferLen, pi);
-      if (SOCKET_ERROR == p_count)
-      {
-        fprintf (stderr, "WSAEnumNameSpaceProviders (&%lu, %p) failed: %lu\n", dwBufferLen, pi, GetLastError ());
-        free (pi);
-        WSACleanup ();
-        return 7;
-      }
-    }
-    else
-    {
-      fprintf (stderr, "WSAEnumNameSpaceProviders (&%lu, %p) failed: %lu\n", dwBufferLen, pi, GetLastError ());
-      free (pi);
-      WSACleanup ();
-      return 8;
+          p_count = WSAEnumNameSpaceProviders(&dwBufferLen, pi);
+          if (SOCKET_ERROR == p_count)
+            {
+              fprintf(stderr, "WSAEnumNameSpaceProviders (&%lu, %p) failed: %lu\n", dwBufferLen, pi, GetLastError());
+              free(pi);
+              WSACleanup();
+              return 7;
+            }
+        }
+      else
+        {
+          fprintf(stderr, "WSAEnumNameSpaceProviders (&%lu, %p) failed: %lu\n", dwBufferLen, pi, GetLastError());
+          free(pi);
+          WSACleanup();
+          return 8;
+        }
     }
-  }
-  for (i= 0; i < p_count; i++)
-  {
-    if (IsEqualGUID (&pi[i].NSProviderId, &id))
+  for (i = 0; i < p_count; i++)
     {
-      fprintf (stderr, "GNUnet DNS provider is already installed\n");
-      free (pi);
-      WSACleanup ();
-      return 0;
+      if (IsEqualGUID(&pi[i].NSProviderId, &id))
+        {
+          fprintf(stderr, "GNUnet DNS provider is already installed\n");
+          free(pi);
+          WSACleanup();
+          return 0;
+        }
     }
-  }
-  free (pi);
+  free(pi);
 
-  cmdl = GetCommandLineW ();
+  cmdl = GetCommandLineW();
   if (cmdl == NULL)
-  {
-    WSACleanup ();
-    return 2;
-  }
-  wargv = CommandLineToArgvW (cmdl, &wargc);
+    {
+      WSACleanup();
+      return 2;
+    }
+  wargv = CommandLineToArgvW(cmdl, &wargc);
   if (wargv == NULL)
-  {
-    WSACleanup ();
-    return 3;
-  }
+    {
+      WSACleanup();
+      return 3;
+    }
   r = 4;
 
   if (wargc == 2)
-  {
-    ret = WSCInstallNameSpace (L"GNUnet DNS provider", wargv[1], NS_DNS, 0, &id);
-    if (ret == NO_ERROR)
-    {
-      fprintf (stderr, "Installed GNUnet DNS provider\n");
-      r = 0;
-    }
-    else
     {
-      r = 1;
-      fprintf (stderr,
-          "WSCInstallNameSpace (L\"GNUnet DNS provider\", \"%S\", %d, 0, %p) failed: %lu\n",
-          wargv[1], NS_DNS, &id, GetLastError ());
+      ret = WSCInstallNameSpace(L"GNUnet DNS provider", wargv[1], NS_DNS, 0, &id);
+      if (ret == NO_ERROR)
+        {
+          fprintf(stderr, "Installed GNUnet DNS provider\n");
+          r = 0;
+        }
+      else
+        {
+          r = 1;
+          fprintf(stderr,
+                  "WSCInstallNameSpace (L\"GNUnet DNS provider\", \"%S\", %d, 0, %p) failed: %lu\n",
+                  wargv[1], NS_DNS, &id, GetLastError());
+        }
     }
-  }
   else
-    fprintf (stderr, "Usage: %S <path-to-libw32nsp>\n", wargv[0]);
-  WSACleanup ();
+    fprintf(stderr, "Usage: %S <path-to-libw32nsp>\n", wargv[0]);
+  WSACleanup();
   return r;
 }
diff --git a/src/gns/w32nsp-resolve.c b/src/gns/w32nsp-resolve.c
index 841f5b9e6..ad0fd3586 100644
--- a/src/gns/w32nsp-resolve.c
+++ b/src/gns/w32nsp-resolve.c
@@ -11,19 +11,19 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/w32nsp-resolve.c
  * @brief W32 integration for GNS
  * @author LRN
  */
 /* Instead of including gnunet_common.h */
-#define GNUNET_memcpy(dst,src,n) do { if (0 != n) { (void) memcpy (dst,src,n); } } while (0)
+#define GNUNET_memcpy(dst, src, n) do { if (0 != n) { (void)memcpy(dst, src, n); } } while (0)
 
 #include <ws2tcpip.h>
 #include <windows.h>
@@ -34,15 +34,15 @@
 #include "gnunet_w32nsp_lib.h"
 #include <stdio.h>
 
-typedef int (WSPAPI *LPNSPSTARTUP) (LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines);
+typedef int (WSPAPI *LPNSPSTARTUP)(LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines);
 
-GUID host = {0x0002a800,0,0,{ 0xC0,0,0,0,0,0,0,0x46 }};
-GUID ip4 = {0x00090035,0,1,{ 0xc0,0,0,0,0,0,0,0x046}};
-GUID ip6 = {0x00090035,0,0x001c, { 0xc0,0,0,0,0,0,0,0x046}};
+GUID host = { 0x0002a800, 0, 0, { 0xC0, 0, 0, 0, 0, 0, 0, 0x46 } };
+GUID ip4 = { 0x00090035, 0, 1, { 0xc0, 0, 0, 0, 0, 0, 0, 0x046 } };
+GUID ip6 = { 0x00090035, 0, 0x001c, { 0xc0, 0, 0, 0, 0, 0, 0, 0x046 } };
 
 DEFINE_GUID(W32_DNS, 0x22059D40, 0x7E9E, 0x11CF, 0xAE, 0x5A, 0x00, 0xAA, 0x00, 0xA7, 0x11, 0x2B);
 
-#define DEFINE_DNS_GUID(a,x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
+#define DEFINE_DNS_GUID(a, x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_A, 0x0001);
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_NS, 0x0002);
 DEFINE_DNS_GUID(SVCID_DNS_TYPE_CNAME, 0x0005);
@@ -63,15 +63,15 @@ DEFINE_GUID(SVCID_INET_HOSTADDRBYNAME, 0x0002a803, 0x0000, 0x0000, 0xc0, 0x00, 0
 VOID
 FixList(PCHAR ** List, PCHAR Base)
 {
-    if(*List)
+  if (*List)
     {
-        PCHAR * Addr;
+      PCHAR * Addr;
 
-        Addr = *List = (PCHAR *)( ((DWORD)*List + Base) );
-        while(*Addr)
+      Addr = *List = (PCHAR *)(((DWORD)*List + Base));
+      while (*Addr)
         {
-            *Addr = (PCHAR)(((DWORD)*Addr + Base));
-            Addr++;
+          *Addr = (PCHAR)(((DWORD)*Addr + Base));
+          Addr++;
         }
     }
 }
@@ -84,82 +84,92 @@ FixList(PCHAR ** List, PCHAR Base)
 VOID
 UnpackHostEnt(struct hostent * hostent)
 {
-     PCHAR pch;
+  PCHAR pch;
 
-     pch = (PCHAR)hostent;
+  pch = (PCHAR)hostent;
 
-     if(hostent->h_name)
-     {
-         hostent->h_name = (PCHAR)((DWORD)hostent->h_name + pch);
-     }
-     FixList(&hostent->h_aliases, pch);
-     FixList(&hostent->h_addr_list, pch);
+  if (hostent->h_name)
+    {
+      hostent->h_name = (PCHAR)((DWORD)hostent->h_name + pch);
+    }
+  FixList(&hostent->h_aliases, pch);
+  FixList(&hostent->h_addr_list, pch);
 }
 
 
 static void
-print_hostent (struct hostent *he)
+print_hostent(struct hostent *he)
 {
   int i;
   char **pAlias;
 
   printf("\tOfficial name: %s\n", he->h_name);
-  for (i=0, pAlias = he->h_aliases; *pAlias != 0; pAlias++) {
+  for (i = 0, pAlias = he->h_aliases; *pAlias != 0; pAlias++)
+    {
       printf("\tAlternate name #%d: %s\n", ++i, *pAlias);
-  }
+    }
   printf("\tAddress type: ");
-  switch (he->h_addrtype) {
-  case AF_INET:
+  switch (he->h_addrtype)
+    {
+    case AF_INET:
       printf("AF_INET\n");
       break;
-  case AF_INET6:
+
+    case AF_INET6:
       printf("AF_INET6\n");
       break;
-  case AF_NETBIOS:
+
+    case AF_NETBIOS:
       printf("AF_NETBIOS\n");
       break;
-  default:
+
+    default:
       printf(" %d\n", he->h_addrtype);
       break;
-  }
+    }
   printf("\tAddress length: %d\n", he->h_length);
 
-  if (he->h_addrtype == AF_INET) {
-    struct sockaddr_in addr;
-    memset (&addr, 0, sizeof (addr));
-    addr.sin_family = AF_INET;
-    addr.sin_port = 0;
-    i = 0;
-    while (he->h_addr_list[i] != 0) {
-      char buf[1024];
-      DWORD buflen = 1024;
-      addr.sin_addr = *(struct in_addr *) he->h_addr_list[i++];
-      if (NO_ERROR == WSAAddressToStringA ((LPSOCKADDR) &addr, sizeof (addr), NULL, buf, &buflen))
-        printf("\tIPv4 Address #%d: %s\n", i, buf);
-      else
-        printf("\tIPv4 Address #%d: Can't convert: %lu\n", i, GetLastError ());
+  if (he->h_addrtype == AF_INET)
+    {
+      struct sockaddr_in addr;
+      memset(&addr, 0, sizeof(addr));
+      addr.sin_family = AF_INET;
+      addr.sin_port = 0;
+      i = 0;
+      while (he->h_addr_list[i] != 0)
+        {
+          char buf[1024];
+          DWORD buflen = 1024;
+          addr.sin_addr = *(struct in_addr *)he->h_addr_list[i++];
+          if (NO_ERROR == WSAAddressToStringA((LPSOCKADDR)&addr, sizeof(addr), NULL, buf, &buflen))
+            printf("\tIPv4 Address #%d: %s\n", i, buf);
+          else
+            printf("\tIPv4 Address #%d: Can't convert: %lu\n", i, GetLastError());
+        }
     }
-  } else if (he->h_addrtype == AF_INET6) {
-    struct sockaddr_in6 addr;
-    memset (&addr, 0, sizeof (addr));
-    addr.sin6_family = AF_INET6;
-    addr.sin6_port = 0;
-    i = 0;
-    while (he->h_addr_list[i] != 0) {
-      char buf[1024];
-      DWORD buflen = 1024;
-      addr.sin6_addr = *(struct in6_addr *) he->h_addr_list[i++];
-      if (NO_ERROR == WSAAddressToStringA ((LPSOCKADDR) &addr, sizeof (addr), NULL, buf, &buflen))
-        printf("\tIPv6 Address #%d: %s\n", i, buf);
-      else
-        printf("\tIPv6 Address #%d: Can't convert: %lu\n", i, GetLastError ());
+  else if (he->h_addrtype == AF_INET6)
+    {
+      struct sockaddr_in6 addr;
+      memset(&addr, 0, sizeof(addr));
+      addr.sin6_family = AF_INET6;
+      addr.sin6_port = 0;
+      i = 0;
+      while (he->h_addr_list[i] != 0)
+        {
+          char buf[1024];
+          DWORD buflen = 1024;
+          addr.sin6_addr = *(struct in6_addr *)he->h_addr_list[i++];
+          if (NO_ERROR == WSAAddressToStringA((LPSOCKADDR)&addr, sizeof(addr), NULL, buf, &buflen))
+            printf("\tIPv6 Address #%d: %s\n", i, buf);
+          else
+            printf("\tIPv6 Address #%d: Can't convert: %lu\n", i, GetLastError());
+        }
     }
-  }
 }
 
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   int ret;
   int r = 1;
@@ -170,277 +180,285 @@ main (int argc, char **argv)
   int wargc;
   wchar_t **wargv;
 
-  if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
-  {
-    fprintf (stderr, "WSAStartup() failed: %lu\n", GetLastError());
-    return 5;
-  }
+  if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
+    {
+      fprintf(stderr, "WSAStartup() failed: %lu\n", GetLastError());
+      return 5;
+    }
 
-  cmdl = GetCommandLineW ();
+  cmdl = GetCommandLineW();
   if (cmdl == NULL)
-  {
-    WSACleanup();
-    return 2;
-  }
-  wargv = CommandLineToArgvW (cmdl, &wargc);
+    {
+      WSACleanup();
+      return 2;
+    }
+  wargv = CommandLineToArgvW(cmdl, &wargc);
   if (wargv == NULL)
-  {
-    WSACleanup();
-    return 3;
-  }
+    {
+      WSACleanup();
+      return 3;
+    }
   r = 4;
 
   if (wargc == 5)
-  {
-    if (wcscmp (wargv[1], L"A") == 0)
-      sc = SVCID_DNS_TYPE_A;
-    else if (wcscmp (wargv[1], L"AAAA") == 0)
-      sc = SVCID_DNS_TYPE_AAAA;
-    else if (wcscmp (wargv[1], L"name") == 0)
-      sc = SVCID_HOSTNAME;
-    else if (wcscmp (wargv[1], L"addr") == 0)
-      sc = SVCID_INET_HOSTADDRBYNAME;
-    else
-      wargc -= 1;
-    if (wcscmp (wargv[4], L"mswdns") == 0)
-      prov = W32_DNS;
-    else if (wcscmp (wargv[4], L"gnunetdns") == 0)
-      prov = GNUNET_NAMESPACE_PROVIDER_DNS;
-    else
-      wargc -= 1;
-  }
+    {
+      if (wcscmp(wargv[1], L"A") == 0)
+        sc = SVCID_DNS_TYPE_A;
+      else if (wcscmp(wargv[1], L"AAAA") == 0)
+        sc = SVCID_DNS_TYPE_AAAA;
+      else if (wcscmp(wargv[1], L"name") == 0)
+        sc = SVCID_HOSTNAME;
+      else if (wcscmp(wargv[1], L"addr") == 0)
+        sc = SVCID_INET_HOSTADDRBYNAME;
+      else
+        wargc -= 1;
+      if (wcscmp(wargv[4], L"mswdns") == 0)
+        prov = W32_DNS;
+      else if (wcscmp(wargv[4], L"gnunetdns") == 0)
+        prov = GNUNET_NAMESPACE_PROVIDER_DNS;
+      else
+        wargc -= 1;
+    }
   else if (wargc == 3)
-  {
-  }
+    {
+    }
   else
-  {
-    fprintf (stderr, "Usage: %S <record type> <service name> <NSP library path> <NSP id>\n"
-        "record type      - one of the following: A | AAAA | name | addr\n"
-        "service name     - a string to resolve; \" \" (a space) means 'blank'\n"
-        "NSP library path - path to libw32nsp\n"
-        "NSP id           - one of the following: mswdns | gnunetdns\n",
-        wargv[0]);
-  }
-
-  if (wargc == 5)
-  {
-    HMODULE nsp;
-
-    nsp = LoadLibraryW (wargv[3]);
-    if (nsp == NULL)
     {
-      fprintf (stderr, "Failed to load library `%S'\n", wargv[3]);
+      fprintf(stderr, "Usage: %S <record type> <service name> <NSP library path> <NSP id>\n"
+              "record type      - one of the following: A | AAAA | name | addr\n"
+              "service name     - a string to resolve; \" \" (a space) means 'blank'\n"
+              "NSP library path - path to libw32nsp\n"
+              "NSP id           - one of the following: mswdns | gnunetdns\n",
+              wargv[0]);
     }
-    else
+
+  if (wargc == 5)
     {
-      LPNSPSTARTUP startup = (LPNSPSTARTUP) GetProcAddress (nsp, "NSPStartup");
-      if (startup == NULL)
-        startup = (LPNSPSTARTUP) GetProcAddress (nsp, "NSPStartup@8");
-      if (startup != NULL)
-      {
-        NSP_ROUTINE api;
-        api.cbSize = sizeof (api);
-        ret = startup (&prov, &api);
-        if (NO_ERROR != ret)
-          fprintf (stderr, "startup failed: %lu\n", GetLastError ());
-        else
+      HMODULE nsp;
+
+      nsp = LoadLibraryW(wargv[3]);
+      if (nsp == NULL)
         {
-          HANDLE lookup;
-          WSAQUERYSETW search;
-          char buf[4096];
-          WSAQUERYSETW *result = (WSAQUERYSETW *) buf;
-          DWORD resultsize;
-          DWORD err;
-          memset (&search, 0, sizeof (search));
-          search.dwSize = sizeof (search);
-          search.lpszServiceInstanceName = (wcscmp (wargv[2], L" ") == 0) ? NULL : wargv[2];
-          search.lpServiceClassId = &sc;
-          search.lpNSProviderId = &prov;
-          search.dwNameSpace = NS_ALL;
-          ret = api.NSPLookupServiceBegin (&prov, &search, NULL, LUP_RETURN_ALL, &lookup);
-          if (ret != NO_ERROR)
-          {
-            fprintf (stderr, "lookup start failed\n");
-          }
-          else
-          {
-            resultsize = 4096;
-            ret = api.NSPLookupServiceNext (lookup, LUP_RETURN_ALL, &resultsize, result);
-            err = GetLastError ();
-            if (ret != NO_ERROR)
-            {
-              fprintf (stderr, "lookup next failed: %lu\n", err);
-            }
-            else
+          fprintf(stderr, "Failed to load library `%S'\n", wargv[3]);
+        }
+      else
+        {
+          LPNSPSTARTUP startup = (LPNSPSTARTUP)GetProcAddress(nsp, "NSPStartup");
+          if (startup == NULL)
+            startup = (LPNSPSTARTUP)GetProcAddress(nsp, "NSPStartup@8");
+          if (startup != NULL)
             {
-              int i;
-              printf ("Got result:\n");
-              printf ("  lpszServiceInstanceName: %S\n", result->lpszServiceInstanceName ? result->lpszServiceInstanceName : L"NULL");
-              if (result->lpServiceClassId)
-                printf ("  lpServiceClassId:        { 0x%08lX,0x%04X,0x%04X, { 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X } }\n",
-                    result->lpServiceClassId->Data1, result->lpServiceClassId->Data2, result->lpServiceClassId->Data3, result->lpServiceClassId->Data4[0],
-                    result->lpServiceClassId->Data4[1], result->lpServiceClassId->Data4[2], result->lpServiceClassId->Data4[3], result->lpServiceClassId->Data4[4],
-                    result->lpServiceClassId->Data4[5], result->lpServiceClassId->Data4[6], result->lpServiceClassId->Data4[7]);
-              else
-                printf ("  lpServiceClassId:        NULL\n");
-              if (result->lpVersion)
-                printf ("  lpVersion:               0x%08lX, %d\n", result->lpVersion->dwVersion, result->lpVersion->ecHow);
+              NSP_ROUTINE api;
+              api.cbSize = sizeof(api);
+              ret = startup(&prov, &api);
+              if (NO_ERROR != ret)
+                fprintf(stderr, "startup failed: %lu\n", GetLastError());
               else
-                printf ("  lpVersion:               NULL\n");
-              printf ("  lpszComment:             %S\n", result->lpszComment ? result->lpszComment : L"NULL");
-              printf ("  dwNameSpace:             %lu\n", result->dwNameSpace);
-              if (result->lpNSProviderId)
-                printf ("  lpNSProviderId:          { 0x%08lX,0x%04X,0x%04X, { 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X } }\n",
-                    result->lpNSProviderId->Data1, result->lpNSProviderId->Data2, result->lpNSProviderId->Data3, result->lpNSProviderId->Data4[0],
-                    result->lpNSProviderId->Data4[1], result->lpNSProviderId->Data4[2], result->lpNSProviderId->Data4[3], result->lpNSProviderId->Data4[4],
-                    result->lpNSProviderId->Data4[5], result->lpNSProviderId->Data4[6], result->lpNSProviderId->Data4[7]);
-              else
-                printf ("  lpNSProviderId:          NULL\n");
-              printf ("  lpszContext:             %S\n", result->lpszContext ? result->lpszContext : L"NULL");
-              printf ("  dwNumberOfProtocols:     %lu\n", result->dwNumberOfProtocols);
-              printf ("  lpszQueryString:         %S\n", result->lpszQueryString ? result->lpszQueryString : L"NULL");
-              printf ("  dwNumberOfCsAddrs:       %lu\n", result->dwNumberOfCsAddrs);
-              for (i = 0; i < result->dwNumberOfCsAddrs; i++)
-              {
-                switch (result->lpcsaBuffer[i].iSocketType)
                 {
-                case SOCK_STREAM:
-                  printf ("    %d: iSocketType = SOCK_STREAM\n", i);
-                  break;
-                case SOCK_DGRAM:
-                  printf ("    %d: iSocketType = SOCK_DGRAM\n", i);
-                  break;
-                default:
-                  printf ("    %d: iSocketType = %d\n", i, result->lpcsaBuffer[i].iSocketType);
-                }
-                switch (result->lpcsaBuffer[i].iProtocol)
-                {
-                case IPPROTO_TCP:
-                  printf ("    %d: iProtocol   = IPPROTO_TCP\n", i);
-                  break;
-                case IPPROTO_UDP:
-                  printf ("    %d: iProtocol   = IPPROTO_UDP\n", i);
-                  break;
-                default:
-                  printf ("    %d: iProtocol   = %d\n", i, result->lpcsaBuffer[i].iProtocol);
-                }
-                switch (result->lpcsaBuffer[i].LocalAddr.lpSockaddr->sa_family)
-                {
-                case AF_INET:
-                  printf ("    %d: loc family  = AF_INET\n", i);
-                  break;
-                case AF_INET6:
-                  printf ("    %d: loc family  = AF_INET6\n", i);
-                  break;
-                default:
-                  printf ("    %d: loc family  = %hu\n", i, result->lpcsaBuffer[i].LocalAddr.lpSockaddr->sa_family);
-                }
-                switch (result->lpcsaBuffer[i].RemoteAddr.lpSockaddr->sa_family)
-                {
-                case AF_INET:
-                  printf ("    %d: rem family  = AF_INET\n", i);
-                  break;
-                case AF_INET6:
-                  printf ("    %d: rem family  = AF_INET6\n", i);
-                  break;
-                default:
-                  printf ("    %d: rem family = %hu\n", i, result->lpcsaBuffer[i].RemoteAddr.lpSockaddr->sa_family);
-                }
-                char buf[1024];
-                DWORD buflen = 1024;
-                if (NO_ERROR == WSAAddressToStringA (result->lpcsaBuffer[i].LocalAddr.lpSockaddr, result->lpcsaBuffer[i].LocalAddr.iSockaddrLength, NULL, buf, &buflen))
-                  printf("\tLocal Address #%d: %s\n", i, buf);
-                else
-                  printf("\tLocal Address #%d: Can't convert: %lu\n", i, GetLastError ());
-                buflen = 1024;
-                if (NO_ERROR == WSAAddressToStringA (result->lpcsaBuffer[i].RemoteAddr.lpSockaddr, result->lpcsaBuffer[i].RemoteAddr.iSockaddrLength, NULL, buf, &buflen))
-                  printf("\tRemote Address #%d: %s\n", i, buf);
-                else
-                  printf("\tRemote Address #%d: Can't convert: %lu\n", i, GetLastError ());
-              }
-              printf ("  dwOutputFlags:           0x%08lX\n", result->dwOutputFlags);
-              printf ("  lpBlob:                  0x%p\n", result->lpBlob);
-              if (result->lpBlob)
-              {
-                struct hostent *he = malloc (result->lpBlob->cbSize);
-                if (he != NULL)
-                {
-                  GNUNET_memcpy (he, result->lpBlob->pBlobData, result->lpBlob->cbSize);
-                  UnpackHostEnt (he);
-                  print_hostent (he);
-                  free (he);
+                  HANDLE lookup;
+                  WSAQUERYSETW search;
+                  char buf[4096];
+                  WSAQUERYSETW *result = (WSAQUERYSETW *)buf;
+                  DWORD resultsize;
+                  DWORD err;
+                  memset(&search, 0, sizeof(search));
+                  search.dwSize = sizeof(search);
+                  search.lpszServiceInstanceName = (wcscmp(wargv[2], L" ") == 0) ? NULL : wargv[2];
+                  search.lpServiceClassId = &sc;
+                  search.lpNSProviderId = &prov;
+                  search.dwNameSpace = NS_ALL;
+                  ret = api.NSPLookupServiceBegin(&prov, &search, NULL, LUP_RETURN_ALL, &lookup);
+                  if (ret != NO_ERROR)
+                    {
+                      fprintf(stderr, "lookup start failed\n");
+                    }
+                  else
+                    {
+                      resultsize = 4096;
+                      ret = api.NSPLookupServiceNext(lookup, LUP_RETURN_ALL, &resultsize, result);
+                      err = GetLastError();
+                      if (ret != NO_ERROR)
+                        {
+                          fprintf(stderr, "lookup next failed: %lu\n", err);
+                        }
+                      else
+                        {
+                          int i;
+                          printf("Got result:\n");
+                          printf("  lpszServiceInstanceName: %S\n", result->lpszServiceInstanceName ? result->lpszServiceInstanceName : L"NULL");
+                          if (result->lpServiceClassId)
+                            printf("  lpServiceClassId:        { 0x%08lX,0x%04X,0x%04X, { 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X } }\n",
+                                   result->lpServiceClassId->Data1, result->lpServiceClassId->Data2, result->lpServiceClassId->Data3, result->lpServiceClassId->Data4[0],
+                                   result->lpServiceClassId->Data4[1], result->lpServiceClassId->Data4[2], result->lpServiceClassId->Data4[3], result->lpServiceClassId->Data4[4],
+                                   result->lpServiceClassId->Data4[5], result->lpServiceClassId->Data4[6], result->lpServiceClassId->Data4[7]);
+                          else
+                            printf("  lpServiceClassId:        NULL\n");
+                          if (result->lpVersion)
+                            printf("  lpVersion:               0x%08lX, %d\n", result->lpVersion->dwVersion, result->lpVersion->ecHow);
+                          else
+                            printf("  lpVersion:               NULL\n");
+                          printf("  lpszComment:             %S\n", result->lpszComment ? result->lpszComment : L"NULL");
+                          printf("  dwNameSpace:             %lu\n", result->dwNameSpace);
+                          if (result->lpNSProviderId)
+                            printf("  lpNSProviderId:          { 0x%08lX,0x%04X,0x%04X, { 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X } }\n",
+                                   result->lpNSProviderId->Data1, result->lpNSProviderId->Data2, result->lpNSProviderId->Data3, result->lpNSProviderId->Data4[0],
+                                   result->lpNSProviderId->Data4[1], result->lpNSProviderId->Data4[2], result->lpNSProviderId->Data4[3], result->lpNSProviderId->Data4[4],
+                                   result->lpNSProviderId->Data4[5], result->lpNSProviderId->Data4[6], result->lpNSProviderId->Data4[7]);
+                          else
+                            printf("  lpNSProviderId:          NULL\n");
+                          printf("  lpszContext:             %S\n", result->lpszContext ? result->lpszContext : L"NULL");
+                          printf("  dwNumberOfProtocols:     %lu\n", result->dwNumberOfProtocols);
+                          printf("  lpszQueryString:         %S\n", result->lpszQueryString ? result->lpszQueryString : L"NULL");
+                          printf("  dwNumberOfCsAddrs:       %lu\n", result->dwNumberOfCsAddrs);
+                          for (i = 0; i < result->dwNumberOfCsAddrs; i++)
+                            {
+                              switch (result->lpcsaBuffer[i].iSocketType)
+                                {
+                                case SOCK_STREAM:
+                                  printf("    %d: iSocketType = SOCK_STREAM\n", i);
+                                  break;
+
+                                case SOCK_DGRAM:
+                                  printf("    %d: iSocketType = SOCK_DGRAM\n", i);
+                                  break;
+
+                                default:
+                                  printf("    %d: iSocketType = %d\n", i, result->lpcsaBuffer[i].iSocketType);
+                                }
+                              switch (result->lpcsaBuffer[i].iProtocol)
+                                {
+                                case IPPROTO_TCP:
+                                  printf("    %d: iProtocol   = IPPROTO_TCP\n", i);
+                                  break;
+
+                                case IPPROTO_UDP:
+                                  printf("    %d: iProtocol   = IPPROTO_UDP\n", i);
+                                  break;
+
+                                default:
+                                  printf("    %d: iProtocol   = %d\n", i, result->lpcsaBuffer[i].iProtocol);
+                                }
+                              switch (result->lpcsaBuffer[i].LocalAddr.lpSockaddr->sa_family)
+                                {
+                                case AF_INET:
+                                  printf("    %d: loc family  = AF_INET\n", i);
+                                  break;
+
+                                case AF_INET6:
+                                  printf("    %d: loc family  = AF_INET6\n", i);
+                                  break;
+
+                                default:
+                                  printf("    %d: loc family  = %hu\n", i, result->lpcsaBuffer[i].LocalAddr.lpSockaddr->sa_family);
+                                }
+                              switch (result->lpcsaBuffer[i].RemoteAddr.lpSockaddr->sa_family)
+                                {
+                                case AF_INET:
+                                  printf("    %d: rem family  = AF_INET\n", i);
+                                  break;
+
+                                case AF_INET6:
+                                  printf("    %d: rem family  = AF_INET6\n", i);
+                                  break;
+
+                                default:
+                                  printf("    %d: rem family = %hu\n", i, result->lpcsaBuffer[i].RemoteAddr.lpSockaddr->sa_family);
+                                }
+                              char buf[1024];
+                              DWORD buflen = 1024;
+                              if (NO_ERROR == WSAAddressToStringA(result->lpcsaBuffer[i].LocalAddr.lpSockaddr, result->lpcsaBuffer[i].LocalAddr.iSockaddrLength, NULL, buf, &buflen))
+                                printf("\tLocal Address #%d: %s\n", i, buf);
+                              else
+                                printf("\tLocal Address #%d: Can't convert: %lu\n", i, GetLastError());
+                              buflen = 1024;
+                              if (NO_ERROR == WSAAddressToStringA(result->lpcsaBuffer[i].RemoteAddr.lpSockaddr, result->lpcsaBuffer[i].RemoteAddr.iSockaddrLength, NULL, buf, &buflen))
+                                printf("\tRemote Address #%d: %s\n", i, buf);
+                              else
+                                printf("\tRemote Address #%d: Can't convert: %lu\n", i, GetLastError());
+                            }
+                          printf("  dwOutputFlags:           0x%08lX\n", result->dwOutputFlags);
+                          printf("  lpBlob:                  0x%p\n", result->lpBlob);
+                          if (result->lpBlob)
+                            {
+                              struct hostent *he = malloc(result->lpBlob->cbSize);
+                              if (he != NULL)
+                                {
+                                  GNUNET_memcpy(he, result->lpBlob->pBlobData, result->lpBlob->cbSize);
+                                  UnpackHostEnt(he);
+                                  print_hostent(he);
+                                  free(he);
+                                }
+                            }
+                        }
+                      ret = api.NSPLookupServiceEnd(lookup);
+                      if (ret != NO_ERROR)
+                        printf("NSPLookupServiceEnd() failed: %lu\n", GetLastError());
+                    }
+                  api.NSPCleanup(&prov);
                 }
-              }
             }
-            ret = api.NSPLookupServiceEnd (lookup);
-            if (ret != NO_ERROR)
-              printf ("NSPLookupServiceEnd() failed: %lu\n", GetLastError ());
-          }
-          api.NSPCleanup (&prov);
+          FreeLibrary(nsp);
         }
-      }
-      FreeLibrary (nsp);
     }
-  }
   else if (wargc == 3)
-  {
-    int s;
-    ADDRINFOW hints;
-    ADDRINFOW *result;
-    ADDRINFOW *pos;
+    {
+      int s;
+      ADDRINFOW hints;
+      ADDRINFOW *result;
+      ADDRINFOW *pos;
 
-    memset (&hints, 0, sizeof (struct addrinfo));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
+      memset(&hints, 0, sizeof(struct addrinfo));
+      hints.ai_family = AF_UNSPEC;
+      hints.ai_socktype = SOCK_STREAM;
 
-    if (0 != (s = GetAddrInfoW (wargv[2], NULL, &hints, &result)))
-    {
-      fprintf (stderr, "Cound not resolve `%S' using GetAddrInfoW: %lu\n",
-          wargv[2], GetLastError ());
-    }
-    else
-    {
-      for (pos = result; pos != NULL; pos = pos->ai_next)
-      {
-        wchar_t tmpbuf[1024];
-        DWORD buflen = 1024;
-        if (0 == WSAAddressToStringW (pos->ai_addr, pos->ai_addrlen, NULL, tmpbuf, &buflen))
-          fprintf (stderr, "Result:\n"
-                         "  flags: 0x%X\n"
-                         "  family: 0x%X\n"
-                         "  socktype: 0x%X\n"
-                         "  protocol: 0x%X\n"
-                         "  addrlen: %u\n"
-                         "  addr: %S\n"
-                         "  canonname: %S\n",
-                         pos->ai_flags,
-                         pos->ai_family,
-                         pos->ai_socktype,
-                         pos->ai_protocol,
-                         pos->ai_addrlen,
-                         tmpbuf,
-                         pos->ai_canonname);
-        else
-          fprintf (stderr, "Result:\n"
-                         "  flags: 0x%X\n"
-                         "  family: 0x%X\n"
-                         "  socktype: 0x%X\n"
-                         "  protocol: 0x%X\n"
-                         "  addrlen: %u\n"
-                         "  addr: %S\n"
-                         "  canonname: %S\n",
-                         pos->ai_flags,
-                         pos->ai_family,
-                         pos->ai_socktype,
-                         pos->ai_protocol,
-                         pos->ai_addrlen,
-                         L"<can't stringify>",
-                         pos->ai_canonname);
-      }
-      if (NULL != result)
-        FreeAddrInfoW (result);
+      if (0 != (s = GetAddrInfoW(wargv[2], NULL, &hints, &result)))
+        {
+          fprintf(stderr, "Cound not resolve `%S' using GetAddrInfoW: %lu\n",
+                  wargv[2], GetLastError());
+        }
+      else
+        {
+          for (pos = result; pos != NULL; pos = pos->ai_next)
+            {
+              wchar_t tmpbuf[1024];
+              DWORD buflen = 1024;
+              if (0 == WSAAddressToStringW(pos->ai_addr, pos->ai_addrlen, NULL, tmpbuf, &buflen))
+                fprintf(stderr, "Result:\n"
+                        "  flags: 0x%X\n"
+                        "  family: 0x%X\n"
+                        "  socktype: 0x%X\n"
+                        "  protocol: 0x%X\n"
+                        "  addrlen: %u\n"
+                        "  addr: %S\n"
+                        "  canonname: %S\n",
+                        pos->ai_flags,
+                        pos->ai_family,
+                        pos->ai_socktype,
+                        pos->ai_protocol,
+                        pos->ai_addrlen,
+                        tmpbuf,
+                        pos->ai_canonname);
+              else
+                fprintf(stderr, "Result:\n"
+                        "  flags: 0x%X\n"
+                        "  family: 0x%X\n"
+                        "  socktype: 0x%X\n"
+                        "  protocol: 0x%X\n"
+                        "  addrlen: %u\n"
+                        "  addr: %S\n"
+                        "  canonname: %S\n",
+                        pos->ai_flags,
+                        pos->ai_family,
+                        pos->ai_socktype,
+                        pos->ai_protocol,
+                        pos->ai_addrlen,
+                        L"<can't stringify>",
+                        pos->ai_canonname);
+            }
+          if (NULL != result)
+            FreeAddrInfoW(result);
+        }
     }
-  }
   WSACleanup();
   return r;
 }
diff --git a/src/gns/w32nsp-uninstall.c b/src/gns/w32nsp-uninstall.c
index b2a9b083e..f5031f341 100644
--- a/src/gns/w32nsp-uninstall.c
+++ b/src/gns/w32nsp-uninstall.c
@@ -6,26 +6,26 @@
 #include <stdio.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   int ret;
   GUID id = GNUNET_NAMESPACE_PROVIDER_DNS;
   WSADATA wsd;
 
-  if (WSAStartup (MAKEWORD (2,2), &wsd) != 0)
-  {
-    fprintf (stderr, "WSAStartup () failed: %lu\n", GetLastError ());
-    return 5;
-  }
+  if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
+    {
+      fprintf(stderr, "WSAStartup () failed: %lu\n", GetLastError());
+      return 5;
+    }
 
-  ret = WSCUnInstallNameSpace (&id);
+  ret = WSCUnInstallNameSpace(&id);
   if (ret == NO_ERROR)
-  {
-    fprintf (stderr, "Uninstalled GNUnet DNS provider\n");
-    WSACleanup ();
-    return 0;
-  }
-  fprintf (stderr, "WSCUnInstallNameSpace () failed: %lu\n", GetLastError ());
-  WSACleanup ();
+    {
+      fprintf(stderr, "Uninstalled GNUnet DNS provider\n");
+      WSACleanup();
+      return 0;
+    }
+  fprintf(stderr, "WSCUnInstallNameSpace () failed: %lu\n", GetLastError());
+  WSACleanup();
   return 1;
 }
\ No newline at end of file
diff --git a/src/gns/w32nsp.c b/src/gns/w32nsp.c
index 56d07a50c..5178cb822 100644
--- a/src/gns/w32nsp.c
+++ b/src/gns/w32nsp.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file gns/w32nsp.c
  * @brief W32 integration for GNS
@@ -32,7 +32,7 @@
 #endif
 #if VERBOSE
 #  define __printf__ printf
-#  define DEBUGLOG(s, ...) printf (s, ##__VA_ARGS__)
+#  define DEBUGLOG(s, ...) printf(s, ## __VA_ARGS__)
 #endif
 
 #include <stdint.h>
@@ -80,8 +80,7 @@
 
 static CRITICAL_SECTION records_cs;
 
-struct record
-{
+struct record {
   SOCKET s;
   DWORD flags;
   uint8_t state;
@@ -94,58 +93,60 @@ static size_t records_len = 0;
 static size_t records_size = 0;
 
 static int
-resize_records ()
+resize_records()
 {
   size_t new_size = records_len > 0 ? records_len * 2 : 5;
-  struct record *new_records = malloc (new_size * sizeof (struct record));
+  struct record *new_records = malloc(new_size * sizeof(struct record));
+
   if (new_records == NULL)
-  {
-    SetLastError (WSA_NOT_ENOUGH_MEMORY);
-    return 0;
-  }
-  GNUNET_memcpy (new_records, records, records_len * sizeof (struct record));
-  memset (&new_records[records_len], 0, sizeof (struct record) * (new_size - records_len));
+    {
+      SetLastError(WSA_NOT_ENOUGH_MEMORY);
+      return 0;
+    }
+  GNUNET_memcpy(new_records, records, records_len * sizeof(struct record));
+  memset(&new_records[records_len], 0, sizeof(struct record) * (new_size - records_len));
   records_size = new_size;
-  free (records);
+  free(records);
   records = new_records;
   return 1;
 }
 
 static int
-add_record (SOCKET s, const wchar_t *name, DWORD flags)
+add_record(SOCKET s, const wchar_t *name, DWORD flags)
 {
   int res = 1;
   int i;
   int empty = -1;
+
   //EnterCriticalSection (&records_cs);
   for (i = 0; i < records_len; i++)
     if (records[i].state == 0)
       break;
   empty = i;
   if (i == records_len)
-  {
-    res = resize_records ();
-    if (res)
-      empty = records_len++;
-  }
+    {
+      res = resize_records();
+      if (res)
+        empty = records_len++;
+    }
   if (res)
-  {
-    struct record r;
-    r.s = s;
-    r.flags = flags;
-    r.name = (wchar_t *) name;
-    r.state = 1;
-    r.buf = NULL;
-    if (name)
-      r.name = wcsdup (name);
-    records[empty] = r;
-  }
+    {
+      struct record r;
+      r.s = s;
+      r.flags = flags;
+      r.name = (wchar_t *)name;
+      r.state = 1;
+      r.buf = NULL;
+      if (name)
+        r.name = wcsdup(name);
+      records[empty] = r;
+    }
   //LeaveCriticalSection (&records_cs);
   return res;
 }
 
 /* These are not defined by mingw.org headers at the moment*/
-typedef INT (WSPAPI *LPNSPIOCTL) (HANDLE,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSACOMPLETION,LPWSATHREADID);
+typedef INT (WSPAPI *LPNSPIOCTL)(HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSACOMPLETION, LPWSATHREADID);
 typedef struct _NSP_ROUTINE_XP {
   DWORD cbSize;
   DWORD dwMajorVersion;
@@ -162,39 +163,39 @@ typedef struct _NSP_ROUTINE_XP {
 } NSP_ROUTINE_XP;
 
 static SOCKET
-connect_to_dns_resolver ()
+connect_to_dns_resolver()
 {
   struct sockaddr_in addr;
   SOCKET r;
   int ret;
 
-  r = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  r = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (INVALID_SOCKET == r)
-  {
-    SetLastError (16004);
-    return r;
-  }
+    {
+      SetLastError(16004);
+      return r;
+    }
 
   addr.sin_family = AF_INET;
-  addr.sin_port = htons (5353); /* TCP 5353 is not registered; UDP 5353 is */
-  addr.sin_addr.s_addr = inet_addr ("127.0.0.1");
+  addr.sin_port = htons(5353);  /* TCP 5353 is not registered; UDP 5353 is */
+  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
-  ret = connect (r, (struct sockaddr *) &addr, sizeof (addr));
+  ret = connect(r, (struct sockaddr *)&addr, sizeof(addr));
   if (SOCKET_ERROR == ret)
-  {
-    DWORD err = GetLastError ();
-    closesocket (r);
-    SetLastError (err);
-    SetLastError (16005);
-    r = INVALID_SOCKET;
-  }
+    {
+      DWORD err = GetLastError();
+      closesocket(r);
+      SetLastError(err);
+      SetLastError(16005);
+      r = INVALID_SOCKET;
+    }
   return r;
 }
 
 static int
-send_name_to_ip_request (LPWSAQUERYSETW lpqsRestrictions,
-    LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags,
-    SOCKET *resolver)
+send_name_to_ip_request(LPWSAQUERYSETW lpqsRestrictions,
+                        LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags,
+                        SOCKET *resolver)
 {
   struct GNUNET_W32RESOLVER_GetMessage *msg;
   int af4 = 0;
@@ -202,91 +203,95 @@ send_name_to_ip_request (LPWSAQUERYSETW lpqsRestrictions,
   char *buf;
   int ret = 1;
   int i;
-  size_t size = sizeof (struct GNUNET_W32RESOLVER_GetMessage);
+  size_t size = sizeof(struct GNUNET_W32RESOLVER_GetMessage);
   size_t namelen = 0;
+
   if (lpqsRestrictions->lpszServiceInstanceName)
-    namelen = sizeof (wchar_t) * (wcslen (lpqsRestrictions->lpszServiceInstanceName) + 1);
+    namelen = sizeof(wchar_t) * (wcslen(lpqsRestrictions->lpszServiceInstanceName) + 1);
   size += namelen;
-  buf = malloc (size);
-  msg = (struct GNUNET_W32RESOLVER_GetMessage *) buf;
-  msg->header.size = htons (size);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST);
+  buf = malloc(size);
+  msg = (struct GNUNET_W32RESOLVER_GetMessage *)buf;
+  msg->header.size = htons(size);
+  msg->header.type = htons(GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST);
   if (lpqsRestrictions->dwNumberOfProtocols > 0)
-  {
-    int i;
-    for (i = 0; i < lpqsRestrictions->dwNumberOfProtocols; i++)
     {
-      if (lpqsRestrictions->lpafpProtocols[0].iAddressFamily == AF_INET)
-        af4 = 1;
-      if (lpqsRestrictions->lpafpProtocols[0].iAddressFamily == AF_INET6)
-        af6 = 1;
+      int i;
+      for (i = 0; i < lpqsRestrictions->dwNumberOfProtocols; i++)
+        {
+          if (lpqsRestrictions->lpafpProtocols[0].iAddressFamily == AF_INET)
+            af4 = 1;
+          if (lpqsRestrictions->lpafpProtocols[0].iAddressFamily == AF_INET6)
+            af6 = 1;
+        }
     }
-  }
   if (af4 && !af6)
-    msg->af = htonl (AF_INET);
+    msg->af = htonl(AF_INET);
   else if (af6 && !af4)
-    msg->af = htonl (AF_INET6);
+    msg->af = htonl(AF_INET6);
   else
-    msg->af = htonl (AF_UNSPEC);
+    msg->af = htonl(AF_UNSPEC);
   if (lpqsRestrictions->lpszServiceInstanceName)
-    GNUNET_memcpy (&msg[1], lpqsRestrictions->lpszServiceInstanceName, namelen);
-  msg->sc_data1 = htonl (lpqsRestrictions->lpServiceClassId->Data1);
-  msg->sc_data2 = htons (lpqsRestrictions->lpServiceClassId->Data2);
-  msg->sc_data3 = htons (lpqsRestrictions->lpServiceClassId->Data3);
+    GNUNET_memcpy(&msg[1], lpqsRestrictions->lpszServiceInstanceName, namelen);
+  msg->sc_data1 = htonl(lpqsRestrictions->lpServiceClassId->Data1);
+  msg->sc_data2 = htons(lpqsRestrictions->lpServiceClassId->Data2);
+  msg->sc_data3 = htons(lpqsRestrictions->lpServiceClassId->Data3);
   for (i = 0; i < 8; i++)
     msg->sc_data4[i] = lpqsRestrictions->lpServiceClassId->Data4[i];
-  *resolver = connect_to_dns_resolver ();
+  *resolver = connect_to_dns_resolver();
   if (*resolver != INVALID_SOCKET)
-  {
-    if (size != send (*resolver, buf, size, 0))
     {
+      if (size != send(*resolver, buf, size, 0))
+        {
 #if VERBOSE
-      DWORD err = GetLastError ();
+          DWORD err = GetLastError();
 #endif
-      closesocket (*resolver);
-      *resolver = INVALID_SOCKET;
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to send request: %lu\n", err);
-      SetLastError (WSATRY_AGAIN);
-      ret = 0;
+          closesocket(*resolver);
+          *resolver = INVALID_SOCKET;
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: failed to send request: %lu\n", err);
+          SetLastError(WSATRY_AGAIN);
+          ret = 0;
+        }
     }
-  }
   else
     ret = 0;
-  free (buf);
+  free(buf);
   return ret;
 }
 
 static int WSPAPI
-NSPCleanup (LPGUID lpProviderId)
+NSPCleanup(LPGUID lpProviderId)
 {
-  DEBUGLOG ("NSPCleanup\n");
-  if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
-  {
-    return NO_ERROR;
-  }
-  SetLastError (WSAEINVALIDPROVIDER);
+  DEBUGLOG("NSPCleanup\n");
+  if (IsEqualGUID(lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
+    {
+      return NO_ERROR;
+    }
+  SetLastError(WSAEINVALIDPROVIDER);
   return SOCKET_ERROR;
 }
 
 BOOL WINAPI
-DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
   switch (fdwReason)
-  {
+    {
     case DLL_PROCESS_ATTACH:
-      if (!InitializeCriticalSectionAndSpinCount (&records_cs, 0x00000400))
-      {
-        return FALSE;
-      }
+      if (!InitializeCriticalSectionAndSpinCount(&records_cs, 0x00000400))
+        {
+          return FALSE;
+        }
       break;
+
     case DLL_THREAD_ATTACH:
       break;
+
     case DLL_THREAD_DETACH:
       break;
+
     case DLL_PROCESS_DETACH:
-      DeleteCriticalSection (&records_cs);
+      DeleteCriticalSection(&records_cs);
       break;
-  }
+    }
   return TRUE;
 }
 
@@ -294,374 +299,375 @@ DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 
 
 static int WSPAPI
-GNUNET_W32NSP_LookupServiceBegin (LPGUID lpProviderId, LPWSAQUERYSETW lpqsRestrictions,
-    LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags,
-    LPHANDLE lphLookup)
+GNUNET_W32NSP_LookupServiceBegin(LPGUID lpProviderId, LPWSAQUERYSETW lpqsRestrictions,
+                                 LPWSASERVICECLASSINFOW lpServiceClassInfo, DWORD dwControlFlags,
+                                 LPHANDLE lphLookup)
 {
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin\n");
-  if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
-  {
-    SOCKET s;
-    if (lpqsRestrictions->dwNameSpace != NS_DNS && lpqsRestrictions->dwNameSpace != NS_ALL)
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin\n");
+  if (IsEqualGUID(lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
     {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong namespace\n");
-      SetLastError (WSAEINVAL);
+      SOCKET s;
+      if (lpqsRestrictions->dwNameSpace != NS_DNS && lpqsRestrictions->dwNameSpace != NS_ALL)
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: wrong namespace\n");
+          SetLastError(WSAEINVAL);
+          return SOCKET_ERROR;
+        }
+      if (lpqsRestrictions->lpszServiceInstanceName != NULL)
+        {
+          wchar_t *s = lpqsRestrictions->lpszServiceInstanceName;
+          size_t len = wcslen(s);
+          if (len >= 5 && wcscmp(&s[len - 5], L".zkey") == 0)
+            {
+            }
+          else if (len >= 4 && wcscmp(&s[len - 4], L".gnu") == 0)
+            {
+            }
+          else
+            {
+              DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: unsupported TLD\n");
+              SetLastError(WSAEINVAL);
+              return SOCKET_ERROR;
+            }
+        }
+
+      if (send_name_to_ip_request(lpqsRestrictions,
+                                  lpServiceClassInfo, dwControlFlags, &s))
+        {
+          if (!(add_record(s, lpqsRestrictions->lpszServiceInstanceName, dwControlFlags)))
+            {
+              DWORD err = GetLastError();
+              DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: failed to add a record\n");
+              closesocket(s);
+              SetLastError(err);
+              return SOCKET_ERROR;
+            }
+          *lphLookup = (HANDLE)s;
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: OK (%lu)\n", GetLastError());
+          return NO_ERROR;
+        }
       return SOCKET_ERROR;
     }
-    if (lpqsRestrictions->lpszServiceInstanceName != NULL)
-    {
-      wchar_t *s = lpqsRestrictions->lpszServiceInstanceName;
-      size_t len = wcslen (s);
-      if (len >= 5 && wcscmp (&s[len - 5], L".zkey") == 0)
-      {
-      }
-      else if (len >= 4 && wcscmp (&s[len - 4], L".gnu") == 0)
-      {
-      }
-      else
-      {
-        DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: unsupported TLD\n");
-        SetLastError (WSAEINVAL);
-        return SOCKET_ERROR;
-      }
-    }
-
-    if (send_name_to_ip_request (lpqsRestrictions,
-        lpServiceClassInfo, dwControlFlags, &s))
-    {
-      if (!(add_record (s, lpqsRestrictions->lpszServiceInstanceName, dwControlFlags)))
-      {
-        DWORD err = GetLastError ();
-        DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: failed to add a record\n");
-        closesocket (s);
-        SetLastError (err);
-        return SOCKET_ERROR;
-      }
-      *lphLookup = (HANDLE) s;
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: OK (%lu)\n", GetLastError ());
-      return NO_ERROR;
-    }
-    return SOCKET_ERROR;
-  }
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceBegin: wrong provider\n");
-  SetLastError (WSAEINVALIDPROVIDER);
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceBegin: wrong provider\n");
+  SetLastError(WSAEINVALIDPROVIDER);
   return SOCKET_ERROR;
 }
 
 #define UnmarshallPtr(ptr, ptrtype, base) \
   if (ptr) \
-    ptr = (ptrtype *) (base + (uintptr_t) ptr)
+  ptr = (ptrtype *) (base + (uintptr_t)ptr)
 
 static void
-UnmarshallWSAQUERYSETW (LPWSAQUERYSETW req)
+UnmarshallWSAQUERYSETW(LPWSAQUERYSETW req)
 {
   int i;
-  char *base = (char *) req;
-  UnmarshallPtr (req->lpszServiceInstanceName, wchar_t, base);
-  UnmarshallPtr (req->lpServiceClassId, GUID, base);
-  UnmarshallPtr (req->lpVersion, WSAVERSION, base);
-  UnmarshallPtr (req->lpszComment, wchar_t, base);
-  UnmarshallPtr (req->lpNSProviderId, GUID, base);
-  UnmarshallPtr (req->lpszContext, wchar_t, base);
-  UnmarshallPtr (req->lpafpProtocols, AFPROTOCOLS, base);
-  UnmarshallPtr (req->lpszQueryString, wchar_t, base);
-  UnmarshallPtr (req->lpcsaBuffer, CSADDR_INFO, base);
+  char *base = (char *)req;
+
+  UnmarshallPtr(req->lpszServiceInstanceName, wchar_t, base);
+  UnmarshallPtr(req->lpServiceClassId, GUID, base);
+  UnmarshallPtr(req->lpVersion, WSAVERSION, base);
+  UnmarshallPtr(req->lpszComment, wchar_t, base);
+  UnmarshallPtr(req->lpNSProviderId, GUID, base);
+  UnmarshallPtr(req->lpszContext, wchar_t, base);
+  UnmarshallPtr(req->lpafpProtocols, AFPROTOCOLS, base);
+  UnmarshallPtr(req->lpszQueryString, wchar_t, base);
+  UnmarshallPtr(req->lpcsaBuffer, CSADDR_INFO, base);
   for (i = 0; i < req->dwNumberOfCsAddrs; i++)
-  {
-    UnmarshallPtr (req->lpcsaBuffer[i].LocalAddr.lpSockaddr, SOCKADDR, base);
-    UnmarshallPtr (req->lpcsaBuffer[i].RemoteAddr.lpSockaddr, SOCKADDR, base);
-  }
-  UnmarshallPtr (req->lpBlob, BLOB, base);
+    {
+      UnmarshallPtr(req->lpcsaBuffer[i].LocalAddr.lpSockaddr, SOCKADDR, base);
+      UnmarshallPtr(req->lpcsaBuffer[i].RemoteAddr.lpSockaddr, SOCKADDR, base);
+    }
+  UnmarshallPtr(req->lpBlob, BLOB, base);
   if (req->lpBlob)
-    UnmarshallPtr (req->lpBlob->pBlobData, BYTE, base);
+    UnmarshallPtr(req->lpBlob->pBlobData, BYTE, base);
 }
 
 static int WSAAPI
-GNUNET_W32NSP_LookupServiceNext (HANDLE hLookup, DWORD dwControlFlags,
-    LPDWORD lpdwBufferLength, LPWSAQUERYSETW lpqsResults)
+GNUNET_W32NSP_LookupServiceNext(HANDLE hLookup, DWORD dwControlFlags,
+                                LPDWORD lpdwBufferLength, LPWSAQUERYSETW lpqsResults)
 {
   /*DWORD effective_flags;*/
   int i;
-  struct GNUNET_MessageHeader header = {0, 0};
+  struct GNUNET_MessageHeader header = { 0, 0 };
   int rec = -1;
   int rc;
   int to_receive;
   int t;
   char *buf;
 
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext\n");
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceNext\n");
   //EnterCriticalSection (&records_cs);
   for (i = 0; i < records_len; i++)
-  {
-    if (records[i].s == (SOCKET) hLookup)
     {
-      rec = i;
-      break;
+      if (records[i].s == (SOCKET)hLookup)
+        {
+          rec = i;
+          break;
+        }
     }
-  }
   if (rec == -1)
-  {
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: invalid handle\n");
-    SetLastError (WSA_INVALID_HANDLE);
-    //LeaveCriticalSection (&records_cs);
-    return SOCKET_ERROR;
-  }
+    {
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: invalid handle\n");
+      SetLastError(WSA_INVALID_HANDLE);
+      //LeaveCriticalSection (&records_cs);
+      return SOCKET_ERROR;
+    }
   if (records[rec].state & 4)
-  {
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: session is closed\n");
-    SetLastError (WSA_E_NO_MORE);
-    //LeaveCriticalSection (&records_cs);
-    return SOCKET_ERROR;
-  }
+    {
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: session is closed\n");
+      SetLastError(WSA_E_NO_MORE);
+      //LeaveCriticalSection (&records_cs);
+      return SOCKET_ERROR;
+    }
   /*effective_flags = dwControlFlags & records[rec].flags;*/
   if (records[rec].buf)
-  {
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: checking buffer\n");
-    header = *((struct GNUNET_MessageHeader *) records[rec].buf);
-    if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage))
     {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n");
-      SetLastError (WSAEFAULT);
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: checking buffer\n");
+      header = *((struct GNUNET_MessageHeader *)records[rec].buf);
+      if (*lpdwBufferLength < header.size - sizeof(struct GNUNET_W32RESOLVER_GetMessage))
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n");
+          SetLastError(WSAEFAULT);
+          //LeaveCriticalSection (&records_cs);
+          return SOCKET_ERROR;
+        }
+      GNUNET_memcpy(lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)records[rec].buf)[1], header.size - sizeof(struct GNUNET_W32RESOLVER_GetMessage));
+      free(records[rec].buf);
+      records[rec].buf = NULL;
       //LeaveCriticalSection (&records_cs);
-      return SOCKET_ERROR;
+      UnmarshallWSAQUERYSETW((LPWSAQUERYSETW)lpqsResults);
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: OK (from buffer)\n");
+      return NO_ERROR;
     }
-    GNUNET_memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)records[rec].buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage));
-    free (records[rec].buf);
-    records[rec].buf = NULL;
-    //LeaveCriticalSection (&records_cs);
-    UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK (from buffer)\n");
-    return NO_ERROR;
-  }
   records[rec].state |= 8;
   //LeaveCriticalSection (&records_cs);
-  to_receive = sizeof (header);
+  to_receive = sizeof(header);
   rc = 0;
 #if VERBOSE
   {
     unsigned long have;
-    int ior = ioctlsocket ((SOCKET) hLookup, FIONREAD, &have);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: reading %d bytes as a header from %p, %lu bytes available\n", to_receive, hLookup, have);
+    int ior = ioctlsocket((SOCKET)hLookup, FIONREAD, &have);
+    DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: reading %d bytes as a header from %p, %lu bytes available\n", to_receive, hLookup, have);
   }
 #endif
   while (to_receive > 0)
-  {
-    t = recv ((SOCKET) hLookup, &((char *) &header)[rc], to_receive, 0);
-    if (t > 0)
     {
-      rc += t;
-      to_receive -= t;
+      t = recv((SOCKET)hLookup, &((char *)&header)[rc], to_receive, 0);
+      if (t > 0)
+        {
+          rc += t;
+          to_receive -= t;
+        }
+      else
+        break;
     }
-    else
-      break;
-  }
 #if VERBOSE
   {
     unsigned long have;
-    int ior = ioctlsocket ((SOCKET) hLookup, FIONREAD, &have);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: read %d bytes as a header from %p, %lu bytes available\n", rc, hLookup, have);
+    int ior = ioctlsocket((SOCKET)hLookup, FIONREAD, &have);
+    DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: read %d bytes as a header from %p, %lu bytes available\n", rc, hLookup, have);
   }
 #endif
   //EnterCriticalSection (&records_cs);
   records[rec].state &= ~8;
-  if (rc != sizeof (header))
-  {
-    if (records[rec].state & 2)
-    {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n");
-      SetLastError (WSA_E_CANCELLED);
-    }
-    else
+  if (rc != sizeof(header))
     {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data for a header (rc %d != %u, state is 0x%0X)\n", rc, sizeof (header), records[rec].state);
-      SetLastError (WSA_E_NO_MORE);
+      if (records[rec].state & 2)
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: call cancelled\n");
+          SetLastError(WSA_E_CANCELLED);
+        }
+      else
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data for a header (rc %d != %u, state is 0x%0X)\n", rc, sizeof(header), records[rec].state);
+          SetLastError(WSA_E_NO_MORE);
+        }
+      records[rec].state |= 4;
+      //LeaveCriticalSection (&records_cs);
+      return SOCKET_ERROR;
     }
-    records[rec].state |= 4;
-    //LeaveCriticalSection (&records_cs);
-    return SOCKET_ERROR;
-  }
   records[rec].state &= ~8;
-  header.type = ntohs (header.type);
-  header.size = ntohs (header.size);
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: header type %d, header size %u\n", header.type, header.size);
+  header.type = ntohs(header.type);
+  header.size = ntohs(header.size);
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: header type %d, header size %u\n", header.type, header.size);
   if (header.type != GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE ||
       (header.type == GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE &&
-      header.size == sizeof (header)))
-  {
-    records[rec].state |= 4;
-    if (header.type != GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE)
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: header type is wrong\n");
-    else
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: empty header - no data\n");
-    //LeaveCriticalSection (&records_cs);
-    SetLastError (WSA_E_NO_MORE);
-    return SOCKET_ERROR;
-  }
-  buf = malloc (header.size);
+       header.size == sizeof(header)))
+    {
+      records[rec].state |= 4;
+      if (header.type != GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE)
+        DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: header type is wrong\n");
+      else
+        DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: empty header - no data\n");
+      //LeaveCriticalSection (&records_cs);
+      SetLastError(WSA_E_NO_MORE);
+      return SOCKET_ERROR;
+    }
+  buf = malloc(header.size);
   if (buf == NULL)
-  {
-    records[rec].state |= 4;
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: malloc() failed\n");
-    //LeaveCriticalSection (&records_cs);
-    SetLastError (WSA_E_NO_MORE);
-    return SOCKET_ERROR;
-  }
+    {
+      records[rec].state |= 4;
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: malloc() failed\n");
+      //LeaveCriticalSection (&records_cs);
+      SetLastError(WSA_E_NO_MORE);
+      return SOCKET_ERROR;
+    }
   records[rec].state |= 8;
   //LeaveCriticalSection (&records_cs);
-  GNUNET_memcpy (buf, &header, sizeof (header));
-  to_receive = header.size - sizeof (header);
+  GNUNET_memcpy(buf, &header, sizeof(header));
+  to_receive = header.size - sizeof(header);
   rc = 0;
 #if VERBOSE
   {
     unsigned long have;
-    int ior = ioctlsocket ((SOCKET) hLookup, FIONREAD, &have);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: reading %d bytes as a body from %p, %lu bytes available\n", to_receive, hLookup, have);
+    int ior = ioctlsocket((SOCKET)hLookup, FIONREAD, &have);
+    DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: reading %d bytes as a body from %p, %lu bytes available\n", to_receive, hLookup, have);
   }
 #endif
   while (to_receive > 0)
-  {
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: recv (%d)\n", to_receive);
-    t = recv ((SOCKET) hLookup, &((char *) &((struct GNUNET_MessageHeader *) buf)[1])[rc], to_receive, 0);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: recv returned %d\n", t);
-    if (t > 0)
     {
-      rc += t;
-      to_receive -= t;
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: recv (%d)\n", to_receive);
+      t = recv((SOCKET)hLookup, &((char *)&((struct GNUNET_MessageHeader *)buf)[1])[rc], to_receive, 0);
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: recv returned %d\n", t);
+      if (t > 0)
+        {
+          rc += t;
+          to_receive -= t;
+        }
+      else
+        break;
     }
-    else
-      break;
-  }
 #if VERBOSE
   {
     unsigned long have;
-    int ior = ioctlsocket ((SOCKET) hLookup, FIONREAD, &have);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: read %d bytes as a body from %p, %lu bytes available\n", rc, hLookup, have);
+    int ior = ioctlsocket((SOCKET)hLookup, FIONREAD, &have);
+    DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: read %d bytes as a body from %p, %lu bytes available\n", rc, hLookup, have);
   }
 #endif
   //EnterCriticalSection (&records_cs);
   records[rec].state &= ~8;
-  if (rc != header.size - sizeof (header))
-  {
-    free (buf);
-    if (records[rec].state & 2)
+  if (rc != header.size - sizeof(header))
     {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: call cancelled\n");
-      SetLastError (WSA_E_CANCELLED);
+      free(buf);
+      if (records[rec].state & 2)
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: call cancelled\n");
+          SetLastError(WSA_E_CANCELLED);
+        }
+      else
+        {
+          DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data for the rest (rc %d != %d, state is 0x%0X)\n", rc, header.size - sizeof(header), records[rec].state);
+          SetLastError(WSA_E_NO_MORE);
+        }
+      records[rec].state |= 4;
+      //LeaveCriticalSection (&records_cs);
+      return SOCKET_ERROR;
     }
-    else
+  if (*lpdwBufferLength < header.size - sizeof(struct GNUNET_W32RESOLVER_GetMessage))
     {
-      DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: failed to receive enough data for the rest (rc %d != %d, state is 0x%0X)\n", rc, header.size - sizeof (header), records[rec].state);
-      SetLastError (WSA_E_NO_MORE);
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n");
+      SetLastError(WSAEFAULT);
+      records[rec].buf = buf;
+      //LeaveCriticalSection (&records_cs);
+      return SOCKET_ERROR;
     }
-    records[rec].state |= 4;
-    //LeaveCriticalSection (&records_cs);
-    return SOCKET_ERROR;
-  }
-  if (*lpdwBufferLength < header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage))
-  {
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: client buffer is too small\n");
-    SetLastError (WSAEFAULT);
-    records[rec].buf = buf;
-    //LeaveCriticalSection (&records_cs);
-    return SOCKET_ERROR;
-  }
   //LeaveCriticalSection (&records_cs);
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: writing %d bytes into result buffer\n", header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage));
-  GNUNET_memcpy (lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)buf)[1], header.size - sizeof (struct GNUNET_W32RESOLVER_GetMessage));
-  free (buf);
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: OK\n");
-  UnmarshallWSAQUERYSETW ((LPWSAQUERYSETW) lpqsResults);
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceNext: returning (%lu)\n", GetLastError ());
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: writing %d bytes into result buffer\n", header.size - sizeof(struct GNUNET_W32RESOLVER_GetMessage));
+  GNUNET_memcpy(lpqsResults, &((struct GNUNET_W32RESOLVER_GetMessage *)buf)[1], header.size - sizeof(struct GNUNET_W32RESOLVER_GetMessage));
+  free(buf);
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: OK\n");
+  UnmarshallWSAQUERYSETW((LPWSAQUERYSETW)lpqsResults);
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceNext: returning (%lu)\n", GetLastError());
   return NO_ERROR;
 }
 
 static int WSPAPI
-GNUNET_W32NSP_LookupServiceEnd (HANDLE hLookup)
+GNUNET_W32NSP_LookupServiceEnd(HANDLE hLookup)
 {
   int i;
   int rec = -1;
 
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd\n");
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceEnd\n");
   //EnterCriticalSection (&records_cs);
   for (i = 0; i < records_len; i++)
-  {
-    if (records[i].s == (SOCKET) hLookup)
     {
-      rec = i;
-      break;
+      if (records[i].s == (SOCKET)hLookup)
+        {
+          rec = i;
+          break;
+        }
     }
-  }
   if (rec == -1)
-  {
-    SetLastError (WSA_INVALID_HANDLE);
-    //LeaveCriticalSection (&records_cs);
-    DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: invalid handle\n");
-    return SOCKET_ERROR;
-  }
+    {
+      SetLastError(WSA_INVALID_HANDLE);
+      //LeaveCriticalSection (&records_cs);
+      DEBUGLOG("GNUNET_W32NSP_LookupServiceEnd: invalid handle\n");
+      return SOCKET_ERROR;
+    }
   records[rec].state |= 2;
-  closesocket (records[rec].s);
+  closesocket(records[rec].s);
   while (records[rec].state & 8)
-  {
-    //LeaveCriticalSection (&records_cs);
-    Sleep (10);
-    //EnterCriticalSection (&records_cs);
-  }
+    {
+      //LeaveCriticalSection (&records_cs);
+      Sleep(10);
+      //EnterCriticalSection (&records_cs);
+    }
   if (records[rec].buf)
-    free (records[rec].buf);
+    free(records[rec].buf);
   records[rec].buf = NULL;
   records[rec].state = 0;
   if (records[rec].name)
-    free (records[rec].name);
+    free(records[rec].name);
   //LeaveCriticalSection (&records_cs);
-  DEBUGLOG ("GNUNET_W32NSP_LookupServiceEnd: OK\n");
+  DEBUGLOG("GNUNET_W32NSP_LookupServiceEnd: OK\n");
   return NO_ERROR;
 }
 
 static int WSAAPI
-GNUNET_W32NSP_SetService (LPGUID lpProviderId,
-    LPWSASERVICECLASSINFOW lpServiceClassInfo, LPWSAQUERYSETW lpqsRegInfo,
-    WSAESETSERVICEOP essOperation, DWORD dwControlFlags)
+GNUNET_W32NSP_SetService(LPGUID lpProviderId,
+                         LPWSASERVICECLASSINFOW lpServiceClassInfo, LPWSAQUERYSETW lpqsRegInfo,
+                         WSAESETSERVICEOP essOperation, DWORD dwControlFlags)
 {
-  DEBUGLOG ("GNUNET_W32NSP_SetService\n");
-  SetLastError (WSAEOPNOTSUPP);
+  DEBUGLOG("GNUNET_W32NSP_SetService\n");
+  SetLastError(WSAEOPNOTSUPP);
   return SOCKET_ERROR;
 }
 
 static int WSAAPI
-GNUNET_W32NSP_InstallServiceClass (LPGUID lpProviderId,
-    LPWSASERVICECLASSINFOW lpServiceClassInfo)
+GNUNET_W32NSP_InstallServiceClass(LPGUID lpProviderId,
+                                  LPWSASERVICECLASSINFOW lpServiceClassInfo)
 {
-  DEBUGLOG ("GNUNET_W32NSP_InstallServiceClass\n");
-  SetLastError (WSAEOPNOTSUPP);
+  DEBUGLOG("GNUNET_W32NSP_InstallServiceClass\n");
+  SetLastError(WSAEOPNOTSUPP);
   return SOCKET_ERROR;
 }
 
 
 static int WSAAPI
-GNUNET_W32NSP_RemoveServiceClass (LPGUID lpProviderId, LPGUID lpServiceClassId)
+GNUNET_W32NSP_RemoveServiceClass(LPGUID lpProviderId, LPGUID lpServiceClassId)
 {
-  DEBUGLOG ("GNUNET_W32NSP_RemoveServiceClass\n");
-  SetLastError (WSAEOPNOTSUPP);
+  DEBUGLOG("GNUNET_W32NSP_RemoveServiceClass\n");
+  SetLastError(WSAEOPNOTSUPP);
   return SOCKET_ERROR;
 }
 
 static int WSAAPI
-GNUNET_W32NSP_GetServiceClassInfo (LPGUID lpProviderId, LPDWORD lpdwBufSize,
-  LPWSASERVICECLASSINFOW lpServiceClassInfo)
+GNUNET_W32NSP_GetServiceClassInfo(LPGUID lpProviderId, LPDWORD lpdwBufSize,
+                                  LPWSASERVICECLASSINFOW lpServiceClassInfo)
 {
-  DEBUGLOG ("GNUNET_W32NSP_GetServiceClassInfo\n");
-  SetLastError (WSAEOPNOTSUPP);
+  DEBUGLOG("GNUNET_W32NSP_GetServiceClassInfo\n");
+  SetLastError(WSAEOPNOTSUPP);
   return SOCKET_ERROR;
 }
 
 static int WSAAPI
-GNUNET_W32NSP_Ioctl (HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
-    DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
-    LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion,
-    LPWSATHREADID lpThreadId)
+GNUNET_W32NSP_Ioctl(HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
+                    DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
+                    LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion,
+                    LPWSATHREADID lpThreadId)
 {
-  DEBUGLOG ("GNUNET_W32NSP_Ioctl\n");
-  SetLastError (WSAEOPNOTSUPP);
+  DEBUGLOG("GNUNET_W32NSP_Ioctl\n");
+  SetLastError(WSAEOPNOTSUPP);
   return SOCKET_ERROR;
 }
 
@@ -671,35 +677,35 @@ GNUNET_W32NSP_Ioctl (HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
  * provider. All other routines are passed as pointers in lpnspRoutines.
  */
 int WSAAPI
-GNUNET_W32NSP_NSPStartup (LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines)
+GNUNET_W32NSP_NSPStartup(LPGUID lpProviderId, LPNSP_ROUTINE lpnspRoutines)
 {
-  if (IsEqualGUID (lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
-  {
-    if (!connect_to_dns_resolver ())
+  if (IsEqualGUID(lpProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS))
     {
-      return SOCKET_ERROR;
+      if (!connect_to_dns_resolver())
+        {
+          return SOCKET_ERROR;
+        }
+      /* This assumes that NSP_ROUTINE struct doesn't have a NSPIoctl member.
+       * If it does, you need to use FIELD_OFFSET() macro to get offset of NSPIoctl
+       * and use that offset as cbSize.
+       */
+      lpnspRoutines->cbSize = sizeof(NSP_ROUTINE);
+
+      lpnspRoutines->dwMajorVersion = NSPAPI_VERSION_MAJOR;
+      lpnspRoutines->dwMinorVersion = NSPAPI_VERSION_MINOR;
+      lpnspRoutines->NSPCleanup = NSPCleanup;
+      lpnspRoutines->NSPLookupServiceBegin = GNUNET_W32NSP_LookupServiceBegin;
+      lpnspRoutines->NSPLookupServiceNext = GNUNET_W32NSP_LookupServiceNext;
+      lpnspRoutines->NSPLookupServiceEnd = GNUNET_W32NSP_LookupServiceEnd;
+      lpnspRoutines->NSPSetService = GNUNET_W32NSP_SetService;
+      lpnspRoutines->NSPInstallServiceClass = GNUNET_W32NSP_InstallServiceClass;
+      lpnspRoutines->NSPRemoveServiceClass = GNUNET_W32NSP_RemoveServiceClass;
+      lpnspRoutines->NSPGetServiceClassInfo = GNUNET_W32NSP_GetServiceClassInfo;
+      /*((NSP_ROUTINE_XP *) lpnspRoutines)->NSPIoctl = GNUNET_W32NSP_Ioctl;*/
+      lpnspRoutines->NSPIoctl = GNUNET_W32NSP_Ioctl;
+      return NO_ERROR;
     }
-    /* This assumes that NSP_ROUTINE struct doesn't have a NSPIoctl member.
-     * If it does, you need to use FIELD_OFFSET() macro to get offset of NSPIoctl
-     * and use that offset as cbSize.
-     */
-    lpnspRoutines->cbSize = sizeof(NSP_ROUTINE);
-
-    lpnspRoutines->dwMajorVersion = NSPAPI_VERSION_MAJOR;
-    lpnspRoutines->dwMinorVersion = NSPAPI_VERSION_MINOR;
-    lpnspRoutines->NSPCleanup = NSPCleanup;
-    lpnspRoutines->NSPLookupServiceBegin = GNUNET_W32NSP_LookupServiceBegin;
-    lpnspRoutines->NSPLookupServiceNext = GNUNET_W32NSP_LookupServiceNext;
-    lpnspRoutines->NSPLookupServiceEnd = GNUNET_W32NSP_LookupServiceEnd;
-    lpnspRoutines->NSPSetService = GNUNET_W32NSP_SetService;
-    lpnspRoutines->NSPInstallServiceClass = GNUNET_W32NSP_InstallServiceClass;
-    lpnspRoutines->NSPRemoveServiceClass = GNUNET_W32NSP_RemoveServiceClass;
-    lpnspRoutines->NSPGetServiceClassInfo = GNUNET_W32NSP_GetServiceClassInfo;
-    /*((NSP_ROUTINE_XP *) lpnspRoutines)->NSPIoctl = GNUNET_W32NSP_Ioctl;*/
-    lpnspRoutines->NSPIoctl = GNUNET_W32NSP_Ioctl;
-    return NO_ERROR;
-  }
-  SetLastError (WSAEINVALIDPROVIDER);
+  SetLastError(WSAEINVALIDPROVIDER);
   return SOCKET_ERROR;
 }
 
diff --git a/src/gns/w32resolver.h b/src/gns/w32resolver.h
index c73559cf0..17521ba50 100644
--- a/src/gns/w32resolver.h
+++ b/src/gns/w32resolver.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -50,8 +50,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * The last W32RESOLVER_RESPONSE will just be a header without any data
  * (used to indicate the end of the list).
  */
-struct GNUNET_W32RESOLVER_GetMessage
-{
+struct GNUNET_W32RESOLVER_GetMessage {
   /**
    * Type:  GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST
    */