uncrustify as demanded.

30 files changed, 8381 insertions, 8417 deletions

diff --git a/src/namestore/gnunet-namestore-fcfsd.c b/src/namestore/gnunet-namestore-fcfsd.c
index 58e824ea6..3abf1ed21 100644
--- a/src/namestore/gnunet-namestore-fcfsd.c
+++ b/src/namestore/gnunet-namestore-fcfsd.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-namestore-fcfsd.c
  * @brief HTTP daemon that offers first-come-first-serve GNS domain registration
@@ -74,41 +74,38 @@
 /**
  * Phases a request goes through.
  */
-enum Phase
-  {
-    /**
-     * Start phase (parsing POST, checking).
-     */
-    RP_START = 0,
-
-    /**
-     * Lookup to see if the domain name is taken.
-     */
-    RP_LOOKUP,
-
-    /**
-     * Storing of the record.
-     */
-    RP_PUT,
-
-    /**
-     * We're done with success.
-     */
-    RP_SUCCESS,
-
-    /**
-     * Send failure message.
-     */
-    RP_FAIL
-  };
+enum Phase {
+  /**
+   * Start phase (parsing POST, checking).
+   */
+  RP_START = 0,
+
+  /**
+   * Lookup to see if the domain name is taken.
+   */
+  RP_LOOKUP,
+
+  /**
+   * Storing of the record.
+   */
+  RP_PUT,
+
+  /**
+   * We're done with success.
+   */
+  RP_SUCCESS,
+
+  /**
+   * Send failure message.
+   */
+  RP_FAIL
+};
 
 
 /**
  * Data kept per request.
  */
-struct Request
-{
-
+struct Request {
   /**
    * Associated session.
    */
@@ -119,7 +116,7 @@ struct Request
    * a POST request).
    */
   struct MHD_PostProcessor *pp;
-   
+
   /**
    * MHD Connection
    */
@@ -161,14 +158,12 @@ struct Request
   char public_key[128];
 
   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
-
 };
 
 /**
  * Zoneinfo request
  */
-struct ZoneinfoRequest
-{
+struct ZoneinfoRequest {
   /**
    * List iterator
    */
@@ -247,21 +242,21 @@ static char *zone;
  * @param cls unused
  */
 static void
-do_httpd (void *cls);
+do_httpd(void *cls);
 
 
 /**
  * Schedule task to run MHD server now.
  */
 static void
-run_httpd_now ()
+run_httpd_now()
 {
   if (NULL != httpd_task)
-  {
-    GNUNET_SCHEDULER_cancel (httpd_task);
-    httpd_task = NULL;
-  }
-  httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
+    {
+      GNUNET_SCHEDULER_cancel(httpd_task);
+      httpd_task = NULL;
+    }
+  httpd_task = GNUNET_SCHEDULER_add_now(&do_httpd, NULL);
 }
 
 
@@ -269,22 +264,22 @@ run_httpd_now ()
  * Create fresh version of zone information.
  */
 static void
-update_zoneinfo_page (void *cls);
+update_zoneinfo_page(void *cls);
+
 
-  
 /**
  * Function called on error in zone iteration.
  */
 static void
-zone_iteration_error (void *cls)
+zone_iteration_error(void *cls)
 {
   struct ZoneinfoRequest *zr = cls;
 
   zr->list_it = NULL;
-  GNUNET_free (zr->zoneinfo);
-  GNUNET_SCHEDULER_cancel (uzp_task);
-  uzp_task = GNUNET_SCHEDULER_add_now (&update_zoneinfo_page,
-                                       NULL);
+  GNUNET_free(zr->zoneinfo);
+  GNUNET_SCHEDULER_cancel(uzp_task);
+  uzp_task = GNUNET_SCHEDULER_add_now(&update_zoneinfo_page,
+                                      NULL);
 }
 
 
@@ -292,7 +287,7 @@ zone_iteration_error (void *cls)
  * Function called once the zone iteration is done.
  */
 static void
-zone_iteration_end (void *cls)
+zone_iteration_end(void *cls)
 {
   struct ZoneinfoRequest *zr = cls;
   struct MHD_Response *response;
@@ -301,19 +296,19 @@ zone_iteration_end (void *cls)
   zr->list_it = NULL;
 
   /* return static form */
-  GNUNET_asprintf (&full_page,
-                   ZONEINFO_PAGE,
-                   zr->zoneinfo,
-                   zr->zoneinfo);
-  response = MHD_create_response_from_buffer (strlen (full_page),
-                                              (void *) full_page,
-                                              MHD_RESPMEM_MUST_FREE);
-  MHD_add_response_header (response,
-                           MHD_HTTP_HEADER_CONTENT_TYPE,
-                           MIME_HTML);
-  MHD_destroy_response (info_page);
+  GNUNET_asprintf(&full_page,
+                  ZONEINFO_PAGE,
+                  zr->zoneinfo,
+                  zr->zoneinfo);
+  response = MHD_create_response_from_buffer(strlen(full_page),
+                                             (void *)full_page,
+                                             MHD_RESPMEM_MUST_FREE);
+  MHD_add_response_header(response,
+                          MHD_HTTP_HEADER_CONTENT_TYPE,
+                          MIME_HTML);
+  MHD_destroy_response(info_page);
   info_page = response;
-  GNUNET_free (zr->zoneinfo);
+  GNUNET_free(zr->zoneinfo);
 }
 
 
@@ -328,59 +323,59 @@ zone_iteration_end (void *cls)
  * @param rd array of records with data to store
  */
 static void
-iterate_cb (void *cls,
-            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-            const char *name,
-            unsigned int rd_len,
-            const struct GNUNET_GNSRECORD_Data *rd)
+iterate_cb(void *cls,
+           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+           const char *name,
+           unsigned int rd_len,
+           const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ZoneinfoRequest *zr = cls;
   size_t bytes_free;
   char* pkey;
   char* new_buf;
 
-  (void) zone_key;
+  (void)zone_key;
   if (1 != rd_len)
-  {
-    GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
-                                         1);
-    return;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iterator_next(zr->list_it,
+                                          1);
+      return;
+    }
 
   if (GNUNET_GNSRECORD_TYPE_PKEY != rd->record_type)
-  {
-    GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
-                                         1);
-    return;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iterator_next(zr->list_it,
+                                          1);
+      return;
+    }
 
   bytes_free = zr->buf_len - zr->write_offset;
-  pkey = GNUNET_GNSRECORD_value_to_string (rd->record_type,
-                                           rd->data,
-                                           rd->data_size);
+  pkey = GNUNET_GNSRECORD_value_to_string(rd->record_type,
+                                          rd->data,
+                                          rd->data_size);
   if (NULL == pkey)
-  {
-    GNUNET_break (0);
-    GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
-                                         1);
-    return;
-  }
-  if (bytes_free < (strlen (name) + strlen (pkey) + 40))
-  {
-    new_buf = GNUNET_malloc (zr->buf_len * 2);
-    GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
-    GNUNET_free (zr->zoneinfo);
-    zr->zoneinfo = new_buf;
-    zr->buf_len *= 2;
-  }
-  sprintf (zr->zoneinfo + zr->write_offset,
-           "<tr><td>%s</td><td>%s</td></tr>",
-           name,
-           pkey);
-  zr->write_offset = strlen (zr->zoneinfo);
-  GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
-                                       1);
-  GNUNET_free (pkey);
+    {
+      GNUNET_break(0);
+      GNUNET_NAMESTORE_zone_iterator_next(zr->list_it,
+                                          1);
+      return;
+    }
+  if (bytes_free < (strlen(name) + strlen(pkey) + 40))
+    {
+      new_buf = GNUNET_malloc(zr->buf_len * 2);
+      GNUNET_memcpy(new_buf, zr->zoneinfo, zr->write_offset);
+      GNUNET_free(zr->zoneinfo);
+      zr->zoneinfo = new_buf;
+      zr->buf_len *= 2;
+    }
+  sprintf(zr->zoneinfo + zr->write_offset,
+          "<tr><td>%s</td><td>%s</td></tr>",
+          name,
+          pkey);
+  zr->write_offset = strlen(zr->zoneinfo);
+  GNUNET_NAMESTORE_zone_iterator_next(zr->list_it,
+                                      1);
+  GNUNET_free(pkey);
 }
 
 
@@ -389,12 +384,12 @@ iterate_cb (void *cls,
  *
  * @param connection connection to use
  */
-static int 
-serve_zoneinfo_page (struct MHD_Connection *connection)
+static int
+serve_zoneinfo_page(struct MHD_Connection *connection)
 {
-  return MHD_queue_response (connection,
-                             MHD_HTTP_OK,
-                             info_page);
+  return MHD_queue_response(connection,
+                            MHD_HTTP_OK,
+                            info_page);
 }
 
 
@@ -402,27 +397,27 @@ serve_zoneinfo_page (struct MHD_Connection *connection)
  * Create fresh version of zone information.
  */
 static void
-update_zoneinfo_page (void *cls)
-{  
+update_zoneinfo_page(void *cls)
+{
   static struct ZoneinfoRequest zr;
 
-  (void) cls;
-  uzp_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                           &update_zoneinfo_page,
-                                           NULL);
+  (void)cls;
+  uzp_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
+                                          &update_zoneinfo_page,
+                                          NULL);
   if (NULL != zr.list_it)
-    return;  
-  zr.zoneinfo = GNUNET_malloc (DEFAULT_ZONEINFO_BUFSIZE);
+    return;
+  zr.zoneinfo = GNUNET_malloc(DEFAULT_ZONEINFO_BUFSIZE);
   zr.buf_len = DEFAULT_ZONEINFO_BUFSIZE;
   zr.write_offset = 0;
-  zr.list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
-                                                      &fcfs_zone_pkey,
-                                                      &zone_iteration_error,
-                                                      &zr,
-                                                      &iterate_cb,
-                                                      &zr,
-                                                      &zone_iteration_end,
-                                                      &zr);
+  zr.list_it = GNUNET_NAMESTORE_zone_iteration_start(ns,
+                                                     &fcfs_zone_pkey,
+                                                     &zone_iteration_error,
+                                                     &zr,
+                                                     &iterate_cb,
+                                                     &zr,
+                                                     &zone_iteration_end,
+                                                     &zr);
 }
 
 
@@ -433,22 +428,22 @@ update_zoneinfo_page (void *cls)
  * @return #MHD_YES on success
  */
 static int
-serve_main_page (struct MHD_Connection *connection)
+serve_main_page(struct MHD_Connection *connection)
 {
   int ret;
   struct MHD_Response *response;
 
   /* return static form */
-  response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
-                                              (void *) MAIN_PAGE,
-                                              MHD_RESPMEM_PERSISTENT);
-  MHD_add_response_header (response,
-                           MHD_HTTP_HEADER_CONTENT_TYPE,
-                           MIME_HTML);
-  ret = MHD_queue_response (connection,
-                            MHD_HTTP_OK,
-                            response);
-  MHD_destroy_response (response);
+  response = MHD_create_response_from_buffer(strlen(MAIN_PAGE),
+                                             (void *)MAIN_PAGE,
+                                             MHD_RESPMEM_PERSISTENT);
+  MHD_add_response_header(response,
+                          MHD_HTTP_HEADER_CONTENT_TYPE,
+                          MIME_HTML);
+  ret = MHD_queue_response(connection,
+                           MHD_HTTP_OK,
+                           response);
+  MHD_destroy_response(response);
   return ret;
 }
 
@@ -461,30 +456,30 @@ serve_main_page (struct MHD_Connection *connection)
  * @param connection connection to use
  */
 static int
-fill_s_reply (const char *info,
-              struct Request *request,
-              struct MHD_Connection *connection)
+fill_s_reply(const char *info,
+             struct Request *request,
+             struct MHD_Connection *connection)
 {
   int ret;
   char *reply;
   struct MHD_Response *response;
 
-  (void) request;
-  GNUNET_asprintf (&reply,
-                   SUBMIT_PAGE,
-                   info,
-                   info);
+  (void)request;
+  GNUNET_asprintf(&reply,
+                  SUBMIT_PAGE,
+                  info,
+                  info);
   /* return static form */
-  response = MHD_create_response_from_buffer (strlen (reply),
-                                              (void *) reply,
-                                              MHD_RESPMEM_MUST_FREE);
-  MHD_add_response_header (response,
-                           MHD_HTTP_HEADER_CONTENT_TYPE,
-                           MIME_HTML);
-  ret = MHD_queue_response (connection,
-                            MHD_HTTP_OK,
-                            response);
-  MHD_destroy_response (response);
+  response = MHD_create_response_from_buffer(strlen(reply),
+                                             (void *)reply,
+                                             MHD_RESPMEM_MUST_FREE);
+  MHD_add_response_header(response,
+                          MHD_HTTP_HEADER_CONTENT_TYPE,
+                          MIME_HTML);
+  ret = MHD_queue_response(connection,
+                           MHD_HTTP_OK,
+                           response);
+  MHD_destroy_response(response);
   return ret;
 }
 
@@ -509,45 +504,45 @@ fill_s_reply (const char *info,
  *         MHD_NO to abort the iteration
  */
 static int
-post_iterator (void *cls,
-               enum MHD_ValueKind kind,
-               const char *key,
-               const char *filename,
-               const char *content_type,
-               const char *transfer_encoding,
-               const char *data,
-               uint64_t off,
-               size_t size)
+post_iterator(void *cls,
+              enum MHD_ValueKind kind,
+              const char *key,
+              const char *filename,
+              const char *content_type,
+              const char *transfer_encoding,
+              const char *data,
+              uint64_t off,
+              size_t size)
 {
   struct Request *request = cls;
 
-  (void) kind;
-  (void) filename;
-  (void) content_type;
-  (void) transfer_encoding;
-  if (0 == strcmp ("domain", key))
+  (void)kind;
+  (void)filename;
+  (void)content_type;
+  (void)transfer_encoding;
+  if (0 == strcmp("domain", key))
     {
       if (size + off >= sizeof(request->domain_name))
-        size = sizeof (request->domain_name) - off - 1;
-      GNUNET_memcpy (&request->domain_name[off],
-              data,
-              size);
-      request->domain_name[size+off] = '\0';
+        size = sizeof(request->domain_name) - off - 1;
+      GNUNET_memcpy(&request->domain_name[off],
+                    data,
+                    size);
+      request->domain_name[size + off] = '\0';
       return MHD_YES;
     }
-  if (0 == strcmp ("pkey", key))
+  if (0 == strcmp("pkey", key))
     {
       if (size + off >= sizeof(request->public_key))
-        size = sizeof (request->public_key) - off - 1;
-      GNUNET_memcpy (&request->public_key[off],
-              data,
-              size);
-      request->public_key[size+off] = '\0';
+        size = sizeof(request->public_key) - off - 1;
+      GNUNET_memcpy(&request->public_key[off],
+                    data,
+                    size);
+      request->public_key[size + off] = '\0';
       return MHD_YES;
     }
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Unsupported form value `%s'\n"),
-              key);
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             _("Unsupported form value `%s'\n"),
+             key);
   return MHD_YES;
 }
 
@@ -563,25 +558,25 @@ post_iterator (void *cls,
  * @param emsg NULL on success, otherwise an error message
  */
 static void
-put_continuation (void *cls,
-                  int32_t success,
-                  const char *emsg)
+put_continuation(void *cls,
+                 int32_t success,
+                 const char *emsg)
 {
   struct Request *request = cls;
 
   request->qe = NULL;
   if (0 >= success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to create record for domain `%s': %s\n"),
-                request->domain_name,
-                emsg);
-    request->phase = RP_FAIL;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to create record for domain `%s': %s\n"),
+                 request->domain_name,
+                 emsg);
+      request->phase = RP_FAIL;
+    }
   else
     request->phase = RP_SUCCESS;
-  MHD_resume_connection (request->con);
-  run_httpd_now ();
+  MHD_resume_connection(request->con);
+  run_httpd_now();
 }
 
 
@@ -589,15 +584,15 @@ put_continuation (void *cls,
  * Function called if we had an error in zone-to-name mapping.
  */
 static void
-zone_to_name_error (void *cls)
+zone_to_name_error(void *cls)
 {
   struct Request *request = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Error when mapping zone to name\n"));
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             _("Error when mapping zone to name\n"));
   request->phase = RP_FAIL;
-  MHD_resume_connection (request->con);
-  run_httpd_now ();
+  MHD_resume_connection(request->con);
+  run_httpd_now();
 }
 
 
@@ -611,39 +606,39 @@ zone_to_name_error (void *cls)
  * @param rd array of records with data to store
  */
 static void
-zone_to_name_cb (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                 const char *name,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+zone_to_name_cb(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                const char *name,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Request *request = cls;
   struct GNUNET_GNSRECORD_Data r;
 
-  (void) rd;
-  (void) zone_key;
+  (void)rd;
+  (void)zone_key;
   request->qe = NULL;
   if (0 != rd_count)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Found existing name `%s' for the given key\n"),
-                name);
-    request->phase = RP_FAIL;
-    MHD_resume_connection (request->con);
-    run_httpd_now ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 _("Found existing name `%s' for the given key\n"),
+                 name);
+      request->phase = RP_FAIL;
+      MHD_resume_connection(request->con);
+      run_httpd_now();
+      return;
+    }
   r.data = &request->pub;
-  r.data_size = sizeof (request->pub);
+  r.data_size = sizeof(request->pub);
   r.expiration_time = UINT64_MAX;
   r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
   r.flags = GNUNET_GNSRECORD_RF_NONE;
-  request->qe = GNUNET_NAMESTORE_records_store (ns,
-                                                &fcfs_zone_pkey,
-                                                request->domain_name,
-                                                1, &r,
-                                                &put_continuation,
-                                                request);
+  request->qe = GNUNET_NAMESTORE_records_store(ns,
+                                               &fcfs_zone_pkey,
+                                               request->domain_name,
+                                               1, &r,
+                                               &put_continuation,
+                                               request);
 }
 
 
@@ -651,13 +646,14 @@ zone_to_name_cb (void *cls,
  * We encountered an error in the name lookup.
  */
 static void
-lookup_it_error (void *cls)
+lookup_it_error(void *cls)
 {
   struct Request *request = cls;
-  MHD_resume_connection (request->con);
+
+  MHD_resume_connection(request->con);
   request->qe = NULL;
   request->phase = RP_FAIL;
-  run_httpd_now ();
+  run_httpd_now();
 }
 
 
@@ -672,57 +668,58 @@ lookup_it_error (void *cls)
  * @param rd array of records with data to store
  */
 static void
-lookup_it_processor (void *cls,
-                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey,
-                        const char *label,
-                        unsigned int rd_count,
-                        const struct GNUNET_GNSRECORD_Data *rd)
+lookup_it_processor(void *cls,
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey,
+                    const char *label,
+                    unsigned int rd_count,
+                    const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Request *request = cls;
 
-  (void) label;
-  (void) rd;
-  (void) zonekey;
-  if (0 == strcmp (label, request->domain_name)) {
-    GNUNET_break (0 != rd_count);
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Found %u existing records for domain `%s'\n"),
-                rd_count,
-                request->domain_name);
-    request->phase = RP_FAIL;
-  }
-  GNUNET_NAMESTORE_zone_iterator_next (request->lookup_it, 1);
+  (void)label;
+  (void)rd;
+  (void)zonekey;
+  if (0 == strcmp(label, request->domain_name))
+    {
+      GNUNET_break(0 != rd_count);
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 _("Found %u existing records for domain `%s'\n"),
+                 rd_count,
+                 request->domain_name);
+      request->phase = RP_FAIL;
+    }
+  GNUNET_NAMESTORE_zone_iterator_next(request->lookup_it, 1);
 }
 
 static void
-lookup_it_finished (void *cls)
+lookup_it_finished(void *cls)
 {
   struct Request *request = cls;
-  
+
   if (RP_FAIL == request->phase)
-  {
-    MHD_resume_connection (request->con);
-    run_httpd_now ();
-    return;
-  }
+    {
+      MHD_resume_connection(request->con);
+      run_httpd_now();
+      return;
+    }
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_ecdsa_public_key_from_string (request->public_key,
-                                                  strlen (request->public_key),
-                                                  &request->pub))
-  {
-    GNUNET_break (0);
-    request->phase = RP_FAIL;
-    MHD_resume_connection (request->con);
-    run_httpd_now ();
-    return;
-  }
-  request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
-                                               &fcfs_zone_pkey,
-                                               &request->pub,
-                                               &zone_to_name_error,
-                                               request,
-                                               &zone_to_name_cb,
-                                               request);
+      GNUNET_CRYPTO_ecdsa_public_key_from_string(request->public_key,
+                                                 strlen(request->public_key),
+                                                 &request->pub))
+    {
+      GNUNET_break(0);
+      request->phase = RP_FAIL;
+      MHD_resume_connection(request->con);
+      run_httpd_now();
+      return;
+    }
+  request->qe = GNUNET_NAMESTORE_zone_to_name(ns,
+                                              &fcfs_zone_pkey,
+                                              &request->pub,
+                                              &zone_to_name_error,
+                                              request,
+                                              &zone_to_name_cb,
+                                              request);
 }
 
 /**
@@ -749,136 +746,141 @@ lookup_it_finished (void *cls)
  *         error while handling the request
  */
 static int
-create_response (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 **ptr)
+create_response(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 **ptr)
 {
   struct MHD_Response *response;
   struct Request *request;
   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
   int ret;
 
-  (void) cls;
-  (void) version;
-  if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
-       (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
-  {
-    if (0 == strcmp (url, FCFS_ZONEINFO_URL))
-      ret = serve_zoneinfo_page (connection);
-    else
-      ret = serve_main_page (connection);
-    if (ret != MHD_YES)
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to create page for `%s'\n"),
-                  url);
-    return ret;
-  }
-  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
-  {
-    request = *ptr;
-    if (NULL == request)
+  (void)cls;
+  (void)version;
+  if ((0 == strcmp(method, MHD_HTTP_METHOD_GET)) ||
+      (0 == strcmp(method, MHD_HTTP_METHOD_HEAD)))
     {
-      request = GNUNET_new (struct Request);
-      request->con = connection;
-      *ptr = request;
-      request->pp = MHD_create_post_processor (connection,
-                                               1024,
-                                               &post_iterator,
-                                               request);
-      if (NULL == request->pp)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _("Failed to setup post processor for `%s'\n"),
-                    url);
-        return MHD_NO; /* internal error */
-      }
-      return MHD_YES;
-    }
-    if (NULL != request->pp)
-    {
-      /* evaluate POST data */
-      MHD_post_process (request->pp,
-                        upload_data,
-                        *upload_data_size);
-      if (0 != *upload_data_size)
-      {
-        *upload_data_size = 0;
-        return MHD_YES;
-      }
-      /* done with POST data, serve response */
-      MHD_destroy_post_processor (request->pp);
-      request->pp = NULL;
+      if (0 == strcmp(url, FCFS_ZONEINFO_URL))
+        ret = serve_zoneinfo_page(connection);
+      else
+        ret = serve_main_page(connection);
+      if (ret != MHD_YES)
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   _("Failed to create page for `%s'\n"),
+                   url);
+      return ret;
     }
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_ecdsa_public_key_from_string (request->public_key,
-                                                    strlen (request->public_key),
-                                                    &pub))
+  if (0 == strcmp(method, MHD_HTTP_METHOD_POST))
     {
-      /* parse error */
-      return fill_s_reply ("Failed to parse given public key",
-                           request, connection);
-    }
-    switch (request->phase)
-    {
-      case RP_START:
-        if (NULL != strchr (request->domain_name, (int) '.'))
+      request = *ptr;
+      if (NULL == request)
         {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      _("Domain name must not contain `.'\n"));
-          request->phase = RP_FAIL;
-          return fill_s_reply ("Domain name must not contain `.', sorry.",
-                               request,
-                               connection);
+          request = GNUNET_new(struct Request);
+          request->con = connection;
+          *ptr = request;
+          request->pp = MHD_create_post_processor(connection,
+                                                  1024,
+                                                  &post_iterator,
+                                                  request);
+          if (NULL == request->pp)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         _("Failed to setup post processor for `%s'\n"),
+                         url);
+              return MHD_NO; /* internal error */
+            }
+          return MHD_YES;
         }
-        if (NULL != strchr (request->domain_name, (int) '+'))
+      if (NULL != request->pp)
         {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      _("Domain name must not contain `+'\n"));
-          request->phase = RP_FAIL;
-          return fill_s_reply ("Domain name must not contain `+', sorry.",
-                               request, connection);
+          /* evaluate POST data */
+          MHD_post_process(request->pp,
+                           upload_data,
+                           *upload_data_size);
+          if (0 != *upload_data_size)
+            {
+              *upload_data_size = 0;
+              return MHD_YES;
+            }
+          /* done with POST data, serve response */
+          MHD_destroy_post_processor(request->pp);
+          request->pp = NULL;
         }
-        request->phase = RP_LOOKUP;
-        MHD_suspend_connection (request->con);
-        request->lookup_it
-          = GNUNET_NAMESTORE_zone_iteration_start (ns,
-                                                   &fcfs_zone_pkey,
-                                                   &lookup_it_error,
-                                                   request,
-                                                   &lookup_it_processor,
-                                                   request,
-                                                   &lookup_it_finished,
-                                                   request);
-        break;
-      case RP_LOOKUP:
-        break;
-      case RP_PUT:
-        break;
-      case RP_FAIL:
-        return fill_s_reply ("Request failed, sorry.",
-                             request, connection);
-      case RP_SUCCESS:
-        return fill_s_reply ("Success.",
-                             request, connection);
-      default:
-        GNUNET_break (0);
-        return MHD_NO;
+      if (GNUNET_OK !=
+          GNUNET_CRYPTO_ecdsa_public_key_from_string(request->public_key,
+                                                     strlen(request->public_key),
+                                                     &pub))
+        {
+          /* parse error */
+          return fill_s_reply("Failed to parse given public key",
+                              request, connection);
+        }
+      switch (request->phase)
+        {
+        case RP_START:
+          if (NULL != strchr(request->domain_name, (int)'.'))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                         _("Domain name must not contain `.'\n"));
+              request->phase = RP_FAIL;
+              return fill_s_reply("Domain name must not contain `.', sorry.",
+                                  request,
+                                  connection);
+            }
+          if (NULL != strchr(request->domain_name, (int)'+'))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                         _("Domain name must not contain `+'\n"));
+              request->phase = RP_FAIL;
+              return fill_s_reply("Domain name must not contain `+', sorry.",
+                                  request, connection);
+            }
+          request->phase = RP_LOOKUP;
+          MHD_suspend_connection(request->con);
+          request->lookup_it
+            = GNUNET_NAMESTORE_zone_iteration_start(ns,
+                                                    &fcfs_zone_pkey,
+                                                    &lookup_it_error,
+                                                    request,
+                                                    &lookup_it_processor,
+                                                    request,
+                                                    &lookup_it_finished,
+                                                    request);
+          break;
+
+        case RP_LOOKUP:
+          break;
+
+        case RP_PUT:
+          break;
+
+        case RP_FAIL:
+          return fill_s_reply("Request failed, sorry.",
+                              request, connection);
+
+        case RP_SUCCESS:
+          return fill_s_reply("Success.",
+                              request, connection);
+
+        default:
+          GNUNET_break(0);
+          return MHD_NO;
+        }
+      return MHD_YES; /* will have a reply later... */
     }
-    return MHD_YES; /* will have a reply later... */
-  }
   /* unsupported HTTP method */
-  response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
-                                              (void *) METHOD_ERROR,
-                                              MHD_RESPMEM_PERSISTENT);
-  ret = MHD_queue_response (connection,
-                            MHD_HTTP_NOT_ACCEPTABLE,
-                            response);
-  MHD_destroy_response (response);
+  response = MHD_create_response_from_buffer(strlen(METHOD_ERROR),
+                                             (void *)METHOD_ERROR,
+                                             MHD_RESPMEM_PERSISTENT);
+  ret = MHD_queue_response(connection,
+                           MHD_HTTP_NOT_ACCEPTABLE,
+                           response);
+  MHD_destroy_response(response);
   return ret;
 }
 
@@ -893,23 +895,23 @@ create_response (void *cls,
  * @param toe status code
  */
 static void
-request_completed_callback (void *cls,
-                            struct MHD_Connection *connection,
-                            void **con_cls,
-                            enum MHD_RequestTerminationCode toe)
+request_completed_callback(void *cls,
+                           struct MHD_Connection *connection,
+                           void **con_cls,
+                           enum MHD_RequestTerminationCode toe)
 {
   struct Request *request = *con_cls;
 
-  (void) cls;
-  (void) connection;
-  (void) toe;
+  (void)cls;
+  (void)connection;
+  (void)toe;
   if (NULL == request)
     return;
   if (NULL != request->pp)
-    MHD_destroy_post_processor (request->pp);
+    MHD_destroy_post_processor(request->pp);
   if (NULL != request->qe)
-    GNUNET_NAMESTORE_cancel (request->qe);
-  GNUNET_free (request);
+    GNUNET_NAMESTORE_cancel(request->qe);
+  GNUNET_free(request);
 }
 
 
@@ -920,7 +922,7 @@ request_completed_callback (void *cls,
  * Schedule tasks to run MHD server.
  */
 static void
-run_httpd ()
+run_httpd()
 {
   fd_set rs;
   fd_set ws;
@@ -933,44 +935,44 @@ run_httpd ()
   UNSIGNED_MHD_LONG_LONG timeout;
   struct GNUNET_TIME_Relative tv;
 
-  FD_ZERO (&rs);
-  FD_ZERO (&ws);
-  FD_ZERO (&es);
-  wrs = GNUNET_NETWORK_fdset_create ();
-  wes = GNUNET_NETWORK_fdset_create ();
-  wws = GNUNET_NETWORK_fdset_create ();
+  FD_ZERO(&rs);
+  FD_ZERO(&ws);
+  FD_ZERO(&es);
+  wrs = GNUNET_NETWORK_fdset_create();
+  wes = GNUNET_NETWORK_fdset_create();
+  wws = GNUNET_NETWORK_fdset_create();
   max = -1;
-  GNUNET_assert (MHD_YES ==
-                 MHD_get_fdset (httpd,
-                                &rs,
-                                &ws,
-                                &es,
-                                &max));
-  haveto = MHD_get_timeout (httpd,
-                            &timeout);
+  GNUNET_assert(MHD_YES ==
+                MHD_get_fdset(httpd,
+                              &rs,
+                              &ws,
+                              &es,
+                              &max));
+  haveto = MHD_get_timeout(httpd,
+                           &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);
-  GNUNET_NETWORK_fdset_copy_native (wes,
-                                    &es,
-                                    max + 1);
+  GNUNET_NETWORK_fdset_copy_native(wrs,
+                                   &rs,
+                                   max + 1);
+  GNUNET_NETWORK_fdset_copy_native(wws,
+                                   &ws,
+                                   max + 1);
+  GNUNET_NETWORK_fdset_copy_native(wes,
+                                   &es,
+                                   max + 1);
   httpd_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                 tv,
-                                 wrs,
-                                 wws,
-                                 &do_httpd,
-                                 NULL);
-  GNUNET_NETWORK_fdset_destroy (wrs);
-  GNUNET_NETWORK_fdset_destroy (wws);
-  GNUNET_NETWORK_fdset_destroy (wes);
+    GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                tv,
+                                wrs,
+                                wws,
+                                &do_httpd,
+                                NULL);
+  GNUNET_NETWORK_fdset_destroy(wrs);
+  GNUNET_NETWORK_fdset_destroy(wws);
+  GNUNET_NETWORK_fdset_destroy(wes);
 }
 
 
@@ -980,12 +982,12 @@ run_httpd ()
  * @param cls unused
  */
 static void
-do_httpd (void *cls)
+do_httpd(void *cls)
 {
-  (void) cls;
+  (void)cls;
   httpd_task = NULL;
-  MHD_run (httpd);
-  run_httpd ();
+  MHD_run(httpd);
+  run_httpd();
 }
 
 
@@ -995,39 +997,39 @@ do_httpd (void *cls)
  * @param cls unused
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != httpd_task)
-  {
-    GNUNET_SCHEDULER_cancel (httpd_task);
-    httpd_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(httpd_task);
+      httpd_task = NULL;
+    }
   if (NULL != uzp_task)
-  {
-    GNUNET_SCHEDULER_cancel (uzp_task);
-    uzp_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(uzp_task);
+      uzp_task = NULL;
+    }
   if (NULL != ns)
-  {
-    GNUNET_NAMESTORE_disconnect (ns);
-    ns = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(ns);
+      ns = NULL;
+    }
   if (NULL != httpd)
-  {
-    MHD_stop_daemon (httpd);
-    httpd = NULL;
-  }
+    {
+      MHD_stop_daemon(httpd);
+      httpd = NULL;
+    }
   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;
+    }
 }
 
 
@@ -1051,56 +1053,55 @@ do_shutdown (void *cls)
  *                   must thus no longer be used
  */
 static void
-identity_cb (void *cls,
-             struct GNUNET_IDENTITY_Ego *ego,
-             void **ctx,
-             const char *name)
+identity_cb(void *cls,
+            struct GNUNET_IDENTITY_Ego *ego,
+            void **ctx,
+            const char *name)
 {
   int options;
 
-  (void) cls;
-  (void) ctx;
+  (void)cls;
+  (void)ctx;
   if (NULL == name)
     return;
-  if (0 != strcmp (name,
-                   zone))
+  if (0 != strcmp(name,
+                  zone))
     return;
   if (NULL == ego)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("No ego configured for `fcfsd` subsystem\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  fcfs_zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("No ego configured for `fcfsd` subsystem\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  fcfs_zone_pkey = *GNUNET_IDENTITY_ego_get_private_key(ego);
 
   options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
   do
-  {
-    httpd = MHD_start_daemon (options,
-                              (uint16_t) port,
-                              NULL, NULL,
-                              &create_response, NULL,
-                              MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
-                              MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
-                              MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-                              MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4 * 1024),
-                              MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
-                              MHD_OPTION_END);
-    if (MHD_USE_DEBUG == options)
-      break;
-    options = MHD_USE_DEBUG;
-  }
+    {
+      httpd = MHD_start_daemon(options,
+                               (uint16_t)port,
+                               NULL, NULL,
+                               &create_response, NULL,
+                               MHD_OPTION_CONNECTION_LIMIT, (unsigned int)128,
+                               MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int)1,
+                               MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int)16,
+                               MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t)(4 * 1024),
+                               MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
+                               MHD_OPTION_END);
+      if (MHD_USE_DEBUG == options)
+        break;
+      options = MHD_USE_DEBUG;
+    }
   while (NULL == httpd);
   if (NULL == httpd)
-  {
-
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to start HTTP server\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  run_httpd ();
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to start HTTP server\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  run_httpd();
 }
 
 
@@ -1113,44 +1114,44 @@ identity_cb (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;
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                             "fcfsd",
-                                             "HTTPPORT",
-                                             &port))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               "fcfsd", "HTTPPORT");
-    return;
-  }
-  ns = GNUNET_NAMESTORE_connect (cfg);
+      GNUNET_CONFIGURATION_get_value_number(cfg,
+                                            "fcfsd",
+                                            "HTTPPORT",
+                                            &port))
+    {
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+                                "fcfsd", "HTTPPORT");
+      return;
+    }
+  ns = GNUNET_NAMESTORE_connect(cfg);
   if (NULL == ns)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to connect to namestore\n"));
-    return;
-  }
-  identity = GNUNET_IDENTITY_connect (cfg,
-                                      &identity_cb,
-                                      NULL);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to namestore\n"));
+      return;
+    }
+  identity = GNUNET_IDENTITY_connect(cfg,
+                                     &identity_cb,
+                                     NULL);
   if (NULL == identity)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to connect to identity\n"));
-    return;
-  }
-  uzp_task = GNUNET_SCHEDULER_add_now (&update_zoneinfo_page,
-                                       NULL);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to identity\n"));
+      return;
+    }
+  uzp_task = GNUNET_SCHEDULER_add_now(&update_zoneinfo_page,
+                                      NULL);
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
 }
 
 
@@ -1162,38 +1163,38 @@ 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_mandatory 
-      (GNUNET_GETOPT_option_string ('z',
-                                    "zone",
-                                    "EGO",
-                                    gettext_noop ("name of the zone that is to be managed by FCFSD"),
-                                    &zone)),
+    GNUNET_GETOPT_option_mandatory
+      (GNUNET_GETOPT_option_string('z',
+                                   "zone",
+                                   "EGO",
+                                   gettext_noop("name of the zone that is to be managed by FCFSD"),
+                                   &zone)),
     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 ("fcfsd",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("fcfsd",
+                   "WARNING",
+                   NULL);
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run (argc,
-                         argv,
-                         "gnunet-namestore-fcfsd",
-                         _("GNU Name System First Come First Serve name registration service"),
-                         options,
-                         &run, NULL)) ? 0 : 1;
-  GNUNET_free ((void*) argv);
-  GNUNET_CRYPTO_ecdsa_key_clear (&fcfs_zone_pkey);
+     GNUNET_PROGRAM_run(argc,
+                        argv,
+                        "gnunet-namestore-fcfsd",
+                        _("GNU Name System First Come First Serve name registration service"),
+                        options,
+                        &run, NULL)) ? 0 : 1;
+  GNUNET_free((void*)argv);
+  GNUNET_CRYPTO_ecdsa_key_clear(&fcfs_zone_pkey);
   return ret;
 }
 
diff --git a/src/namestore/gnunet-namestore.c b/src/namestore/gnunet-namestore.c
index 2b814206b..cc1362a51 100644
--- a/src/namestore/gnunet-namestore.c
+++ b/src/namestore/gnunet-namestore.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-namestore.c
  * @brief command line tool to manipulate the local zone
@@ -37,8 +37,7 @@
 /**
  * Entry in record set for bulk processing.
  */
-struct RecordSetEntry
-{
+struct RecordSetEntry {
   /**
    * Kept in a linked list.
    */
@@ -228,75 +227,75 @@ static struct RecordSetEntry *recordset;
  * @param cls unused
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != get_default)
-  {
-    GNUNET_IDENTITY_cancel (get_default);
-    get_default = NULL;
-  }
+    {
+      GNUNET_IDENTITY_cancel(get_default);
+      get_default = NULL;
+    }
   if (NULL != idh)
-  {
-    GNUNET_IDENTITY_disconnect (idh);
-    idh = NULL;
-  }
+    {
+      GNUNET_IDENTITY_disconnect(idh);
+      idh = NULL;
+    }
   if (NULL != el)
-  {
-    GNUNET_IDENTITY_ego_lookup_cancel (el);
-    el = NULL;
-  }
+    {
+      GNUNET_IDENTITY_ego_lookup_cancel(el);
+      el = 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 != add_qe)
-  {
-    GNUNET_NAMESTORE_cancel (add_qe);
-    add_qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(add_qe);
+      add_qe = NULL;
+    }
   if (NULL != set_qe)
-  {
-    GNUNET_NAMESTORE_cancel (set_qe);
-    set_qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(set_qe);
+      set_qe = NULL;
+    }
   if (NULL != add_qe_uri)
-  {
-    GNUNET_NAMESTORE_cancel (add_qe_uri);
-    add_qe_uri = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(add_qe_uri);
+      add_qe_uri = NULL;
+    }
   if (NULL != get_qe)
-  {
-    GNUNET_NAMESTORE_cancel (get_qe);
-    get_qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(get_qe);
+      get_qe = NULL;
+    }
   if (NULL != del_qe)
-  {
-    GNUNET_NAMESTORE_cancel (del_qe);
-    del_qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(del_qe);
+      del_qe = NULL;
+    }
   if (NULL != ns)
-  {
-    GNUNET_NAMESTORE_disconnect (ns);
-    ns = NULL;
-  }
-  memset (&zone_pkey, 0, sizeof (zone_pkey));
+    {
+      GNUNET_NAMESTORE_disconnect(ns);
+      ns = NULL;
+    }
+  memset(&zone_pkey, 0, sizeof(zone_pkey));
   if (NULL != uri)
-  {
-    GNUNET_free (uri);
-    uri = NULL;
-  }
+    {
+      GNUNET_free(uri);
+      uri = NULL;
+    }
   if (NULL != zm)
-  {
-    GNUNET_NAMESTORE_zone_monitor_stop (zm);
-    zm = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_monitor_stop(zm);
+      zm = NULL;
+    }
   if (NULL != data)
-  {
-    GNUNET_free (data);
-    data = NULL;
-  }
+    {
+      GNUNET_free(data);
+      data = NULL;
+    }
 }
 
 
@@ -304,11 +303,11 @@ do_shutdown (void *cls)
  * Check if we are finished, and if so, perform shutdown.
  */
 static void
-test_finished ()
+test_finished()
 {
   if ((NULL == add_qe) && (NULL == add_qe_uri) && (NULL == get_qe) &&
       (NULL == del_qe) && (NULL == reverse_qe) && (NULL == list_it))
-    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -323,21 +322,21 @@ test_finished ()
  * @param emsg NULL on success, otherwise an error message
  */
 static void
-add_continuation (void *cls, int32_t success, const char *emsg)
+add_continuation(void *cls, int32_t success, const char *emsg)
 {
   struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
 
   *qe = NULL;
   if (GNUNET_YES != success)
-  {
-    fprintf (stderr,
-             _ ("Adding record failed: %s\n"),
-             (GNUNET_NO == success) ? "record exists" : emsg);
-    if (GNUNET_NO != success)
-      ret = 1;
-  }
+    {
+      fprintf(stderr,
+              _("Adding record failed: %s\n"),
+              (GNUNET_NO == success) ? "record exists" : emsg);
+      if (GNUNET_NO != success)
+        ret = 1;
+    }
   ret = 0;
-  test_finished ();
+  test_finished();
 }
 
 
@@ -352,25 +351,25 @@ add_continuation (void *cls, int32_t success, const char *emsg)
  * @param emsg NULL on success, otherwise an error message
  */
 static void
-del_continuation (void *cls, int32_t success, const char *emsg)
+del_continuation(void *cls, int32_t success, const char *emsg)
 {
-  (void) cls;
+  (void)cls;
   del_qe = NULL;
   if (GNUNET_NO == success)
-  {
-    fprintf (stderr,
-             _ ("Deleting record failed, record does not exist%s%s\n"),
-             (NULL != emsg) ? ": " : "",
-             (NULL != emsg) ? emsg : "");
-  }
+    {
+      fprintf(stderr,
+              _("Deleting record failed, record does not exist%s%s\n"),
+              (NULL != emsg) ? ": " : "",
+              (NULL != emsg) ? emsg : "");
+    }
   if (GNUNET_SYSERR == success)
-  {
-    fprintf (stderr,
-             _ ("Deleting record failed%s%s\n"),
-             (NULL != emsg) ? ": " : "",
-             (NULL != emsg) ? emsg : "");
-  }
-  test_finished ();
+    {
+      fprintf(stderr,
+              _("Deleting record failed%s%s\n"),
+              (NULL != emsg) ? ": " : "",
+              (NULL != emsg) ? emsg : "");
+    }
+  test_finished();
 }
 
 
@@ -378,11 +377,11 @@ del_continuation (void *cls, int32_t success, const char *emsg)
  * Function called when we are done with a zone iteration.
  */
 static void
-zone_iteration_finished (void *cls)
+zone_iteration_finished(void *cls)
 {
-  (void) cls;
+  (void)cls;
   list_it = NULL;
-  test_finished ();
+  test_finished();
 }
 
 
@@ -390,13 +389,13 @@ zone_iteration_finished (void *cls)
  * Function called when we encountered an error in a zone iteration.
  */
 static void
-zone_iteration_error_cb (void *cls)
+zone_iteration_error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   list_it = NULL;
-  fprintf (stderr, "Error iterating over zone\n");
+  fprintf(stderr, "Error iterating over zone\n");
   ret = 1;
-  test_finished ();
+  test_finished();
 }
 
 
@@ -408,9 +407,9 @@ zone_iteration_error_cb (void *cls)
  * @param rd array of records with data to store
  */
 static void
-display_record (const char *rname,
-                unsigned int rd_len,
-                const struct GNUNET_GNSRECORD_Data *rd)
+display_record(const char *rname,
+               unsigned int rd_len,
+               const struct GNUNET_GNSRECORD_Data *rd)
 {
   const char *typestr;
   char *s;
@@ -419,69 +418,69 @@ display_record (const char *rname,
   struct GNUNET_TIME_Relative rt;
   int have_record;
 
-  if ((NULL != name) && (0 != strcmp (name, rname)))
-  {
-    GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
-    return;
-  }
+  if ((NULL != name) && (0 != strcmp(name, rname)))
+    {
+      GNUNET_NAMESTORE_zone_iterator_next(list_it, 1);
+      return;
+    }
   have_record = GNUNET_NO;
   for (unsigned int i = 0; i < rd_len; i++)
-  {
-    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
-        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
-      continue;
-    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
-      continue;
-    have_record = GNUNET_YES;
-    break;
-  }
+    {
+      if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
+          (0 != strcmp(rname, GNUNET_GNS_EMPTY_LABEL_AT)))
+        continue;
+      if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
+        continue;
+      have_record = GNUNET_YES;
+      break;
+    }
   if (GNUNET_NO == have_record)
     return;
-  fprintf (stdout, "%s:\n", rname);
+  fprintf(stdout, "%s:\n", rname);
   if (NULL != typestring)
-    type = GNUNET_GNSRECORD_typename_to_number (typestring);
+    type = GNUNET_GNSRECORD_typename_to_number(typestring);
   else
     type = GNUNET_GNSRECORD_TYPE_ANY;
   for (unsigned int i = 0; i < rd_len; i++)
-  {
-    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
-        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
-      continue;
-    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
-      continue;
-    typestr = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
-    s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
-                                          rd[i].data,
-                                          rd[i].data_size);
-    if (NULL == s)
     {
-      fprintf (stdout,
-               _ ("\tCorrupt or unsupported record of type %u\n"),
-               (unsigned int) rd[i].record_type);
-      continue;
+      if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
+          (0 != strcmp(rname, GNUNET_GNS_EMPTY_LABEL_AT)))
+        continue;
+      if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
+        continue;
+      typestr = GNUNET_GNSRECORD_number_to_typename(rd[i].record_type);
+      s = GNUNET_GNSRECORD_value_to_string(rd[i].record_type,
+                                           rd[i].data,
+                                           rd[i].data_size);
+      if (NULL == s)
+        {
+          fprintf(stdout,
+                  _("\tCorrupt or unsupported record of type %u\n"),
+                  (unsigned int)rd[i].record_type);
+          continue;
+        }
+      if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+        {
+          rt.rel_value_us = rd[i].expiration_time;
+          ets = GNUNET_STRINGS_relative_time_to_string(rt, GNUNET_YES);
+        }
+      else
+        {
+          at.abs_value_us = rd[i].expiration_time;
+          ets = GNUNET_STRINGS_absolute_time_to_string(at);
+        }
+      fprintf(stdout,
+              "\t%s: %s (%s)\t%s\t%s\n",
+              typestr,
+              s,
+              ets,
+              (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
+              : "PUBLIC",
+              (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)) ? "SHADOW"
+              : "");
+      GNUNET_free(s);
     }
-    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
-    {
-      rt.rel_value_us = rd[i].expiration_time;
-      ets = GNUNET_STRINGS_relative_time_to_string (rt, GNUNET_YES);
-    }
-    else
-    {
-      at.abs_value_us = rd[i].expiration_time;
-      ets = GNUNET_STRINGS_absolute_time_to_string (at);
-    }
-    fprintf (stdout,
-             "\t%s: %s (%s)\t%s\t%s\n",
-             typestr,
-             s,
-             ets,
-             (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
-                                                                : "PUBLIC",
-             (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)) ? "SHADOW"
-                                                                      : "");
-    GNUNET_free (s);
-  }
-  fprintf (stdout, "%s", "\n");
+  fprintf(stdout, "%s", "\n");
 }
 
 
@@ -495,16 +494,16 @@ display_record (const char *rname,
  * @param rd array of records with data to store
  */
 static void
-display_record_iterator (void *cls,
-                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                         const char *rname,
-                         unsigned int rd_len,
-                         const struct GNUNET_GNSRECORD_Data *rd)
+display_record_iterator(void *cls,
+                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                        const char *rname,
+                        unsigned int rd_len,
+                        const struct GNUNET_GNSRECORD_Data *rd)
 {
-  (void) cls;
-  (void) zone_key;
-  display_record (rname, rd_len, rd);
-  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
+  (void)cls;
+  (void)zone_key;
+  display_record(rname, rd_len, rd);
+  GNUNET_NAMESTORE_zone_iterator_next(list_it, 1);
 }
 
 
@@ -518,16 +517,16 @@ display_record_iterator (void *cls,
  * @param rd array of records with data to store
  */
 static void
-display_record_monitor (void *cls,
-                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                        const char *rname,
-                        unsigned int rd_len,
-                        const struct GNUNET_GNSRECORD_Data *rd)
+display_record_monitor(void *cls,
+                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                       const char *rname,
+                       unsigned int rd_len,
+                       const struct GNUNET_GNSRECORD_Data *rd)
 {
-  (void) cls;
-  (void) zone_key;
-  display_record (rname, rd_len, rd);
-  GNUNET_NAMESTORE_zone_monitor_next (zm, 1);
+  (void)cls;
+  (void)zone_key;
+  display_record(rname, rd_len, rd);
+  GNUNET_NAMESTORE_zone_monitor_next(zm, 1);
 }
 
 
@@ -541,17 +540,17 @@ display_record_monitor (void *cls,
  * @param rd array of records with data to store
  */
 static void
-display_record_lookup (void *cls,
-                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                       const char *rname,
-                       unsigned int rd_len,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+display_record_lookup(void *cls,
+                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                      const char *rname,
+                      unsigned int rd_len,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
-  (void) cls;
-  (void) zone_key;
+  (void)cls;
+  (void)zone_key;
   get_qe = NULL;
-  display_record (rname, rd_len, rd);
-  test_finished ();
+  display_record(rname, rd_len, rd);
+  test_finished();
 }
 
 
@@ -561,10 +560,10 @@ display_record_lookup (void *cls,
  * @param cls NULL
  */
 static void
-sync_cb (void *cls)
+sync_cb(void *cls)
 {
-  (void) cls;
-  fprintf (stdout, "%s", "Monitor is now in sync.\n");
+  (void)cls;
+  fprintf(stdout, "%s", "Monitor is now in sync.\n");
 }
 
 
@@ -574,10 +573,10 @@ sync_cb (void *cls)
  * @param cls NULL
  */
 static void
-monitor_error_cb (void *cls)
+monitor_error_cb(void *cls)
 {
-  (void) cls;
-  fprintf (stderr, "%s", "Monitor disconnected and out of sync.\n");
+  (void)cls;
+  fprintf(stderr, "%s", "Monitor disconnected and out of sync.\n");
 }
 
 
@@ -587,12 +586,12 @@ monitor_error_cb (void *cls)
  * @param cls NULL
  */
 static void
-lookup_error_cb (void *cls)
+lookup_error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   get_qe = NULL;
-  fprintf (stderr, "%s", "Failed to lookup record.\n");
-  test_finished ();
+  fprintf(stderr, "%s", "Failed to lookup record.\n");
+  test_finished();
 }
 
 
@@ -600,13 +599,13 @@ lookup_error_cb (void *cls)
  * Function called if lookup fails.
  */
 static void
-add_error_cb (void *cls)
+add_error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   add_qe = NULL;
-  GNUNET_break (0);
+  GNUNET_break(0);
   ret = 1;
-  test_finished ();
+  test_finished();
 }
 
 
@@ -621,114 +620,118 @@ add_error_cb (void *cls)
  * @param rd array of records with data to store
  */
 static void
-get_existing_record (void *cls,
-                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                     const char *rec_name,
-                     unsigned int rd_count,
-                     const struct GNUNET_GNSRECORD_Data *rd)
+get_existing_record(void *cls,
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                    const char *rec_name,
+                    unsigned int rd_count,
+                    const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
   struct GNUNET_GNSRECORD_Data *rde;
 
-  (void) cls;
-  (void) zone_key;
+  (void)cls;
+  (void)zone_key;
   add_qe = NULL;
-  if (0 != strcmp (rec_name, name))
-  {
-    GNUNET_break (0);
-    ret = 1;
-    test_finished ();
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received %u records for name `%s'\n",
-              rd_count,
-              rec_name);
-  for (unsigned int i = 0; i < rd_count; i++)
-  {
-    switch (rd[i].record_type)
+  if (0 != strcmp(rec_name, name))
     {
-    case GNUNET_DNSPARSER_TYPE_CNAME:
-      fprintf (
-        stderr,
-        _ (
-          "A %s record exists already under `%s', no other records can be added.\n"),
-        "CNAME",
-        rec_name);
+      GNUNET_break(0);
       ret = 1;
-      test_finished ();
+      test_finished();
       return;
-    case GNUNET_GNSRECORD_TYPE_PKEY:
-      fprintf (
-        stderr,
-        _ (
-          "A %s record exists already under `%s', no other records can be added.\n"),
-        "PKEY",
-        rec_name);
-      ret = 1;
-      test_finished ();
-      return;
-    case GNUNET_DNSPARSER_TYPE_SOA:
-      if (GNUNET_DNSPARSER_TYPE_SOA == type)
-      {
-        fprintf (
-          stderr,
-          _ (
-            "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
-          rec_name);
-        ret = 1;
-        test_finished ();
-        return;
-      }
-      break;
     }
-  }
-  switch (type)
-  {
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-    if (0 != rd_count)
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received %u records for name `%s'\n",
+             rd_count,
+             rec_name);
+  for (unsigned int i = 0; i < rd_count; i++)
     {
-      fprintf (stderr,
-               _ (
-                 "Records already exist under `%s', cannot add `%s' record.\n"),
-               rec_name,
-               "CNAME");
-      ret = 1;
-      test_finished ();
-      return;
+      switch (rd[i].record_type)
+        {
+        case GNUNET_DNSPARSER_TYPE_CNAME:
+          fprintf(
+            stderr,
+            _(
+              "A %s record exists already under `%s', no other records can be added.\n"),
+            "CNAME",
+            rec_name);
+          ret = 1;
+          test_finished();
+          return;
+
+        case GNUNET_GNSRECORD_TYPE_PKEY:
+          fprintf(
+            stderr,
+            _(
+              "A %s record exists already under `%s', no other records can be added.\n"),
+            "PKEY",
+            rec_name);
+          ret = 1;
+          test_finished();
+          return;
+
+        case GNUNET_DNSPARSER_TYPE_SOA:
+          if (GNUNET_DNSPARSER_TYPE_SOA == type)
+            {
+              fprintf(
+                stderr,
+                _(
+                  "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
+                rec_name);
+              ret = 1;
+              test_finished();
+              return;
+            }
+          break;
+        }
     }
-    break;
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    if (0 != rd_count)
+  switch (type)
     {
-      fprintf (stderr,
-               _ (
-                 "Records already exist under `%s', cannot add `%s' record.\n"),
-               rec_name,
-               "PKEY");
-      ret = 1;
-      test_finished ();
-      return;
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+      if (0 != rd_count)
+        {
+          fprintf(stderr,
+                  _(
+                    "Records already exist under `%s', cannot add `%s' record.\n"),
+                  rec_name,
+                  "CNAME");
+          ret = 1;
+          test_finished();
+          return;
+        }
+      break;
+
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      if (0 != rd_count)
+        {
+          fprintf(stderr,
+                  _(
+                    "Records already exist under `%s', cannot add `%s' record.\n"),
+                  rec_name,
+                  "PKEY");
+          ret = 1;
+          test_finished();
+          return;
+        }
+      break;
+
+    case GNUNET_GNSRECORD_TYPE_GNS2DNS:
+      for (unsigned int i = 0; i < rd_count; i++)
+        if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
+          {
+            fprintf(
+              stderr,
+              _(
+                "Non-GNS2DNS records already exist under `%s', cannot add GNS2DNS record.\n"),
+              rec_name);
+            ret = 1;
+            test_finished();
+            return;
+          }
+      break;
     }
-    break;
-  case GNUNET_GNSRECORD_TYPE_GNS2DNS:
-    for (unsigned int i = 0; i < rd_count; i++)
-      if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
-      {
-        fprintf (
-          stderr,
-          _ (
-            "Non-GNS2DNS records already exist under `%s', cannot add GNS2DNS record.\n"),
-          rec_name);
-        ret = 1;
-        test_finished ();
-        return;
-      }
-    break;
-  }
-  memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
-  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
+  memset(rdn, 0, sizeof(struct GNUNET_GNSRECORD_Data));
+  GNUNET_memcpy(&rdn[1], rd, rd_count * sizeof(struct GNUNET_GNSRECORD_Data));
   rde = &rdn[0];
   rde->data = data;
   rde->data_size = data_size;
@@ -742,14 +745,14 @@ get_existing_record (void *cls,
     rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
   else if (GNUNET_NO != etime_is_rel)
     rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
-  GNUNET_assert (NULL != name);
-  add_qe = GNUNET_NAMESTORE_records_store (ns,
-                                           &zone_pkey,
-                                           name,
-                                           rd_count + 1,
-                                           rde,
-                                           &add_continuation,
-                                           &add_qe);
+  GNUNET_assert(NULL != name);
+  add_qe = GNUNET_NAMESTORE_records_store(ns,
+                                          &zone_pkey,
+                                          name,
+                                          rd_count + 1,
+                                          rde,
+                                          &add_continuation,
+                                          &add_qe);
 }
 
 
@@ -757,11 +760,11 @@ get_existing_record (void *cls,
  * Function called if we encountered an error in zone-to-name.
  */
 static void
-reverse_error_cb (void *cls)
+reverse_error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   reverse_qe = NULL;
-  fprintf (stdout, "%s.zkey\n", reverse_pkey);
+  fprintf(stdout, "%s.zkey\n", reverse_pkey);
 }
 
 
@@ -776,22 +779,22 @@ reverse_error_cb (void *cls)
  * @param rd array of records with data to store
  */
 static void
-handle_reverse_lookup (void *cls,
-                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                       const char *label,
-                       unsigned int rd_count,
-                       const struct GNUNET_GNSRECORD_Data *rd)
+handle_reverse_lookup(void *cls,
+                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                      const char *label,
+                      unsigned int rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
-  (void) cls;
-  (void) zone;
-  (void) rd_count;
-  (void) rd;
+  (void)cls;
+  (void)zone;
+  (void)rd_count;
+  (void)rd;
   reverse_qe = NULL;
   if (NULL == label)
-    fprintf (stdout, "%s\n", reverse_pkey);
+    fprintf(stdout, "%s\n", reverse_pkey);
   else
-    fprintf (stdout, "%s.%s\n", label, ego_name);
-  test_finished ();
+    fprintf(stdout, "%s.%s\n", label, ego_name);
+  test_finished();
 }
 
 
@@ -799,13 +802,13 @@ handle_reverse_lookup (void *cls,
  * Function called if lookup for deletion fails.
  */
 static void
-del_lookup_error_cb (void *cls)
+del_lookup_error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   del_qe = NULL;
-  GNUNET_break (0);
+  GNUNET_break(0);
   ret = 1;
-  test_finished ();
+  test_finished();
 }
 
 
@@ -821,80 +824,80 @@ del_lookup_error_cb (void *cls)
  * @param rd existing records
  */
 static void
-del_monitor (void *cls,
-             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-             const char *label,
-             unsigned int rd_count,
-             const struct GNUNET_GNSRECORD_Data *rd)
+del_monitor(void *cls,
+            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+            const char *label,
+            unsigned int rd_count,
+            const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data rdx[rd_count];
   unsigned int rd_left;
   uint32_t type;
   char *vs;
 
-  (void) cls;
-  (void) zone;
+  (void)cls;
+  (void)zone;
   del_qe = NULL;
   if (0 == rd_count)
-  {
-    fprintf (stderr,
-             _ (
-               "There are no records under label `%s' that could be deleted.\n"),
-             label);
-    ret = 1;
-    test_finished ();
-    return;
-  }
+    {
+      fprintf(stderr,
+              _(
+                "There are no records under label `%s' that could be deleted.\n"),
+              label);
+      ret = 1;
+      test_finished();
+      return;
+    }
   if ((NULL == value) && (NULL == typestring))
-  {
-    /* delete everything */
-    del_qe = GNUNET_NAMESTORE_records_store (ns,
-                                             &zone_pkey,
-                                             name,
-                                             0,
-                                             NULL,
-                                             &del_continuation,
-                                             NULL);
-    return;
-  }
+    {
+      /* delete everything */
+      del_qe = GNUNET_NAMESTORE_records_store(ns,
+                                              &zone_pkey,
+                                              name,
+                                              0,
+                                              NULL,
+                                              &del_continuation,
+                                              NULL);
+      return;
+    }
   rd_left = 0;
   if (NULL != typestring)
-    type = GNUNET_GNSRECORD_typename_to_number (typestring);
+    type = GNUNET_GNSRECORD_typename_to_number(typestring);
   else
     type = GNUNET_GNSRECORD_TYPE_ANY;
   for (unsigned int i = 0; i < rd_count; i++)
-  {
-    vs = NULL;
-    if (! (((GNUNET_GNSRECORD_TYPE_ANY == type) ||
-            (rd[i].record_type == type)) &&
-           ((NULL == value) ||
-            (NULL ==
-             (vs = (GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
+    {
+      vs = NULL;
+      if (!(((GNUNET_GNSRECORD_TYPE_ANY == type) ||
+             (rd[i].record_type == type)) &&
+            ((NULL == value) ||
+             (NULL ==
+              (vs = (GNUNET_GNSRECORD_value_to_string(rd[i].record_type,
                                                       rd[i].data,
                                                       rd[i].data_size)))) ||
-            (0 == strcmp (vs, value)))))
-      rdx[rd_left++] = rd[i];
-    GNUNET_free_non_null (vs);
-  }
+             (0 == strcmp(vs, value)))))
+        rdx[rd_left++] = rd[i];
+      GNUNET_free_non_null(vs);
+    }
   if (rd_count == rd_left)
-  {
-    /* nothing got deleted */
-    fprintf (
-      stderr,
-      _ (
-        "There are no records under label `%s' that match the request for deletion.\n"),
-      label);
-    test_finished ();
-    return;
-  }
+    {
+      /* nothing got deleted */
+      fprintf(
+        stderr,
+        _(
+          "There are no records under label `%s' that match the request for deletion.\n"),
+        label);
+      test_finished();
+      return;
+    }
   /* delete everything but what we copied to 'rdx' */
-  del_qe = GNUNET_NAMESTORE_records_store (ns,
-                                           &zone_pkey,
-                                           name,
-                                           rd_left,
-                                           rdx,
-                                           &del_continuation,
-                                           NULL);
+  del_qe = GNUNET_NAMESTORE_records_store(ns,
+                                          &zone_pkey,
+                                          name,
+                                          rd_left,
+                                          rdx,
+                                          &del_continuation,
+                                          NULL);
 }
 
 
@@ -907,39 +910,39 @@ del_monitor (void *cls,
  * @return #GNUNET_OK on success
  */
 static int
-parse_expiration (const char *expirationstring,
-                  int *etime_is_rel,
-                  uint64_t *etime)
+parse_expiration(const char *expirationstring,
+                 int *etime_is_rel,
+                 uint64_t *etime)
 {
   struct GNUNET_TIME_Relative etime_rel;
   struct GNUNET_TIME_Absolute etime_abs;
 
-  if (0 == strcmp (expirationstring, "never"))
-  {
-    *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
-    *etime_is_rel = GNUNET_NO;
-    return GNUNET_OK;
-  }
+  if (0 == strcmp(expirationstring, "never"))
+    {
+      *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
+      *etime_is_rel = GNUNET_NO;
+      return GNUNET_OK;
+    }
   if (GNUNET_OK ==
-      GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
-  {
-    *etime_is_rel = GNUNET_YES;
-    *etime = etime_rel.rel_value_us;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Storing record with relative expiration time of %s\n",
-                GNUNET_STRINGS_relative_time_to_string (etime_rel, GNUNET_NO));
-    return GNUNET_OK;
-  }
+      GNUNET_STRINGS_fancy_time_to_relative(expirationstring, &etime_rel))
+    {
+      *etime_is_rel = GNUNET_YES;
+      *etime = etime_rel.rel_value_us;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Storing record with relative expiration time of %s\n",
+                 GNUNET_STRINGS_relative_time_to_string(etime_rel, GNUNET_NO));
+      return GNUNET_OK;
+    }
   if (GNUNET_OK ==
-      GNUNET_STRINGS_fancy_time_to_absolute (expirationstring, &etime_abs))
-  {
-    *etime_is_rel = GNUNET_NO;
-    *etime = etime_abs.abs_value_us;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Storing record with absolute expiration time of %s\n",
-                GNUNET_STRINGS_absolute_time_to_string (etime_abs));
-    return GNUNET_OK;
-  }
+      GNUNET_STRINGS_fancy_time_to_absolute(expirationstring, &etime_abs))
+    {
+      *etime_is_rel = GNUNET_NO;
+      *etime = etime_abs.abs_value_us;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Storing record with absolute expiration time of %s\n",
+                 GNUNET_STRINGS_absolute_time_to_string(etime_abs));
+      return GNUNET_OK;
+    }
   return GNUNET_SYSERR;
 }
 
@@ -955,19 +958,19 @@ parse_expiration (const char *expirationstring,
  * @param emsg NULL on success, otherwise an error message
  */
 static void
-replace_cont (void *cls, int success, const char *emsg)
+replace_cont(void *cls, int success, const char *emsg)
 {
-  (void) cls;
+  (void)cls;
 
   set_qe = NULL;
   if (GNUNET_OK != success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                _ ("Failed to replace records: %s\n"),
-                emsg);
-    ret = 1; /* fail from 'main' */
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE,
+                 _("Failed to replace records: %s\n"),
+                 emsg);
+      ret = 1; /* fail from 'main' */
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -978,261 +981,261 @@ replace_cont (void *cls, int success, const char *emsg)
  * @param cfg configuration to use
  */
 static void
-run_with_zone_pkey (const struct GNUNET_CONFIGURATION_Handle *cfg)
+run_with_zone_pkey(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_GNSRECORD_Data rd;
 
-  if (! (add | del | list | (NULL != nickstring) | (NULL != uri) |
-         (NULL != reverse_pkey) | (NULL != recordset)))
-  {
-    /* nothing more to be done */
-    fprintf (stderr, _ ("No options given\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  ns = GNUNET_NAMESTORE_connect (cfg);
-  if (NULL == ns)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Failed to connect to namestore\n"));
-    return;
-  }
-
-  if (NULL != recordset)
-  {
-    /* replace entire record set */
-    unsigned int rd_count;
-    struct GNUNET_GNSRECORD_Data *rd;
-
-    if (NULL == name)
+  if (!(add | del | list | (NULL != nickstring) | (NULL != uri) |
+        (NULL != reverse_pkey) | (NULL != recordset)))
     {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-R",
-               _ ("replace"));
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
-    }
-    rd_count = 0;
-    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
-      rd_count++;
-    rd = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
-    rd_count = 0;
-    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
-    {
-      rd[rd_count] = e->record;
-      rd_count++;
-    }
-    set_qe = GNUNET_NAMESTORE_records_store (ns,
-                                             &zone_pkey,
-                                             name,
-                                             rd_count,
-                                             rd,
-                                             &replace_cont,
-                                             NULL);
-    GNUNET_free (rd);
-    return;
-  }
-
-  if (add)
-  {
-    if (NULL == name)
-    {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-n",
-               _ ("add"));
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
-    }
-    if (NULL == typestring)
-    {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-t",
-               _ ("add"));
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
+      /* nothing more to be done */
+      fprintf(stderr, _("No options given\n"));
+      GNUNET_SCHEDULER_shutdown();
       return;
     }
-    type = GNUNET_GNSRECORD_typename_to_number (typestring);
-    if (UINT32_MAX == type)
-    {
-      fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
-    }
-    if (NULL == value)
-    {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-V",
-               _ ("add"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-    if (GNUNET_OK !=
-        GNUNET_GNSRECORD_string_to_value (type, value, &data, &data_size))
+  ns = GNUNET_NAMESTORE_connect(cfg);
+  if (NULL == ns)
     {
-      fprintf (stderr,
-               _ ("Value `%s' invalid for record type `%s'\n"),
-               value,
-               typestring);
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to namestore\n"));
       return;
     }
-    if (NULL == expirationstring)
+
+  if (NULL != recordset)
     {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-e",
-               _ ("add"));
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
+      /* replace entire record set */
+      unsigned int rd_count;
+      struct GNUNET_GNSRECORD_Data *rd;
+
+      if (NULL == name)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-R",
+                  _("replace"));
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      rd_count = 0;
+      for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
+        rd_count++;
+      rd = GNUNET_new_array(rd_count, struct GNUNET_GNSRECORD_Data);
+      rd_count = 0;
+      for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
+        {
+          rd[rd_count] = e->record;
+          rd_count++;
+        }
+      set_qe = GNUNET_NAMESTORE_records_store(ns,
+                                              &zone_pkey,
+                                              name,
+                                              rd_count,
+                                              rd,
+                                              &replace_cont,
+                                              NULL);
+      GNUNET_free(rd);
       return;
     }
-    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
+
+  if (add)
     {
-      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
+      if (NULL == name)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-n",
+                  _("add"));
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      if (NULL == typestring)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-t",
+                  _("add"));
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      type = GNUNET_GNSRECORD_typename_to_number(typestring);
+      if (UINT32_MAX == type)
+        {
+          fprintf(stderr, _("Unsupported type `%s'\n"), typestring);
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      if (NULL == value)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-V",
+                  _("add"));
+          ret = 1;
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      if (GNUNET_OK !=
+          GNUNET_GNSRECORD_string_to_value(type, value, &data, &data_size))
+        {
+          fprintf(stderr,
+                  _("Value `%s' invalid for record type `%s'\n"),
+                  value,
+                  typestring);
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      if (NULL == expirationstring)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-e",
+                  _("add"));
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      if (GNUNET_OK != parse_expiration(expirationstring, &etime_is_rel, &etime))
+        {
+          fprintf(stderr, _("Invalid time format `%s'\n"), expirationstring);
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      add_qe = GNUNET_NAMESTORE_records_lookup(ns,
+                                               &zone_pkey,
+                                               name,
+                                               &add_error_cb,
+                                               NULL,
+                                               &get_existing_record,
+                                               NULL);
     }
-    add_qe = GNUNET_NAMESTORE_records_lookup (ns,
-                                              &zone_pkey,
-                                              name,
-                                              &add_error_cb,
-                                              NULL,
-                                              &get_existing_record,
-                                              NULL);
-  }
   if (del)
-  {
-    if (NULL == name)
     {
-      fprintf (stderr,
-               _ ("Missing option `%s' for operation `%s'\n"),
-               "-n",
-               _ ("del"));
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
+      if (NULL == name)
+        {
+          fprintf(stderr,
+                  _("Missing option `%s' for operation `%s'\n"),
+                  "-n",
+                  _("del"));
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      del_qe = GNUNET_NAMESTORE_records_lookup(ns,
+                                               &zone_pkey,
+                                               name,
+                                               &del_lookup_error_cb,
+                                               NULL,
+                                               &del_monitor,
+                                               NULL);
     }
-    del_qe = GNUNET_NAMESTORE_records_lookup (ns,
-                                              &zone_pkey,
-                                              name,
-                                              &del_lookup_error_cb,
-                                              NULL,
-                                              &del_monitor,
-                                              NULL);
-  }
   if (list)
-  {
-    if (NULL != name)
-      get_qe = GNUNET_NAMESTORE_records_lookup (ns,
-                                                &zone_pkey,
-                                                name,
-                                                &lookup_error_cb,
-                                                NULL,
-                                                &display_record_lookup,
-                                                NULL);
-    else
-      list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
-                                                       &zone_pkey,
-                                                       &zone_iteration_error_cb,
-                                                       NULL,
-                                                       &display_record_iterator,
-                                                       NULL,
-                                                       &zone_iteration_finished,
-                                                       NULL);
-  }
+    {
+      if (NULL != name)
+        get_qe = GNUNET_NAMESTORE_records_lookup(ns,
+                                                 &zone_pkey,
+                                                 name,
+                                                 &lookup_error_cb,
+                                                 NULL,
+                                                 &display_record_lookup,
+                                                 NULL);
+      else
+        list_it = GNUNET_NAMESTORE_zone_iteration_start(ns,
+                                                        &zone_pkey,
+                                                        &zone_iteration_error_cb,
+                                                        NULL,
+                                                        &display_record_iterator,
+                                                        NULL,
+                                                        &zone_iteration_finished,
+                                                        NULL);
+    }
   if (NULL != reverse_pkey)
-  {
-    struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
-
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_ecdsa_public_key_from_string (reverse_pkey,
-                                                    strlen (reverse_pkey),
-                                                    &pubkey))
     {
-      fprintf (stderr,
-               _ ("Invalid public key for reverse lookup `%s'\n"),
-               reverse_pkey);
-      GNUNET_SCHEDULER_shutdown ();
+      struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
+
+      if (GNUNET_OK !=
+          GNUNET_CRYPTO_ecdsa_public_key_from_string(reverse_pkey,
+                                                     strlen(reverse_pkey),
+                                                     &pubkey))
+        {
+          fprintf(stderr,
+                  _("Invalid public key for reverse lookup `%s'\n"),
+                  reverse_pkey);
+          GNUNET_SCHEDULER_shutdown();
+        }
+      reverse_qe = GNUNET_NAMESTORE_zone_to_name(ns,
+                                                 &zone_pkey,
+                                                 &pubkey,
+                                                 &reverse_error_cb,
+                                                 NULL,
+                                                 &handle_reverse_lookup,
+                                                 NULL);
     }
-    reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
-                                                &zone_pkey,
-                                                &pubkey,
-                                                &reverse_error_cb,
-                                                NULL,
-                                                &handle_reverse_lookup,
-                                                NULL);
-  }
   if (NULL != uri)
-  {
-    char sh[105];
-    char sname[64];
-    struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
-
-    GNUNET_STRINGS_utf8_tolower (uri, uri);
-    if ((2 != (sscanf (uri, "gnunet://gns/%52s/%63s", sh, sname))) ||
-        (GNUNET_OK !=
-         GNUNET_CRYPTO_ecdsa_public_key_from_string (sh, strlen (sh), &pkey)))
     {
-      fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
+      char sh[105];
+      char sname[64];
+      struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
+
+      GNUNET_STRINGS_utf8_tolower(uri, uri);
+      if ((2 != (sscanf(uri, "gnunet://gns/%52s/%63s", sh, sname))) ||
+          (GNUNET_OK !=
+           GNUNET_CRYPTO_ecdsa_public_key_from_string(sh, strlen(sh), &pkey)))
+        {
+          fprintf(stderr, _("Invalid URI `%s'\n"), uri);
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      memset(&rd, 0, sizeof(rd));
+      rd.data = &pkey;
+      rd.data_size = sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
+      rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
+      rd.expiration_time = etime;
+      if (GNUNET_YES == etime_is_rel)
+        rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+      if (1 == is_shadow)
+        rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
+      add_qe_uri = GNUNET_NAMESTORE_records_store(ns,
+                                                  &zone_pkey,
+                                                  sname,
+                                                  1,
+                                                  &rd,
+                                                  &add_continuation,
+                                                  &add_qe_uri);
     }
-    memset (&rd, 0, sizeof (rd));
-    rd.data = &pkey;
-    rd.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
-    rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
-    rd.expiration_time = etime;
-    if (GNUNET_YES == etime_is_rel)
-      rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-    if (1 == is_shadow)
-      rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
-    add_qe_uri = GNUNET_NAMESTORE_records_store (ns,
-                                                 &zone_pkey,
-                                                 sname,
-                                                 1,
-                                                 &rd,
-                                                 &add_continuation,
-                                                 &add_qe_uri);
-  }
   if (NULL != nickstring)
-  {
-    if (0 == strlen (nickstring))
     {
-      fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
-      GNUNET_SCHEDULER_shutdown ();
-      ret = 1;
-      return;
+      if (0 == strlen(nickstring))
+        {
+          fprintf(stderr, _("Invalid nick `%s'\n"), nickstring);
+          GNUNET_SCHEDULER_shutdown();
+          ret = 1;
+          return;
+        }
+      add_qe_uri = GNUNET_NAMESTORE_set_nick(ns,
+                                             &zone_pkey,
+                                             nickstring,
+                                             &add_continuation,
+                                             &add_qe_uri);
     }
-    add_qe_uri = GNUNET_NAMESTORE_set_nick (ns,
-                                            &zone_pkey,
-                                            nickstring,
-                                            &add_continuation,
-                                            &add_qe_uri);
-  }
   if (monitor)
-  {
-    zm = GNUNET_NAMESTORE_zone_monitor_start (cfg,
-                                              &zone_pkey,
-                                              GNUNET_YES,
-                                              &monitor_error_cb,
-                                              NULL,
-                                              &display_record_monitor,
-                                              NULL,
-                                              &sync_cb,
-                                              NULL);
-  }
+    {
+      zm = GNUNET_NAMESTORE_zone_monitor_start(cfg,
+                                               &zone_pkey,
+                                               GNUNET_YES,
+                                               &monitor_error_cb,
+                                               NULL,
+                                               &display_record_monitor,
+                                               NULL,
+                                               &sync_cb,
+                                               NULL);
+    }
 }
 
 
@@ -1244,37 +1247,37 @@ run_with_zone_pkey (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param ego an ego known to identity service, or NULL
  */
 static void
-identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
+identity_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
   el = NULL;
-  if ((NULL != name) && (0 != strchr (name, '.')))
-  {
-    fprintf (stderr,
-             _ ("Label `%s' contains `.' which is not allowed\n"),
-             name);
-    GNUNET_SCHEDULER_shutdown ();
-    ret = -1;
-    return;
-  }
+  if ((NULL != name) && (0 != strchr(name, '.')))
+    {
+      fprintf(stderr,
+              _("Label `%s' contains `.' which is not allowed\n"),
+              name);
+      GNUNET_SCHEDULER_shutdown();
+      ret = -1;
+      return;
+    }
 
   if (NULL == ego)
-  {
-    if (NULL != ego_name)
     {
-      fprintf (stderr,
-               _ ("Ego `%s' not known to identity service\n"),
-               ego_name);
+      if (NULL != ego_name)
+        {
+          fprintf(stderr,
+                  _("Ego `%s' not known to identity service\n"),
+                  ego_name);
+        }
+      GNUNET_SCHEDULER_shutdown();
+      ret = -1;
+      return;
     }
-    GNUNET_SCHEDULER_shutdown ();
-    ret = -1;
-    return;
-  }
-  zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
-  GNUNET_free_non_null (ego_name);
+  zone_pkey = *GNUNET_IDENTITY_ego_get_private_key(ego);
+  GNUNET_free_non_null(ego_name);
   ego_name = NULL;
-  run_with_zone_pkey (cfg);
+  run_with_zone_pkey(cfg);
 }
 
 
@@ -1289,27 +1292,27 @@ identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
  * @param name unused
  */
 static void
-default_ego_cb (void *cls,
-                struct GNUNET_IDENTITY_Ego *ego,
-                void **ctx,
-                const char *name)
+default_ego_cb(void *cls,
+               struct GNUNET_IDENTITY_Ego *ego,
+               void **ctx,
+               const char *name)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
-  (void) ctx;
-  (void) name;
+  (void)ctx;
+  (void)name;
   get_default = NULL;
   if (NULL == ego)
-  {
-    fprintf (stderr, _ ("No default ego configured in identity service\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    ret = -1;
-    return;
-  }
+    {
+      fprintf(stderr, _("No default ego configured in identity service\n"));
+      GNUNET_SCHEDULER_shutdown();
+      ret = -1;
+      return;
+    }
   else
-  {
-    identity_cb ((void *) cfg, ego);
-  }
+    {
+      identity_cb((void *)cfg, ego);
+    }
 }
 
 
@@ -1326,19 +1329,19 @@ default_ego_cb (void *cls,
  * @param name name associated with @a ego
  */
 static void
-id_connect_cb (void *cls,
-               struct GNUNET_IDENTITY_Ego *ego,
-               void **ctx,
-               const char *name)
+id_connect_cb(void *cls,
+              struct GNUNET_IDENTITY_Ego *ego,
+              void **ctx,
+              const char *name)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
-  (void) ctx;
-  (void) name;
+  (void)ctx;
+  (void)name;
   if (NULL != ego)
     return;
   get_default =
-    GNUNET_IDENTITY_get (idh, "namestore", &default_ego_cb, (void *) cfg);
+    GNUNET_IDENTITY_get(idh, "namestore", &default_ego_cb, (void *)cfg);
 }
 
 
@@ -1351,53 +1354,53 @@ id_connect_cb (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)
 {
   const char *pkey_str;
 
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
   if (NULL != args[0])
-    GNUNET_log (
+    GNUNET_log(
       GNUNET_ERROR_TYPE_WARNING,
-      _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
+      _("Superfluous command line arguments (starting with `%s') ignored\n"),
       args[0]);
   if ((NULL != args[0]) && (NULL == uri))
-    uri = GNUNET_strdup (args[0]);
+    uri = GNUNET_strdup(args[0]);
 
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
-  pkey_str = getenv ("GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, (void *)cfg);
+  pkey_str = getenv("GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
   if (NULL != pkey_str)
-  {
-    if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pkey_str,
-                                                    strlen (pkey_str),
-                                                    &zone_pkey,
-                                                    sizeof (zone_pkey)))
     {
-      fprintf (stderr,
-               "Malformed private key `%s' in $%s\n",
-               pkey_str,
-               "GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown ();
+      if (GNUNET_OK != GNUNET_STRINGS_string_to_data(pkey_str,
+                                                     strlen(pkey_str),
+                                                     &zone_pkey,
+                                                     sizeof(zone_pkey)))
+        {
+          fprintf(stderr,
+                  "Malformed private key `%s' in $%s\n",
+                  pkey_str,
+                  "GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
+          ret = 1;
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      run_with_zone_pkey(cfg);
       return;
     }
-    run_with_zone_pkey (cfg);
-    return;
-  }
   if (NULL == ego_name)
-  {
-    idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
-    if (NULL == idh)
-      fprintf (stderr, _ ("Cannot connect to identity service\n"));
-    ret = -1;
-    return;
-  }
-  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
+    {
+      idh = GNUNET_IDENTITY_connect(cfg, &id_connect_cb, (void *)cfg);
+      if (NULL == idh)
+        fprintf(stderr, _("Cannot connect to identity service\n"));
+      ret = -1;
+      return;
+    }
+  el = GNUNET_IDENTITY_ego_lookup(cfg, ego_name, &identity_cb, (void *)cfg);
 }
 
 
@@ -1419,10 +1422,10 @@ run (void *cls,
  * @return #GNUNET_OK on success
  */
 static int
-multirecord_process (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                     void *scls,
-                     const char *option,
-                     const char *value)
+multirecord_process(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                    void *scls,
+                    const char *option,
+                    const char *value)
 {
   struct RecordSetEntry **head = scls;
   struct RecordSetEntry *r;
@@ -1433,94 +1436,94 @@ multirecord_process (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
   int etime_is_rel;
   void *raw_data;
 
-  (void) ctx;
-  (void) option;
-  cp = GNUNET_strdup (value);
-  tok = strtok_r (cp, " ", &saveptr);
+  (void)ctx;
+  (void)option;
+  cp = GNUNET_strdup(value);
+  tok = strtok_r(cp, " ", &saveptr);
   if (NULL == tok)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Empty record line argument is not allowed.\n"));
-    GNUNET_free (cp);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Empty record line argument is not allowed.\n"));
+      GNUNET_free(cp);
+      return GNUNET_SYSERR;
+    }
   {
     char *etime_in_s;
 
-    GNUNET_asprintf (&etime_in_s, "%s s", tok);
+    GNUNET_asprintf(&etime_in_s, "%s s", tok);
     if (GNUNET_OK !=
-        parse_expiration (etime_in_s, &etime_is_rel, &record.expiration_time))
+        parse_expiration(etime_in_s, &etime_is_rel, &record.expiration_time))
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   _("Invalid expiration time `%s' (must be without unit)\n"),
+                   tok);
+        GNUNET_free(cp);
+        GNUNET_free(etime_in_s);
+        return GNUNET_SYSERR;
+      }
+    GNUNET_free(etime_in_s);
+  }
+  tok = strtok_r(NULL, " ", &saveptr);
+  if (NULL == tok)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Invalid expiration time `%s' (must be without unit)\n"),
-                  tok);
-      GNUNET_free (cp);
-      GNUNET_free (etime_in_s);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Missing entries in record line `%s'.\n"),
+                 value);
+      GNUNET_free(cp);
       return GNUNET_SYSERR;
     }
-    GNUNET_free (etime_in_s);
-  }
-  tok = strtok_r (NULL, " ", &saveptr);
-  if (NULL == tok)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Missing entries in record line `%s'.\n"),
-                value);
-    GNUNET_free (cp);
-    return GNUNET_SYSERR;
-  }
-  record.record_type = GNUNET_GNSRECORD_typename_to_number (tok);
+  record.record_type = GNUNET_GNSRECORD_typename_to_number(tok);
   if (UINT32_MAX == record.record_type)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
-    GNUNET_free (cp);
-    return GNUNET_SYSERR;
-  }
-  tok = strtok_r (NULL, " ", &saveptr);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Unknown record type `%s'\n"), tok);
+      GNUNET_free(cp);
+      return GNUNET_SYSERR;
+    }
+  tok = strtok_r(NULL, " ", &saveptr);
   if (NULL == tok)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Missing entries in record line `%s'.\n"),
-                value);
-    GNUNET_free (cp);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Missing entries in record line `%s'.\n"),
+                 value);
+      GNUNET_free(cp);
+      return GNUNET_SYSERR;
+    }
   record.flags = GNUNET_GNSRECORD_RF_NONE;
   if (etime_is_rel)
     record.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-  if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
+  if (NULL == strchr(tok, (unsigned char)'p'))   /* p = public */
     record.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
-  if (NULL != strchr (tok, (unsigned char) 's'))
+  if (NULL != strchr(tok, (unsigned char)'s'))
     record.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
   /* find beginning of record value */
-  tok = strchr (&value[tok - cp], (unsigned char) ' ');
+  tok = strchr(&value[tok - cp], (unsigned char)' ');
   if (NULL == tok)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Missing entries in record line `%s'.\n"),
-                value);
-    GNUNET_free (cp);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (cp);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Missing entries in record line `%s'.\n"),
+                 value);
+      GNUNET_free(cp);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(cp);
   tok++; /* skip space */
-  if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value (record.record_type,
-                                                     tok,
-                                                     &raw_data,
-                                                     &record.data_size))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Invalid record data for type %s: `%s'.\n"),
-                GNUNET_GNSRECORD_number_to_typename (record.record_type),
-                tok);
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value(record.record_type,
+                                                    tok,
+                                                    &raw_data,
+                                                    &record.data_size))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Invalid record data for type %s: `%s'.\n"),
+                 GNUNET_GNSRECORD_number_to_typename(record.record_type),
+                 tok);
+      return GNUNET_SYSERR;
+    }
 
-  r = GNUNET_malloc (sizeof (struct RecordSetEntry) + record.data_size);
+  r = GNUNET_malloc(sizeof(struct RecordSetEntry) + record.data_size);
   r->next = *head;
   record.data = &r[1];
-  memcpy (&r[1], raw_data, record.data_size);
-  GNUNET_free (raw_data);
+  memcpy(&r[1], raw_data, record.data_size);
+  GNUNET_free(raw_data);
   r->record = record;
   *head = r;
   return GNUNET_OK;
@@ -1537,20 +1540,20 @@ multirecord_process (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] topKeywords set to the desired value
  */
 struct GNUNET_GETOPT_CommandLineOption
-multirecord_option (char shortName,
-                    const char *name,
-                    const char *argumentHelp,
-                    const char *description,
-                    struct RecordSetEntry **rs)
+multirecord_option(char shortName,
+                   const char *name,
+                   const char *argumentHelp,
+                   const char *description,
+                   struct RecordSetEntry **rs)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor =
-                                                  &multirecord_process,
-                                                .scls = (void *) rs};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor =
+                                                   &multirecord_process,
+                                                 .scls = (void *)rs };
 
   return clo;
 }
@@ -1564,112 +1567,112 @@ multirecord_option (char shortName,
  * @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_flag ('a', "add", gettext_noop ("add record"), &add),
-     GNUNET_GETOPT_option_flag ('d',
-                                "delete",
-                                gettext_noop ("delete record"),
-                                &del),
-     GNUNET_GETOPT_option_flag ('D',
-                                "display",
-                                gettext_noop ("display records"),
-                                &list),
-     GNUNET_GETOPT_option_string (
-       'e',
-       "expiration",
-       "TIME",
-       gettext_noop (
-         "expiration time for record to use (for adding only), \"never\" is possible"),
-       &expirationstring),
-     GNUNET_GETOPT_option_string ('i',
-                                  "nick",
-                                  "NICKNAME",
-                                  gettext_noop (
-                                    "set the desired nick name for the zone"),
-                                  &nickstring),
-     GNUNET_GETOPT_option_flag ('m',
-                                "monitor",
-                                gettext_noop (
-                                  "monitor changes in the namestore"),
-                                &monitor),
-     GNUNET_GETOPT_option_string ('n',
-                                  "name",
-                                  "NAME",
-                                  gettext_noop (
-                                    "name of the record to add/delete/display"),
-                                  &name),
-     GNUNET_GETOPT_option_string ('r',
-                                  "reverse",
-                                  "PKEY",
-                                  gettext_noop (
-                                    "determine our name for the given PKEY"),
-                                  &reverse_pkey),
-     multirecord_option (
-       'R',
-       "replace",
-       "RECORDLINE",
-       gettext_noop (
-         "set record set to values given by (possibly multiple) RECORDLINES; can be specified multiple times"),
-       &recordset),
-     GNUNET_GETOPT_option_string ('t',
-                                  "type",
-                                  "TYPE",
-                                  gettext_noop (
-                                    "type of the record to add/delete/display"),
-                                  &typestring),
-     GNUNET_GETOPT_option_string ('u',
-                                  "uri",
-                                  "URI",
-                                  gettext_noop ("URI to import into our zone"),
-                                  &uri),
-     GNUNET_GETOPT_option_string ('V',
-                                  "value",
-                                  "VALUE",
-                                  gettext_noop (
-                                    "value of the record to add/delete"),
-                                  &value),
-     GNUNET_GETOPT_option_flag ('p',
-                                "public",
-                                gettext_noop ("create or list public record"),
-                                &is_public),
-     GNUNET_GETOPT_option_flag (
-       's',
-       "shadow",
-       gettext_noop (
-         "create shadow record (only valid if all other records of the same type have expired"),
-       &is_shadow),
-     GNUNET_GETOPT_option_string ('z',
-                                  "zone",
-                                  "EGO",
-                                  gettext_noop (
-                                    "name of the ego controlling the zone"),
-                                  &ego_name),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_flag('a', "add", gettext_noop("add record"), &add),
+    GNUNET_GETOPT_option_flag('d',
+                              "delete",
+                              gettext_noop("delete record"),
+                              &del),
+    GNUNET_GETOPT_option_flag('D',
+                              "display",
+                              gettext_noop("display records"),
+                              &list),
+    GNUNET_GETOPT_option_string(
+      'e',
+      "expiration",
+      "TIME",
+      gettext_noop(
+        "expiration time for record to use (for adding only), \"never\" is possible"),
+      &expirationstring),
+    GNUNET_GETOPT_option_string('i',
+                                "nick",
+                                "NICKNAME",
+                                gettext_noop(
+                                  "set the desired nick name for the zone"),
+                                &nickstring),
+    GNUNET_GETOPT_option_flag('m',
+                              "monitor",
+                              gettext_noop(
+                                "monitor changes in the namestore"),
+                              &monitor),
+    GNUNET_GETOPT_option_string('n',
+                                "name",
+                                "NAME",
+                                gettext_noop(
+                                  "name of the record to add/delete/display"),
+                                &name),
+    GNUNET_GETOPT_option_string('r',
+                                "reverse",
+                                "PKEY",
+                                gettext_noop(
+                                  "determine our name for the given PKEY"),
+                                &reverse_pkey),
+    multirecord_option(
+      'R',
+      "replace",
+      "RECORDLINE",
+      gettext_noop(
+        "set record set to values given by (possibly multiple) RECORDLINES; can be specified multiple times"),
+      &recordset),
+    GNUNET_GETOPT_option_string('t',
+                                "type",
+                                "TYPE",
+                                gettext_noop(
+                                  "type of the record to add/delete/display"),
+                                &typestring),
+    GNUNET_GETOPT_option_string('u',
+                                "uri",
+                                "URI",
+                                gettext_noop("URI to import into our zone"),
+                                &uri),
+    GNUNET_GETOPT_option_string('V',
+                                "value",
+                                "VALUE",
+                                gettext_noop(
+                                  "value of the record to add/delete"),
+                                &value),
+    GNUNET_GETOPT_option_flag('p',
+                              "public",
+                              gettext_noop("create or list public record"),
+                              &is_public),
+    GNUNET_GETOPT_option_flag(
+      's',
+      "shadow",
+      gettext_noop(
+        "create shadow record (only valid if all other records of the same type have expired"),
+      &is_shadow),
+    GNUNET_GETOPT_option_string('z',
+                                "zone",
+                                "EGO",
+                                gettext_noop(
+                                  "name of the ego controlling the zone"),
+                                &ego_name),
+    GNUNET_GETOPT_OPTION_END };
   int lret;
 
-  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;
 
   is_public = -1;
   is_shadow = -1;
-  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
+  GNUNET_log_setup("gnunet-namestore", "WARNING", NULL);
   if (GNUNET_OK !=
-      (lret = GNUNET_PROGRAM_run (argc,
-                                  argv,
-                                  "gnunet-namestore",
-                                  _ ("GNUnet zone manipulation tool"),
-                                  options,
-                                  &run,
-                                  NULL)))
-  {
-    GNUNET_free ((void *) argv);
-    GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
-    return lret;
-  }
-  GNUNET_free ((void *) argv);
-  GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
+      (lret = GNUNET_PROGRAM_run(argc,
+                                 argv,
+                                 "gnunet-namestore",
+                                 _("GNUnet zone manipulation tool"),
+                                 options,
+                                 &run,
+                                 NULL)))
+    {
+      GNUNET_free((void *)argv);
+      GNUNET_CRYPTO_ecdsa_key_clear(&zone_pkey);
+      return lret;
+    }
+  GNUNET_free((void *)argv);
+  GNUNET_CRYPTO_ecdsa_key_clear(&zone_pkey);
   return ret;
 }
 
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index 3a925b952..71754081e 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.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 namestore/gnunet-service-namestore.c
@@ -36,7 +36,7 @@
 #include "namestore.h"
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util", syscall, filename)
 
 /**
  * If a monitor takes more than 1 minute to process an event, print a warning.
@@ -57,8 +57,7 @@ struct NamestoreClient;
 /**
  * A namestore iteration operation.
  */
-struct ZoneIteration
-{
+struct ZoneIteration {
   /**
    * Next element in the DLL
    */
@@ -125,9 +124,7 @@ struct ZoneIteration
 /**
  * A namestore client
  */
-struct NamestoreClient
-{
-
+struct NamestoreClient {
   /**
    * The client
    */
@@ -155,8 +152,7 @@ struct NamestoreClient
 /**
  * A namestore monitor.
  */
-struct ZoneMonitor
-{
+struct ZoneMonitor {
   /**
    * Next element in the DLL
    */
@@ -233,9 +229,7 @@ struct ZoneMonitor
 /**
  * Pending operation on the namecache.
  */
-struct CacheOperation
-{
-
+struct CacheOperation {
   /**
    * Kept in a DLL.
    */
@@ -273,8 +267,7 @@ struct CacheOperation
  * Information for an ongoing #handle_record_store() operation.
  * Needed as we may wait for monitors to be ready for the notification.
  */
-struct StoreActivity
-{
+struct StoreActivity {
   /**
    * Kept in a DLL.
    */
@@ -311,8 +304,7 @@ struct StoreActivity
 /**
  * Entry in list of cached nick resolutions.
  */
-struct NickCache
-{
+struct NickCache {
   /**
    * Zone the cache entry is for.
    */
@@ -419,38 +411,38 @@ static int disable_namecache;
  * @param cls unused
  */
 static void
-cleanup_task (void *cls)
+cleanup_task(void *cls)
 {
   struct CacheOperation *cop;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping namestore service\n");
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Stopping namestore service\n");
   while (NULL != (cop = cop_head))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Aborting incomplete namecache operation\n");
-    GNUNET_NAMECACHE_cancel (cop->qe);
-    GNUNET_CONTAINER_DLL_remove (cop_head, cop_tail, cop);
-    GNUNET_free (cop);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Aborting incomplete namecache operation\n");
+      GNUNET_NAMECACHE_cancel(cop->qe);
+      GNUNET_CONTAINER_DLL_remove(cop_head, cop_tail, cop);
+      GNUNET_free(cop);
+    }
   if (NULL != namecache)
-  {
-    GNUNET_NAMECACHE_disconnect (namecache);
-    namecache = NULL;
-  }
-  GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, GSN_database));
-  GNUNET_free (db_lib_name);
+    {
+      GNUNET_NAMECACHE_disconnect(namecache);
+      namecache = NULL;
+    }
+  GNUNET_break(NULL == GNUNET_PLUGIN_unload(db_lib_name, GSN_database));
+  GNUNET_free(db_lib_name);
   db_lib_name = NULL;
   if (NULL != monitor_nc)
-  {
-    GNUNET_notification_context_destroy (monitor_nc);
-    monitor_nc = NULL;
-  }
+    {
+      GNUNET_notification_context_destroy(monitor_nc);
+      monitor_nc = NULL;
+    }
   if (NULL != statistics)
-  {
-    GNUNET_STATISTICS_destroy (statistics, GNUNET_NO);
-    statistics = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(statistics, GNUNET_NO);
+      statistics = NULL;
+    }
 }
 
 
@@ -460,11 +452,11 @@ cleanup_task (void *cls)
  * @param sa activity to free
  */
 static void
-free_store_activity (struct StoreActivity *sa)
+free_store_activity(struct StoreActivity *sa)
 {
-  GNUNET_CONTAINER_DLL_remove (sa_head, sa_tail, sa);
-  GNUNET_free (sa->conv_name);
-  GNUNET_free (sa);
+  GNUNET_CONTAINER_DLL_remove(sa_head, sa_tail, sa);
+  GNUNET_free(sa->conv_name);
+  GNUNET_free(sa);
 }
 
 
@@ -481,37 +473,37 @@ free_store_activity (struct StoreActivity *sa)
  * @param rd records stored under @a label in the zone
  */
 static void
-lookup_nick_it (void *cls,
-                uint64_t seq,
-                const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
-                const char *label,
-                unsigned int rd_count,
-                const struct GNUNET_GNSRECORD_Data *rd)
+lookup_nick_it(void *cls,
+               uint64_t seq,
+               const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
+               const char *label,
+               unsigned int rd_count,
+               const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data **res = cls;
 
-  (void) private_key;
-  GNUNET_assert (0 != seq);
-  if (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT))
-  {
-    GNUNET_break (0);
-    return;
-  }
-  for (unsigned int c = 0; c < rd_count; c++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
+  (void)private_key;
+  GNUNET_assert(0 != seq);
+  if (0 != strcmp(label, GNUNET_GNS_EMPTY_LABEL_AT))
     {
-      (*res) =
-        GNUNET_malloc (rd[c].data_size + sizeof (struct GNUNET_GNSRECORD_Data));
-      (*res)->data = &(*res)[1];
-      GNUNET_memcpy ((void *) (*res)->data, rd[c].data, rd[c].data_size);
-      (*res)->data_size = rd[c].data_size;
-      (*res)->expiration_time = rd[c].expiration_time;
-      (*res)->flags = rd[c].flags;
-      (*res)->record_type = GNUNET_GNSRECORD_TYPE_NICK;
+      GNUNET_break(0);
       return;
     }
-  }
+  for (unsigned int c = 0; c < rd_count; c++)
+    {
+      if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
+        {
+          (*res) =
+            GNUNET_malloc(rd[c].data_size + sizeof(struct GNUNET_GNSRECORD_Data));
+          (*res)->data = &(*res)[1];
+          GNUNET_memcpy((void *)(*res)->data, rd[c].data, rd[c].data_size);
+          (*res)->data_size = rd[c].data_size;
+          (*res)->expiration_time = rd[c].expiration_time;
+          (*res)->flags = rd[c].flags;
+          (*res)->record_type = GNUNET_GNSRECORD_TYPE_NICK;
+          return;
+        }
+    }
   (*res) = NULL;
 }
 
@@ -523,39 +515,39 @@ lookup_nick_it (void *cls,
  * @param nick nick entry to cache
  */
 static void
-cache_nick (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-            const struct GNUNET_GNSRECORD_Data *nick)
+cache_nick(const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+           const struct GNUNET_GNSRECORD_Data *nick)
 {
   struct NickCache *oldest;
 
   oldest = NULL;
   for (unsigned int i = 0; i < NC_SIZE; i++)
-  {
-    struct NickCache *pos = &nick_cache[i];
-
-    if ((NULL == oldest) ||
-        (oldest->last_used.abs_value_us > pos->last_used.abs_value_us))
-      oldest = pos;
-    if (0 == GNUNET_memcmp (zone, &pos->zone))
     {
-      oldest = pos;
-      break;
+      struct NickCache *pos = &nick_cache[i];
+
+      if ((NULL == oldest) ||
+          (oldest->last_used.abs_value_us > pos->last_used.abs_value_us))
+        oldest = pos;
+      if (0 == GNUNET_memcmp(zone, &pos->zone))
+        {
+          oldest = pos;
+          break;
+        }
     }
-  }
-  GNUNET_free_non_null (oldest->rd);
+  GNUNET_free_non_null(oldest->rd);
   oldest->zone = *zone;
   if (NULL != nick)
-  {
-    oldest->rd = GNUNET_malloc (sizeof (*nick) + nick->data_size);
-    *oldest->rd = *nick;
-    oldest->rd->data = &oldest->rd[1];
-    memcpy (&oldest->rd[1], nick->data, nick->data_size);
-  }
+    {
+      oldest->rd = GNUNET_malloc(sizeof(*nick) + nick->data_size);
+      *oldest->rd = *nick;
+      oldest->rd->data = &oldest->rd[1];
+      memcpy(&oldest->rd[1], nick->data, nick->data_size);
+    }
   else
-  {
-    oldest->rd = NULL;
-  }
-  oldest->last_used = GNUNET_TIME_absolute_get ();
+    {
+      oldest->rd = NULL;
+    }
+  oldest->last_used = GNUNET_TIME_absolute_get();
 }
 
 
@@ -566,7 +558,7 @@ cache_nick (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
  * @return NULL if no NICK record was found
  */
 static struct GNUNET_GNSRECORD_Data *
-get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
+get_nick_record(const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
   struct GNUNET_GNSRECORD_Data *nick;
@@ -574,53 +566,53 @@ get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
 
   /* check cache first */
   for (unsigned int i = 0; i < NC_SIZE; i++)
-  {
-    struct NickCache *pos = &nick_cache[i];
-    if ((NULL != pos->rd) && (0 == GNUNET_memcmp (zone, &pos->zone)))
     {
-      if (NULL == pos->rd)
-        return NULL;
-      nick = GNUNET_malloc (sizeof (*nick) + pos->rd->data_size);
-      *nick = *pos->rd;
-      nick->data = &nick[1];
-      memcpy (&nick[1], pos->rd->data, pos->rd->data_size);
-      pos->last_used = GNUNET_TIME_absolute_get ();
-      return nick;
+      struct NickCache *pos = &nick_cache[i];
+      if ((NULL != pos->rd) && (0 == GNUNET_memcmp(zone, &pos->zone)))
+        {
+          if (NULL == pos->rd)
+            return NULL;
+          nick = GNUNET_malloc(sizeof(*nick) + pos->rd->data_size);
+          *nick = *pos->rd;
+          nick->data = &nick[1];
+          memcpy(&nick[1], pos->rd->data, pos->rd->data_size);
+          pos->last_used = GNUNET_TIME_absolute_get();
+          return nick;
+        }
     }
-  }
 
   nick = NULL;
-  res = GSN_database->lookup_records (GSN_database->cls,
-                                      zone,
-                                      GNUNET_GNS_EMPTY_LABEL_AT,
-                                      &lookup_nick_it,
-                                      &nick);
+  res = GSN_database->lookup_records(GSN_database->cls,
+                                     zone,
+                                     GNUNET_GNS_EMPTY_LABEL_AT,
+                                     &lookup_nick_it,
+                                     &nick);
   if ((GNUNET_OK != res) || (NULL == nick))
-  {
-#if ! defined(GNUNET_CULL_LOGGING)
-    static int do_log = GNUNET_LOG_CALL_STATUS;
-
-    if (0 == do_log)
-      do_log = GNUNET_get_log_call_status (GNUNET_ERROR_TYPE_DEBUG,
-                                           "namestore",
-                                           __FILE__,
-                                           __FUNCTION__,
-                                           __LINE__);
-    if (1 == do_log)
     {
-      GNUNET_CRYPTO_ecdsa_key_get_public (zone, &pub);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                  "No nick name set for zone `%s'\n",
-                  GNUNET_GNSRECORD_z2s (&pub));
-    }
+#if !defined(GNUNET_CULL_LOGGING)
+      static int do_log = GNUNET_LOG_CALL_STATUS;
+
+      if (0 == do_log)
+        do_log = GNUNET_get_log_call_status(GNUNET_ERROR_TYPE_DEBUG,
+                                            "namestore",
+                                            __FILE__,
+                                            __FUNCTION__,
+                                            __LINE__);
+      if (1 == do_log)
+        {
+          GNUNET_CRYPTO_ecdsa_key_get_public(zone, &pub);
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                     "No nick name set for zone `%s'\n",
+                     GNUNET_GNSRECORD_z2s(&pub));
+        }
 #endif
-    /* update cache */
-    cache_nick (zone, NULL);
-    return NULL;
-  }
+      /* update cache */
+      cache_nick(zone, NULL);
+      return NULL;
+    }
 
   /* update cache */
-  cache_nick (zone, nick);
+  cache_nick(zone, nick);
   return nick;
 }
 
@@ -641,11 +633,11 @@ get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
  *           allocated in the same chunk of memory!
  */
 static void
-merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd,
-                         unsigned int rd2_length,
-                         const struct GNUNET_GNSRECORD_Data *rd2,
-                         unsigned int *rdc_res,
-                         struct GNUNET_GNSRECORD_Data **rd_res)
+merge_with_nick_records(const struct GNUNET_GNSRECORD_Data *nick_rd,
+                        unsigned int rd2_length,
+                        const struct GNUNET_GNSRECORD_Data *rd2,
+                        unsigned int *rdc_res,
+                        struct GNUNET_GNSRECORD_Data **rd_res)
 {
   uint64_t latest_expiration;
   size_t req;
@@ -655,54 +647,54 @@ merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd,
 
   (*rdc_res) = 1 + rd2_length;
   if (0 == 1 + rd2_length)
-  {
-    GNUNET_break (0);
-    (*rd_res) = NULL;
-    return;
-  }
-  req = sizeof (struct GNUNET_GNSRECORD_Data) + nick_rd->data_size;
-  for (unsigned int i = 0; i < rd2_length; i++)
-  {
-    const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
-
-    if (req + sizeof (struct GNUNET_GNSRECORD_Data) + orig->data_size < req)
     {
-      GNUNET_break (0);
+      GNUNET_break(0);
       (*rd_res) = NULL;
       return;
     }
-    req += sizeof (struct GNUNET_GNSRECORD_Data) + orig->data_size;
-  }
-  target = GNUNET_malloc (req);
+  req = sizeof(struct GNUNET_GNSRECORD_Data) + nick_rd->data_size;
+  for (unsigned int i = 0; i < rd2_length; i++)
+    {
+      const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
+
+      if (req + sizeof(struct GNUNET_GNSRECORD_Data) + orig->data_size < req)
+        {
+          GNUNET_break(0);
+          (*rd_res) = NULL;
+          return;
+        }
+      req += sizeof(struct GNUNET_GNSRECORD_Data) + orig->data_size;
+    }
+  target = GNUNET_malloc(req);
   (*rd_res) = target;
-  data = (char *) &target[1 + rd2_length];
+  data = (char *)&target[1 + rd2_length];
   data_offset = 0;
   latest_expiration = 0;
   for (unsigned int i = 0; i < rd2_length; i++)
-  {
-    const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
-
-    if (0 != (orig->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
     {
-      if ((GNUNET_TIME_absolute_get ().abs_value_us + orig->expiration_time) >
-          latest_expiration)
+      const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
+
+      if (0 != (orig->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+        {
+          if ((GNUNET_TIME_absolute_get().abs_value_us + orig->expiration_time) >
+              latest_expiration)
+            latest_expiration = orig->expiration_time;
+        }
+      else if (orig->expiration_time > latest_expiration)
         latest_expiration = orig->expiration_time;
+      target[i] = *orig;
+      target[i].data = (void *)&data[data_offset];
+      GNUNET_memcpy(&data[data_offset], orig->data, orig->data_size);
+      data_offset += orig->data_size;
     }
-    else if (orig->expiration_time > latest_expiration)
-      latest_expiration = orig->expiration_time;
-    target[i] = *orig;
-    target[i].data = (void *) &data[data_offset];
-    GNUNET_memcpy (&data[data_offset], orig->data, orig->data_size);
-    data_offset += orig->data_size;
-  }
   /* append nick */
   target[rd2_length] = *nick_rd;
   target[rd2_length].expiration_time = latest_expiration;
-  target[rd2_length].data = (void *) &data[data_offset];
-  GNUNET_memcpy (&data[data_offset], nick_rd->data, nick_rd->data_size);
+  target[rd2_length].data = (void *)&data[data_offset];
+  GNUNET_memcpy(&data[data_offset], nick_rd->data, nick_rd->data_size);
   data_offset += nick_rd->data_size;
-  GNUNET_assert (req == (sizeof (struct GNUNET_GNSRECORD_Data)) * (*rdc_res) +
-                          data_offset);
+  GNUNET_assert(req == (sizeof(struct GNUNET_GNSRECORD_Data)) * (*rdc_res) +
+                data_offset);
 }
 
 
@@ -718,12 +710,12 @@ merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd,
  * @param rd array of records
  */
 static void
-send_lookup_response (struct NamestoreClient *nc,
-                      uint32_t request_id,
-                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                      const char *name,
-                      unsigned int rd_count,
-                      const struct GNUNET_GNSRECORD_Data *rd)
+send_lookup_response(struct NamestoreClient *nc,
+                     uint32_t request_id,
+                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                     const char *name,
+                     unsigned int rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_MQ_Envelope *env;
   struct RecordResultMessage *zir_msg;
@@ -735,63 +727,63 @@ send_lookup_response (struct NamestoreClient *nc,
   char *name_tmp;
   char *rd_ser;
 
-  nick = get_nick_record (zone_key);
-  GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (rd_count, rd));
+  nick = get_nick_record(zone_key);
+  GNUNET_assert(-1 != GNUNET_GNSRECORD_records_get_size(rd_count, rd));
 
-  if ((NULL != nick) && (0 != strcmp (name, GNUNET_GNS_EMPTY_LABEL_AT)))
-  {
-    nick->flags =
-      (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
-    merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
-    GNUNET_free (nick);
-  }
+  if ((NULL != nick) && (0 != strcmp(name, GNUNET_GNS_EMPTY_LABEL_AT)))
+    {
+      nick->flags =
+        (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
+      merge_with_nick_records(nick, rd_count, rd, &res_count, &res);
+      GNUNET_free(nick);
+    }
   else
-  {
-    res_count = rd_count;
-    res = (struct GNUNET_GNSRECORD_Data *) rd;
-  }
+    {
+      res_count = rd_count;
+      res = (struct GNUNET_GNSRECORD_Data *)rd;
+    }
 
-  GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (res_count, res));
+  GNUNET_assert(-1 != GNUNET_GNSRECORD_records_get_size(res_count, res));
 
 
-  name_len = strlen (name) + 1;
-  rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, res);
+  name_len = strlen(name) + 1;
+  rd_ser_len = GNUNET_GNSRECORD_records_get_size(res_count, res);
   if (rd_ser_len < 0)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
-  if (((size_t) rd_ser_len) >= UINT16_MAX - name_len - sizeof (*zir_msg))
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
-  env = GNUNET_MQ_msg_extra (zir_msg,
-                             name_len + rd_ser_len,
-                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT);
-  zir_msg->gns_header.r_id = htonl (request_id);
-  zir_msg->name_len = htons (name_len);
-  zir_msg->rd_count = htons (res_count);
-  zir_msg->rd_len = htons ((uint16_t) rd_ser_len);
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
+  if (((size_t)rd_ser_len) >= UINT16_MAX - name_len - sizeof(*zir_msg))
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
+  env = GNUNET_MQ_msg_extra(zir_msg,
+                            name_len + rd_ser_len,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT);
+  zir_msg->gns_header.r_id = htonl(request_id);
+  zir_msg->name_len = htons(name_len);
+  zir_msg->rd_count = htons(res_count);
+  zir_msg->rd_len = htons((uint16_t)rd_ser_len);
   zir_msg->private_key = *zone_key;
-  name_tmp = (char *) &zir_msg[1];
-  GNUNET_memcpy (name_tmp, name, name_len);
+  name_tmp = (char *)&zir_msg[1];
+  GNUNET_memcpy(name_tmp, name, name_len);
   rd_ser = &name_tmp[name_len];
-  GNUNET_assert (
+  GNUNET_assert(
     rd_ser_len ==
-    GNUNET_GNSRECORD_records_serialize (res_count, res, rd_ser_len, rd_ser));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending RECORD_RESULT message with %u records\n",
-              res_count);
-  GNUNET_STATISTICS_update (statistics,
-                            "Record sets sent to clients",
-                            1,
-                            GNUNET_NO);
-  GNUNET_MQ_send (nc->mq, env);
+    GNUNET_GNSRECORD_records_serialize(res_count, res, rd_ser_len, rd_ser));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending RECORD_RESULT message with %u records\n",
+             res_count);
+  GNUNET_STATISTICS_update(statistics,
+                           "Record sets sent to clients",
+                           1,
+                           GNUNET_NO);
+  GNUNET_MQ_send(nc->mq, env);
   if (rd != res)
-    GNUNET_free (res);
+    GNUNET_free(res);
 }
 
 
@@ -803,23 +795,23 @@ send_lookup_response (struct NamestoreClient *nc,
  * @param rid client's request ID
  */
 static void
-send_store_response (struct NamestoreClient *nc, int res, uint32_t rid)
+send_store_response(struct NamestoreClient *nc, int res, uint32_t rid)
 {
   struct GNUNET_MQ_Envelope *env;
   struct RecordStoreResponseMessage *rcr_msg;
 
-  GNUNET_assert (NULL != nc);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending RECORD_STORE_RESPONSE message\n");
-  GNUNET_STATISTICS_update (statistics,
-                            "Store requests completed",
-                            1,
-                            GNUNET_NO);
-  env = GNUNET_MQ_msg (rcr_msg,
-                       GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE);
-  rcr_msg->gns_header.r_id = htonl (rid);
-  rcr_msg->op_result = htonl (res);
-  GNUNET_MQ_send (nc->mq, env);
+  GNUNET_assert(NULL != nc);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Sending RECORD_STORE_RESPONSE message\n");
+  GNUNET_STATISTICS_update(statistics,
+                           "Store requests completed",
+                           1,
+                           GNUNET_NO);
+  env = GNUNET_MQ_msg(rcr_msg,
+                      GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE);
+  rcr_msg->gns_header.r_id = htonl(rid);
+  rcr_msg->op_result = htonl(res);
+  GNUNET_MQ_send(nc->mq, env);
 }
 
 
@@ -830,21 +822,21 @@ send_store_response (struct NamestoreClient *nc, int res, uint32_t rid)
  * @param zi zone iteration we are processing
  */
 static void
-zone_iteration_done_client_continue (struct ZoneIteration *zi)
+zone_iteration_done_client_continue(struct ZoneIteration *zi)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_NAMESTORE_Header *em;
 
-  GNUNET_SERVICE_client_continue (zi->nc->client);
-  if (! zi->send_end)
+  GNUNET_SERVICE_client_continue(zi->nc->client);
+  if (!zi->send_end)
     return;
   /* send empty response to indicate end of list */
-  env = GNUNET_MQ_msg (em, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END);
-  em->r_id = htonl (zi->request_id);
-  GNUNET_MQ_send (zi->nc->mq, env);
+  env = GNUNET_MQ_msg(em, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END);
+  em->r_id = htonl(zi->request_id);
+  GNUNET_MQ_send(zi->nc->mq, env);
 
-  GNUNET_CONTAINER_DLL_remove (zi->nc->op_head, zi->nc->op_tail, zi);
-  GNUNET_free (zi);
+  GNUNET_CONTAINER_DLL_remove(zi->nc->op_head, zi->nc->op_tail, zi);
+  GNUNET_free(zi);
 }
 
 
@@ -856,30 +848,30 @@ zone_iteration_done_client_continue (struct ZoneIteration *zi)
  * @param emsg error messages
  */
 static void
-finish_cache_operation (void *cls, int32_t success, const char *emsg)
+finish_cache_operation(void *cls, int32_t success, const char *emsg)
 {
   struct CacheOperation *cop = cls;
   struct ZoneIteration *zi;
 
   if (NULL != emsg)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Failed to replicate block in namecache: %s\n"),
-                emsg);
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("Failed to replicate block in namecache: %s\n"),
+               emsg);
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CACHE operation completed\n");
-  GNUNET_CONTAINER_DLL_remove (cop_head, cop_tail, cop);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "CACHE operation completed\n");
+  GNUNET_CONTAINER_DLL_remove(cop_head, cop_tail, cop);
   if (NULL != cop->nc)
-    send_store_response (cop->nc, success, cop->rid);
+    send_store_response(cop->nc, success, cop->rid);
   if (NULL != (zi = cop->zi))
-  {
-    zi->cache_ops--;
-    if (0 == zi->cache_ops)
     {
-      /* unchoke zone iteration, cache has caught up */
-      zone_iteration_done_client_continue (zi);
+      zi->cache_ops--;
+      if (0 == zi->cache_ops)
+        {
+          /* unchoke zone iteration, cache has caught up */
+          zone_iteration_done_client_continue(zi);
+        }
     }
-  }
-  GNUNET_free (cop);
+  GNUNET_free(cop);
 }
 
 
@@ -896,13 +888,13 @@ finish_cache_operation (void *cls, int32_t success, const char *emsg)
  * @param rd records stored under the given @a name
  */
 static void
-refresh_block (struct NamestoreClient *nc,
-               struct ZoneIteration *zi,
-               uint32_t rid,
-               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-               const char *name,
-               unsigned int rd_count,
-               const struct GNUNET_GNSRECORD_Data *rd)
+refresh_block(struct NamestoreClient *nc,
+              struct ZoneIteration *zi,
+              uint32_t rid,
+              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+              const char *name,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Block *block;
   struct CacheOperation *cop;
@@ -912,64 +904,64 @@ refresh_block (struct NamestoreClient *nc,
   unsigned int res_count;
   struct GNUNET_TIME_Absolute exp_time;
 
-  nick = get_nick_record (zone_key);
+  nick = get_nick_record(zone_key);
   res_count = rd_count;
-  res = (struct GNUNET_GNSRECORD_Data *) rd; /* fixme: a bit unclean... */
+  res = (struct GNUNET_GNSRECORD_Data *)rd;  /* fixme: a bit unclean... */
   if (NULL != nick)
-  {
-    nick->flags =
-      (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
-    merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
-    GNUNET_free (nick);
-  }
+    {
+      nick->flags =
+        (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
+      merge_with_nick_records(nick, rd_count, rd, &res_count, &res);
+      GNUNET_free(nick);
+    }
   if (0 == res_count)
-  {
-    if (NULL != nc)
-      send_store_response (nc, GNUNET_OK, rid);
-    return; /* no data, no need to update cache */
-  }
+    {
+      if (NULL != nc)
+        send_store_response(nc, GNUNET_OK, rid);
+      return; /* no data, no need to update cache */
+    }
   if (GNUNET_YES == disable_namecache)
-  {
-    GNUNET_STATISTICS_update (statistics,
-                              "Namecache updates skipped (NC disabled)",
-                              1,
-                              GNUNET_NO);
-    if (NULL != nc)
-      send_store_response (nc, GNUNET_OK, rid);
-    return;
-  }
-  exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, res);
+    {
+      GNUNET_STATISTICS_update(statistics,
+                               "Namecache updates skipped (NC disabled)",
+                               1,
+                               GNUNET_NO);
+      if (NULL != nc)
+        send_store_response(nc, GNUNET_OK, rid);
+      return;
+    }
+  exp_time = GNUNET_GNSRECORD_record_get_expiration_time(res_count, res);
   if (cache_keys)
     block =
-      GNUNET_GNSRECORD_block_create2 (zone_key, exp_time, name, res, res_count);
+      GNUNET_GNSRECORD_block_create2(zone_key, exp_time, name, res, res_count);
   else
     block =
-      GNUNET_GNSRECORD_block_create (zone_key, exp_time, name, res, res_count);
-  GNUNET_assert (NULL != block);
-  GNUNET_CRYPTO_ecdsa_key_get_public (zone_key, &pkey);
-  GNUNET_log (
+      GNUNET_GNSRECORD_block_create(zone_key, exp_time, name, res, res_count);
+  GNUNET_assert(NULL != block);
+  GNUNET_CRYPTO_ecdsa_key_get_public(zone_key, &pkey);
+  GNUNET_log(
     GNUNET_ERROR_TYPE_DEBUG,
     "Caching block for label `%s' with %u records and expiration %s in zone `%s' in namecache\n",
     name,
     res_count,
-    GNUNET_STRINGS_absolute_time_to_string (exp_time),
-    GNUNET_GNSRECORD_z2s (&pkey));
-  GNUNET_STATISTICS_update (statistics,
-                            "Namecache updates pushed",
-                            1,
-                            GNUNET_NO);
-  cop = GNUNET_new (struct CacheOperation);
+    GNUNET_STRINGS_absolute_time_to_string(exp_time),
+    GNUNET_GNSRECORD_z2s(&pkey));
+  GNUNET_STATISTICS_update(statistics,
+                           "Namecache updates pushed",
+                           1,
+                           GNUNET_NO);
+  cop = GNUNET_new(struct CacheOperation);
   cop->nc = nc;
   cop->zi = zi;
   if (NULL != zi)
     zi->cache_ops++;
   cop->rid = rid;
-  GNUNET_CONTAINER_DLL_insert (cop_head, cop_tail, cop);
-  cop->qe = GNUNET_NAMECACHE_block_cache (namecache,
-                                          block,
-                                          &finish_cache_operation,
-                                          cop);
-  GNUNET_free (block);
+  GNUNET_CONTAINER_DLL_insert(cop_head, cop_tail, cop);
+  cop->qe = GNUNET_NAMECACHE_block_cache(namecache,
+                                         block,
+                                         &finish_cache_operation,
+                                         cop);
+  GNUNET_free(block);
 }
 
 
@@ -979,16 +971,16 @@ refresh_block (struct NamestoreClient *nc,
  * @param cls a `struct ZoneMonitor` to warn about
  */
 static void
-warn_monitor_slow (void *cls)
+warn_monitor_slow(void *cls)
 {
   struct ZoneMonitor *zm = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "No response from monitor since %s\n",
-              GNUNET_STRINGS_absolute_time_to_string (zm->sa_waiting_start));
-  zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
-                                                      &warn_monitor_slow,
-                                                      zm);
+  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+             "No response from monitor since %s\n",
+             GNUNET_STRINGS_absolute_time_to_string(zm->sa_waiting_start));
+  zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed(MONITOR_STALL_WARN_DELAY,
+                                                     &warn_monitor_slow,
+                                                     zm);
 }
 
 
@@ -998,7 +990,7 @@ warn_monitor_slow (void *cls)
  * @param sa store activity to process
  */
 static void
-continue_store_activity (struct StoreActivity *sa)
+continue_store_activity(struct StoreActivity *sa)
 {
   const struct RecordStoreMessage *rp_msg = sa->rsm;
   unsigned int rd_count;
@@ -1008,63 +1000,63 @@ continue_store_activity (struct StoreActivity *sa)
   const char *name_tmp;
   const char *rd_ser;
 
-  rid = ntohl (rp_msg->gns_header.r_id);
-  name_len = ntohs (rp_msg->name_len);
-  rd_count = ntohs (rp_msg->rd_count);
-  rd_ser_len = ntohs (rp_msg->rd_len);
-  name_tmp = (const char *) &rp_msg[1];
+  rid = ntohl(rp_msg->gns_header.r_id);
+  name_len = ntohs(rp_msg->name_len);
+  rd_count = ntohs(rp_msg->rd_count);
+  rd_ser_len = ntohs(rp_msg->rd_len);
+  name_tmp = (const char *)&rp_msg[1];
   rd_ser = &name_tmp[name_len];
   {
-    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
+    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];
 
     /* We did this before, must succeed again */
-    GNUNET_assert (
+    GNUNET_assert(
       GNUNET_OK ==
-      GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd));
+      GNUNET_GNSRECORD_records_deserialize(rd_ser_len, rd_ser, rd_count, rd));
 
     for (struct ZoneMonitor *zm = sa->zm_pos; NULL != zm; zm = sa->zm_pos)
-    {
-      if ((0 != GNUNET_memcmp (&rp_msg->private_key, &zm->zone)) &&
-          (0 != GNUNET_memcmp (&zm->zone, &zero)))
-      {
-        sa->zm_pos = zm->next; /* not interesting to this monitor */
-        continue;
-      }
-      if (zm->limit == zm->iteration_cnt)
       {
-        zm->sa_waiting = GNUNET_YES;
-        zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
-        if (NULL != zm->sa_wait_warning)
-          GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
-        zm->sa_wait_warning =
-          GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
-                                        &warn_monitor_slow,
-                                        zm);
-        return; /* blocked on zone monitor */
+        if ((0 != GNUNET_memcmp(&rp_msg->private_key, &zm->zone)) &&
+            (0 != GNUNET_memcmp(&zm->zone, &zero)))
+          {
+            sa->zm_pos = zm->next; /* not interesting to this monitor */
+            continue;
+          }
+        if (zm->limit == zm->iteration_cnt)
+          {
+            zm->sa_waiting = GNUNET_YES;
+            zm->sa_waiting_start = GNUNET_TIME_absolute_get();
+            if (NULL != zm->sa_wait_warning)
+              GNUNET_SCHEDULER_cancel(zm->sa_wait_warning);
+            zm->sa_wait_warning =
+              GNUNET_SCHEDULER_add_delayed(MONITOR_STALL_WARN_DELAY,
+                                           &warn_monitor_slow,
+                                           zm);
+            return; /* blocked on zone monitor */
+          }
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Notifying monitor about changes under label `%s'\n",
+                   sa->conv_name);
+        zm->limit--;
+        send_lookup_response(zm->nc,
+                             0,
+                             &rp_msg->private_key,
+                             sa->conv_name,
+                             rd_count,
+                             rd);
+        sa->zm_pos = zm->next;
       }
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Notifying monitor about changes under label `%s'\n",
-                  sa->conv_name);
-      zm->limit--;
-      send_lookup_response (zm->nc,
-                            0,
-                            &rp_msg->private_key,
-                            sa->conv_name,
-                            rd_count,
-                            rd);
-      sa->zm_pos = zm->next;
-    }
     /* great, done with the monitors, unpack (again) for refresh_block operation */
-    refresh_block (sa->nc,
-                   NULL,
-                   rid,
-                   &rp_msg->private_key,
-                   sa->conv_name,
-                   rd_count,
-                   rd);
+    refresh_block(sa->nc,
+                  NULL,
+                  rid,
+                  &rp_msg->private_key,
+                  sa->conv_name,
+                  rd_count,
+                  rd);
   }
-  GNUNET_SERVICE_client_continue (sa->nc->client);
-  free_store_activity (sa);
+  GNUNET_SERVICE_client_continue(sa->nc->client);
+  free_store_activity(sa);
 }
 
 
@@ -1077,64 +1069,64 @@ continue_store_activity (struct StoreActivity *sa)
  * @param app_ctx the `struct NamestoreClient` of @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 NamestoreClient *nc = app_ctx;
   struct ZoneIteration *no;
   struct CacheOperation *cop;
 
-  (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);
   for (struct ZoneMonitor *zm = monitor_head; NULL != zm; zm = zm->next)
-  {
-    struct StoreActivity *san;
-
-    if (nc != zm->nc)
-      continue;
-    GNUNET_CONTAINER_DLL_remove (monitor_head, monitor_tail, zm);
-    if (NULL != zm->task)
     {
-      GNUNET_SCHEDULER_cancel (zm->task);
-      zm->task = NULL;
-    }
-    if (NULL != zm->sa_wait_warning)
-    {
-      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
-      zm->sa_wait_warning = NULL;
-    }
-    for (struct StoreActivity *sa = sa_head; NULL != sa; sa = san)
-    {
-      san = sa->next;
-      if (zm == sa->zm_pos)
-      {
-        sa->zm_pos = zm->next;
-        /* this may free sa */
-        continue_store_activity (sa);
-      }
+      struct StoreActivity *san;
+
+      if (nc != zm->nc)
+        continue;
+      GNUNET_CONTAINER_DLL_remove(monitor_head, monitor_tail, zm);
+      if (NULL != zm->task)
+        {
+          GNUNET_SCHEDULER_cancel(zm->task);
+          zm->task = NULL;
+        }
+      if (NULL != zm->sa_wait_warning)
+        {
+          GNUNET_SCHEDULER_cancel(zm->sa_wait_warning);
+          zm->sa_wait_warning = NULL;
+        }
+      for (struct StoreActivity *sa = sa_head; NULL != sa; sa = san)
+        {
+          san = sa->next;
+          if (zm == sa->zm_pos)
+            {
+              sa->zm_pos = zm->next;
+              /* this may free sa */
+              continue_store_activity(sa);
+            }
+        }
+      GNUNET_free(zm);
+      break;
     }
-    GNUNET_free (zm);
-    break;
-  }
   for (struct StoreActivity *sa = sa_head; NULL != sa; sa = sa->next)
-  {
-    if (sa->nc == nc)
     {
-      /* this may free sa */
-      free_store_activity (sa);
-      break; /* there can only be one per nc */
+      if (sa->nc == nc)
+        {
+          /* this may free sa */
+          free_store_activity(sa);
+          break; /* there can only be one per nc */
+        }
     }
-  }
   while (NULL != (no = nc->op_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, no);
-    GNUNET_free (no);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(nc->op_head, nc->op_tail, no);
+      GNUNET_free(no);
+    }
   for (cop = cop_head; NULL != cop; cop = cop->next)
     if (nc == cop->nc)
       cop->nc = NULL;
-  GNUNET_free (nc);
+  GNUNET_free(nc);
 }
 
 
@@ -1147,15 +1139,15 @@ 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 NamestoreClient *nc;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
-  nc = GNUNET_new (struct NamestoreClient);
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
+  nc = GNUNET_new(struct NamestoreClient);
   nc->client = client;
   nc->mq = mq;
   return nc;
@@ -1165,9 +1157,7 @@ client_connect_cb (void *cls,
 /**
  * Closure for #lookup_it().
  */
-struct RecordLookupContext
-{
-
+struct RecordLookupContext {
   /**
    * FIXME.
    */
@@ -1213,93 +1203,93 @@ struct RecordLookupContext
  * @param rd array of records with data to store
  */
 static void
-lookup_it (void *cls,
-           uint64_t seq,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+lookup_it(void *cls,
+          uint64_t seq,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RecordLookupContext *rlc = cls;
 
-  (void) private_key;
-  GNUNET_assert (0 != seq);
-  if (0 != strcmp (label, rlc->label))
+  (void)private_key;
+  GNUNET_assert(0 != seq);
+  if (0 != strcmp(label, rlc->label))
     return;
   rlc->found = GNUNET_YES;
   if (0 == rd_count)
-  {
-    rlc->rd_ser_len = 0;
-    rlc->res_rd_count = 0;
-    rlc->res_rd = NULL;
-    return;
-  }
-  if ((NULL != rlc->nick) && (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT)))
-  {
-    /* Merge */
-    struct GNUNET_GNSRECORD_Data *rd_res;
-    unsigned int rdc_res;
-
-    rd_res = NULL;
-    rdc_res = 0;
-    rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^
-                       GNUNET_GNSRECORD_RF_PRIVATE;
-    merge_with_nick_records (rlc->nick, rd_count, rd, &rdc_res, &rd_res);
-    rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res, rd_res);
-    if (rlc->rd_ser_len < 0)
     {
-      GNUNET_break (0);
-      GNUNET_free (rd_res);
-      rlc->found = GNUNET_NO;
       rlc->rd_ser_len = 0;
-      return;
-    }
-    rlc->res_rd_count = rdc_res;
-    rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
-    if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rdc_res,
-                                                               rd_res,
-                                                               rlc->rd_ser_len,
-                                                               rlc->res_rd))
-    {
-      GNUNET_break (0);
-      GNUNET_free (rlc->res_rd);
-      rlc->res_rd = NULL;
       rlc->res_rd_count = 0;
-      rlc->rd_ser_len = 0;
-      GNUNET_free (rd_res);
-      rlc->found = GNUNET_NO;
+      rlc->res_rd = NULL;
       return;
     }
-    GNUNET_free (rd_res);
-    GNUNET_free (rlc->nick);
-    rlc->nick = NULL;
-  }
-  else
-  {
-    rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
-    if (rlc->rd_ser_len < 0)
+  if ((NULL != rlc->nick) && (0 != strcmp(label, GNUNET_GNS_EMPTY_LABEL_AT)))
     {
-      GNUNET_break (0);
-      rlc->found = GNUNET_NO;
-      rlc->rd_ser_len = 0;
-      return;
+      /* Merge */
+      struct GNUNET_GNSRECORD_Data *rd_res;
+      unsigned int rdc_res;
+
+      rd_res = NULL;
+      rdc_res = 0;
+      rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^
+                         GNUNET_GNSRECORD_RF_PRIVATE;
+      merge_with_nick_records(rlc->nick, rd_count, rd, &rdc_res, &rd_res);
+      rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size(rdc_res, rd_res);
+      if (rlc->rd_ser_len < 0)
+        {
+          GNUNET_break(0);
+          GNUNET_free(rd_res);
+          rlc->found = GNUNET_NO;
+          rlc->rd_ser_len = 0;
+          return;
+        }
+      rlc->res_rd_count = rdc_res;
+      rlc->res_rd = GNUNET_malloc(rlc->rd_ser_len);
+      if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize(rdc_res,
+                                                                rd_res,
+                                                                rlc->rd_ser_len,
+                                                                rlc->res_rd))
+        {
+          GNUNET_break(0);
+          GNUNET_free(rlc->res_rd);
+          rlc->res_rd = NULL;
+          rlc->res_rd_count = 0;
+          rlc->rd_ser_len = 0;
+          GNUNET_free(rd_res);
+          rlc->found = GNUNET_NO;
+          return;
+        }
+      GNUNET_free(rd_res);
+      GNUNET_free(rlc->nick);
+      rlc->nick = NULL;
     }
-    rlc->res_rd_count = rd_count;
-    rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
-    if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rd_count,
-                                                               rd,
-                                                               rlc->rd_ser_len,
-                                                               rlc->res_rd))
+  else
     {
-      GNUNET_break (0);
-      GNUNET_free (rlc->res_rd);
-      rlc->res_rd = NULL;
-      rlc->res_rd_count = 0;
-      rlc->rd_ser_len = 0;
-      rlc->found = GNUNET_NO;
-      return;
+      rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size(rd_count, rd);
+      if (rlc->rd_ser_len < 0)
+        {
+          GNUNET_break(0);
+          rlc->found = GNUNET_NO;
+          rlc->rd_ser_len = 0;
+          return;
+        }
+      rlc->res_rd_count = rd_count;
+      rlc->res_rd = GNUNET_malloc(rlc->rd_ser_len);
+      if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize(rd_count,
+                                                                rd,
+                                                                rlc->rd_ser_len,
+                                                                rlc->res_rd))
+        {
+          GNUNET_break(0);
+          GNUNET_free(rlc->res_rd);
+          rlc->res_rd = NULL;
+          rlc->res_rd_count = 0;
+          rlc->rd_ser_len = 0;
+          rlc->found = GNUNET_NO;
+          return;
+        }
     }
-  }
 }
 
 
@@ -1311,20 +1301,20 @@ lookup_it (void *cls,
  * @return #GNUNET_OK if @a ll_msg is well-formed
  */
 static int
-check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
+check_record_lookup(void *cls, const struct LabelLookupMessage *ll_msg)
 {
   uint32_t name_len;
   size_t src_size;
 
-  (void) cls;
-  name_len = ntohl (ll_msg->label_len);
-  src_size = ntohs (ll_msg->gns_header.header.size);
-  if (name_len != src_size - sizeof (struct LabelLookupMessage))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_MQ_check_zero_termination (ll_msg);
+  (void)cls;
+  name_len = ntohl(ll_msg->label_len);
+  src_size = ntohs(ll_msg->gns_header.header.size);
+  if (name_len != src_size - sizeof(struct LabelLookupMessage))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_MQ_check_zero_termination(ll_msg);
   return GNUNET_OK;
 }
 
@@ -1336,7 +1326,7 @@ check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
  * @param ll_msg message of type `struct LabelLookupMessage`
  */
 static void
-handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
+handle_record_lookup(void *cls, const struct LabelLookupMessage *ll_msg)
 {
   struct NamestoreClient *nc = cls;
   struct GNUNET_MQ_Envelope *env;
@@ -1348,52 +1338,52 @@ handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
   uint32_t name_len;
   int res;
 
-  name_len = ntohl (ll_msg->label_len);
-  name_tmp = (const char *) &ll_msg[1];
-  GNUNET_SERVICE_client_continue (nc->client);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
-              name_tmp);
+  name_len = ntohl(ll_msg->label_len);
+  name_tmp = (const char *)&ll_msg[1];
+  GNUNET_SERVICE_client_continue(nc->client);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
+             name_tmp);
 
-  conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
+  conv_name = GNUNET_GNSRECORD_string_to_lowercase(name_tmp);
   if (NULL == conv_name)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error converting name `%s'\n",
-                name_tmp);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Error converting name `%s'\n",
+                 name_tmp);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
   rlc.label = conv_name;
   rlc.found = GNUNET_NO;
   rlc.res_rd_count = 0;
   rlc.res_rd = NULL;
   rlc.rd_ser_len = 0;
-  rlc.nick = get_nick_record (&ll_msg->zone);
-  res = GSN_database->lookup_records (GSN_database->cls,
-                                      &ll_msg->zone,
-                                      conv_name,
-                                      &lookup_it,
-                                      &rlc);
-  GNUNET_free (conv_name);
+  rlc.nick = get_nick_record(&ll_msg->zone);
+  res = GSN_database->lookup_records(GSN_database->cls,
+                                     &ll_msg->zone,
+                                     conv_name,
+                                     &lookup_it,
+                                     &rlc);
+  GNUNET_free(conv_name);
   env =
-    GNUNET_MQ_msg_extra (llr_msg,
-                         name_len + rlc.rd_ser_len,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE);
+    GNUNET_MQ_msg_extra(llr_msg,
+                        name_len + rlc.rd_ser_len,
+                        GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE);
   llr_msg->gns_header.r_id = ll_msg->gns_header.r_id;
   llr_msg->private_key = ll_msg->zone;
-  llr_msg->name_len = htons (name_len);
-  llr_msg->rd_count = htons (rlc.res_rd_count);
-  llr_msg->rd_len = htons (rlc.rd_ser_len);
-  res_name = (char *) &llr_msg[1];
+  llr_msg->name_len = htons(name_len);
+  llr_msg->rd_count = htons(rlc.res_rd_count);
+  llr_msg->rd_len = htons(rlc.rd_ser_len);
+  res_name = (char *)&llr_msg[1];
   if ((GNUNET_YES == rlc.found) && (GNUNET_OK == res))
-    llr_msg->found = ntohs (GNUNET_YES);
+    llr_msg->found = ntohs(GNUNET_YES);
   else
-    llr_msg->found = ntohs (GNUNET_NO);
-  GNUNET_memcpy (&llr_msg[1], name_tmp, name_len);
-  GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len);
-  GNUNET_MQ_send (nc->mq, env);
-  GNUNET_free_non_null (rlc.res_rd);
+    llr_msg->found = ntohs(GNUNET_NO);
+  GNUNET_memcpy(&llr_msg[1], name_tmp, name_len);
+  GNUNET_memcpy(&res_name[name_len], rlc.res_rd, rlc.rd_ser_len);
+  GNUNET_MQ_send(nc->mq, env);
+  GNUNET_free_non_null(rlc.res_rd);
 }
 
 
@@ -1405,7 +1395,7 @@ handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
  * @return #GNUNET_OK if @a rp_msg is well-formed
  */
 static int
-check_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
+check_record_store(void *cls, const struct RecordStoreMessage *rp_msg)
 {
   size_t name_len;
   size_t msg_size;
@@ -1413,27 +1403,27 @@ check_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
   size_t rd_ser_len;
   const char *name_tmp;
 
-  (void) cls;
-  name_len = ntohs (rp_msg->name_len);
-  msg_size = ntohs (rp_msg->gns_header.header.size);
-  rd_ser_len = ntohs (rp_msg->rd_len);
-  msg_size_exp = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
+  (void)cls;
+  name_len = ntohs(rp_msg->name_len);
+  msg_size = ntohs(rp_msg->gns_header.header.size);
+  rd_ser_len = ntohs(rp_msg->rd_len);
+  msg_size_exp = sizeof(struct RecordStoreMessage) + name_len + rd_ser_len;
   if (msg_size != msg_size_exp)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   if ((0 == name_len) || (name_len > MAX_NAME_LEN))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  name_tmp = (const char *) &rp_msg[1];
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  name_tmp = (const char *)&rp_msg[1];
   if ('\0' != name_tmp[name_len - 1])
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -1445,7 +1435,7 @@ check_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
  * @param rp_msg message of type `struct RecordStoreMessage`
  */
 static void
-handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
+handle_record_store(void *cls, const struct RecordStoreMessage *rp_msg)
 {
   struct NamestoreClient *nc = cls;
   size_t name_len;
@@ -1458,112 +1448,112 @@ handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
   int res;
   struct StoreActivity *sa;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received NAMESTORE_RECORD_STORE message\n");
-  rid = ntohl (rp_msg->gns_header.r_id);
-  name_len = ntohs (rp_msg->name_len);
-  rd_count = ntohs (rp_msg->rd_count);
-  rd_ser_len = ntohs (rp_msg->rd_len);
-  GNUNET_break (0 == ntohs (rp_msg->reserved));
-  name_tmp = (const char *) &rp_msg[1];
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received NAMESTORE_RECORD_STORE message\n");
+  rid = ntohl(rp_msg->gns_header.r_id);
+  name_len = ntohs(rp_msg->name_len);
+  rd_count = ntohs(rp_msg->rd_count);
+  rd_ser_len = ntohs(rp_msg->rd_len);
+  GNUNET_break(0 == ntohs(rp_msg->reserved));
+  name_tmp = (const char *)&rp_msg[1];
   rd_ser = &name_tmp[name_len];
   {
-    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
+    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];
 
     if (GNUNET_OK !=
-        GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVICE_client_drop (nc->client);
-      return;
-    }
+        GNUNET_GNSRECORD_records_deserialize(rd_ser_len, rd_ser, rd_count, rd))
+      {
+        GNUNET_break(0);
+        GNUNET_SERVICE_client_drop(nc->client);
+        return;
+      }
 
     /* Extracting and converting private key */
-    conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
+    conv_name = GNUNET_GNSRECORD_string_to_lowercase(name_tmp);
     if (NULL == conv_name)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Error converting name `%s'\n",
-                  name_tmp);
-      GNUNET_SERVICE_client_drop (nc->client);
-      return;
-    }
-    GNUNET_STATISTICS_update (statistics,
-                              "Well-formed store requests received",
-                              1,
-                              GNUNET_NO);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Creating %u records for name `%s'\n",
-                (unsigned int) rd_count,
-                conv_name);
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   "Error converting name `%s'\n",
+                   name_tmp);
+        GNUNET_SERVICE_client_drop(nc->client);
+        return;
+      }
+    GNUNET_STATISTICS_update(statistics,
+                             "Well-formed store requests received",
+                             1,
+                             GNUNET_NO);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Creating %u records for name `%s'\n",
+               (unsigned int)rd_count,
+               conv_name);
     if ((0 == rd_count) &&
-        (GNUNET_NO == GSN_database->lookup_records (GSN_database->cls,
-                                                    &rp_msg->private_key,
-                                                    conv_name,
-                                                    NULL,
-                                                    0)))
-    {
-      /* This name does not exist, so cannot be removed */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Name `%s' does not exist, no deletion required\n",
-                  conv_name);
-      res = GNUNET_NO;
-    }
-    else
-    {
-      /* remove "NICK" records, unless this is for the
-         #GNUNET_GNS_EMPTY_LABEL_AT label */
-      struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL (rd_count)];
-      unsigned int rd_clean_off;
-      int have_nick;
-
-      rd_clean_off = 0;
-      have_nick = GNUNET_NO;
-      for (unsigned int i = 0; i < rd_count; i++)
+        (GNUNET_NO == GSN_database->lookup_records(GSN_database->cls,
+                                                   &rp_msg->private_key,
+                                                   conv_name,
+                                                   NULL,
+                                                   0)))
       {
-        rd_clean[rd_clean_off] = rd[i];
-        if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) ||
-            (GNUNET_GNSRECORD_TYPE_NICK != rd[i].record_type))
-          rd_clean_off++;
-
-        if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
-            (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type))
-        {
-          cache_nick (&rp_msg->private_key, &rd[i]);
-          have_nick = GNUNET_YES;
-        }
+        /* This name does not exist, so cannot be removed */
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Name `%s' does not exist, no deletion required\n",
+                   conv_name);
+        res = GNUNET_NO;
       }
-      if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
-          (GNUNET_NO == have_nick))
+    else
       {
-        /* remove nick record from cache, in case we have one there */
-        cache_nick (&rp_msg->private_key, NULL);
+        /* remove "NICK" records, unless this is for the
+         #GNUNET_GNS_EMPTY_LABEL_AT label */
+        struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL(rd_count)];
+        unsigned int rd_clean_off;
+        int have_nick;
+
+        rd_clean_off = 0;
+        have_nick = GNUNET_NO;
+        for (unsigned int i = 0; i < rd_count; i++)
+          {
+            rd_clean[rd_clean_off] = rd[i];
+            if ((0 == strcmp(GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) ||
+                (GNUNET_GNSRECORD_TYPE_NICK != rd[i].record_type))
+              rd_clean_off++;
+
+            if ((0 == strcmp(GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
+                (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type))
+              {
+                cache_nick(&rp_msg->private_key, &rd[i]);
+                have_nick = GNUNET_YES;
+              }
+          }
+        if ((0 == strcmp(GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
+            (GNUNET_NO == have_nick))
+          {
+            /* remove nick record from cache, in case we have one there */
+            cache_nick(&rp_msg->private_key, NULL);
+          }
+        res = GSN_database->store_records(GSN_database->cls,
+                                          &rp_msg->private_key,
+                                          conv_name,
+                                          rd_clean_off,
+                                          rd_clean);
       }
-      res = GSN_database->store_records (GSN_database->cls,
-                                         &rp_msg->private_key,
-                                         conv_name,
-                                         rd_clean_off,
-                                         rd_clean);
-    }
 
     if (GNUNET_OK != res)
-    {
-      /* store not successful, not need to tell monitors */
-      send_store_response (nc, res, rid);
-      GNUNET_SERVICE_client_continue (nc->client);
-      GNUNET_free (conv_name);
-      return;
-    }
+      {
+        /* store not successful, not need to tell monitors */
+        send_store_response(nc, res, rid);
+        GNUNET_SERVICE_client_continue(nc->client);
+        GNUNET_free(conv_name);
+        return;
+      }
 
-    sa = GNUNET_malloc (sizeof (struct StoreActivity) +
-                        ntohs (rp_msg->gns_header.header.size));
-    GNUNET_CONTAINER_DLL_insert (sa_head, sa_tail, sa);
+    sa = GNUNET_malloc(sizeof(struct StoreActivity) +
+                       ntohs(rp_msg->gns_header.header.size));
+    GNUNET_CONTAINER_DLL_insert(sa_head, sa_tail, sa);
     sa->nc = nc;
-    sa->rsm = (const struct RecordStoreMessage *) &sa[1];
-    GNUNET_memcpy (&sa[1], rp_msg, ntohs (rp_msg->gns_header.header.size));
+    sa->rsm = (const struct RecordStoreMessage *)&sa[1];
+    GNUNET_memcpy(&sa[1], rp_msg, ntohs(rp_msg->gns_header.header.size));
     sa->zm_pos = monitor_head;
     sa->conv_name = conv_name;
-    continue_store_activity (sa);
+    continue_store_activity(sa);
   }
 }
 
@@ -1572,8 +1562,7 @@ handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
  * Context for record remove operations passed from #handle_zone_to_name to
  * #handle_zone_to_name_it as closure
  */
-struct ZoneToNameCtx
-{
+struct ZoneToNameCtx {
   /**
    * Namestore client
    */
@@ -1604,12 +1593,12 @@ struct ZoneToNameCtx
  * @param rd record data
  */
 static void
-handle_zone_to_name_it (void *cls,
-                        uint64_t seq,
-                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                        const char *name,
-                        unsigned int rd_count,
-                        const struct GNUNET_GNSRECORD_Data *rd)
+handle_zone_to_name_it(void *cls,
+                       uint64_t seq,
+                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                       const char *name,
+                       unsigned int rd_count,
+                       const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ZoneToNameCtx *ztn_ctx = cls;
   struct GNUNET_MQ_Envelope *env;
@@ -1621,45 +1610,45 @@ handle_zone_to_name_it (void *cls,
   char *name_tmp;
   char *rd_tmp;
 
-  GNUNET_assert (0 != seq);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Found result for zone-to-name lookup: `%s'\n",
-              name);
+  GNUNET_assert(0 != seq);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Found result for zone-to-name lookup: `%s'\n",
+             name);
   res = GNUNET_YES;
-  name_len = (NULL == name) ? 0 : strlen (name) + 1;
-  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
+  name_len = (NULL == name) ? 0 : strlen(name) + 1;
+  rd_ser_len = GNUNET_GNSRECORD_records_get_size(rd_count, rd);
   if (rd_ser_len < 0)
-  {
-    GNUNET_break (0);
-    ztn_ctx->success = GNUNET_SYSERR;
-    return;
-  }
-  msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
+    {
+      GNUNET_break(0);
+      ztn_ctx->success = GNUNET_SYSERR;
+      return;
+    }
+  msg_size = sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
   if (msg_size >= GNUNET_MAX_MESSAGE_SIZE)
-  {
-    GNUNET_break (0);
-    ztn_ctx->success = GNUNET_SYSERR;
-    return;
-  }
+    {
+      GNUNET_break(0);
+      ztn_ctx->success = GNUNET_SYSERR;
+      return;
+    }
   env =
-    GNUNET_MQ_msg_extra (ztnr_msg,
-                         name_len + rd_ser_len,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
-  ztnr_msg->gns_header.header.size = htons (msg_size);
-  ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid);
-  ztnr_msg->res = htons (res);
-  ztnr_msg->rd_len = htons (rd_ser_len);
-  ztnr_msg->rd_count = htons (rd_count);
-  ztnr_msg->name_len = htons (name_len);
+    GNUNET_MQ_msg_extra(ztnr_msg,
+                        name_len + rd_ser_len,
+                        GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
+  ztnr_msg->gns_header.header.size = htons(msg_size);
+  ztnr_msg->gns_header.r_id = htonl(ztn_ctx->rid);
+  ztnr_msg->res = htons(res);
+  ztnr_msg->rd_len = htons(rd_ser_len);
+  ztnr_msg->rd_count = htons(rd_count);
+  ztnr_msg->name_len = htons(name_len);
   ztnr_msg->zone = *zone_key;
-  name_tmp = (char *) &ztnr_msg[1];
-  GNUNET_memcpy (name_tmp, name, name_len);
+  name_tmp = (char *)&ztnr_msg[1];
+  GNUNET_memcpy(name_tmp, name, name_len);
   rd_tmp = &name_tmp[name_len];
-  GNUNET_assert (
+  GNUNET_assert(
     rd_ser_len ==
-    GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_tmp));
+    GNUNET_GNSRECORD_records_serialize(rd_count, rd, rd_ser_len, rd_tmp));
   ztn_ctx->success = GNUNET_OK;
-  GNUNET_MQ_send (ztn_ctx->nc->mq, env);
+  GNUNET_MQ_send(ztn_ctx->nc->mq, env);
 }
 
 
@@ -1670,41 +1659,41 @@ handle_zone_to_name_it (void *cls,
  * @param ztn_msg message of type 'struct ZoneToNameMessage'
  */
 static void
-handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg)
+handle_zone_to_name(void *cls, const struct ZoneToNameMessage *ztn_msg)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneToNameCtx ztn_ctx;
   struct GNUNET_MQ_Envelope *env;
   struct ZoneToNameResponseMessage *ztnr_msg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n");
-  ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n");
+  ztn_ctx.rid = ntohl(ztn_msg->gns_header.r_id);
   ztn_ctx.nc = nc;
   ztn_ctx.success = GNUNET_NO;
-  if (GNUNET_SYSERR == GSN_database->zone_to_name (GSN_database->cls,
-                                                   &ztn_msg->zone,
-                                                   &ztn_msg->value_zone,
-                                                   &handle_zone_to_name_it,
-                                                   &ztn_ctx))
-  {
-    /* internal error, hang up instead of signalling something
-       that might be wrong */
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
+  if (GNUNET_SYSERR == GSN_database->zone_to_name(GSN_database->cls,
+                                                  &ztn_msg->zone,
+                                                  &ztn_msg->value_zone,
+                                                  &handle_zone_to_name_it,
+                                                  &ztn_ctx))
+    {
+      /* internal error, hang up instead of signalling something
+         that might be wrong */
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
   if (GNUNET_NO == ztn_ctx.success)
-  {
-    /* no result found, send empty response */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Found no result for zone-to-name lookup.\n");
-    env = GNUNET_MQ_msg (ztnr_msg,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
-    ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id;
-    ztnr_msg->res = htons (GNUNET_NO);
-    GNUNET_MQ_send (nc->mq, env);
-  }
-  GNUNET_SERVICE_client_continue (nc->client);
+    {
+      /* no result found, send empty response */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Found no result for zone-to-name lookup.\n");
+      env = GNUNET_MQ_msg(ztnr_msg,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
+      ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id;
+      ztnr_msg->res = htons(GNUNET_NO);
+      GNUNET_MQ_send(nc->mq, env);
+    }
+  GNUNET_SERVICE_client_continue(nc->client);
 }
 
 
@@ -1712,8 +1701,7 @@ handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg)
  * Context for record remove operations passed from
  * #run_zone_iteration_round to #zone_iterate_proc as closure
  */
-struct ZoneIterationProcResult
-{
+struct ZoneIterationProcResult {
   /**
    * The zone iteration handle
    */
@@ -1737,53 +1725,53 @@ struct ZoneIterationProcResult
  * @param rd record data
  */
 static void
-zone_iterate_proc (void *cls,
-                   uint64_t seq,
-                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                   const char *name,
-                   unsigned int rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd)
+zone_iterate_proc(void *cls,
+                  uint64_t seq,
+                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                  const char *name,
+                  unsigned int rd_count,
+                  const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ZoneIterationProcResult *proc = cls;
   int do_refresh_block;
 
-  GNUNET_assert (0 != seq);
+  GNUNET_assert(0 != seq);
   if ((NULL == zone_key) && (NULL == name))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n");
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n");
+      return;
+    }
   if ((NULL == zone_key) || (NULL == name))
-  {
-    /* what is this!? should never happen */
-    GNUNET_break (0);
-    return;
-  }
+    {
+      /* what is this!? should never happen */
+      GNUNET_break(0);
+      return;
+    }
   if (0 == proc->limit)
-  {
-    /* what is this!? should never happen */
-    GNUNET_break (0);
-    return;
-  }
+    {
+      /* what is this!? should never happen */
+      GNUNET_break(0);
+      return;
+    }
   proc->limit--;
   proc->zi->seq = seq;
-  send_lookup_response (proc->zi->nc,
-                        proc->zi->request_id,
-                        zone_key,
-                        name,
-                        rd_count,
-                        rd);
+  send_lookup_response(proc->zi->nc,
+                       proc->zi->request_id,
+                       zone_key,
+                       name,
+                       rd_count,
+                       rd);
 
 
   do_refresh_block = GNUNET_NO;
   for (unsigned int i = 0; i < rd_count; i++)
     if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
-    {
-      do_refresh_block = GNUNET_YES;
-      break;
-    }
+      {
+        do_refresh_block = GNUNET_YES;
+        break;
+      }
   if (GNUNET_YES == do_refresh_block)
-    refresh_block (NULL, proc->zi, 0, zone_key, name, rd_count, rd);
+    refresh_block(NULL, proc->zi, 0, zone_key, name, rd_count, rd);
 }
 
 
@@ -1794,42 +1782,42 @@ zone_iterate_proc (void *cls,
  * @param limit number of results to return in one pass
  */
 static void
-run_zone_iteration_round (struct ZoneIteration *zi, uint64_t limit)
+run_zone_iteration_round(struct ZoneIteration *zi, uint64_t limit)
 {
   struct ZoneIterationProcResult proc;
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_TIME_Relative duration;
 
-  memset (&proc, 0, sizeof (proc));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asked to return up to %llu records at position %llu\n",
-              (unsigned long long) limit,
-              (unsigned long long) zi->seq);
+  memset(&proc, 0, sizeof(proc));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Asked to return up to %llu records at position %llu\n",
+             (unsigned long long)limit,
+             (unsigned long long)zi->seq);
   proc.zi = zi;
   proc.limit = limit;
-  start = GNUNET_TIME_absolute_get ();
-  GNUNET_break (GNUNET_SYSERR !=
-                GSN_database->iterate_records (GSN_database->cls,
-                                               (0 == GNUNET_is_zero (&zi->zone))
-                                                 ? NULL
-                                                 : &zi->zone,
-                                               zi->seq,
-                                               limit,
-                                               &zone_iterate_proc,
-                                               &proc));
-  duration = GNUNET_TIME_absolute_get_duration (start);
-  duration = GNUNET_TIME_relative_divide (duration, limit - proc.limit);
-  GNUNET_STATISTICS_set (statistics,
-                         "NAMESTORE iteration delay (μs/record)",
-                         duration.rel_value_us,
-                         GNUNET_NO);
+  start = GNUNET_TIME_absolute_get();
+  GNUNET_break(GNUNET_SYSERR !=
+               GSN_database->iterate_records(GSN_database->cls,
+                                             (0 == GNUNET_is_zero(&zi->zone))
+                                             ? NULL
+                                             : &zi->zone,
+                                             zi->seq,
+                                             limit,
+                                             &zone_iterate_proc,
+                                             &proc));
+  duration = GNUNET_TIME_absolute_get_duration(start);
+  duration = GNUNET_TIME_relative_divide(duration, limit - proc.limit);
+  GNUNET_STATISTICS_set(statistics,
+                        "NAMESTORE iteration delay (μs/record)",
+                        duration.rel_value_us,
+                        GNUNET_NO);
   if (0 == proc.limit)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Returned %llu results, more results available\n",
-                (unsigned long long) limit);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Returned %llu results, more results available\n",
+               (unsigned long long)limit);
   zi->send_end = (0 != proc.limit);
   if (0 == zi->cache_ops)
-    zone_iteration_done_client_continue (zi);
+    zone_iteration_done_client_continue(zi);
 }
 
 
@@ -1840,22 +1828,22 @@ run_zone_iteration_round (struct ZoneIteration *zi, uint64_t limit)
  * @param zis_msg message from the client
  */
 static void
-handle_iteration_start (void *cls,
-                        const struct ZoneIterationStartMessage *zis_msg)
+handle_iteration_start(void *cls,
+                       const struct ZoneIterationStartMessage *zis_msg)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneIteration *zi;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ZONE_ITERATION_START message\n");
-  zi = GNUNET_new (struct ZoneIteration);
-  zi->request_id = ntohl (zis_msg->gns_header.r_id);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received ZONE_ITERATION_START message\n");
+  zi = GNUNET_new(struct ZoneIteration);
+  zi->request_id = ntohl(zis_msg->gns_header.r_id);
   zi->offset = 0;
   zi->nc = nc;
   zi->zone = zis_msg->zone;
 
-  GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi);
-  run_zone_iteration_round (zi, 1);
+  GNUNET_CONTAINER_DLL_insert(nc->op_head, nc->op_tail, zi);
+  run_zone_iteration_round(zi, 1);
 }
 
 
@@ -1866,28 +1854,28 @@ handle_iteration_start (void *cls,
  * @param zis_msg message from the client
  */
 static void
-handle_iteration_stop (void *cls,
-                       const struct ZoneIterationStopMessage *zis_msg)
+handle_iteration_stop(void *cls,
+                      const struct ZoneIterationStopMessage *zis_msg)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneIteration *zi;
   uint32_t rid;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ZONE_ITERATION_STOP message\n");
-  rid = ntohl (zis_msg->gns_header.r_id);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received ZONE_ITERATION_STOP message\n");
+  rid = ntohl(zis_msg->gns_header.r_id);
   for (zi = nc->op_head; NULL != zi; zi = zi->next)
     if (zi->request_id == rid)
       break;
   if (NULL == zi)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
-  GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, zi);
-  GNUNET_free (zi);
-  GNUNET_SERVICE_client_continue (nc->client);
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
+  GNUNET_CONTAINER_DLL_remove(nc->op_head, nc->op_tail, zi);
+  GNUNET_free(zi);
+  GNUNET_SERVICE_client_continue(nc->client);
 }
 
 
@@ -1898,32 +1886,32 @@ handle_iteration_stop (void *cls,
  * @param message message from the client
  */
 static void
-handle_iteration_next (void *cls,
-                       const struct ZoneIterationNextMessage *zis_msg)
+handle_iteration_next(void *cls,
+                      const struct ZoneIterationNextMessage *zis_msg)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneIteration *zi;
   uint32_t rid;
   uint64_t limit;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ZONE_ITERATION_NEXT message\n");
-  GNUNET_STATISTICS_update (statistics,
-                            "Iteration NEXT messages received",
-                            1,
-                            GNUNET_NO);
-  rid = ntohl (zis_msg->gns_header.r_id);
-  limit = GNUNET_ntohll (zis_msg->limit);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received ZONE_ITERATION_NEXT message\n");
+  GNUNET_STATISTICS_update(statistics,
+                           "Iteration NEXT messages received",
+                           1,
+                           GNUNET_NO);
+  rid = ntohl(zis_msg->gns_header.r_id);
+  limit = GNUNET_ntohll(zis_msg->limit);
   for (zi = nc->op_head; NULL != zi; zi = zi->next)
     if (zi->request_id == rid)
       break;
   if (NULL == zi)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
-  run_zone_iteration_round (zi, limit);
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
+  run_zone_iteration_round(zi, limit);
 }
 
 
@@ -1933,37 +1921,37 @@ handle_iteration_next (void *cls,
  * monitor not being ready.
  */
 static void
-monitor_unblock (struct ZoneMonitor *zm)
+monitor_unblock(struct ZoneMonitor *zm)
 {
   struct StoreActivity *sa = sa_head;
 
   while ((NULL != sa) && (zm->limit > zm->iteration_cnt))
-  {
-    struct StoreActivity *sn = sa->next;
+    {
+      struct StoreActivity *sn = sa->next;
 
-    if (sa->zm_pos == zm)
-      continue_store_activity (sa);
-    sa = sn;
-  }
+      if (sa->zm_pos == zm)
+        continue_store_activity(sa);
+      sa = sn;
+    }
   if (zm->limit > zm->iteration_cnt)
-  {
-    zm->sa_waiting = GNUNET_NO;
-    if (NULL != zm->sa_wait_warning)
     {
-      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
-      zm->sa_wait_warning = NULL;
+      zm->sa_waiting = GNUNET_NO;
+      if (NULL != zm->sa_wait_warning)
+        {
+          GNUNET_SCHEDULER_cancel(zm->sa_wait_warning);
+          zm->sa_wait_warning = NULL;
+        }
     }
-  }
   else if (GNUNET_YES == zm->sa_waiting)
-  {
-    zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
-    if (NULL != zm->sa_wait_warning)
-      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
-    zm->sa_wait_warning =
-      GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
-                                    &warn_monitor_slow,
-                                    zm);
-  }
+    {
+      zm->sa_waiting_start = GNUNET_TIME_absolute_get();
+      if (NULL != zm->sa_wait_warning)
+        GNUNET_SCHEDULER_cancel(zm->sa_wait_warning);
+      zm->sa_wait_warning =
+        GNUNET_SCHEDULER_add_delayed(MONITOR_STALL_WARN_DELAY,
+                                     &warn_monitor_slow,
+                                     zm);
+    }
 }
 
 
@@ -1973,18 +1961,18 @@ monitor_unblock (struct ZoneMonitor *zm)
  * @param zm monitor that is now in sync
  */
 static void
-monitor_sync (struct ZoneMonitor *zm)
+monitor_sync(struct ZoneMonitor *zm)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *sync;
 
-  env = GNUNET_MQ_msg (sync, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC);
-  GNUNET_MQ_send (zm->nc->mq, env);
+  env = GNUNET_MQ_msg(sync, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC);
+  GNUNET_MQ_send(zm->nc->mq, env);
   /* mark iteration done */
   zm->in_first_iteration = GNUNET_NO;
   zm->iteration_cnt = 0;
   if ((zm->limit > 0) && (zm->sa_waiting))
-    monitor_unblock (zm);
+    monitor_unblock(zm);
 }
 
 
@@ -1994,7 +1982,7 @@ monitor_sync (struct ZoneMonitor *zm)
  * @param cls zone monitor that does its initial iteration
  */
 static void
-monitor_iteration_next (void *cls);
+monitor_iteration_next(void *cls);
 
 
 /**
@@ -2008,32 +1996,32 @@ monitor_iteration_next (void *cls);
  * @param rd array of records
  */
 static void
-monitor_iterate_cb (void *cls,
-                    uint64_t seq,
-                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                    const char *name,
-                    unsigned int rd_count,
-                    const struct GNUNET_GNSRECORD_Data *rd)
+monitor_iterate_cb(void *cls,
+                   uint64_t seq,
+                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                   const char *name,
+                   unsigned int rd_count,
+                   const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ZoneMonitor *zm = cls;
 
-  GNUNET_assert (0 != seq);
+  GNUNET_assert(0 != seq);
   zm->seq = seq;
-  GNUNET_assert (NULL != name);
-  GNUNET_STATISTICS_update (statistics,
-                            "Monitor notifications sent",
-                            1,
-                            GNUNET_NO);
+  GNUNET_assert(NULL != name);
+  GNUNET_STATISTICS_update(statistics,
+                           "Monitor notifications sent",
+                           1,
+                           GNUNET_NO);
   zm->limit--;
   zm->iteration_cnt--;
-  send_lookup_response (zm->nc, 0, zone_key, name, rd_count, rd);
+  send_lookup_response(zm->nc, 0, zone_key, name, rd_count, rd);
   if ((0 == zm->iteration_cnt) && (0 != zm->limit))
-  {
-    /* We are done with the current iteration batch, AND the
-       client would right now accept more, so go again! */
-    GNUNET_assert (NULL == zm->task);
-    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm);
-  }
+    {
+      /* We are done with the current iteration batch, AND the
+         client would right now accept more, so go again! */
+      GNUNET_assert(NULL == zm->task);
+      zm->task = GNUNET_SCHEDULER_add_now(&monitor_iteration_next, zm);
+    }
 }
 
 
@@ -2044,25 +2032,25 @@ monitor_iterate_cb (void *cls,
  * @param zis_msg message from the client
  */
 static void
-handle_monitor_start (void *cls, const struct ZoneMonitorStartMessage *zis_msg)
+handle_monitor_start(void *cls, const struct ZoneMonitorStartMessage *zis_msg)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneMonitor *zm;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_MONITOR_START message\n");
-  zm = GNUNET_new (struct ZoneMonitor);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_MONITOR_START message\n");
+  zm = GNUNET_new(struct ZoneMonitor);
   zm->nc = nc;
   zm->zone = zis_msg->zone;
   zm->limit = 1;
-  zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first));
-  GNUNET_CONTAINER_DLL_insert (monitor_head, monitor_tail, zm);
-  GNUNET_SERVICE_client_mark_monitor (nc->client);
-  GNUNET_SERVICE_client_continue (nc->client);
-  GNUNET_notification_context_add (monitor_nc, nc->mq);
+  zm->in_first_iteration = (GNUNET_YES == ntohl(zis_msg->iterate_first));
+  GNUNET_CONTAINER_DLL_insert(monitor_head, monitor_tail, zm);
+  GNUNET_SERVICE_client_mark_monitor(nc->client);
+  GNUNET_SERVICE_client_continue(nc->client);
+  GNUNET_notification_context_add(monitor_nc, nc->mq);
   if (zm->in_first_iteration)
-    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm);
+    zm->task = GNUNET_SCHEDULER_add_now(&monitor_iteration_next, zm);
   else
-    monitor_sync (zm);
+    monitor_sync(zm);
 }
 
 
@@ -2072,36 +2060,36 @@ handle_monitor_start (void *cls, const struct ZoneMonitorStartMessage *zis_msg)
  * @param cls zone monitor that does its initial iteration
  */
 static void
-monitor_iteration_next (void *cls)
+monitor_iteration_next(void *cls)
 {
   struct ZoneMonitor *zm = cls;
   int ret;
 
   zm->task = NULL;
-  GNUNET_assert (0 == zm->iteration_cnt);
+  GNUNET_assert(0 == zm->iteration_cnt);
   if (zm->limit > 16)
     zm->iteration_cnt = zm->limit / 2; /* leave half for monitor events */
   else
     zm->iteration_cnt = zm->limit; /* use it all */
-  ret = GSN_database->iterate_records (GSN_database->cls,
-                                       (0 == GNUNET_is_zero (&zm->zone))
-                                         ? NULL
-                                         : &zm->zone,
-                                       zm->seq,
-                                       zm->iteration_cnt,
-                                       &monitor_iterate_cb,
-                                       zm);
+  ret = GSN_database->iterate_records(GSN_database->cls,
+                                      (0 == GNUNET_is_zero(&zm->zone))
+                                      ? NULL
+                                      : &zm->zone,
+                                      zm->seq,
+                                      zm->iteration_cnt,
+                                      &monitor_iterate_cb,
+                                      zm);
   if (GNUNET_SYSERR == ret)
-  {
-    GNUNET_SERVICE_client_drop (zm->nc->client);
-    return;
-  }
+    {
+      GNUNET_SERVICE_client_drop(zm->nc->client);
+      return;
+    }
   if (GNUNET_NO == ret)
-  {
-    /* empty zone */
-    monitor_sync (zm);
-    return;
-  }
+    {
+      /* empty zone */
+      monitor_sync(zm);
+      return;
+    }
 }
 
 
@@ -2112,55 +2100,55 @@ monitor_iteration_next (void *cls)
  * @param nm message from the client
  */
 static void
-handle_monitor_next (void *cls, const struct ZoneMonitorNextMessage *nm)
+handle_monitor_next(void *cls, const struct ZoneMonitorNextMessage *nm)
 {
   struct NamestoreClient *nc = cls;
   struct ZoneMonitor *zm;
   uint64_t inc;
 
-  inc = GNUNET_ntohll (nm->limit);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ZONE_MONITOR_NEXT message with limit %llu\n",
-              (unsigned long long) inc);
+  inc = GNUNET_ntohll(nm->limit);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received ZONE_MONITOR_NEXT message with limit %llu\n",
+             (unsigned long long)inc);
   for (zm = monitor_head; NULL != zm; zm = zm->next)
     if (zm->nc == nc)
       break;
   if (NULL == zm)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
-  GNUNET_SERVICE_client_continue (nc->client);
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
+  GNUNET_SERVICE_client_continue(nc->client);
   if (zm->limit + inc < zm->limit)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (nc->client);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(nc->client);
+      return;
+    }
   zm->limit += inc;
   if ((zm->in_first_iteration) && (zm->limit == inc))
-  {
-    /* We are still iterating, and the previous iteration must
-       have stopped due to the client's limit, so continue it! */
-    GNUNET_assert (NULL == zm->task);
-    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next, zm);
-  }
-  GNUNET_assert (zm->iteration_cnt <= zm->limit);
+    {
+      /* We are still iterating, and the previous iteration must
+         have stopped due to the client's limit, so continue it! */
+      GNUNET_assert(NULL == zm->task);
+      zm->task = GNUNET_SCHEDULER_add_now(&monitor_iteration_next, zm);
+    }
+  GNUNET_assert(zm->iteration_cnt <= zm->limit);
   if ((zm->limit > zm->iteration_cnt) && (zm->sa_waiting))
-  {
-    monitor_unblock (zm);
-  }
+    {
+      monitor_unblock(zm);
+    }
   else if (GNUNET_YES == zm->sa_waiting)
-  {
-    if (NULL != zm->sa_wait_warning)
-      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
-    zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
-    zm->sa_wait_warning =
-      GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
-                                    &warn_monitor_slow,
-                                    zm);
-  }
+    {
+      if (NULL != zm->sa_wait_warning)
+        GNUNET_SCHEDULER_cancel(zm->sa_wait_warning);
+      zm->sa_waiting_start = GNUNET_TIME_absolute_get();
+      zm->sa_wait_warning =
+        GNUNET_SCHEDULER_add_delayed(MONITOR_STALL_WARN_DELAY,
+                                     &warn_monitor_slow,
+                                     zm);
+    }
 }
 
 
@@ -2172,92 +2160,92 @@ handle_monitor_next (void *cls, const struct ZoneMonitorNextMessage *nm)
  * @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)
 {
   char *database;
 
-  (void) cls;
-  (void) service;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n");
+  (void)cls;
+  (void)service;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n");
   cache_keys =
-    GNUNET_CONFIGURATION_get_value_yesno (cfg, "namestore", "CACHE_KEYS");
+    GNUNET_CONFIGURATION_get_value_yesno(cfg, "namestore", "CACHE_KEYS");
   disable_namecache =
-    GNUNET_CONFIGURATION_get_value_yesno (cfg, "namecache", "DISABLE");
+    GNUNET_CONFIGURATION_get_value_yesno(cfg, "namecache", "DISABLE");
   GSN_cfg = cfg;
-  monitor_nc = GNUNET_notification_context_create (1);
+  monitor_nc = GNUNET_notification_context_create(1);
   if (GNUNET_YES != disable_namecache)
-  {
-    namecache = GNUNET_NAMECACHE_connect (cfg);
-    GNUNET_assert (NULL != namecache);
-  }
+    {
+      namecache = GNUNET_NAMECACHE_connect(cfg);
+      GNUNET_assert(NULL != namecache);
+    }
   /* Loading database plugin */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                          "namestore",
-                                                          "database",
-                                                          &database))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
-
-  GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database);
-  GSN_database = GNUNET_PLUGIN_load (db_lib_name, (void *) GSN_cfg);
-  GNUNET_free (database);
-  statistics = GNUNET_STATISTICS_create ("namestore", cfg);
-  GNUNET_SCHEDULER_add_shutdown (&cleanup_task, NULL);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                         "namestore",
+                                                         "database",
+                                                         &database))
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
+
+  GNUNET_asprintf(&db_lib_name, "libgnunet_plugin_namestore_%s", database);
+  GSN_database = GNUNET_PLUGIN_load(db_lib_name, (void *)GSN_cfg);
+  GNUNET_free(database);
+  statistics = GNUNET_STATISTICS_create("namestore", cfg);
+  GNUNET_SCHEDULER_add_shutdown(&cleanup_task, NULL);
   if (NULL == GSN_database)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Could not load database backend `%s'\n",
-                db_lib_name);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Could not load database backend `%s'\n",
+                 db_lib_name);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
 }
 
 
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN (
+GNUNET_SERVICE_MAIN(
   "namestore",
   GNUNET_SERVICE_OPTION_NONE,
   &run,
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size (record_store,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE,
-                         struct RecordStoreMessage,
-                         NULL),
-  GNUNET_MQ_hd_var_size (record_lookup,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP,
-                         struct LabelLookupMessage,
-                         NULL),
-  GNUNET_MQ_hd_fixed_size (zone_to_name,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME,
-                           struct ZoneToNameMessage,
-                           NULL),
-  GNUNET_MQ_hd_fixed_size (iteration_start,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START,
-                           struct ZoneIterationStartMessage,
-                           NULL),
-  GNUNET_MQ_hd_fixed_size (iteration_next,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT,
-                           struct ZoneIterationNextMessage,
-                           NULL),
-  GNUNET_MQ_hd_fixed_size (iteration_stop,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP,
-                           struct ZoneIterationStopMessage,
-                           NULL),
-  GNUNET_MQ_hd_fixed_size (monitor_start,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START,
-                           struct ZoneMonitorStartMessage,
-                           NULL),
-  GNUNET_MQ_hd_fixed_size (monitor_next,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT,
-                           struct ZoneMonitorNextMessage,
-                           NULL),
-  GNUNET_MQ_handler_end ());
+  GNUNET_MQ_hd_var_size(record_store,
+                        GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE,
+                        struct RecordStoreMessage,
+                        NULL),
+  GNUNET_MQ_hd_var_size(record_lookup,
+                        GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP,
+                        struct LabelLookupMessage,
+                        NULL),
+  GNUNET_MQ_hd_fixed_size(zone_to_name,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME,
+                          struct ZoneToNameMessage,
+                          NULL),
+  GNUNET_MQ_hd_fixed_size(iteration_start,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START,
+                          struct ZoneIterationStartMessage,
+                          NULL),
+  GNUNET_MQ_hd_fixed_size(iteration_next,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT,
+                          struct ZoneIterationNextMessage,
+                          NULL),
+  GNUNET_MQ_hd_fixed_size(iteration_stop,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP,
+                          struct ZoneIterationStopMessage,
+                          NULL),
+  GNUNET_MQ_hd_fixed_size(monitor_start,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START,
+                          struct ZoneMonitorStartMessage,
+                          NULL),
+  GNUNET_MQ_hd_fixed_size(monitor_next,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT,
+                          struct ZoneMonitorNextMessage,
+                          NULL),
+  GNUNET_MQ_handler_end());
 
 
 /* end of gnunet-service-namestore.c */
diff --git a/src/namestore/gnunet-zoneimport.c b/src/namestore/gnunet-zoneimport.c
index 4c5205ab3..60d8b0537 100644
--- a/src/namestore/gnunet-zoneimport.c
+++ b/src/namestore/gnunet-zoneimport.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 src/namestore/gnunet-zoneimport.c
  * @brief import a DNS zone for publication in GNS, incremental
@@ -57,7 +57,7 @@
  * How long do we wait at least between series of requests?
  */
 #define SERIES_DELAY \
-  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)
+  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 10)
 
 /**
  * How long do DNS records have to last at least after being imported?
@@ -76,9 +76,7 @@ static struct GNUNET_TIME_Relative minimum_expiration_time;
  * each dot represents a zone cut, we then need to create a
  * zone on-the-fly to capture those records properly.
  */
-struct Zone
-{
-
+struct Zone {
   /**
    * Kept in a DLL.
    */
@@ -104,8 +102,7 @@ struct Zone
 /**
  * Record for the request to be stored by GNS.
  */
-struct Record
-{
+struct Record {
   /**
    * Kept in a DLL.
    */
@@ -128,8 +125,7 @@ struct Record
  * thus optimizing it is crucial for the overall memory consumption of
  * the zone importer.
  */
-struct Request
-{
+struct Request {
   /**
    * Requests are kept in a heap while waiting to be resolved.
    */
@@ -379,28 +375,28 @@ typedef void (*RecordProcessor) (void *cls,
  * @param rp_cls closure for @a rp
  */
 static void
-for_all_records (const struct GNUNET_DNSPARSER_Packet *p,
-                 RecordProcessor rp,
-                 void *rp_cls)
+for_all_records(const struct GNUNET_DNSPARSER_Packet *p,
+                RecordProcessor rp,
+                void *rp_cls)
 {
   for (unsigned int i = 0; i < p->num_answers; i++)
-  {
-    struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
+    {
+      struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
 
-    rp (rp_cls, rs);
-  }
+      rp(rp_cls, rs);
+    }
   for (unsigned int i = 0; i < p->num_authority_records; i++)
-  {
-    struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
+    {
+      struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
 
-    rp (rp_cls, rs);
-  }
+      rp(rp_cls, rs);
+    }
   for (unsigned int i = 0; i < p->num_additional_records; i++)
-  {
-    struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
+    {
+      struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
 
-    rp (rp_cls, rs);
-  }
+      rp(rp_cls, rs);
+    }
 }
 
 
@@ -412,23 +408,23 @@ for_all_records (const struct GNUNET_DNSPARSER_Packet *p,
  *         overwritten upon the next request!
  */
 static const char *
-get_label (struct Request *req)
+get_label(struct Request *req)
 {
   static char label[64];
   const char *dot;
 
-  dot = strchr (req->hostname, (unsigned char) '.');
+  dot = strchr(req->hostname, (unsigned char)'.');
   if (NULL == dot)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  if (((size_t) (dot - req->hostname)) >= sizeof (label))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  GNUNET_memcpy (label, req->hostname, dot - req->hostname);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  if (((size_t)(dot - req->hostname)) >= sizeof(label))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  GNUNET_memcpy(label, req->hostname, dot - req->hostname);
   label[dot - req->hostname] = '\0';
   return label;
 }
@@ -443,7 +439,7 @@ get_label (struct Request *req)
  *         allocated query buffer
  */
 static void *
-build_dns_query (struct Request *req, size_t *raw_size)
+build_dns_query(struct Request *req, size_t *raw_size)
 {
   static char raw[512];
   char *rawp;
@@ -451,37 +447,37 @@ build_dns_query (struct Request *req, size_t *raw_size)
   struct GNUNET_DNSPARSER_Query q;
   int ret;
 
-  q.name = (char *) req->hostname;
+  q.name = (char *)req->hostname;
   q.type = GNUNET_DNSPARSER_TYPE_NS;
   q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 
-  memset (&p, 0, sizeof (p));
+  memset(&p, 0, sizeof(p));
   p.num_queries = 1;
   p.queries = &q;
   p.id = req->id;
-  ret = GNUNET_DNSPARSER_pack (&p, UINT16_MAX, &rawp, raw_size);
+  ret = GNUNET_DNSPARSER_pack(&p, UINT16_MAX, &rawp, raw_size);
   if (GNUNET_OK != ret)
-  {
-    if (GNUNET_NO == ret)
-      GNUNET_free (rawp);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to pack query for hostname `%s'\n",
-                req->hostname);
-    rejects++;
-    return NULL;
-  }
-  if (*raw_size > sizeof (raw))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to pack query for hostname `%s'\n",
-                req->hostname);
-    rejects++;
-    GNUNET_break (0);
-    GNUNET_free (rawp);
-    return NULL;
-  }
-  GNUNET_memcpy (raw, rawp, *raw_size);
-  GNUNET_free (rawp);
+    {
+      if (GNUNET_NO == ret)
+        GNUNET_free(rawp);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to pack query for hostname `%s'\n",
+                 req->hostname);
+      rejects++;
+      return NULL;
+    }
+  if (*raw_size > sizeof(raw))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to pack query for hostname `%s'\n",
+                 req->hostname);
+      rejects++;
+      GNUNET_break(0);
+      GNUNET_free(rawp);
+      return NULL;
+    }
+  GNUNET_memcpy(raw, rawp, *raw_size);
+  GNUNET_free(rawp);
   return raw;
 }
 
@@ -492,16 +488,16 @@ build_dns_query (struct Request *req, size_t *raw_size)
  * @param req request to free records of
  */
 static void
-free_records (struct Request *req)
+free_records(struct Request *req)
 {
   struct Record *rec;
 
   /* Free records */
   while (NULL != (rec = req->rec_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (req->rec_head, req->rec_tail, rec);
-    GNUNET_free (rec);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(req->rec_head, req->rec_tail, rec);
+      GNUNET_free(rec);
+    }
 }
 
 
@@ -511,10 +507,10 @@ free_records (struct Request *req)
  * @param req request to free
  */
 static void
-free_request (struct Request *req)
+free_request(struct Request *req)
 {
-  free_records (req);
-  GNUNET_free (req);
+  free_records(req);
+  GNUNET_free(req);
 }
 
 
@@ -524,7 +520,7 @@ free_request (struct Request *req)
  * @param cls NULL
  */
 static void
-process_queue (void *cls);
+process_queue(void *cls);
 
 
 /**
@@ -533,17 +529,17 @@ process_queue (void *cls);
  * @param req request to insert into #req_heap
  */
 static void
-insert_sorted (struct Request *req)
+insert_sorted(struct Request *req)
 {
   req->hn =
-    GNUNET_CONTAINER_heap_insert (req_heap, req, req->expires.abs_value_us);
-  if (req == GNUNET_CONTAINER_heap_peek (req_heap))
-  {
-    if (NULL != t)
-      GNUNET_SCHEDULER_cancel (t);
-    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-    t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL);
-  }
+    GNUNET_CONTAINER_heap_insert(req_heap, req, req->expires.abs_value_us);
+  if (req == GNUNET_CONTAINER_heap_peek(req_heap))
+    {
+      if (NULL != t)
+        GNUNET_SCHEDULER_cancel(t);
+      sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+      t = GNUNET_SCHEDULER_add_at(req->expires, &process_queue, NULL);
+    }
 }
 
 
@@ -557,30 +553,29 @@ insert_sorted (struct Request *req)
  * @param data_len number of bytes in @a data
  */
 static void
-add_record (struct Request *req,
-            uint32_t type,
-            struct GNUNET_TIME_Absolute expiration_time,
-            const void *data,
-            size_t data_len)
+add_record(struct Request *req,
+           uint32_t type,
+           struct GNUNET_TIME_Absolute expiration_time,
+           const void *data,
+           size_t data_len)
 {
   struct Record *rec;
 
-  rec = GNUNET_malloc (sizeof (struct Record) + data_len);
+  rec = GNUNET_malloc(sizeof(struct Record) + data_len);
   rec->grd.data = &rec[1];
   rec->grd.expiration_time = expiration_time.abs_value_us;
   rec->grd.data_size = data_len;
   rec->grd.record_type = type;
   rec->grd.flags = GNUNET_GNSRECORD_RF_NONE;
-  GNUNET_memcpy (&rec[1], data, data_len);
-  GNUNET_CONTAINER_DLL_insert (req->rec_head, req->rec_tail, rec);
+  GNUNET_memcpy(&rec[1], data, data_len);
+  GNUNET_CONTAINER_DLL_insert(req->rec_head, req->rec_tail, rec);
 }
 
 
 /**
  * Closure for #check_for_glue.
  */
-struct GlueClosure
-{
+struct GlueClosure {
   /**
    * Overall request we are processing.
    */
@@ -605,113 +600,115 @@ struct GlueClosure
  * @param rec record that may contain glue information
  */
 static void
-check_for_glue (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
+check_for_glue(void *cls, const struct GNUNET_DNSPARSER_Record *rec)
 {
   struct GlueClosure *gc = cls;
   char dst[65536];
   size_t dst_len;
   size_t off;
   char ip[INET6_ADDRSTRLEN + 1];
-  socklen_t ip_size = (socklen_t) sizeof (ip);
+  socklen_t ip_size = (socklen_t)sizeof(ip);
   struct GNUNET_TIME_Absolute expiration_time;
   struct GNUNET_TIME_Relative left;
 
-  if (0 != strcasecmp (rec->name, gc->ns))
+  if (0 != strcasecmp(rec->name, gc->ns))
     return;
   expiration_time = rec->expiration_time;
-  left = GNUNET_TIME_absolute_get_remaining (expiration_time);
+  left = GNUNET_TIME_absolute_get_remaining(expiration_time);
   if (0 == left.rel_value_us)
     return; /* ignore expired glue records */
   /* if expiration window is too short, bump it to configured minimum */
   if (left.rel_value_us < minimum_expiration_time.rel_value_us)
     expiration_time =
-      GNUNET_TIME_relative_to_absolute (minimum_expiration_time);
-  dst_len = sizeof (dst);
+      GNUNET_TIME_relative_to_absolute(minimum_expiration_time);
+  dst_len = sizeof(dst);
   off = 0;
   switch (rec->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_A:
-    if (sizeof (struct in_addr) != rec->data.raw.data_len)
-    {
-      GNUNET_break (0);
-      return;
-    }
-    if (NULL == inet_ntop (AF_INET, rec->data.raw.data, ip, ip_size))
-    {
-      GNUNET_break (0);
-      return;
-    }
-    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                         dst_len,
-                                                         &off,
-                                                         gc->req->hostname)) &&
-        (GNUNET_OK ==
-         GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip)))
-    {
-      add_record (gc->req,
-                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
-                  expiration_time,
-                  dst,
-                  off);
-      gc->found = GNUNET_YES;
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_AAAA:
-    if (sizeof (struct in6_addr) != rec->data.raw.data_len)
-    {
-      GNUNET_break (0);
-      return;
-    }
-    if (NULL == inet_ntop (AF_INET6, rec->data.raw.data, ip, ip_size))
-    {
-      GNUNET_break (0);
-      return;
-    }
-    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                         dst_len,
-                                                         &off,
-                                                         gc->req->hostname)) &&
-        (GNUNET_OK ==
-         GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip)))
-    {
-      add_record (gc->req,
-                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
-                  expiration_time,
-                  dst,
-                  off);
-      gc->found = GNUNET_YES;
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                         dst_len,
-                                                         &off,
-                                                         gc->req->hostname)) &&
-        (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                         dst_len,
-                                                         &off,
-                                                         rec->data.hostname)))
     {
-      add_record (gc->req,
-                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
-                  expiration_time,
-                  dst,
-                  off);
-      gc->found = GNUNET_YES;
+    case GNUNET_DNSPARSER_TYPE_A:
+      if (sizeof(struct in_addr) != rec->data.raw.data_len)
+        {
+          GNUNET_break(0);
+          return;
+        }
+      if (NULL == inet_ntop(AF_INET, rec->data.raw.data, ip, ip_size))
+        {
+          GNUNET_break(0);
+          return;
+        }
+      if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          gc->req->hostname)) &&
+          (GNUNET_OK ==
+           GNUNET_DNSPARSER_builder_add_name(dst, dst_len, &off, ip)))
+        {
+          add_record(gc->req,
+                     GNUNET_GNSRECORD_TYPE_GNS2DNS,
+                     expiration_time,
+                     dst,
+                     off);
+          gc->found = GNUNET_YES;
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_AAAA:
+      if (sizeof(struct in6_addr) != rec->data.raw.data_len)
+        {
+          GNUNET_break(0);
+          return;
+        }
+      if (NULL == inet_ntop(AF_INET6, rec->data.raw.data, ip, ip_size))
+        {
+          GNUNET_break(0);
+          return;
+        }
+      if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          gc->req->hostname)) &&
+          (GNUNET_OK ==
+           GNUNET_DNSPARSER_builder_add_name(dst, dst_len, &off, ip)))
+        {
+          add_record(gc->req,
+                     GNUNET_GNSRECORD_TYPE_GNS2DNS,
+                     expiration_time,
+                     dst,
+                     off);
+          gc->found = GNUNET_YES;
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+      if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          gc->req->hostname)) &&
+          (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          rec->data.hostname)))
+        {
+          add_record(gc->req,
+                     GNUNET_GNSRECORD_TYPE_GNS2DNS,
+                     expiration_time,
+                     dst,
+                     off);
+          gc->found = GNUNET_YES;
+        }
+      break;
+
+    default:
+      /* useless, do nothing */
+      break;
     }
-    break;
-  default:
-    /* useless, do nothing */
-    break;
-  }
 }
 
 
 /**
  * Closure for #process_record().
  */
-struct ProcessRecordContext
-{
+struct ProcessRecordContext {
   /**
    * Answer we got back and are currently parsing, or NULL
    * if not active.
@@ -732,7 +729,7 @@ struct ProcessRecordContext
  * @param rec response
  */
 static void
-process_record (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
+process_record(void *cls, const struct GNUNET_DNSPARSER_Record *rec)
 {
   struct ProcessRecordContext *prc = cls;
   struct Request *req = prc->req;
@@ -742,175 +739,183 @@ process_record (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
   struct GNUNET_TIME_Absolute expiration_time;
   struct GNUNET_TIME_Relative left;
 
-  dst_len = sizeof (dst);
+  dst_len = sizeof(dst);
   off = 0;
   records++;
-  if (0 != strcasecmp (rec->name, req->hostname))
-  {
-    GNUNET_log (
-      GNUNET_ERROR_TYPE_DEBUG,
-      "DNS returned record from zone `%s' of type %u while resolving `%s'\n",
-      rec->name,
-      (unsigned int) rec->type,
-      req->hostname);
-    return; /* does not match hostname, might be glue, but
-               not useful for this pass! */
-  }
+  if (0 != strcasecmp(rec->name, req->hostname))
+    {
+      GNUNET_log(
+        GNUNET_ERROR_TYPE_DEBUG,
+        "DNS returned record from zone `%s' of type %u while resolving `%s'\n",
+        rec->name,
+        (unsigned int)rec->type,
+        req->hostname);
+      return; /* does not match hostname, might be glue, but
+                 not useful for this pass! */
+    }
   expiration_time = rec->expiration_time;
-  left = GNUNET_TIME_absolute_get_remaining (expiration_time);
+  left = GNUNET_TIME_absolute_get_remaining(expiration_time);
   if (0 == left.rel_value_us)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "DNS returned expired record for `%s'\n",
-                req->hostname);
-    GNUNET_STATISTICS_update (stats,
-                              "# expired records obtained from DNS",
-                              1,
-                              GNUNET_NO);
-    return; /* record expired */
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "DNS returned expired record for `%s'\n",
+                 req->hostname);
+      GNUNET_STATISTICS_update(stats,
+                               "# expired records obtained from DNS",
+                               1,
+                               GNUNET_NO);
+      return; /* record expired */
+    }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "DNS returned record that expires at %s for `%s'\n",
-              GNUNET_STRINGS_absolute_time_to_string (expiration_time),
-              req->hostname);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "DNS returned record that expires at %s for `%s'\n",
+             GNUNET_STRINGS_absolute_time_to_string(expiration_time),
+             req->hostname);
   /* if expiration window is too short, bump it to configured minimum */
   if (left.rel_value_us < minimum_expiration_time.rel_value_us)
     expiration_time =
-      GNUNET_TIME_relative_to_absolute (minimum_expiration_time);
+      GNUNET_TIME_relative_to_absolute(minimum_expiration_time);
   switch (rec->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_NS: {
-    struct GlueClosure gc;
-
-    /* check for glue */
-    gc.req = req;
-    gc.ns = rec->data.hostname;
-    gc.found = GNUNET_NO;
-    for_all_records (prc->p, &check_for_glue, &gc);
-    if ((GNUNET_NO == gc.found) &&
-        (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
+    {
+    case GNUNET_DNSPARSER_TYPE_NS: {
+      struct GlueClosure gc;
+
+      /* check for glue */
+      gc.req = req;
+      gc.ns = rec->data.hostname;
+      gc.found = GNUNET_NO;
+      for_all_records(prc->p, &check_for_glue, &gc);
+      if ((GNUNET_NO == gc.found) &&
+          (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          req->hostname)) &&
+          (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
+                                                          dst_len,
+                                                          &off,
+                                                          rec->data.hostname)))
+        {
+          /* FIXME: actually check if this is out-of-bailiwick,
+               and if not request explicit resolution... */
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converted OOB (`%s') NS record for `%s'\n",
+                     rec->data.hostname,
+                     rec->name);
+          add_record(req,
+                     GNUNET_GNSRECORD_TYPE_GNS2DNS,
+                     expiration_time,
+                     dst,
+                     off);
+        }
+      else
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converted NS record for `%s' using glue\n",
+                     rec->name);
+        }
+      break;
+    }
+
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+      if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
                                                          dst_len,
                                                          &off,
-                                                         req->hostname)) &&
-        (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
+                                                         rec->data.hostname))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting CNAME (`%s') record for `%s'\n",
+                     rec->data.hostname,
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_DNAME:
+      /* No support for DNAME in GNS yet! FIXME: support later! */
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "FIXME: not supported: %s DNAME %s\n",
+                 rec->name,
+                 rec->data.hostname);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_MX:
+      if (GNUNET_OK ==
+          GNUNET_DNSPARSER_builder_add_mx(dst, dst_len, &off, rec->data.mx))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting MX (`%s') record for `%s'\n",
+                     rec->data.mx->mxhost,
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SOA:
+      if (GNUNET_OK ==
+          GNUNET_DNSPARSER_builder_add_soa(dst, dst_len, &off, rec->data.soa))
+        {
+          /* NOTE: GNS does not really use SOAs */
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting SOA record for `%s'\n",
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SRV:
+      if (GNUNET_OK ==
+          GNUNET_DNSPARSER_builder_add_srv(dst, dst_len, &off, rec->data.srv))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting SRV record for `%s'\n",
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_PTR:
+      if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name(dst,
                                                          dst_len,
                                                          &off,
-                                                         rec->data.hostname)))
-    {
-      /* FIXME: actually check if this is out-of-bailiwick,
-           and if not request explicit resolution... */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converted OOB (`%s') NS record for `%s'\n",
-                  rec->data.hostname,
-                  rec->name);
-      add_record (req,
-                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
-                  expiration_time,
-                  dst,
-                  off);
-    }
-    else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converted NS record for `%s' using glue\n",
-                  rec->name);
-    }
-    break;
-  }
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-    if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                        dst_len,
-                                                        &off,
-                                                        rec->data.hostname))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting CNAME (`%s') record for `%s'\n",
-                  rec->data.hostname,
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_DNAME:
-    /* No support for DNAME in GNS yet! FIXME: support later! */
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "FIXME: not supported: %s DNAME %s\n",
-                rec->name,
-                rec->data.hostname);
-    break;
-  case GNUNET_DNSPARSER_TYPE_MX:
-    if (GNUNET_OK ==
-        GNUNET_DNSPARSER_builder_add_mx (dst, dst_len, &off, rec->data.mx))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting MX (`%s') record for `%s'\n",
-                  rec->data.mx->mxhost,
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_SOA:
-    if (GNUNET_OK ==
-        GNUNET_DNSPARSER_builder_add_soa (dst, dst_len, &off, rec->data.soa))
-    {
-      /* NOTE: GNS does not really use SOAs */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting SOA record for `%s'\n",
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_SRV:
-    if (GNUNET_OK ==
-        GNUNET_DNSPARSER_builder_add_srv (dst, dst_len, &off, rec->data.srv))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting SRV record for `%s'\n",
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_PTR:
-    if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
-                                                        dst_len,
-                                                        &off,
-                                                        rec->data.hostname))
-    {
-      /* !?: what does a PTR record do in a regular TLD??? */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting PTR record for `%s' (weird)\n",
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
-  case GNUNET_DNSPARSER_TYPE_CERT:
-    if (GNUNET_OK ==
-        GNUNET_DNSPARSER_builder_add_cert (dst, dst_len, &off, rec->data.cert))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Converting CERT record for `%s'\n",
-                  rec->name);
-      add_record (req, rec->type, expiration_time, dst, off);
-    }
-    break;
+                                                         rec->data.hostname))
+        {
+          /* !?: what does a PTR record do in a regular TLD??? */
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting PTR record for `%s' (weird)\n",
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_CERT:
+      if (GNUNET_OK ==
+          GNUNET_DNSPARSER_builder_add_cert(dst, dst_len, &off, rec->data.cert))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Converting CERT record for `%s'\n",
+                     rec->name);
+          add_record(req, rec->type, expiration_time, dst, off);
+        }
+      break;
+
     /* Rest is 'raw' encoded and just needs to be copied IF
        the hostname matches the requested name; otherwise we
        simply cannot use it. */
-  case GNUNET_DNSPARSER_TYPE_A:
-  case GNUNET_DNSPARSER_TYPE_AAAA:
-  case GNUNET_DNSPARSER_TYPE_TXT:
-  default:
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Converting record of type %u for `%s'\n",
-                (unsigned int) rec->type,
-                rec->name);
-    add_record (req,
-                rec->type,
-                expiration_time,
-                rec->data.raw.data,
-                rec->data.raw.data_len);
-    break;
-  }
+    case GNUNET_DNSPARSER_TYPE_A:
+    case GNUNET_DNSPARSER_TYPE_AAAA:
+    case GNUNET_DNSPARSER_TYPE_TXT:
+    default:
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Converting record of type %u for `%s'\n",
+                 (unsigned int)rec->type,
+                 rec->name);
+      add_record(req,
+                 rec->type,
+                 expiration_time,
+                 rec->data.raw.data,
+                 rec->data.raw.data_len);
+      break;
+    }
 }
 
 
@@ -925,89 +930,89 @@ process_record (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
  * @param emsg NULL on success, otherwise an error message
  */
 static void
-store_completed_cb (void *cls, int32_t success, const char *emsg)
+store_completed_cb(void *cls, int32_t success, const char *emsg)
 {
   static struct GNUNET_TIME_Absolute last;
   struct Request *req = cls;
 
   req->qe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to store zone data for `%s': %s\n",
-                req->hostname,
-                emsg);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to store zone data for `%s': %s\n",
+                 req->hostname,
+                 emsg);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Stored records under `%s' (%d)\n",
-                req->hostname,
-                success);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Stored records under `%s' (%d)\n",
+                 req->hostname,
+                 success);
+    }
   total_reg_proc_dns_ns++; /* finished regular processing */
   pending_rs--;
-  free_records (req);
+  free_records(req);
   /* compute NAMESTORE statistics */
   {
     static uint64_t total_ns_latency_cnt;
     static struct GNUNET_TIME_Relative total_ns_latency;
     struct GNUNET_TIME_Relative ns_latency;
 
-    ns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
-    total_ns_latency = GNUNET_TIME_relative_add (total_ns_latency, ns_latency);
+    ns_latency = GNUNET_TIME_absolute_get_duration(req->op_start_time);
+    total_ns_latency = GNUNET_TIME_relative_add(total_ns_latency, ns_latency);
     if (0 == total_ns_latency_cnt)
-      last = GNUNET_TIME_absolute_get ();
+      last = GNUNET_TIME_absolute_get();
     total_ns_latency_cnt++;
     if (0 == (total_ns_latency_cnt % 1000))
-    {
-      struct GNUNET_TIME_Relative delta;
-
-      delta = GNUNET_TIME_absolute_get_duration (last);
-      last = GNUNET_TIME_absolute_get ();
-      fprintf (stderr,
-               "Processed 1000 records in %s\n",
-               GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
-      GNUNET_STATISTICS_set (stats,
-                             "# average NAMESTORE PUT latency (μs)",
-                             total_ns_latency.rel_value_us /
-                               total_ns_latency_cnt,
-                             GNUNET_NO);
-    }
+      {
+        struct GNUNET_TIME_Relative delta;
+
+        delta = GNUNET_TIME_absolute_get_duration(last);
+        last = GNUNET_TIME_absolute_get();
+        fprintf(stderr,
+                "Processed 1000 records in %s\n",
+                GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_YES));
+        GNUNET_STATISTICS_set(stats,
+                              "# average NAMESTORE PUT latency (μs)",
+                              total_ns_latency.rel_value_us /
+                              total_ns_latency_cnt,
+                              GNUNET_NO);
+      }
   }
   /* compute and publish overall velocity */
   if (0 == (total_reg_proc_dns_ns % 100))
-  {
-    struct GNUNET_TIME_Relative runtime;
-
-    runtime = GNUNET_TIME_absolute_get_duration (start_time_reg_proc);
-    runtime = GNUNET_TIME_relative_subtract (runtime, idle_time);
-    runtime =
-      GNUNET_TIME_relative_divide (runtime,
-                                   total_reg_proc_dns + total_reg_proc_dns_ns);
-    GNUNET_STATISTICS_set (stats,
-                           "# Regular processing completed without NAMESTORE",
-                           total_reg_proc_dns,
-                           GNUNET_NO);
-    GNUNET_STATISTICS_set (stats,
-                           "# Regular processing completed with NAMESTORE PUT",
-                           total_reg_proc_dns_ns,
-                           GNUNET_NO);
-    GNUNET_STATISTICS_set (stats,
-                           "# average request processing latency (μs)",
-                           runtime.rel_value_us,
-                           GNUNET_NO);
-    GNUNET_STATISTICS_set (stats,
-                           "# total time spent idle (μs)",
-                           idle_time.rel_value_us,
-                           GNUNET_NO);
-  }
+    {
+      struct GNUNET_TIME_Relative runtime;
+
+      runtime = GNUNET_TIME_absolute_get_duration(start_time_reg_proc);
+      runtime = GNUNET_TIME_relative_subtract(runtime, idle_time);
+      runtime =
+        GNUNET_TIME_relative_divide(runtime,
+                                    total_reg_proc_dns + total_reg_proc_dns_ns);
+      GNUNET_STATISTICS_set(stats,
+                            "# Regular processing completed without NAMESTORE",
+                            total_reg_proc_dns,
+                            GNUNET_NO);
+      GNUNET_STATISTICS_set(stats,
+                            "# Regular processing completed with NAMESTORE PUT",
+                            total_reg_proc_dns_ns,
+                            GNUNET_NO);
+      GNUNET_STATISTICS_set(stats,
+                            "# average request processing latency (μs)",
+                            runtime.rel_value_us,
+                            GNUNET_NO);
+      GNUNET_STATISTICS_set(stats,
+                            "# total time spent idle (μs)",
+                            idle_time.rel_value_us,
+                            GNUNET_NO);
+    }
 
   if (NULL == t)
-  {
-    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-    t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
-  }
+    {
+      sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+      t = GNUNET_SCHEDULER_add_now(&process_queue, NULL);
+    }
 }
 
 
@@ -1019,148 +1024,148 @@ store_completed_cb (void *cls, int32_t success, const char *emsg)
  * @param dns_len number of bytes in @a dns
  */
 static void
-process_result (void *cls,
-                const struct GNUNET_TUN_DnsHeader *dns,
-                size_t dns_len)
+process_result(void *cls,
+               const struct GNUNET_TUN_DnsHeader *dns,
+               size_t dns_len)
 {
   struct Request *req = cls;
   struct Record *rec;
   struct GNUNET_DNSPARSER_Packet *p;
   unsigned int rd_count;
 
-  GNUNET_assert (NULL == req->hn);
+  GNUNET_assert(NULL == req->hn);
   if (NULL == dns)
-  {
-    /* stub gave up */
-    GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
-    pending--;
-    if (NULL == t)
     {
-      sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-      t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
+      /* stub gave up */
+      GNUNET_CONTAINER_DLL_remove(req_head, req_tail, req);
+      pending--;
+      if (NULL == t)
+        {
+          sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+          t = GNUNET_SCHEDULER_add_now(&process_queue, NULL);
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Stub gave up on DNS reply for `%s'\n",
+                 req->hostname);
+      GNUNET_STATISTICS_update(stats, "# DNS lookups timed out", 1, GNUNET_NO);
+      if (req->issue_num > MAX_RETRIES)
+        {
+          failures++;
+          free_request(req);
+          GNUNET_STATISTICS_update(stats, "# requests given up on", 1, GNUNET_NO);
+          return;
+        }
+      total_reg_proc_dns++;
+      req->rs = NULL;
+      insert_sorted(req);
+      return;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Stub gave up on DNS reply for `%s'\n",
-                req->hostname);
-    GNUNET_STATISTICS_update (stats, "# DNS lookups timed out", 1, GNUNET_NO);
-    if (req->issue_num > MAX_RETRIES)
+  if (req->id != dns->id)
     {
-      failures++;
-      free_request (req);
-      GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "DNS ID did not match request, ignoring reply\n");
+      GNUNET_STATISTICS_update(stats, "# DNS ID mismatches", 1, GNUNET_NO);
       return;
     }
-    total_reg_proc_dns++;
-    req->rs = NULL;
-    insert_sorted (req);
-    return;
-  }
-  if (req->id != dns->id)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "DNS ID did not match request, ignoring reply\n");
-    GNUNET_STATISTICS_update (stats, "# DNS ID mismatches", 1, GNUNET_NO);
-    return;
-  }
-  GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
-  GNUNET_DNSSTUB_resolve_cancel (req->rs);
+  GNUNET_CONTAINER_DLL_remove(req_head, req_tail, req);
+  GNUNET_DNSSTUB_resolve_cancel(req->rs);
   req->rs = NULL;
   pending--;
-  p = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len);
+  p = GNUNET_DNSPARSER_parse((const char *)dns, dns_len);
   if (NULL == p)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to parse DNS reply for `%s'\n",
-                req->hostname);
-    GNUNET_STATISTICS_update (stats, "# DNS parser errors", 1, GNUNET_NO);
-    if (NULL == t)
-    {
-      sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-      t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
-    }
-    if (req->issue_num > MAX_RETRIES)
     {
-      failures++;
-      free_request (req);
-      GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to parse DNS reply for `%s'\n",
+                 req->hostname);
+      GNUNET_STATISTICS_update(stats, "# DNS parser errors", 1, GNUNET_NO);
+      if (NULL == t)
+        {
+          sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+          t = GNUNET_SCHEDULER_add_now(&process_queue, NULL);
+        }
+      if (req->issue_num > MAX_RETRIES)
+        {
+          failures++;
+          free_request(req);
+          GNUNET_STATISTICS_update(stats, "# requests given up on", 1, GNUNET_NO);
+          return;
+        }
+      insert_sorted(req);
       return;
     }
-    insert_sorted (req);
-    return;
-  }
   /* import new records */
   req->issue_num = 0; /* success, reset counter! */
   {
-    struct ProcessRecordContext prc = {.req = req, .p = p};
+    struct ProcessRecordContext prc = { .req = req, .p = p };
 
-    for_all_records (p, &process_record, &prc);
+    for_all_records(p, &process_record, &prc);
   }
-  GNUNET_DNSPARSER_free_packet (p);
+  GNUNET_DNSPARSER_free_packet(p);
   /* count records found, determine minimum expiration time */
   req->expires = GNUNET_TIME_UNIT_FOREVER_ABS;
   {
     struct GNUNET_TIME_Relative dns_latency;
 
-    dns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
+    dns_latency = GNUNET_TIME_absolute_get_duration(req->op_start_time);
     total_dns_latency =
-      GNUNET_TIME_relative_add (total_dns_latency, dns_latency);
+      GNUNET_TIME_relative_add(total_dns_latency, dns_latency);
     total_dns_latency_cnt++;
     if (0 == (total_dns_latency_cnt % 1000))
-    {
-      GNUNET_STATISTICS_set (stats,
-                             "# average DNS lookup latency (μs)",
-                             total_dns_latency.rel_value_us /
-                               total_dns_latency_cnt,
-                             GNUNET_NO);
-    }
+      {
+        GNUNET_STATISTICS_set(stats,
+                              "# average DNS lookup latency (μs)",
+                              total_dns_latency.rel_value_us /
+                              total_dns_latency_cnt,
+                              GNUNET_NO);
+      }
   }
   rd_count = 0;
   for (rec = req->rec_head; NULL != rec; rec = rec->next)
-  {
-    struct GNUNET_TIME_Absolute at;
+    {
+      struct GNUNET_TIME_Absolute at;
 
-    at.abs_value_us = rec->grd.expiration_time;
-    req->expires = GNUNET_TIME_absolute_min (req->expires, at);
-    rd_count++;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Obtained %u records for `%s'\n",
-              rd_count,
-              req->hostname);
+      at.abs_value_us = rec->grd.expiration_time;
+      req->expires = GNUNET_TIME_absolute_min(req->expires, at);
+      rd_count++;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Obtained %u records for `%s'\n",
+             rd_count,
+             req->hostname);
   /* Instead of going for SOA, simplified for now to look each
      day in case we got an empty response */
   if (0 == rd_count)
-  {
-    req->expires = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS);
-    GNUNET_STATISTICS_update (stats,
-                              "# empty DNS replies (usually NXDOMAIN)",
-                              1,
-                              GNUNET_NO);
-  }
+    {
+      req->expires = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_DAYS);
+      GNUNET_STATISTICS_update(stats,
+                               "# empty DNS replies (usually NXDOMAIN)",
+                               1,
+                               GNUNET_NO);
+    }
   else
-  {
-    record_sets++;
-  }
+    {
+      record_sets++;
+    }
   /* convert records to namestore import format */
   {
-    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
+    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];
     unsigned int off = 0;
 
     /* convert linked list into array */
     for (rec = req->rec_head; NULL != rec; rec = rec->next)
       rd[off++] = rec->grd;
     pending_rs++;
-    req->op_start_time = GNUNET_TIME_absolute_get ();
-    req->qe = GNUNET_NAMESTORE_records_store (ns,
-                                              &req->zone->key,
-                                              get_label (req),
-                                              rd_count,
-                                              rd,
-                                              &store_completed_cb,
-                                              req);
-    GNUNET_assert (NULL != req->qe);
+    req->op_start_time = GNUNET_TIME_absolute_get();
+    req->qe = GNUNET_NAMESTORE_records_store(ns,
+                                             &req->zone->key,
+                                             get_label(req),
+                                             rd_count,
+                                             rd,
+                                             &store_completed_cb,
+                                             req);
+    GNUNET_assert(NULL != req->qe);
   }
-  insert_sorted (req);
+  insert_sorted(req);
 }
 
 
@@ -1170,7 +1175,7 @@ process_result (void *cls,
  * @param cls NULL
  */
 static void
-process_queue (void *cls)
+process_queue(void *cls)
 {
   struct Request *req;
   unsigned int series;
@@ -1178,82 +1183,82 @@ process_queue (void *cls)
   size_t raw_size;
   struct GNUNET_TIME_Relative delay;
 
-  (void) cls;
-  delay = GNUNET_TIME_absolute_get_duration (sleep_time_reg_proc);
-  idle_time = GNUNET_TIME_relative_add (idle_time, delay);
+  (void)cls;
+  delay = GNUNET_TIME_absolute_get_duration(sleep_time_reg_proc);
+  idle_time = GNUNET_TIME_relative_add(idle_time, delay);
   series = 0;
   t = NULL;
   while (pending + pending_rs < THRESH)
-  {
-    req = GNUNET_CONTAINER_heap_peek (req_heap);
-    if (NULL == req)
-      break;
-    if (NULL != req->qe)
-      return; /* namestore op still pending */
-    if (NULL != req->rs)
     {
-      GNUNET_break (0);
-      return; /* already submitted */
+      req = GNUNET_CONTAINER_heap_peek(req_heap);
+      if (NULL == req)
+        break;
+      if (NULL != req->qe)
+        return; /* namestore op still pending */
+      if (NULL != req->rs)
+        {
+          GNUNET_break(0);
+          return; /* already submitted */
+        }
+      if (GNUNET_TIME_absolute_get_remaining(req->expires).rel_value_us > 0)
+        break;
+      GNUNET_assert(req == GNUNET_CONTAINER_heap_remove_root(req_heap));
+      req->hn = NULL;
+      GNUNET_CONTAINER_DLL_insert(req_head, req_tail, req);
+      GNUNET_assert(NULL == req->rs);
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Requesting resolution for `%s'\n",
+                 req->hostname);
+      raw = build_dns_query(req, &raw_size);
+      if (NULL == raw)
+        {
+          GNUNET_break(0);
+          free_request(req);
+          continue;
+        }
+      req->op_start_time = GNUNET_TIME_absolute_get();
+      req->rs = GNUNET_DNSSTUB_resolve(ctx, raw, raw_size, &process_result, req);
+      GNUNET_assert(NULL != req->rs);
+      req->issue_num++;
+      lookups++;
+      pending++;
+      series++;
+      if (series > MAX_SERIES)
+        break;
     }
-    if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0)
-      break;
-    GNUNET_assert (req == GNUNET_CONTAINER_heap_remove_root (req_heap));
-    req->hn = NULL;
-    GNUNET_CONTAINER_DLL_insert (req_head, req_tail, req);
-    GNUNET_assert (NULL == req->rs);
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Requesting resolution for `%s'\n",
-                req->hostname);
-    raw = build_dns_query (req, &raw_size);
-    if (NULL == raw)
+  if (pending + pending_rs >= THRESH)
     {
-      GNUNET_break (0);
-      free_request (req);
-      continue;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Stopped processing queue (%u+%u/%u)]\n",
+                 pending,
+                 pending_rs,
+                 THRESH);
+      return; /* wait for replies */
     }
-    req->op_start_time = GNUNET_TIME_absolute_get ();
-    req->rs = GNUNET_DNSSTUB_resolve (ctx, raw, raw_size, &process_result, req);
-    GNUNET_assert (NULL != req->rs);
-    req->issue_num++;
-    lookups++;
-    pending++;
-    series++;
-    if (series > MAX_SERIES)
-      break;
-  }
-  if (pending + pending_rs >= THRESH)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Stopped processing queue (%u+%u/%u)]\n",
-                pending,
-                pending_rs,
-                THRESH);
-    return; /* wait for replies */
-  }
-  req = GNUNET_CONTAINER_heap_peek (req_heap);
+  req = GNUNET_CONTAINER_heap_peek(req_heap);
   if (NULL == req)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Stopped processing queue: empty queue\n");
-    return;
-  }
-  if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Waiting until %s for next record (`%s') to expire\n",
-                GNUNET_STRINGS_absolute_time_to_string (req->expires),
-                req->hostname);
-    if (NULL != t)
-      GNUNET_SCHEDULER_cancel (t);
-    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-    t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Throttling\n");
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Stopped processing queue: empty queue\n");
+      return;
+    }
+  if (GNUNET_TIME_absolute_get_remaining(req->expires).rel_value_us > 0)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Waiting until %s for next record (`%s') to expire\n",
+                 GNUNET_STRINGS_absolute_time_to_string(req->expires),
+                 req->hostname);
+      if (NULL != t)
+        GNUNET_SCHEDULER_cancel(t);
+      sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+      t = GNUNET_SCHEDULER_add_at(req->expires, &process_queue, NULL);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Throttling\n");
   if (NULL != t)
-    GNUNET_SCHEDULER_cancel (t);
-  sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
-  t = GNUNET_SCHEDULER_add_delayed (SERIES_DELAY, &process_queue, NULL);
+    GNUNET_SCHEDULER_cancel(t);
+  sleep_time_reg_proc = GNUNET_TIME_absolute_get();
+  t = GNUNET_SCHEDULER_add_delayed(SERIES_DELAY, &process_queue, NULL);
 }
 
 
@@ -1267,13 +1272,13 @@ process_queue (void *cls)
  * @return #GNUNET_OK
  */
 static int
-free_request_it (void *cls, const struct GNUNET_HashCode *key, void *value)
+free_request_it(void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct Request *req = value;
 
-  (void) cls;
-  (void) key;
-  free_request (req);
+  (void)cls;
+  (void)key;
+  free_request(req);
   return GNUNET_OK;
 }
 
@@ -1284,73 +1289,73 @@ free_request_it (void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param cls NULL
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
   struct Request *req;
   struct Zone *zone;
 
-  (void) cls;
+  (void)cls;
   if (NULL != id)
-  {
-    GNUNET_IDENTITY_disconnect (id);
-    id = NULL;
-  }
+    {
+      GNUNET_IDENTITY_disconnect(id);
+      id = NULL;
+    }
   if (NULL != t)
-  {
-    GNUNET_SCHEDULER_cancel (t);
-    t = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(t);
+      t = NULL;
+    }
   while (NULL != (req = req_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
-    if (NULL != req->qe)
-      GNUNET_NAMESTORE_cancel (req->qe);
-    free_request (req);
-  }
-  while (NULL != (req = GNUNET_CONTAINER_heap_remove_root (req_heap)))
-  {
-    req->hn = NULL;
-    if (NULL != req->qe)
-      GNUNET_NAMESTORE_cancel (req->qe);
-    free_request (req);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(req_head, req_tail, req);
+      if (NULL != req->qe)
+        GNUNET_NAMESTORE_cancel(req->qe);
+      free_request(req);
+    }
+  while (NULL != (req = GNUNET_CONTAINER_heap_remove_root(req_heap)))
+    {
+      req->hn = NULL;
+      if (NULL != req->qe)
+        GNUNET_NAMESTORE_cancel(req->qe);
+      free_request(req);
+    }
   if (NULL != zone_it)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zone_it);
-    zone_it = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zone_it);
+      zone_it = NULL;
+    }
   if (NULL != ns)
-  {
-    GNUNET_NAMESTORE_disconnect (ns);
-    ns = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(ns);
+      ns = NULL;
+    }
   if (NULL != ctx)
-  {
-    GNUNET_DNSSTUB_stop (ctx);
-    ctx = NULL;
-  }
+    {
+      GNUNET_DNSSTUB_stop(ctx);
+      ctx = NULL;
+    }
   if (NULL != req_heap)
-  {
-    GNUNET_CONTAINER_heap_destroy (req_heap);
-    req_heap = NULL;
-  }
+    {
+      GNUNET_CONTAINER_heap_destroy(req_heap);
+      req_heap = NULL;
+    }
   if (NULL != ns_pending)
-  {
-    GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &free_request_it, NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (ns_pending);
-    ns_pending = NULL;
-  }
+    {
+      GNUNET_CONTAINER_multihashmap_iterate(ns_pending, &free_request_it, NULL);
+      GNUNET_CONTAINER_multihashmap_destroy(ns_pending);
+      ns_pending = NULL;
+    }
   while (NULL != (zone = zone_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (zone_head, zone_tail, zone);
-    GNUNET_free (zone->domain);
-    GNUNET_free (zone);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(zone_head, zone_tail, zone);
+      GNUNET_free(zone->domain);
+      GNUNET_free(zone);
+    }
   if (NULL != stats)
-  {
-    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-    stats = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+      stats = NULL;
+    }
 }
 
 
@@ -1361,7 +1366,7 @@ do_shutdown (void *cls)
  * @param cls NULL
  */
 static void
-iterate_zones (void *cls);
+iterate_zones(void *cls);
 
 
 /**
@@ -1371,16 +1376,16 @@ iterate_zones (void *cls);
  * @param cls a `struct Zone`
  */
 static void
-ns_lookup_error_cb (void *cls)
+ns_lookup_error_cb(void *cls)
 {
   struct Zone *zone = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Failed to load data from namestore for zone `%s'\n",
-              zone->domain);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Failed to load data from namestore for zone `%s'\n",
+             zone->domain);
   zone_it = NULL;
   ns_iterator_trigger_next = 0;
-  iterate_zones (NULL);
+  iterate_zones(NULL);
 }
 
 
@@ -1394,11 +1399,11 @@ ns_lookup_error_cb (void *cls)
  * @param rd array of records with data to store
  */
 static void
-ns_lookup_result_cb (void *cls,
-                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
-                     const char *label,
-                     unsigned int rd_count,
-                     const struct GNUNET_GNSRECORD_Data *rd)
+ns_lookup_result_cb(void *cls,
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+                    const char *label,
+                    unsigned int rd_count,
+                    const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Zone *zone = cls;
   struct Request *req;
@@ -1406,85 +1411,85 @@ ns_lookup_result_cb (void *cls,
   char *fqdn;
 
   ns_iterator_trigger_next--;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Obtained NAMESTORE reply, %llu left in round\n",
-              (unsigned long long) ns_iterator_trigger_next);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Obtained NAMESTORE reply, %llu left in round\n",
+             (unsigned long long)ns_iterator_trigger_next);
   if (0 == ns_iterator_trigger_next)
-  {
-    ns_iterator_trigger_next = NS_BATCH_SIZE;
-    GNUNET_STATISTICS_update (stats,
-                              "# NAMESTORE records requested from cache",
-                              ns_iterator_trigger_next,
-                              GNUNET_NO);
-    GNUNET_NAMESTORE_zone_iterator_next (zone_it, ns_iterator_trigger_next);
-  }
-  GNUNET_asprintf (&fqdn, "%s.%s", label, zone->domain);
-  GNUNET_CRYPTO_hash (fqdn, strlen (fqdn) + 1, &hc);
-  GNUNET_free (fqdn);
-  req = GNUNET_CONTAINER_multihashmap_get (ns_pending, &hc);
+    {
+      ns_iterator_trigger_next = NS_BATCH_SIZE;
+      GNUNET_STATISTICS_update(stats,
+                               "# NAMESTORE records requested from cache",
+                               ns_iterator_trigger_next,
+                               GNUNET_NO);
+      GNUNET_NAMESTORE_zone_iterator_next(zone_it, ns_iterator_trigger_next);
+    }
+  GNUNET_asprintf(&fqdn, "%s.%s", label, zone->domain);
+  GNUNET_CRYPTO_hash(fqdn, strlen(fqdn) + 1, &hc);
+  GNUNET_free(fqdn);
+  req = GNUNET_CONTAINER_multihashmap_get(ns_pending, &hc);
   if (NULL == req)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Ignoring record `%s' in zone `%s': not on my list!\n",
-                label,
-                zone->domain);
-    return;
-  }
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (ns_pending, &hc, req));
-  GNUNET_break (0 == GNUNET_memcmp (key, &req->zone->key));
-  GNUNET_break (0 == strcasecmp (label, get_label (req)));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Ignoring record `%s' in zone `%s': not on my list!\n",
+                 label,
+                 zone->domain);
+      return;
+    }
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_remove(ns_pending, &hc, req));
+  GNUNET_break(0 == GNUNET_memcmp(key, &req->zone->key));
+  GNUNET_break(0 == strcasecmp(label, get_label(req)));
   for (unsigned int i = 0; i < rd_count; i++)
-  {
-    struct GNUNET_TIME_Absolute at;
-
-    if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
     {
-      struct GNUNET_TIME_Relative rel;
+      struct GNUNET_TIME_Absolute at;
 
-      rel.rel_value_us = rd->expiration_time;
-      at = GNUNET_TIME_relative_to_absolute (rel);
+      if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+        {
+          struct GNUNET_TIME_Relative rel;
+
+          rel.rel_value_us = rd->expiration_time;
+          at = GNUNET_TIME_relative_to_absolute(rel);
+        }
+      else
+        {
+          at.abs_value_us = rd->expiration_time;
+        }
+      add_record(req, rd->record_type, at, rd->data, rd->data_size);
     }
-    else
+  if (0 == rd_count)
     {
-      at.abs_value_us = rd->expiration_time;
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Empty record set in namestore for `%s'\n",
+                 req->hostname);
     }
-    add_record (req, rd->record_type, at, rd->data, rd->data_size);
-  }
-  if (0 == rd_count)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Empty record set in namestore for `%s'\n",
-                req->hostname);
-  }
   else
-  {
-    unsigned int pos = 0;
-
-    cached++;
-    req->expires = GNUNET_TIME_UNIT_FOREVER_ABS;
-    for (struct Record *rec = req->rec_head; NULL != rec; rec = rec->next)
     {
-      struct GNUNET_TIME_Absolute at;
-
-      at.abs_value_us = rec->grd.expiration_time;
-      req->expires = GNUNET_TIME_absolute_min (req->expires, at);
-      pos++;
+      unsigned int pos = 0;
+
+      cached++;
+      req->expires = GNUNET_TIME_UNIT_FOREVER_ABS;
+      for (struct Record *rec = req->rec_head; NULL != rec; rec = rec->next)
+        {
+          struct GNUNET_TIME_Absolute at;
+
+          at.abs_value_us = rec->grd.expiration_time;
+          req->expires = GNUNET_TIME_absolute_min(req->expires, at);
+          pos++;
+        }
+      if (0 == pos)
+        req->expires = GNUNET_TIME_UNIT_ZERO_ABS;
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Hot-start with %u existing records for `%s'\n",
+                 pos,
+                 req->hostname);
     }
-    if (0 == pos)
-      req->expires = GNUNET_TIME_UNIT_ZERO_ABS;
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Hot-start with %u existing records for `%s'\n",
-                pos,
-                req->hostname);
-  }
-  free_records (req);
+  free_records(req);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding `%s' to worklist to start at %s\n",
-              req->hostname,
-              GNUNET_STRINGS_absolute_time_to_string (req->expires));
-  insert_sorted (req);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Adding `%s' to worklist to start at %s\n",
+             req->hostname,
+             GNUNET_STRINGS_absolute_time_to_string(req->expires));
+  insert_sorted(req);
 }
 
 
@@ -1494,7 +1499,7 @@ ns_lookup_result_cb (void *cls,
  * @param hostname name to resolve
  */
 static void
-queue (const char *hostname)
+queue(const char *hostname)
 {
   struct Request *req;
   const char *dot;
@@ -1502,55 +1507,55 @@ queue (const char *hostname)
   size_t hlen;
   struct GNUNET_HashCode hc;
 
-  if (GNUNET_OK != GNUNET_DNSPARSER_check_name (hostname))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Refusing invalid hostname `%s'\n",
-                hostname);
-    rejects++;
-    return;
-  }
-  dot = strchr (hostname, (unsigned char) '.');
+  if (GNUNET_OK != GNUNET_DNSPARSER_check_name(hostname))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Refusing invalid hostname `%s'\n",
+                 hostname);
+      rejects++;
+      return;
+    }
+  dot = strchr(hostname, (unsigned char)'.');
   if (NULL == dot)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Refusing invalid hostname `%s' (lacks '.')\n",
-                hostname);
-    rejects++;
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Refusing invalid hostname `%s' (lacks '.')\n",
+                 hostname);
+      rejects++;
+      return;
+    }
   for (zone = zone_head; NULL != zone; zone = zone->next)
-    if (0 == strcmp (zone->domain, dot + 1))
+    if (0 == strcmp(zone->domain, dot + 1))
       break;
   if (NULL == zone)
-  {
-    rejects++;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Domain name `%s' not in ego list!\n",
-                dot + 1);
-    return;
-  }
+    {
+      rejects++;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Domain name `%s' not in ego list!\n",
+                 dot + 1);
+      return;
+    }
 
-  hlen = strlen (hostname) + 1;
-  req = GNUNET_malloc (sizeof (struct Request) + hlen);
+  hlen = strlen(hostname) + 1;
+  req = GNUNET_malloc(sizeof(struct Request) + hlen);
   req->zone = zone;
-  req->hostname = (char *) &req[1];
-  GNUNET_memcpy (req->hostname, hostname, hlen);
-  req->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                                 UINT16_MAX);
-  GNUNET_CRYPTO_hash (req->hostname, hlen, &hc);
-  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
-                     ns_pending,
-                     &hc,
-                     req,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Duplicate hostname `%s' ignored\n",
-                hostname);
-    GNUNET_free (req);
-    return;
-  }
+  req->hostname = (char *)&req[1];
+  GNUNET_memcpy(req->hostname, hostname, hlen);
+  req->id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
+                                               UINT16_MAX);
+  GNUNET_CRYPTO_hash(req->hostname, hlen, &hc);
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
+        ns_pending,
+        &hc,
+        req,
+        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Duplicate hostname `%s' ignored\n",
+                 hostname);
+      GNUNET_free(req);
+      return;
+    }
 }
 
 
@@ -1566,13 +1571,13 @@ queue (const char *hostname)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-move_to_queue (void *cls, const struct GNUNET_HashCode *key, void *value)
+move_to_queue(void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct Request *req = value;
 
-  (void) cls;
-  (void) key;
-  insert_sorted (req);
+  (void)cls;
+  (void)key;
+  insert_sorted(req);
   return GNUNET_OK;
 }
 
@@ -1584,65 +1589,65 @@ move_to_queue (void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param cls NULL
  */
 static void
-iterate_zones (void *cls)
+iterate_zones(void *cls)
 {
   static struct Zone *last;
 
-  (void) cls;
+  (void)cls;
   if (NULL != zone_it)
-  {
-    zone_it = NULL;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Finished iteration over zone `%s'!\n",
-                last->domain);
-    /* subtract left-overs from previous iteration */
-    GNUNET_STATISTICS_update (stats,
-                              "# NAMESTORE records requested from cache",
-                              (long long) (-ns_iterator_trigger_next),
-                              GNUNET_NO);
-    ns_iterator_trigger_next = 0;
-  }
-  GNUNET_assert (NULL != zone_tail);
+    {
+      zone_it = NULL;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Finished iteration over zone `%s'!\n",
+                 last->domain);
+      /* subtract left-overs from previous iteration */
+      GNUNET_STATISTICS_update(stats,
+                               "# NAMESTORE records requested from cache",
+                               (long long)(-ns_iterator_trigger_next),
+                               GNUNET_NO);
+      ns_iterator_trigger_next = 0;
+    }
+  GNUNET_assert(NULL != zone_tail);
   if (zone_tail == last)
-  {
-    /* Done iterating over relevant zones in NAMESTORE, move
-       rest of hash map to work queue as well. */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Finished all NAMESTORE iterations!\n");
-    GNUNET_STATISTICS_set (stats,
-                           "# Domain names without cached reply",
-                           GNUNET_CONTAINER_multihashmap_size (ns_pending),
-                           GNUNET_NO);
-    GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &move_to_queue, NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (ns_pending);
-    ns_pending = NULL;
-    start_time_reg_proc = GNUNET_TIME_absolute_get ();
-    total_reg_proc_dns = 0;
-    total_reg_proc_dns_ns = 0;
-    return;
-  }
+    {
+      /* Done iterating over relevant zones in NAMESTORE, move
+         rest of hash map to work queue as well. */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Finished all NAMESTORE iterations!\n");
+      GNUNET_STATISTICS_set(stats,
+                            "# Domain names without cached reply",
+                            GNUNET_CONTAINER_multihashmap_size(ns_pending),
+                            GNUNET_NO);
+      GNUNET_CONTAINER_multihashmap_iterate(ns_pending, &move_to_queue, NULL);
+      GNUNET_CONTAINER_multihashmap_destroy(ns_pending);
+      ns_pending = NULL;
+      start_time_reg_proc = GNUNET_TIME_absolute_get();
+      total_reg_proc_dns = 0;
+      total_reg_proc_dns_ns = 0;
+      return;
+    }
   if (NULL == last)
     last = zone_head;
   else
     last = last->next;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting iteration over zone `%s'!\n",
-              last->domain);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting iteration over zone `%s'!\n",
+             last->domain);
   /* subtract left-overs from previous iteration */
-  GNUNET_STATISTICS_update (stats,
-                            "# NAMESTORE records requested from cache",
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update(stats,
+                           "# NAMESTORE records requested from cache",
+                           1,
+                           GNUNET_NO);
   ns_iterator_trigger_next = 1;
-  GNUNET_STATISTICS_update (stats, "# zones iterated", 1, GNUNET_NO);
-  zone_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
-                                                   &last->key,
-                                                   &ns_lookup_error_cb,
-                                                   NULL,
-                                                   &ns_lookup_result_cb,
-                                                   last,
-                                                   &iterate_zones,
-                                                   NULL);
+  GNUNET_STATISTICS_update(stats, "# zones iterated", 1, GNUNET_NO);
+  zone_it = GNUNET_NAMESTORE_zone_iteration_start(ns,
+                                                  &last->key,
+                                                  &ns_lookup_error_cb,
+                                                  NULL,
+                                                  &ns_lookup_result_cb,
+                                                  last,
+                                                  &iterate_zones,
+                                                  NULL);
 }
 
 
@@ -1652,44 +1657,44 @@ iterate_zones (void *cls)
  * @param cls NULL
  */
 static void
-process_stdin (void *cls)
+process_stdin(void *cls)
 {
   static struct GNUNET_TIME_Absolute last;
   static uint64_t idot;
   char hn[256];
 
-  (void) cls;
+  (void)cls;
   t = NULL;
   if (NULL != id)
-  {
-    GNUNET_IDENTITY_disconnect (id);
-    id = NULL;
-  }
-  while (NULL != fgets (hn, sizeof (hn), stdin))
-  {
-    if (strlen (hn) > 0)
-      hn[strlen (hn) - 1] = '\0'; /* eat newline */
-    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));
-      GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO);
+      GNUNET_IDENTITY_disconnect(id);
+      id = NULL;
     }
-    queue (hn);
-  }
-  fprintf (stderr,
-           "Done reading %llu domain names\n",
-           (unsigned long long) idot);
-  GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO);
-  iterate_zones (NULL);
+  while (NULL != fgets(hn, sizeof(hn), stdin))
+    {
+      if (strlen(hn) > 0)
+        hn[strlen(hn) - 1] = '\0'; /* eat newline */
+      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));
+          GNUNET_STATISTICS_set(stats, "# domain names provided", idot, GNUNET_NO);
+        }
+      queue(hn);
+    }
+  fprintf(stderr,
+          "Done reading %llu domain names\n",
+          (unsigned long long)idot);
+  GNUNET_STATISTICS_set(stats, "# domain names provided", idot, GNUNET_NO);
+  iterate_zones(NULL);
 }
 
 
@@ -1728,36 +1733,36 @@ process_stdin (void *cls)
  *                   must thus no longer be used
  */
 static void
-identity_cb (void *cls,
-             struct GNUNET_IDENTITY_Ego *ego,
-             void **ctx,
-             const char *name)
+identity_cb(void *cls,
+            struct GNUNET_IDENTITY_Ego *ego,
+            void **ctx,
+            const char *name)
 {
-  (void) cls;
-  (void) ctx;
+  (void)cls;
+  (void)ctx;
 
   if (NULL == ego)
-  {
-    /* end of iteration */
-    if (NULL == zone_head)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No zone found\n");
-      GNUNET_SCHEDULER_shutdown ();
+      /* end of iteration */
+      if (NULL == zone_head)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No zone found\n");
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      /* zone_head non-null, process hostnames from stdin */
+      t = GNUNET_SCHEDULER_add_now(&process_stdin, NULL);
       return;
     }
-    /* zone_head non-null, process hostnames from stdin */
-    t = GNUNET_SCHEDULER_add_now (&process_stdin, NULL);
-    return;
-  }
   if (NULL != name)
-  {
-    struct Zone *zone;
+    {
+      struct Zone *zone;
 
-    zone = GNUNET_new (struct Zone);
-    zone->key = *GNUNET_IDENTITY_ego_get_private_key (ego);
-    zone->domain = GNUNET_strdup (name);
-    GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone);
-  }
+      zone = GNUNET_new(struct Zone);
+      zone->key = *GNUNET_IDENTITY_ego_get_private_key(ego);
+      zone->domain = GNUNET_strdup(name);
+      GNUNET_CONTAINER_DLL_insert(zone_head, zone_tail, zone);
+    }
 }
 
 
@@ -1771,52 +1776,52 @@ identity_cb (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;
-  stats = GNUNET_STATISTICS_create ("zoneimport", cfg);
-  req_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  ns_pending = GNUNET_CONTAINER_multihashmap_create (map_size, GNUNET_NO);
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
+  stats = GNUNET_STATISTICS_create("zoneimport", cfg);
+  req_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  ns_pending = GNUNET_CONTAINER_multihashmap_create(map_size, GNUNET_NO);
   if (NULL == ns_pending)
-  {
-    fprintf (stderr, "Failed to allocate memory for main hash map\n");
-    return;
-  }
-  ctx = GNUNET_DNSSTUB_start (256);
+    {
+      fprintf(stderr, "Failed to allocate memory for main hash map\n");
+      return;
+    }
+  ctx = GNUNET_DNSSTUB_start(256);
   if (NULL == ctx)
-  {
-    fprintf (stderr, "Failed to initialize GNUnet DNS STUB\n");
-    return;
-  }
+    {
+      fprintf(stderr, "Failed to initialize GNUnet DNS STUB\n");
+      return;
+    }
   if (NULL == args[0])
-  {
-    fprintf (stderr,
-             "You must provide a list of DNS resolvers on the command line\n");
-    return;
-  }
-  for (unsigned int i = 0; NULL != args[i]; i++)
-  {
-    if (GNUNET_OK != GNUNET_DNSSTUB_add_dns_ip (ctx, args[i]))
     {
-      fprintf (stderr, "Failed to use `%s' for DNS resolver\n", args[i]);
+      fprintf(stderr,
+              "You must provide a list of DNS resolvers on the command line\n");
       return;
     }
-  }
+  for (unsigned int i = 0; NULL != args[i]; i++)
+    {
+      if (GNUNET_OK != GNUNET_DNSSTUB_add_dns_ip(ctx, args[i]))
+        {
+          fprintf(stderr, "Failed to use `%s' for DNS resolver\n", args[i]);
+          return;
+        }
+    }
 
 
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
-  ns = GNUNET_NAMESTORE_connect (cfg);
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
+  ns = GNUNET_NAMESTORE_connect(cfg);
   if (NULL == ns)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+    {
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  id = GNUNET_IDENTITY_connect(cfg, &identity_cb, NULL);
 }
 
 
@@ -1828,46 +1833,46 @@ run (void *cls,
  * @return 0 on success
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-    {GNUNET_GETOPT_option_uint ('s',
-                                "size",
-                                "MAPSIZE",
-                                gettext_noop (
-                                  "size to use for the main hash map"),
-                                &map_size),
-     GNUNET_GETOPT_option_relative_time (
-       'm',
-       "minimum-expiration",
-       "RELATIVETIME",
-       gettext_noop ("minimum expiration time we assume for imported records"),
-       &minimum_expiration_time),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_uint('s',
+                              "size",
+                              "MAPSIZE",
+                              gettext_noop(
+                                "size to use for the main hash map"),
+                              &map_size),
+    GNUNET_GETOPT_option_relative_time(
+      'm',
+      "minimum-expiration",
+      "RELATIVETIME",
+      gettext_noop("minimum expiration time we assume for imported records"),
+      &minimum_expiration_time),
+    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;
-  if (GNUNET_OK != (ret = GNUNET_PROGRAM_run (argc,
-                                              argv,
-                                              "gnunet-zoneimport",
-                                              "import DNS zone into namestore",
-                                              options,
-                                              &run,
-                                              NULL)))
+  if (GNUNET_OK != (ret = GNUNET_PROGRAM_run(argc,
+                                             argv,
+                                             "gnunet-zoneimport",
+                                             "import DNS zone into namestore",
+                                             options,
+                                             &run,
+                                             NULL)))
     return ret;
-  GNUNET_free ((void *) argv);
-  fprintf (stderr,
-           "Rejected %u names, had %u cached, did %u lookups, stored %u record sets\n"
-           "Found %u records, %u lookups failed, %u/%u pending on shutdown\n",
-           rejects,
-           cached,
-           lookups,
-           record_sets,
-           records,
-           failures,
-           pending,
-           pending_rs);
+  GNUNET_free((void *)argv);
+  fprintf(stderr,
+          "Rejected %u names, had %u cached, did %u lookups, stored %u record sets\n"
+          "Found %u records, %u lookups failed, %u/%u pending on shutdown\n",
+          rejects,
+          cached,
+          lookups,
+          record_sets,
+          records,
+          failures,
+          pending,
+          pending_rs);
   return 0;
 }
 
diff --git a/src/namestore/namestore.h b/src/namestore/namestore.h
index 67d61f9b3..e9a38f0b4 100644
--- a/src/namestore/namestore.h
+++ b/src/namestore/namestore.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 namestore/namestore.h
@@ -37,8 +37,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * Generic namestore message with op id
  */
-struct GNUNET_NAMESTORE_Header
-{
+struct GNUNET_NAMESTORE_Header {
   /**
    * header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_*
    * header.size will be message size
@@ -55,8 +54,7 @@ struct GNUNET_NAMESTORE_Header
 /**
  * Store a record to the namestore (as authority).
  */
-struct RecordStoreMessage
-{
+struct RecordStoreMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE
    */
@@ -102,8 +100,7 @@ struct RecordStoreMessage
 /**
  * Response to a record storage request.
  */
-struct RecordStoreResponseMessage
-{
+struct RecordStoreResponseMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE
    */
@@ -119,8 +116,7 @@ struct RecordStoreResponseMessage
 /**
  * Lookup a label
  */
-struct LabelLookupMessage
-{
+struct LabelLookupMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP
    */
@@ -145,8 +141,7 @@ struct LabelLookupMessage
 /**
  * Lookup a label
  */
-struct LabelLookupResponseMessage
-{
+struct LabelLookupResponseMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
    */
@@ -189,8 +184,7 @@ struct LabelLookupResponseMessage
 /**
  * Lookup a name for a zone hash
  */
-struct ZoneToNameMessage
-{
+struct ZoneToNameMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME
    */
@@ -211,8 +205,7 @@ struct ZoneToNameMessage
 /**
  * Respone for zone to name lookup
  */
-struct ZoneToNameResponseMessage
-{
+struct ZoneToNameResponseMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE
    */
@@ -248,15 +241,13 @@ struct ZoneToNameResponseMessage
    * name with length name_len
    * serialized record data with rd_count records
    */
-
 };
 
 
 /**
  * Record is returned from the namestore (as authority).
  */
-struct RecordResultMessage
-{
+struct RecordResultMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
    */
@@ -297,8 +288,7 @@ struct RecordResultMessage
 /**
  * Start monitoring a zone.
  */
-struct ZoneMonitorStartMessage
-{
+struct ZoneMonitorStartMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START
    */
@@ -314,15 +304,13 @@ struct ZoneMonitorStartMessage
    * Zone key.
    */
   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
-
 };
 
 
 /**
  * Ask for next result of zone iteration for the given operation
  */
-struct ZoneMonitorNextMessage
-{
+struct ZoneMonitorNextMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT
    */
@@ -339,7 +327,6 @@ struct ZoneMonitorNextMessage
    * should be send again). In NBO.
    */
   uint64_t limit;
-
 };
 
 
@@ -347,8 +334,7 @@ struct ZoneMonitorNextMessage
 /**
  * Start a zone iteration for the given zone
  */
-struct ZoneIterationStartMessage
-{
+struct ZoneIterationStartMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START
    */
@@ -358,15 +344,13 @@ struct ZoneIterationStartMessage
    * Zone key.  All zeros for "all zones".
    */
   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
-
 };
 
 
 /**
  * Ask for next result of zone iteration for the given operation
  */
-struct ZoneIterationNextMessage
-{
+struct ZoneIterationNextMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT
    */
@@ -378,15 +362,13 @@ struct ZoneIterationNextMessage
    * should be send again). In NBO.
    */
   uint64_t limit;
-
 };
 
 
 /**
  * Stop zone iteration for the given operation
  */
-struct ZoneIterationStopMessage
-{
+struct ZoneIterationStopMessage {
   /**
    * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP
    */
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index 6c64062ea..c80ca0bd5 100644
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_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 namestore/namestore_api.c
@@ -38,7 +38,7 @@
 #include "namestore.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "namestore-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "namestore-api", __VA_ARGS__)
 
 /**
  * We grant the namestore up to 1 minute of latency, if it is slower than
@@ -50,9 +50,7 @@
  * An QueueEntry used to store information for a pending
  * NAMESTORE record operation
  */
-struct GNUNET_NAMESTORE_QueueEntry
-{
-
+struct GNUNET_NAMESTORE_QueueEntry {
   /**
    * Kept in a DLL.
    */
@@ -119,9 +117,7 @@ struct GNUNET_NAMESTORE_QueueEntry
 /**
  * Handle for a zone iterator operation
  */
-struct GNUNET_NAMESTORE_ZoneIterator
-{
-
+struct GNUNET_NAMESTORE_ZoneIterator {
   /**
    * Kept in a DLL.
    */
@@ -188,9 +184,7 @@ struct GNUNET_NAMESTORE_ZoneIterator
 /**
  * Connection to the NAMESTORE service.
  */
-struct GNUNET_NAMESTORE_Handle
-{
-
+struct GNUNET_NAMESTORE_Handle {
   /**
    * Configuration to use.
    */
@@ -249,7 +243,7 @@ struct GNUNET_NAMESTORE_Handle
  * @param h our handle
  */
 static void
-force_reconnect (struct GNUNET_NAMESTORE_Handle *h);
+force_reconnect(struct GNUNET_NAMESTORE_Handle *h);
 
 
 /**
@@ -260,7 +254,7 @@ force_reconnect (struct GNUNET_NAMESTORE_Handle *h);
  * @return NULL if @a rid was not found
  */
 static struct GNUNET_NAMESTORE_QueueEntry *
-find_qe (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
+find_qe(struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
 
@@ -279,7 +273,7 @@ find_qe (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
  * @return NULL if @a rid was not found
  */
 static struct GNUNET_NAMESTORE_ZoneIterator *
-find_zi (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
+find_zi(struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
 {
   struct GNUNET_NAMESTORE_ZoneIterator *ze;
 
@@ -296,16 +290,16 @@ find_zi (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
  * @param qe entry to free
  */
 static void
-free_qe (struct GNUNET_NAMESTORE_QueueEntry *qe)
+free_qe(struct GNUNET_NAMESTORE_QueueEntry *qe)
 {
   struct GNUNET_NAMESTORE_Handle *h = qe->h;
 
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, qe);
+  GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
   if (NULL != qe->env)
-    GNUNET_MQ_discard (qe->env);
+    GNUNET_MQ_discard(qe->env);
   if (NULL != qe->timeout_task)
-    GNUNET_SCHEDULER_cancel (qe->timeout_task);
-  GNUNET_free (qe);
+    GNUNET_SCHEDULER_cancel(qe->timeout_task);
+  GNUNET_free(qe);
 }
 
 
@@ -315,14 +309,14 @@ free_qe (struct GNUNET_NAMESTORE_QueueEntry *qe)
  * @param ze entry to free
  */
 static void
-free_ze (struct GNUNET_NAMESTORE_ZoneIterator *ze)
+free_ze(struct GNUNET_NAMESTORE_ZoneIterator *ze)
 {
   struct GNUNET_NAMESTORE_Handle *h = ze->h;
 
-  GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, ze);
+  GNUNET_CONTAINER_DLL_remove(h->z_head, h->z_tail, ze);
   if (NULL != ze->env)
-    GNUNET_MQ_discard (ze->env);
-  GNUNET_free (ze);
+    GNUNET_MQ_discard(ze->env);
+  GNUNET_free(ze);
 }
 
 
@@ -336,16 +330,16 @@ free_ze (struct GNUNET_NAMESTORE_ZoneIterator *ze)
  * @return #GNUNET_OK if @a rd_buf is well-formed
  */
 static int
-check_rd (size_t rd_len, const void *rd_buf, unsigned int rd_count)
+check_rd(size_t rd_len, const void *rd_buf, unsigned int rd_count)
 {
   struct GNUNET_GNSRECORD_Data rd[rd_count];
 
   if (GNUNET_OK !=
-      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_buf, rd_count, rd))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_GNSRECORD_records_deserialize(rd_len, rd_buf, rd_count, rd))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -358,27 +352,27 @@ check_rd (size_t rd_len, const void *rd_buf, unsigned int rd_count)
  * @param msg the message we received
  */
 static void
-handle_record_store_response (void *cls,
-                              const struct RecordStoreResponseMessage *msg)
+handle_record_store_response(void *cls,
+                             const struct RecordStoreResponseMessage *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   int res;
   const char *emsg;
 
-  qe = find_qe (h, ntohl (msg->gns_header.r_id));
-  res = ntohl (msg->op_result);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received RECORD_STORE_RESPONSE with result %d\n",
-       res);
+  qe = find_qe(h, ntohl(msg->gns_header.r_id));
+  res = ntohl(msg->op_result);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received RECORD_STORE_RESPONSE with result %d\n",
+      res);
   /* TODO: add actual error message from namestore to response... */
   if (GNUNET_SYSERR == res)
-    emsg = _ ("Namestore failed to store record\n");
+    emsg = _("Namestore failed to store record\n");
   else
     emsg = NULL;
   if (NULL != qe->cont)
-    qe->cont (qe->cont_cls, res, emsg);
-  free_qe (qe);
+    qe->cont(qe->cont_cls, res, emsg);
+  free_qe(qe);
 }
 
 
@@ -391,7 +385,7 @@ handle_record_store_response (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-check_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
+check_lookup_result(void *cls, const struct LabelLookupResponseMessage *msg)
 {
   const char *name;
   size_t exp_msg_len;
@@ -399,32 +393,32 @@ check_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
   size_t name_len;
   size_t rd_len;
 
-  (void) cls;
-  rd_len = ntohs (msg->rd_len);
-  msg_len = ntohs (msg->gns_header.header.size);
-  name_len = ntohs (msg->name_len);
-  exp_msg_len = sizeof (*msg) + name_len + rd_len;
+  (void)cls;
+  rd_len = ntohs(msg->rd_len);
+  msg_len = ntohs(msg->gns_header.header.size);
+  name_len = ntohs(msg->name_len);
+  exp_msg_len = sizeof(*msg) + name_len + rd_len;
   if (msg_len != exp_msg_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  name = (const char *) &msg[1];
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  name = (const char *)&msg[1];
   if ((name_len > 0) && ('\0' != name[name_len - 1]))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  if (GNUNET_NO == ntohs (msg->found))
-  {
-    if (0 != ntohs (msg->rd_count))
     {
-      GNUNET_break (0);
+      GNUNET_break(0);
       return GNUNET_SYSERR;
     }
-    return GNUNET_OK;
-  }
-  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
+  if (GNUNET_NO == ntohs(msg->found))
+    {
+      if (0 != ntohs(msg->rd_count))
+        {
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      return GNUNET_OK;
+    }
+  return check_rd(rd_len, &name[name_len], ntohs(msg->rd_count));
 }
 
 
@@ -436,7 +430,7 @@ check_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
+handle_lookup_result(void *cls, const struct LabelLookupResponseMessage *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
@@ -446,40 +440,40 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
   size_t rd_len;
   unsigned int rd_count;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_LOOKUP_RESULT\n");
-  qe = find_qe (h, ntohl (msg->gns_header.r_id));
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_LOOKUP_RESULT\n");
+  qe = find_qe(h, ntohl(msg->gns_header.r_id));
   if (NULL == qe)
     return;
-  rd_len = ntohs (msg->rd_len);
-  rd_count = ntohs (msg->rd_count);
-  name_len = ntohs (msg->name_len);
-  name = (const char *) &msg[1];
-  if (GNUNET_NO == ntohs (msg->found))
-  {
-    /* label was not in namestore */
-    if (NULL != qe->proc)
-      qe->proc (qe->proc_cls, &msg->private_key, name, 0, NULL);
-    free_qe (qe);
-    return;
-  }
+  rd_len = ntohs(msg->rd_len);
+  rd_count = ntohs(msg->rd_count);
+  name_len = ntohs(msg->name_len);
+  name = (const char *)&msg[1];
+  if (GNUNET_NO == ntohs(msg->found))
+    {
+      /* label was not in namestore */
+      if (NULL != qe->proc)
+        qe->proc(qe->proc_cls, &msg->private_key, name, 0, NULL);
+      free_qe(qe);
+      return;
+    }
 
   rd_tmp = &name[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    GNUNET_assert (
+    GNUNET_assert(
       GNUNET_OK ==
-      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
+      GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd));
     if (0 == name_len)
       name = NULL;
     if (NULL != qe->proc)
-      qe->proc (qe->proc_cls,
-                &msg->private_key,
-                name,
-                rd_count,
-                (rd_count > 0) ? rd : NULL);
+      qe->proc(qe->proc_cls,
+               &msg->private_key,
+               name,
+               rd_count,
+               (rd_count > 0) ? rd : NULL);
   }
-  free_qe (qe);
+  free_qe(qe);
 }
 
 
@@ -492,7 +486,7 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-check_record_result (void *cls, const struct RecordResultMessage *msg)
+check_record_result(void *cls, const struct RecordResultMessage *msg)
 {
   static struct GNUNET_CRYPTO_EcdsaPrivateKey priv_dummy;
   const char *name;
@@ -500,32 +494,32 @@ check_record_result (void *cls, const struct RecordResultMessage *msg)
   size_t name_len;
   size_t rd_len;
 
-  (void) cls;
-  rd_len = ntohs (msg->rd_len);
-  msg_len = ntohs (msg->gns_header.header.size);
-  name_len = ntohs (msg->name_len);
-  if (0 != ntohs (msg->reserved))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  if (msg_len != sizeof (struct RecordResultMessage) + name_len + rd_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  name = (const char *) &msg[1];
+  (void)cls;
+  rd_len = ntohs(msg->rd_len);
+  msg_len = ntohs(msg->gns_header.header.size);
+  name_len = ntohs(msg->name_len);
+  if (0 != ntohs(msg->reserved))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  if (msg_len != sizeof(struct RecordResultMessage) + name_len + rd_len)
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  name = (const char *)&msg[1];
   if ((0 == name_len) || ('\0' != name[name_len - 1]))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  if (0 == GNUNET_memcmp (&msg->private_key, &priv_dummy))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  if (0 == GNUNET_memcmp(&msg->private_key, &priv_dummy))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  return check_rd(rd_len, &name[name_len], ntohs(msg->rd_count));
 }
 
 
@@ -537,7 +531,7 @@ check_record_result (void *cls, const struct RecordResultMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_record_result (void *cls, const struct RecordResultMessage *msg)
+handle_record_result(void *cls, const struct RecordResultMessage *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
@@ -548,49 +542,49 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg)
   size_t rd_len;
   unsigned int rd_count;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n");
-  rd_len = ntohs (msg->rd_len);
-  rd_count = ntohs (msg->rd_count);
-  name_len = ntohs (msg->name_len);
-  ze = find_zi (h, ntohl (msg->gns_header.r_id));
-  qe = find_qe (h, ntohl (msg->gns_header.r_id));
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n");
+  rd_len = ntohs(msg->rd_len);
+  rd_count = ntohs(msg->rd_count);
+  name_len = ntohs(msg->name_len);
+  ze = find_zi(h, ntohl(msg->gns_header.r_id));
+  qe = find_qe(h, ntohl(msg->gns_header.r_id));
   if ((NULL == ze) && (NULL == qe))
     return; /* rid not found */
   if ((NULL != ze) && (NULL != qe))
-  {
-    GNUNET_break (0); /* rid ambigous */
-    force_reconnect (h);
-    return;
-  }
-  name = (const char *) &msg[1];
+    {
+      GNUNET_break(0); /* rid ambigous */
+      force_reconnect(h);
+      return;
+    }
+  name = (const char *)&msg[1];
   rd_tmp = &name[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    GNUNET_assert (
+    GNUNET_assert(
       GNUNET_OK ==
-      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
+      GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd));
     if (0 == name_len)
       name = NULL;
     if (NULL != qe)
-    {
-      if (NULL != qe->proc)
-        qe->proc (qe->proc_cls,
-                  &msg->private_key,
-                  name,
-                  rd_count,
-                  (rd_count > 0) ? rd : NULL);
-      free_qe (qe);
-      return;
-    }
+      {
+        if (NULL != qe->proc)
+          qe->proc(qe->proc_cls,
+                   &msg->private_key,
+                   name,
+                   rd_count,
+                   (rd_count > 0) ? rd : NULL);
+        free_qe(qe);
+        return;
+      }
     if (NULL != ze)
-    {
-      if (NULL != ze->proc)
-        ze->proc (ze->proc_cls, &msg->private_key, name, rd_count, rd);
-      return;
-    }
+      {
+        if (NULL != ze->proc)
+          ze->proc(ze->proc_cls, &msg->private_key, name, rd_count, rd);
+        return;
+      }
   }
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
@@ -602,33 +596,33 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_record_result_end (void *cls, const struct GNUNET_NAMESTORE_Header *msg)
+handle_record_result_end(void *cls, const struct GNUNET_NAMESTORE_Header *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   struct GNUNET_NAMESTORE_ZoneIterator *ze;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT_END\n");
-  ze = find_zi (h, ntohl (msg->r_id));
-  qe = find_qe (h, ntohl (msg->r_id));
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT_END\n");
+  ze = find_zi(h, ntohl(msg->r_id));
+  qe = find_qe(h, ntohl(msg->r_id));
   if ((NULL == ze) && (NULL == qe))
     return; /* rid not found */
   if ((NULL != ze) && (NULL != qe))
-  {
-    GNUNET_break (0); /* rid ambigous */
-    force_reconnect (h);
-    return;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration completed!\n");
+    {
+      GNUNET_break(0); /* rid ambigous */
+      force_reconnect(h);
+      return;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Zone iteration completed!\n");
   if (NULL == ze)
-  {
-    GNUNET_break (0);
-    force_reconnect (h);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      force_reconnect(h);
+      return;
+    }
   if (NULL != ze->finish_cb)
-    ze->finish_cb (ze->finish_cb_cls);
-  free_ze (ze);
+    ze->finish_cb(ze->finish_cb_cls);
+  free_ze(ze);
 }
 
 
@@ -641,31 +635,31 @@ handle_record_result_end (void *cls, const struct GNUNET_NAMESTORE_Header *msg)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if message malformed
  */
 static int
-check_zone_to_name_response (void *cls,
-                             const struct ZoneToNameResponseMessage *msg)
+check_zone_to_name_response(void *cls,
+                            const struct ZoneToNameResponseMessage *msg)
 {
   size_t name_len;
   size_t rd_ser_len;
   const char *name_tmp;
 
-  (void) cls;
-  if (GNUNET_OK != ntohs (msg->res))
+  (void)cls;
+  if (GNUNET_OK != ntohs(msg->res))
     return GNUNET_OK;
-  name_len = ntohs (msg->name_len);
-  rd_ser_len = ntohs (msg->rd_len);
-  if (ntohs (msg->gns_header.header.size) !=
-      sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  name_tmp = (const char *) &msg[1];
+  name_len = ntohs(msg->name_len);
+  rd_ser_len = ntohs(msg->rd_len);
+  if (ntohs(msg->gns_header.header.size) !=
+      sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len)
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  name_tmp = (const char *)&msg[1];
   if ((name_len > 0) && ('\0' != name_tmp[name_len - 1]))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  return check_rd (rd_ser_len, &name_tmp[name_len], ntohs (msg->rd_count));
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  return check_rd(rd_ser_len, &name_tmp[name_len], ntohs(msg->rd_count));
 }
 
 
@@ -677,8 +671,8 @@ check_zone_to_name_response (void *cls,
  * @param msg the message we received
  */
 static void
-handle_zone_to_name_response (void *cls,
-                              const struct ZoneToNameResponseMessage *msg)
+handle_zone_to_name_response(void *cls,
+                             const struct ZoneToNameResponseMessage *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
@@ -689,54 +683,57 @@ handle_zone_to_name_response (void *cls,
   const char *name_tmp;
   const char *rd_tmp;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n");
-  qe = find_qe (h, ntohl (msg->gns_header.r_id));
-  res = ntohs (msg->res);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n");
+  qe = find_qe(h, ntohl(msg->gns_header.r_id));
+  res = ntohs(msg->res);
   switch (res)
-  {
-  case GNUNET_SYSERR:
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "An error occurred during zone to name operation\n");
-    break;
-  case GNUNET_NO:
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Namestore has no result for zone to name mapping \n");
-    if (NULL != qe->proc)
-      qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL);
-    free_qe (qe);
-    return;
-  case GNUNET_YES:
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Namestore has result for zone to name mapping \n");
-    name_len = ntohs (msg->name_len);
-    rd_count = ntohs (msg->rd_count);
-    rd_ser_len = ntohs (msg->rd_len);
-    name_tmp = (const char *) &msg[1];
-    rd_tmp = &name_tmp[name_len];
     {
-      struct GNUNET_GNSRECORD_Data rd[rd_count];
+    case GNUNET_SYSERR:
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "An error occurred during zone to name operation\n");
+      break;
+
+    case GNUNET_NO:
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Namestore has no result for zone to name mapping \n");
+      if (NULL != qe->proc)
+        qe->proc(qe->proc_cls, &msg->zone, NULL, 0, NULL);
+      free_qe(qe);
+      return;
 
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
+    case GNUNET_YES:
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Namestore has result for zone to name mapping \n");
+      name_len = ntohs(msg->name_len);
+      rd_count = ntohs(msg->rd_count);
+      rd_ser_len = ntohs(msg->rd_len);
+      name_tmp = (const char *)&msg[1];
+      rd_tmp = &name_tmp[name_len];
+      {
+        struct GNUNET_GNSRECORD_Data rd[rd_count];
+
+        GNUNET_assert(GNUNET_OK ==
+                      GNUNET_GNSRECORD_records_deserialize(rd_ser_len,
                                                            rd_tmp,
                                                            rd_count,
                                                            rd));
-      /* normal end, call continuation with result */
-      if (NULL != qe->proc)
-        qe->proc (qe->proc_cls, &msg->zone, name_tmp, rd_count, rd);
-      /* return is important here: break would call continuation with error! */
-      free_qe (qe);
+        /* normal end, call continuation with result */
+        if (NULL != qe->proc)
+          qe->proc(qe->proc_cls, &msg->zone, name_tmp, rd_count, rd);
+        /* return is important here: break would call continuation with error! */
+        free_qe(qe);
+        return;
+      }
+
+    default:
+      GNUNET_break(0);
+      force_reconnect(h);
       return;
     }
-  default:
-    GNUNET_break (0);
-    force_reconnect (h);
-    return;
-  }
   /* error case, call continuation with error */
   if (NULL != qe->error_cb)
-    qe->error_cb (qe->error_cb_cls);
-  free_qe (qe);
+    qe->error_cb(qe->error_cb_cls);
+  free_qe(qe);
 }
 
 
@@ -749,12 +746,12 @@ handle_zone_to_name_response (void *cls,
  * @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_NAMESTORE_Handle *h = cls;
 
-  (void) error;
-  force_reconnect (h);
+  (void)error;
+  force_reconnect(h);
 }
 
 
@@ -764,49 +761,49 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param h the handle to the NAMESTORE service
  */
 static void
-reconnect (struct GNUNET_NAMESTORE_Handle *h)
+reconnect(struct GNUNET_NAMESTORE_Handle *h)
 {
   struct GNUNET_MQ_MessageHandler handlers[] =
-    {GNUNET_MQ_hd_fixed_size (record_store_response,
-                              GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE,
-                              struct RecordStoreResponseMessage,
-                              h),
-     GNUNET_MQ_hd_var_size (zone_to_name_response,
-                            GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE,
-                            struct ZoneToNameResponseMessage,
-                            h),
-     GNUNET_MQ_hd_var_size (record_result,
-                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
-                            struct RecordResultMessage,
+  { GNUNET_MQ_hd_fixed_size(record_store_response,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE,
+                            struct RecordStoreResponseMessage,
                             h),
-     GNUNET_MQ_hd_fixed_size (record_result_end,
-                              GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END,
-                              struct GNUNET_NAMESTORE_Header,
-                              h),
-     GNUNET_MQ_hd_var_size (lookup_result,
-                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE,
-                            struct LabelLookupResponseMessage,
+    GNUNET_MQ_hd_var_size(zone_to_name_response,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE,
+                          struct ZoneToNameResponseMessage,
+                          h),
+    GNUNET_MQ_hd_var_size(record_result,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
+                          struct RecordResultMessage,
+                          h),
+    GNUNET_MQ_hd_fixed_size(record_result_end,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END,
+                            struct GNUNET_NAMESTORE_Header,
                             h),
-     GNUNET_MQ_handler_end ()};
+    GNUNET_MQ_hd_var_size(lookup_result,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE,
+                          struct LabelLookupResponseMessage,
+                          h),
+    GNUNET_MQ_handler_end() };
   struct GNUNET_NAMESTORE_ZoneIterator *it;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
 
-  GNUNET_assert (NULL == h->mq);
+  GNUNET_assert(NULL == h->mq);
   h->mq =
-    GNUNET_CLIENT_connect (h->cfg, "namestore", handlers, &mq_error_handler, h);
+    GNUNET_CLIENT_connect(h->cfg, "namestore", handlers, &mq_error_handler, h);
   if (NULL == h->mq)
     return;
   /* re-transmit pending requests that waited for a reconnect... */
   for (it = h->z_head; NULL != it; it = it->next)
-  {
-    GNUNET_MQ_send (h->mq, it->env);
-    it->env = NULL;
-  }
+    {
+      GNUNET_MQ_send(h->mq, it->env);
+      it->env = NULL;
+    }
   for (qe = h->op_head; NULL != qe; qe = qe->next)
-  {
-    GNUNET_MQ_send (h->mq, qe->env);
-    qe->env = NULL;
-  }
+    {
+      GNUNET_MQ_send(h->mq, qe->env);
+      qe->env = NULL;
+    }
 }
 
 
@@ -816,12 +813,12 @@ reconnect (struct GNUNET_NAMESTORE_Handle *h)
  * @param cls handle to use to re-connect.
  */
 static void
-reconnect_task (void *cls)
+reconnect_task(void *cls)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
 
   h->reconnect_task = NULL;
-  reconnect (h);
+  reconnect(h);
 }
 
 
@@ -831,34 +828,34 @@ reconnect_task (void *cls)
  * @param h our handle
  */
 static void
-force_reconnect (struct GNUNET_NAMESTORE_Handle *h)
+force_reconnect(struct GNUNET_NAMESTORE_Handle *h)
 {
   struct GNUNET_NAMESTORE_ZoneIterator *ze;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
 
-  GNUNET_MQ_destroy (h->mq);
+  GNUNET_MQ_destroy(h->mq);
   h->mq = NULL;
   while (NULL != (ze = h->z_head))
-  {
-    if (NULL != ze->error_cb)
-      ze->error_cb (ze->error_cb_cls);
-    free_ze (ze);
-  }
+    {
+      if (NULL != ze->error_cb)
+        ze->error_cb(ze->error_cb_cls);
+      free_ze(ze);
+    }
   while (NULL != (qe = h->op_head))
-  {
-    if (NULL != qe->error_cb)
-      qe->error_cb (qe->error_cb_cls);
-    if (NULL != qe->cont)
-      qe->cont (qe->cont_cls,
-                GNUNET_SYSERR,
-                "failure in communication with namestore service");
-    free_qe (qe);
-  }
+    {
+      if (NULL != qe->error_cb)
+        qe->error_cb(qe->error_cb_cls);
+      if (NULL != qe->cont)
+        qe->cont(qe->cont_cls,
+                 GNUNET_SYSERR,
+                 "failure in communication with namestore service");
+      free_qe(qe);
+    }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting to namestore\n");
-  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Reconnecting to namestore\n");
+  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF(h->reconnect_delay);
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect_task, h);
+    GNUNET_SCHEDULER_add_delayed(h->reconnect_delay, &reconnect_task, h);
 }
 
 
@@ -869,7 +866,7 @@ force_reconnect (struct GNUNET_NAMESTORE_Handle *h)
  * @return next operation id to use
  */
 static uint32_t
-get_op_id (struct GNUNET_NAMESTORE_Handle *h)
+get_op_id(struct GNUNET_NAMESTORE_Handle *h)
 {
   return h->last_op_id_used++;
 }
@@ -882,18 +879,18 @@ get_op_id (struct GNUNET_NAMESTORE_Handle *h)
  * @return handle to the GNS service, or NULL on error
  */
 struct GNUNET_NAMESTORE_Handle *
-GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_NAMESTORE_Handle *h;
 
-  h = GNUNET_new (struct GNUNET_NAMESTORE_Handle);
+  h = GNUNET_new(struct GNUNET_NAMESTORE_Handle);
   h->cfg = cfg;
-  reconnect (h);
+  reconnect(h);
   if (NULL == h->mq)
-  {
-    GNUNET_free (h);
-    return NULL;
-  }
+    {
+      GNUNET_free(h);
+      return NULL;
+    }
   return h;
 }
 
@@ -905,35 +902,35 @@ GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param h handle to the namestore
  */
 void
-GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
+GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
 {
   struct GNUNET_NAMESTORE_QueueEntry *q;
   struct GNUNET_NAMESTORE_ZoneIterator *z;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
-  GNUNET_break (NULL == h->op_head);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+  GNUNET_break(NULL == h->op_head);
   while (NULL != (q = h->op_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
-    GNUNET_free (q);
-  }
-  GNUNET_break (NULL == h->z_head);
+    {
+      GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, q);
+      GNUNET_free(q);
+    }
+  GNUNET_break(NULL == h->z_head);
   while (NULL != (z = h->z_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, z);
-    GNUNET_free (z);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(h->z_head, h->z_tail, z);
+      GNUNET_free(z);
+    }
   if (NULL != h->mq)
-  {
-    GNUNET_MQ_destroy (h->mq);
-    h->mq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(h->mq);
+      h->mq = NULL;
+    }
   if (NULL != h->reconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = NULL;
-  }
-  GNUNET_free (h);
+    {
+      GNUNET_SCHEDULER_cancel(h->reconnect_task);
+      h->reconnect_task = NULL;
+    }
+  GNUNET_free(h);
 }
 
 
@@ -944,21 +941,21 @@ GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
  * @param cls a `struct GNUNET_NAMESTORE_QueueEntry *`
  */
 static void
-warn_delay (void *cls)
+warn_delay(void *cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe = cls;
 
   qe->timeout_task = NULL;
-  LOG (GNUNET_ERROR_TYPE_WARNING,
-       "Did not receive response from namestore after %s!\n",
-       GNUNET_STRINGS_relative_time_to_string (NAMESTORE_DELAY_TOLERANCE,
-                                               GNUNET_YES));
+  LOG(GNUNET_ERROR_TYPE_WARNING,
+      "Did not receive response from namestore after %s!\n",
+      GNUNET_STRINGS_relative_time_to_string(NAMESTORE_DELAY_TOLERANCE,
+                                             GNUNET_YES));
   if (NULL != qe->cont)
-  {
-    qe->cont (qe->cont_cls, GNUNET_SYSERR, "timeout");
-    qe->cont = NULL;
-  }
-  GNUNET_NAMESTORE_cancel (qe);
+    {
+      qe->cont(qe->cont_cls, GNUNET_SYSERR, "timeout");
+      qe->cont = NULL;
+    }
+  GNUNET_NAMESTORE_cancel(qe);
 }
 
 
@@ -977,7 +974,7 @@ warn_delay (void *cls)
  * @return handle to abort the request
  */
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_records_store (
+GNUNET_NAMESTORE_records_store(
   struct GNUNET_NAMESTORE_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
   const char *label,
@@ -996,69 +993,69 @@ GNUNET_NAMESTORE_records_store (
   struct RecordStoreMessage *msg;
   ssize_t sret;
 
-  name_len = strlen (label) + 1;
+  name_len = strlen(label) + 1;
   if (name_len > MAX_NAME_LEN)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  rd_ser_len = GNUNET_GNSRECORD_records_get_size(rd_count, rd);
   if (rd_ser_len < 0)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
   if (rd_ser_len > UINT16_MAX)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  rid = get_op_id (h);
-  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  rid = get_op_id(h);
+  qe = GNUNET_new(struct GNUNET_NAMESTORE_QueueEntry);
   qe->h = h;
   qe->cont = cont;
   qe->cont_cls = cont_cls;
   qe->op_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
 
   /* setup msg */
-  env = GNUNET_MQ_msg_extra (msg,
-                             name_len + rd_ser_len,
-                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
-  msg->gns_header.r_id = htonl (rid);
-  msg->name_len = htons (name_len);
-  msg->rd_count = htons (rd_count);
-  msg->rd_len = htons (rd_ser_len);
-  msg->reserved = htons (0);
+  env = GNUNET_MQ_msg_extra(msg,
+                            name_len + rd_ser_len,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
+  msg->gns_header.r_id = htonl(rid);
+  msg->name_len = htons(name_len);
+  msg->rd_count = htons(rd_count);
+  msg->rd_len = htons(rd_ser_len);
+  msg->reserved = htons(0);
   msg->private_key = *pkey;
 
-  name_tmp = (char *) &msg[1];
-  GNUNET_memcpy (name_tmp, label, name_len);
+  name_tmp = (char *)&msg[1];
+  GNUNET_memcpy(name_tmp, label, name_len);
   rd_ser = &name_tmp[name_len];
-  sret = GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_ser);
+  sret = GNUNET_GNSRECORD_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
   if ((0 > sret) || (sret != rd_ser_len))
-  {
-    GNUNET_break (0);
-    GNUNET_free (env);
-    return NULL;
-  }
-  GNUNET_assert (rd_ser_len == sret);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending NAMESTORE_RECORD_STORE message for name `%s' with %u records\n",
-       label,
-       rd_count);
+    {
+      GNUNET_break(0);
+      GNUNET_free(env);
+      return NULL;
+    }
+  GNUNET_assert(rd_ser_len == sret);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Sending NAMESTORE_RECORD_STORE message for name `%s' with %u records\n",
+      label,
+      rd_count);
   qe->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (NAMESTORE_DELAY_TOLERANCE, &warn_delay, qe);
+    GNUNET_SCHEDULER_add_delayed(NAMESTORE_DELAY_TOLERANCE, &warn_delay, qe);
   if (NULL == h->mq)
-  {
-    qe->env = env;
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Delaying NAMESTORE_RECORD_STORE message as namestore is not ready!\n");
-  }
+    {
+      qe->env = env;
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Delaying NAMESTORE_RECORD_STORE message as namestore is not ready!\n");
+    }
   else
-  {
-    GNUNET_MQ_send (h->mq, env);
-  }
+    {
+      GNUNET_MQ_send(h->mq, env);
+    }
   return qe;
 }
 
@@ -1074,29 +1071,29 @@ GNUNET_NAMESTORE_records_store (
  * @return handle to abort the request
  */
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_set_nick (struct GNUNET_NAMESTORE_Handle *h,
-                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
-                           const char *nick,
-                           GNUNET_NAMESTORE_ContinuationWithStatus cont,
-                           void *cont_cls)
+GNUNET_NAMESTORE_set_nick(struct GNUNET_NAMESTORE_Handle *h,
+                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
+                          const char *nick,
+                          GNUNET_NAMESTORE_ContinuationWithStatus cont,
+                          void *cont_cls)
 {
   struct GNUNET_GNSRECORD_Data rd;
 
   if (NULL == h->mq)
     return NULL;
-  memset (&rd, 0, sizeof (rd));
+  memset(&rd, 0, sizeof(rd));
   rd.data = nick;
-  rd.data_size = strlen (nick) + 1;
+  rd.data_size = strlen(nick) + 1;
   rd.record_type = GNUNET_GNSRECORD_TYPE_NICK;
   rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
   rd.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
-  return GNUNET_NAMESTORE_records_store (h,
-                                         pkey,
-                                         GNUNET_GNS_EMPTY_LABEL_AT,
-                                         1,
-                                         &rd,
-                                         cont,
-                                         cont_cls);
+  return GNUNET_NAMESTORE_records_store(h,
+                                        pkey,
+                                        GNUNET_GNS_EMPTY_LABEL_AT,
+                                        1,
+                                        &rd,
+                                        cont,
+                                        cont_cls);
 }
 
 
@@ -1113,7 +1110,7 @@ GNUNET_NAMESTORE_set_nick (struct GNUNET_NAMESTORE_Handle *h,
  * @return handle to abort the request
  */
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_records_lookup (
+GNUNET_NAMESTORE_records_lookup(
   struct GNUNET_NAMESTORE_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
   const char *label,
@@ -1127,32 +1124,32 @@ GNUNET_NAMESTORE_records_lookup (
   struct LabelLookupMessage *msg;
   size_t label_len;
 
-  if (1 == (label_len = strlen (label) + 1))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+  if (1 == (label_len = strlen(label) + 1))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
 
-  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
+  qe = GNUNET_new(struct GNUNET_NAMESTORE_QueueEntry);
   qe->h = h;
   qe->error_cb = error_cb;
   qe->error_cb_cls = error_cb_cls;
   qe->proc = rm;
   qe->proc_cls = rm_cls;
-  qe->op_id = get_op_id (h);
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
+  qe->op_id = get_op_id(h);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
 
-  env = GNUNET_MQ_msg_extra (msg,
-                             label_len,
-                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
-  msg->gns_header.r_id = htonl (qe->op_id);
+  env = GNUNET_MQ_msg_extra(msg,
+                            label_len,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
+  msg->gns_header.r_id = htonl(qe->op_id);
   msg->zone = *pkey;
-  msg->label_len = htonl (label_len);
-  GNUNET_memcpy (&msg[1], label, label_len);
+  msg->label_len = htonl(label_len);
+  GNUNET_memcpy(&msg[1], label, label_len);
   if (NULL == h->mq)
     qe->env = env;
   else
-    GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_send(h->mq, env);
   return qe;
 }
 
@@ -1173,7 +1170,7 @@ GNUNET_NAMESTORE_records_lookup (
  *         cancel
  */
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_zone_to_name (
+GNUNET_NAMESTORE_zone_to_name(
   struct GNUNET_NAMESTORE_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
   const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
@@ -1187,24 +1184,24 @@ GNUNET_NAMESTORE_zone_to_name (
   struct ZoneToNameMessage *msg;
   uint32_t rid;
 
-  rid = get_op_id (h);
-  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
+  rid = get_op_id(h);
+  qe = GNUNET_new(struct GNUNET_NAMESTORE_QueueEntry);
   qe->h = h;
   qe->error_cb = error_cb;
   qe->error_cb_cls = error_cb_cls;
   qe->proc = proc;
   qe->proc_cls = proc_cls;
   qe->op_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
 
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
-  msg->gns_header.r_id = htonl (rid);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
+  msg->gns_header.r_id = htonl(rid);
   msg->zone = *zone;
   msg->value_zone = *value_zone;
   if (NULL == h->mq)
     qe->env = env;
   else
-    GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_send(h->mq, env);
   return qe;
 }
 
@@ -1229,7 +1226,7 @@ GNUNET_NAMESTORE_zone_to_name (
  * @return an iterator handle to use for iteration
  */
 struct GNUNET_NAMESTORE_ZoneIterator *
-GNUNET_NAMESTORE_zone_iteration_start (
+GNUNET_NAMESTORE_zone_iteration_start(
   struct GNUNET_NAMESTORE_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
   GNUNET_SCHEDULER_TaskCallback error_cb,
@@ -1244,9 +1241,9 @@ GNUNET_NAMESTORE_zone_iteration_start (
   struct ZoneIterationStartMessage *msg;
   uint32_t rid;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n");
-  rid = get_op_id (h);
-  it = GNUNET_new (struct GNUNET_NAMESTORE_ZoneIterator);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n");
+  rid = get_op_id(h);
+  it = GNUNET_new(struct GNUNET_NAMESTORE_ZoneIterator);
   it->h = h;
   it->error_cb = error_cb;
   it->error_cb_cls = error_cb_cls;
@@ -1257,15 +1254,15 @@ GNUNET_NAMESTORE_zone_iteration_start (
   it->op_id = rid;
   if (NULL != zone)
     it->zone = *zone;
-  GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it);
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
-  msg->gns_header.r_id = htonl (rid);
+  GNUNET_CONTAINER_DLL_insert_tail(h->z_head, h->z_tail, it);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
+  msg->gns_header.r_id = htonl(rid);
   if (NULL != zone)
     msg->zone = *zone;
   if (NULL == h->mq)
     it->env = env;
   else
-    GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_send(h->mq, env);
   return it;
 }
 
@@ -1279,20 +1276,20 @@ GNUNET_NAMESTORE_zone_iteration_start (
  *         (before #GNUNET_NAMESTORE_zone_iterator_next is to be called again)
  */
 void
-GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it,
-                                     uint64_t limit)
+GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it,
+                                    uint64_t limit)
 {
   struct GNUNET_NAMESTORE_Handle *h = it->h;
   struct ZoneIterationNextMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending ZONE_ITERATION_NEXT message with limit %llu\n",
-       (unsigned long long) limit);
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
-  msg->gns_header.r_id = htonl (it->op_id);
-  msg->limit = GNUNET_htonll (limit);
-  GNUNET_MQ_send (h->mq, env);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Sending ZONE_ITERATION_NEXT message with limit %llu\n",
+      (unsigned long long)limit);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
+  msg->gns_header.r_id = htonl(it->op_id);
+  msg->limit = GNUNET_htonll(limit);
+  GNUNET_MQ_send(h->mq, env);
 }
 
 
@@ -1302,21 +1299,21 @@ GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it,
  * @param it the iterator
  */
 void
-GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
+GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
 {
   struct GNUNET_NAMESTORE_Handle *h = it->h;
   struct GNUNET_MQ_Envelope *env;
   struct ZoneIterationStopMessage *msg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_STOP message\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_STOP message\n");
   if (NULL != h->mq)
-  {
-    env =
-      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
-    msg->gns_header.r_id = htonl (it->op_id);
-    GNUNET_MQ_send (h->mq, env);
-  }
-  free_ze (it);
+    {
+      env =
+        GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
+      msg->gns_header.r_id = htonl(it->op_id);
+      GNUNET_MQ_send(h->mq, env);
+    }
+  free_ze(it);
 }
 
 
@@ -1327,9 +1324,9 @@ GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
  * @param qe operation to cancel
  */
 void
-GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe)
+GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
 {
-  free_qe (qe);
+  free_qe(qe);
 }
 
 
diff --git a/src/namestore/namestore_api_monitor.c b/src/namestore/namestore_api_monitor.c
index 2881a28ac..d87a76eed 100644
--- a/src/namestore/namestore_api_monitor.c
+++ b/src/namestore/namestore_api_monitor.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 namestore/namestore_api_monitor.c
  * @brief API to monitor changes in the NAMESTORE
@@ -37,8 +37,7 @@
 /**
  * Handle for a monitoring activity.
  */
-struct GNUNET_NAMESTORE_ZoneMonitor
-{
+struct GNUNET_NAMESTORE_ZoneMonitor {
   /**
    * Configuration (to reconnect).
    */
@@ -97,7 +96,7 @@ struct GNUNET_NAMESTORE_ZoneMonitor
  * @param zm monitor to reconnect
  */
 static void
-reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm);
+reconnect(struct GNUNET_NAMESTORE_ZoneMonitor *zm);
 
 
 /**
@@ -107,14 +106,14 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm);
  * @param msg the sync message
  */
 static void
-handle_sync (void *cls, const struct GNUNET_MessageHeader *msg)
+handle_sync(void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 
-  (void) cls;
-  (void) msg;
+  (void)cls;
+  (void)msg;
   if (NULL != zm->sync_cb)
-    zm->sync_cb (zm->sync_cb_cls);
+    zm->sync_cb(zm->sync_cb_cls);
 }
 
 
@@ -126,7 +125,7 @@ handle_sync (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param lrm the message from the service.
  */
 static int
-check_result (void *cls, const struct RecordResultMessage *lrm)
+check_result(void *cls, const struct RecordResultMessage *lrm)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
   size_t lrm_len;
@@ -137,49 +136,49 @@ check_result (void *cls, const struct RecordResultMessage *lrm)
   const char *name_tmp;
   const char *rd_ser_tmp;
 
-  (void) cls;
-  if ((0 != GNUNET_memcmp (&lrm->private_key, &zm->zone)) &&
-      (0 != GNUNET_is_zero (&zm->zone)))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  lrm_len = ntohs (lrm->gns_header.header.size);
-  rd_len = ntohs (lrm->rd_len);
-  rd_count = ntohs (lrm->rd_count);
-  name_len = ntohs (lrm->name_len);
+  (void)cls;
+  if ((0 != GNUNET_memcmp(&lrm->private_key, &zm->zone)) &&
+      (0 != GNUNET_is_zero(&zm->zone)))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  lrm_len = ntohs(lrm->gns_header.header.size);
+  rd_len = ntohs(lrm->rd_len);
+  rd_count = ntohs(lrm->rd_count);
+  name_len = ntohs(lrm->name_len);
   if (name_len > MAX_NAME_LEN)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  exp_lrm_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  exp_lrm_len = sizeof(struct RecordResultMessage) + name_len + rd_len;
   if (lrm_len != exp_lrm_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   if (0 == name_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  name_tmp = (const char *) &lrm[1];
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  name_tmp = (const char *)&lrm[1];
   if (name_tmp[name_len - 1] != '\0')
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  rd_ser_tmp = (const char *) &name_tmp[name_len];
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  rd_ser_tmp = (const char *)&name_tmp[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
     if (GNUNET_OK !=
-        GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+        GNUNET_GNSRECORD_records_deserialize(rd_len, rd_ser_tmp, rd_count, rd))
+      {
+        GNUNET_break(0);
+        return GNUNET_SYSERR;
+      }
   }
   return GNUNET_OK;
 }
@@ -193,7 +192,7 @@ check_result (void *cls, const struct RecordResultMessage *lrm)
  * @param lrm the message from the service.
  */
 static void
-handle_result (void *cls, const struct RecordResultMessage *lrm)
+handle_result(void *cls, const struct RecordResultMessage *lrm)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
   size_t name_len;
@@ -202,18 +201,18 @@ handle_result (void *cls, const struct RecordResultMessage *lrm)
   const char *name_tmp;
   const char *rd_ser_tmp;
 
-  rd_len = ntohs (lrm->rd_len);
-  rd_count = ntohs (lrm->rd_count);
-  name_len = ntohs (lrm->name_len);
-  name_tmp = (const char *) &lrm[1];
-  rd_ser_tmp = (const char *) &name_tmp[name_len];
+  rd_len = ntohs(lrm->rd_len);
+  rd_count = ntohs(lrm->rd_count);
+  name_len = ntohs(lrm->name_len);
+  name_tmp = (const char *)&lrm[1];
+  rd_ser_tmp = (const char *)&name_tmp[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    GNUNET_assert (
+    GNUNET_assert(
       GNUNET_OK ==
-      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd));
-    zm->monitor (zm->monitor_cls, &lrm->private_key, name_tmp, rd_count, rd);
+      GNUNET_GNSRECORD_records_deserialize(rd_len, rd_ser_tmp, rd_count, rd));
+    zm->monitor(zm->monitor_cls, &lrm->private_key, name_tmp, rd_count, rd);
   }
 }
 
@@ -227,12 +226,12 @@ handle_result (void *cls, const struct RecordResultMessage *lrm)
  * @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_NAMESTORE_ZoneMonitor *zm = cls;
 
-  (void) error;
-  reconnect (zm);
+  (void)error;
+  reconnect(zm);
 }
 
 
@@ -242,37 +241,37 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param zm monitor to reconnect
  */
 static void
-reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
+reconnect(struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 {
   struct GNUNET_MQ_MessageHandler handlers[] =
-    {GNUNET_MQ_hd_fixed_size (sync,
-                              GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
-                              struct GNUNET_MessageHeader,
-                              zm),
-     GNUNET_MQ_hd_var_size (result,
-                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
-                            struct RecordResultMessage,
+  { GNUNET_MQ_hd_fixed_size(sync,
+                            GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
+                            struct GNUNET_MessageHeader,
                             zm),
-     GNUNET_MQ_handler_end ()};
+    GNUNET_MQ_hd_var_size(result,
+                          GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
+                          struct RecordResultMessage,
+                          zm),
+    GNUNET_MQ_handler_end() };
   struct GNUNET_MQ_Envelope *env;
   struct ZoneMonitorStartMessage *sm;
 
   if (NULL != zm->mq)
-  {
-    GNUNET_MQ_destroy (zm->mq);
-    zm->error_cb (zm->error_cb_cls);
-  }
-  zm->mq = GNUNET_CLIENT_connect (zm->cfg,
-                                  "namestore",
-                                  handlers,
-                                  &mq_error_handler,
-                                  zm);
+    {
+      GNUNET_MQ_destroy(zm->mq);
+      zm->error_cb(zm->error_cb_cls);
+    }
+  zm->mq = GNUNET_CLIENT_connect(zm->cfg,
+                                 "namestore",
+                                 handlers,
+                                 &mq_error_handler,
+                                 zm);
   if (NULL == zm->mq)
     return;
-  env = GNUNET_MQ_msg (sm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
-  sm->iterate_first = htonl (zm->iterate_first);
+  env = GNUNET_MQ_msg(sm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
+  sm->iterate_first = htonl(zm->iterate_first);
   sm->zone = zm->zone;
-  GNUNET_MQ_send (zm->mq, env);
+  GNUNET_MQ_send(zm->mq, env);
 }
 
 
@@ -300,7 +299,7 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
  * @return handle to stop monitoring
  */
 struct GNUNET_NAMESTORE_ZoneMonitor *
-GNUNET_NAMESTORE_zone_monitor_start (
+GNUNET_NAMESTORE_zone_monitor_start(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
   int iterate_first,
@@ -313,7 +312,7 @@ GNUNET_NAMESTORE_zone_monitor_start (
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
-  zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
+  zm = GNUNET_new(struct GNUNET_NAMESTORE_ZoneMonitor);
   if (NULL != zone)
     zm->zone = *zone;
   zm->iterate_first = iterate_first;
@@ -324,12 +323,12 @@ GNUNET_NAMESTORE_zone_monitor_start (
   zm->sync_cb = sync_cb;
   zm->sync_cb_cls = sync_cb_cls;
   zm->cfg = cfg;
-  reconnect (zm);
+  reconnect(zm);
   if (NULL == zm->mq)
-  {
-    GNUNET_free (zm);
-    return NULL;
-  }
+    {
+      GNUNET_free(zm);
+      return NULL;
+    }
   return zm;
 }
 
@@ -356,15 +355,15 @@ GNUNET_NAMESTORE_zone_monitor_start (
  *        (before #GNUNET_NAMESTORE_zone_monitor_next is to be called again)
  */
 void
-GNUNET_NAMESTORE_zone_monitor_next (struct GNUNET_NAMESTORE_ZoneMonitor *zm,
-                                    uint64_t limit)
+GNUNET_NAMESTORE_zone_monitor_next(struct GNUNET_NAMESTORE_ZoneMonitor *zm,
+                                   uint64_t limit)
 {
   struct GNUNET_MQ_Envelope *env;
   struct ZoneMonitorNextMessage *nm;
 
-  env = GNUNET_MQ_msg (nm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT);
-  nm->limit = GNUNET_htonll (limit);
-  GNUNET_MQ_send (zm->mq, env);
+  env = GNUNET_MQ_msg(nm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT);
+  nm->limit = GNUNET_htonll(limit);
+  GNUNET_MQ_send(zm->mq, env);
 }
 
 
@@ -374,14 +373,14 @@ GNUNET_NAMESTORE_zone_monitor_next (struct GNUNET_NAMESTORE_ZoneMonitor *zm,
  * @param zm handle to the monitor activity to stop
  */
 void
-GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
+GNUNET_NAMESTORE_zone_monitor_stop(struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 {
   if (NULL != zm->mq)
-  {
-    GNUNET_MQ_destroy (zm->mq);
-    zm->mq = NULL;
-  }
-  GNUNET_free (zm);
+    {
+      GNUNET_MQ_destroy(zm->mq);
+      zm->mq = NULL;
+    }
+  GNUNET_free(zm);
 }
 
 /* end of namestore_api_monitor.c */
diff --git a/src/namestore/perf_namestore_api_zone_iteration.c b/src/namestore/perf_namestore_api_zone_iteration.c
index 156f9227c..6b79a35f6 100644
--- a/src/namestore/perf_namestore_api_zone_iteration.c
+++ b/src/namestore/perf_namestore_api_zone_iteration.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 namestore/perf_namestore_api_zone_iteration.c
  * @brief testcase for zone iteration functionality: iterate all zones
@@ -35,7 +35,7 @@
  * modern system, so 30 minutes should be OK even for very, very
  * slow systems.
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
 
 /**
  * The runtime of the benchmark is expected to be linear
@@ -87,39 +87,39 @@ static struct GNUNET_TIME_Absolute start;
  * @param cls NULL
  */
 static void
-end (void *cls)
+end(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != qe)
-  {
-    GNUNET_NAMESTORE_cancel (qe);
-    qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(qe);
+      qe = NULL;
+    }
   if (NULL != zi)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zi);
-    zi = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zi);
+      zi = NULL;
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != t)
-  {
-    GNUNET_SCHEDULER_cancel (t);
-    t = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(t);
+      t = NULL;
+    }
   if (NULL != timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (timeout_task);
-    timeout_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(timeout_task);
+      timeout_task = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
 }
 
 
@@ -128,228 +128,228 @@ end (void *cls)
  * fail hard but return "skipped".
  */
 static void
-timeout (void *cls)
+timeout(void *cls)
 {
-  (void) cls;
+  (void)cls;
   timeout_task = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   res = 77;
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data *rd;
 
-  rd = GNUNET_malloc (count + sizeof (struct GNUNET_GNSRECORD_Data));
-  rd->expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
+  rd = GNUNET_malloc(count + sizeof(struct GNUNET_GNSRECORD_Data));
+  rd->expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
   rd->record_type = TEST_RECORD_TYPE;
   rd->data_size = count;
-  rd->data = (void *) &rd[1];
+  rd->data = (void *)&rd[1];
   rd->flags = 0;
-  memset (&rd[1],
-          'a',
-          count);
+  memset(&rd[1],
+         'a',
+         count);
   return rd;
 }
 
 
 static void
-zone_end (void *cls)
+zone_end(void *cls)
 {
   struct GNUNET_TIME_Relative delay;
 
   zi = NULL;
-  delay = GNUNET_TIME_absolute_get_duration (start);
-  fprintf (stdout,
-           "Iterating over %u records took %s\n",
-           off,
-           GNUNET_STRINGS_relative_time_to_string (delay,
-                                                   GNUNET_YES));
+  delay = GNUNET_TIME_absolute_get_duration(start);
+  fprintf(stdout,
+          "Iterating over %u records took %s\n",
+          off,
+          GNUNET_STRINGS_relative_time_to_string(delay,
+                                                 GNUNET_YES));
   if (BENCHMARK_SIZE == off)
-  {
-    res = 0;
-  }
+    {
+      res = 0;
+    }
   else
-  {
-    GNUNET_break (0);
-    res = 1;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_break(0);
+      res = 1;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
   zi = NULL;
   res = 2;
-  GNUNET_break (0);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_break(0);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data *wrd;
   unsigned int xoff;
 
-  GNUNET_assert (NULL != zone);
-  if (1 != sscanf (label,
-                   "l%u",
-                   &xoff))
-  {
-    res = 3;
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if ( (xoff > BENCHMARK_SIZE) ||
-       (0 != (seen[xoff / 8] & (1U << (xoff % 8)))) )
-  {
-    res = 3;
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+  GNUNET_assert(NULL != zone);
+  if (1 != sscanf(label,
+                  "l%u",
+                  &xoff))
+    {
+      res = 3;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if ((xoff > BENCHMARK_SIZE) ||
+      (0 != (seen[xoff / 8] & (1U << (xoff % 8)))))
+    {
+      res = 3;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   seen[xoff / 8] |= (1U << (xoff % 8));
-  wrd = create_record (xoff % MAX_REC_SIZE);
-  if ( (rd->record_type != wrd->record_type) ||
-       (rd->data_size != wrd->data_size) ||
-       (rd->flags != wrd->flags) )
-  {
-    res = 4;
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    GNUNET_free (wrd);
-    return;
-  }
-  if (0 != memcmp (rd->data,
-                   wrd->data,
-                   wrd->data_size))
-  {
-    res = 4;
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    GNUNET_free (wrd);
-    return;
-  }
-  GNUNET_free (wrd);
-  if (0 != GNUNET_memcmp (zone,
-                   privkey))
-  {
-    res = 5;
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+  wrd = create_record(xoff % MAX_REC_SIZE);
+  if ((rd->record_type != wrd->record_type) ||
+      (rd->data_size != wrd->data_size) ||
+      (rd->flags != wrd->flags))
+    {
+      res = 4;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      GNUNET_free(wrd);
+      return;
+    }
+  if (0 != memcmp(rd->data,
+                  wrd->data,
+                  wrd->data_size))
+    {
+      res = 4;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      GNUNET_free(wrd);
+      return;
+    }
+  GNUNET_free(wrd);
+  if (0 != GNUNET_memcmp(zone,
+                         privkey))
+    {
+      res = 5;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   off++;
   left_until_next--;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Obtained record %u, expecting %u more until asking for mor explicitly\n",
-              off,
-              left_until_next);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Obtained record %u, expecting %u more until asking for mor explicitly\n",
+             off,
+             left_until_next);
   if (0 == left_until_next)
-  {
-    left_until_next = BLOCK_SIZE;
-    GNUNET_NAMESTORE_zone_iterator_next (zi,
-                                         left_until_next);
-  }
+    {
+      left_until_next = BLOCK_SIZE;
+      GNUNET_NAMESTORE_zone_iterator_next(zi,
+                                          left_until_next);
+    }
 }
 
 
 static void
-publish_record (void *cls);
+publish_record(void *cls);
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
-  (void) cls;
+  (void)cls;
   qe = NULL;
   if (GNUNET_OK != success)
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  t = GNUNET_SCHEDULER_add_now (&publish_record,
-                                NULL);
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  t = GNUNET_SCHEDULER_add_now(&publish_record,
+                               NULL);
 }
 
 
 static void
-publish_record (void *cls)
+publish_record(void *cls)
 {
   struct GNUNET_GNSRECORD_Data *rd;
   char *label;
 
-  (void) cls;
+  (void)cls;
   t = NULL;
   if (BENCHMARK_SIZE == off)
-  {
-    struct GNUNET_TIME_Relative delay;
+    {
+      struct GNUNET_TIME_Relative delay;
 
-    delay = GNUNET_TIME_absolute_get_duration (start);
-    fprintf (stdout,
-             "Inserting %u records took %s\n",
-             off,
-             GNUNET_STRINGS_relative_time_to_string (delay,
+      delay = GNUNET_TIME_absolute_get_duration(start);
+      fprintf(stdout,
+              "Inserting %u records took %s\n",
+              off,
+              GNUNET_STRINGS_relative_time_to_string(delay,
                                                      GNUNET_YES));
-    start = GNUNET_TIME_absolute_get ();
-    off = 0;
-    left_until_next = 1;
-    zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                                NULL,
-                                                &fail_cb,
-                                                NULL,
-                                                &zone_proc,
-                                                NULL,
-                                                &zone_end,
-                                                NULL);
-    GNUNET_assert (NULL != zi);
-    return;
-  }
-  rd = create_record ((++off) % MAX_REC_SIZE);
-  GNUNET_asprintf (&label,
-                   "l%u",
-                   off);
-  qe = GNUNET_NAMESTORE_records_store (nsh,
-                                       privkey,
-                                       label,
-                                       1, rd,
-                                       &put_cont,
-                                       NULL);
-  GNUNET_free (label);
-  GNUNET_free (rd);
+      start = GNUNET_TIME_absolute_get();
+      off = 0;
+      left_until_next = 1;
+      zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                                 NULL,
+                                                 &fail_cb,
+                                                 NULL,
+                                                 &zone_proc,
+                                                 NULL,
+                                                 &zone_end,
+                                                 NULL);
+      GNUNET_assert(NULL != zi);
+      return;
+    }
+  rd = create_record((++off) % MAX_REC_SIZE);
+  GNUNET_asprintf(&label,
+                  "l%u",
+                  off);
+  qe = GNUNET_NAMESTORE_records_store(nsh,
+                                      privkey,
+                                      label,
+                                      1, rd,
+                                      &put_cont,
+                                      NULL);
+  GNUNET_free(label);
+  GNUNET_free(rd);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &timeout,
-                                               NULL);
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_assert (NULL != nsh);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (NULL != privkey);
-  start = GNUNET_TIME_absolute_get ();
-  t = GNUNET_SCHEDULER_add_now (&publish_record,
+  GNUNET_SCHEDULER_add_shutdown(&end,
                                 NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                              &timeout,
+                                              NULL);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_assert(NULL != nsh);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(NULL != privkey);
+  start = GNUNET_TIME_absolute_get();
+  t = GNUNET_SCHEDULER_add_now(&publish_record,
+                               NULL);
 }
 
 
@@ -357,25 +357,25 @@ run (void *cls,
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("perf-namestore-api-zone-iteration",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("perf-namestore-api-zone-iteration",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/plugin_namestore_flat.c b/src/namestore/plugin_namestore_flat.c
index 4e1d33907..083609359 100644
--- a/src/namestore/plugin_namestore_flat.c
+++ b/src/namestore/plugin_namestore_flat.c
@@ -1,22 +1,22 @@
- /*
-  * This file is part of GNUnet
-  * Copyright (C) 2009-2015, 2018, 2019 GNUnet e.V.
-  *
-  * GNUnet is free software: you can redistribute it and/or modify it
-  * under the terms of the GNU Affero General Public License as published
-  * by the Free Software Foundation, either version 3 of the License,
-  * or (at your option) any later version.
-  *
-  * GNUnet is distributed in the hope that it will be useful, but
-  * WITHOUT ANY WARRANTY; without even the implied warranty of
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  * 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
-  */
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2009-2015, 2018, 2019 GNUnet e.V.
+ *
+ * GNUnet is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * GNUnet is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * 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 namestore/plugin_namestore_flat.c
  * @brief file-based namestore backend
@@ -33,9 +33,7 @@
 /**
  * Context for all functions in this plugin.
  */
-struct Plugin
-{
-
+struct Plugin {
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 
   /**
@@ -47,12 +45,10 @@ struct Plugin
    * HashMap
    */
   struct GNUNET_CONTAINER_MultiHashMap *hm;
-
 };
 
 
-struct FlatFileEntry
-{
+struct FlatFileEntry {
   /**
    * Entry zone
    */
@@ -77,7 +73,6 @@ struct FlatFileEntry
    * Label
    */
   char *label;
-
 };
 
 
@@ -89,27 +84,27 @@ struct FlatFileEntry
  * @param h[out] initialized hash
  */
 static void
-hash_pkey_and_label (const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
-                     const char *label,
-                     struct GNUNET_HashCode *h)
+hash_pkey_and_label(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
+                    const char *label,
+                    struct GNUNET_HashCode *h)
 {
   char *key;
   size_t label_len;
   size_t key_len;
 
-  label_len = strlen (label);
-  key_len = label_len + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
-  key = GNUNET_malloc (key_len);
-  GNUNET_memcpy (key,
-                 label,
-                 label_len);
-  GNUNET_memcpy (key + label_len,
-                 pkey,
-                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
-  GNUNET_CRYPTO_hash (key,
-                      key_len,
-                      h);
-  GNUNET_free (key);
+  label_len = strlen(label);
+  key_len = label_len + sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey);
+  key = GNUNET_malloc(key_len);
+  GNUNET_memcpy(key,
+                label,
+                label_len);
+  GNUNET_memcpy(key + label_len,
+                pkey,
+                sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
+  GNUNET_CRYPTO_hash(key,
+                     key_len,
+                     h);
+  GNUNET_free(key);
 }
 
 
@@ -122,7 +117,7 @@ hash_pkey_and_label (const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
  * @return #GNUNET_OK on success
  */
 static int
-database_setup (struct Plugin *plugin)
+database_setup(struct Plugin *plugin)
 {
   char *flatdbfile;
   char *record_data;
@@ -141,188 +136,188 @@ database_setup (struct Plugin *plugin)
   struct GNUNET_DISK_MapHandle *mh;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
-                                               "namestore-flat",
-                                               "FILENAME",
-                                               &flatdbfile))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               "namestore-flat",
-                               "FILENAME");
-    return GNUNET_SYSERR;
-  }
-  if (GNUNET_OK !=
-      GNUNET_DISK_file_test (flatdbfile))
-  {
-    if (GNUNET_OK !=
-        GNUNET_DISK_directory_create_for_file (flatdbfile))
+      GNUNET_CONFIGURATION_get_value_filename(plugin->cfg,
+                                              "namestore-flat",
+                                              "FILENAME",
+                                              &flatdbfile))
     {
-      GNUNET_break (0);
-      GNUNET_free (flatdbfile);
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+                                "namestore-flat",
+                                "FILENAME");
       return GNUNET_SYSERR;
     }
-  }
+  if (GNUNET_OK !=
+      GNUNET_DISK_file_test(flatdbfile))
+    {
+      if (GNUNET_OK !=
+          GNUNET_DISK_directory_create_for_file(flatdbfile))
+        {
+          GNUNET_break(0);
+          GNUNET_free(flatdbfile);
+          return GNUNET_SYSERR;
+        }
+    }
   /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
   plugin->fn = flatdbfile;
 
   /* Load data from file into hashmap */
-  plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
-                                                     GNUNET_NO);
-  fh = GNUNET_DISK_file_open (flatdbfile,
-                              GNUNET_DISK_OPEN_CREATE |
-                              GNUNET_DISK_OPEN_READWRITE,
-                              GNUNET_DISK_PERM_USER_WRITE |
-                              GNUNET_DISK_PERM_USER_READ);
+  plugin->hm = GNUNET_CONTAINER_multihashmap_create(10,
+                                                    GNUNET_NO);
+  fh = GNUNET_DISK_file_open(flatdbfile,
+                             GNUNET_DISK_OPEN_CREATE |
+                             GNUNET_DISK_OPEN_READWRITE,
+                             GNUNET_DISK_PERM_USER_WRITE |
+                             GNUNET_DISK_PERM_USER_READ);
   if (NULL == fh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-         _("Unable to initialize file: %s.\n"),
-         flatdbfile);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to initialize file: %s.\n"),
+                 flatdbfile);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_file_size (flatdbfile,
-                             &size,
-                             GNUNET_YES,
-                             GNUNET_YES))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-         _("Unable to get filesize: %s.\n"),
-         flatdbfile);
-    GNUNET_DISK_file_close (fh);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_DISK_file_size(flatdbfile,
+                            &size,
+                            GNUNET_YES,
+                            GNUNET_YES))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to get filesize: %s.\n"),
+                 flatdbfile);
+      GNUNET_DISK_file_close(fh);
+      return GNUNET_SYSERR;
+    }
   if (size > SIZE_MAX)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("File too big to map: %llu bytes.\n"),
-                (unsigned long long) size);
-    GNUNET_DISK_file_close (fh);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("File too big to map: %llu bytes.\n"),
+                 (unsigned long long)size);
+      GNUNET_DISK_file_close(fh);
+      return GNUNET_SYSERR;
+    }
   if (0 == size)
-  {
-    GNUNET_DISK_file_close (fh);
-    return GNUNET_OK;
-  }
-  buffer = GNUNET_DISK_file_map (fh,
-                                 &mh,
-                                 GNUNET_DISK_MAP_TYPE_READ,
-                                 size);
+    {
+      GNUNET_DISK_file_close(fh);
+      return GNUNET_OK;
+    }
+  buffer = GNUNET_DISK_file_map(fh,
+                                &mh,
+                                GNUNET_DISK_MAP_TYPE_READ,
+                                size);
   if (NULL == buffer)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "mmap");
-    GNUNET_DISK_file_close (fh);
-    return GNUNET_SYSERR;
-  }
-  if ('\0' != buffer[size-1])
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Namestore database file `%s' malformed\n"),
-                flatdbfile);
-    GNUNET_DISK_file_unmap (mh);
-    GNUNET_DISK_file_close (fh);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                          "mmap");
+      GNUNET_DISK_file_close(fh);
+      return GNUNET_SYSERR;
+    }
+  if ('\0' != buffer[size - 1])
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore database file `%s' malformed\n"),
+                 flatdbfile);
+      GNUNET_DISK_file_unmap(mh);
+      GNUNET_DISK_file_close(fh);
+      return GNUNET_SYSERR;
+    }
 
-  line = strtok (buffer, "\n");
+  line = strtok(buffer, "\n");
   while (NULL != line)
-  {
-    zone_private_key = strtok (line, ",");
-    if (NULL == zone_private_key)
-      break;
-    rvalue = strtok (NULL, ",");
-    if (NULL == rvalue)
-      break;
-    record_count = strtok (NULL, ",");
-    if (NULL == record_count)
-      break;
-    record_data_b64 = strtok (NULL, ",");
-    if (NULL == record_data_b64)
-      break;
-    label = strtok (NULL, ",");
-    if (NULL == label)
-      break;
-    line = strtok (NULL, "\n");
-    entry = GNUNET_new (struct FlatFileEntry);
     {
-      unsigned long long ll;
-      
-      if (1 != sscanf (rvalue,
-                       "%llu",
-                       &ll))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Error parsing entry\n");
-        GNUNET_free (entry);
+      zone_private_key = strtok(line, ",");
+      if (NULL == zone_private_key)
+        break;
+      rvalue = strtok(NULL, ",");
+      if (NULL == rvalue)
+        break;
+      record_count = strtok(NULL, ",");
+      if (NULL == record_count)
         break;
+      record_data_b64 = strtok(NULL, ",");
+      if (NULL == record_data_b64)
+        break;
+      label = strtok(NULL, ",");
+      if (NULL == label)
+        break;
+      line = strtok(NULL, "\n");
+      entry = GNUNET_new(struct FlatFileEntry);
+      {
+        unsigned long long ll;
+
+        if (1 != sscanf(rvalue,
+                        "%llu",
+                        &ll))
+          {
+            GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                       "Error parsing entry\n");
+            GNUNET_free(entry);
+            break;
+          }
+        entry->rvalue = (uint64_t)ll;
       }
-      entry->rvalue = (uint64_t) ll;
-    }
-    {
-      unsigned int ui;
+      {
+        unsigned int ui;
+
+        if (1 != sscanf(record_count,
+                        "%u",
+                        &ui))
+          {
+            GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                       "Error parsing entry\n");
+            GNUNET_free(entry);
+            break;
+          }
+        entry->record_count = (uint32_t)ui;
+      }
+      entry->label = GNUNET_strdup(label);
+      record_data_size
+        = GNUNET_STRINGS_base64_decode(record_data_b64,
+                                       strlen(record_data_b64),
+                                       (void **)&record_data);
+      entry->record_data =
+        GNUNET_new_array(entry->record_count,
+                         struct GNUNET_GNSRECORD_Data);
+      if (GNUNET_OK !=
+          GNUNET_GNSRECORD_records_deserialize(record_data_size,
+                                               record_data,
+                                               entry->record_count,
+                                               entry->record_data))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Unable to deserialize record %s\n",
+                     label);
+          GNUNET_free(entry->label);
+          GNUNET_free(entry);
+          GNUNET_free(record_data);
+          break;
+        }
+      GNUNET_free(record_data);
 
-      if (1 != sscanf (record_count,
-                       "%u",
-                       &ui))
       {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Error parsing entry\n");
-        GNUNET_free (entry);
-        break;
+        struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
+
+        GNUNET_STRINGS_base64_decode(zone_private_key,
+                                     strlen(zone_private_key),
+                                     (void**)&private_key);
+        entry->private_key = *private_key;
+        GNUNET_free(private_key);
       }
-      entry->record_count = (uint32_t) ui;
-    }
-    entry->label = GNUNET_strdup (label);
-    record_data_size
-      = GNUNET_STRINGS_base64_decode (record_data_b64,
-                                      strlen (record_data_b64),
-                                      (void **) &record_data);
-    entry->record_data =
-      GNUNET_new_array (entry->record_count,
-                        struct GNUNET_GNSRECORD_Data);
-    if (GNUNET_OK !=
-        GNUNET_GNSRECORD_records_deserialize (record_data_size,
-                                              record_data,
-                                              entry->record_count,
-                                              entry->record_data))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Unable to deserialize record %s\n",
-                  label);
-      GNUNET_free (entry->label);
-      GNUNET_free (entry);
-      GNUNET_free (record_data);
-      break;
-    }
-    GNUNET_free (record_data);
-    
-    {
-      struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
-      
-      GNUNET_STRINGS_base64_decode (zone_private_key,
-                                    strlen (zone_private_key),
-                                    (void**)&private_key);
-      entry->private_key = *private_key;
-      GNUNET_free (private_key);
-    }
-    
-    hash_pkey_and_label (&entry->private_key,
-                         label,
-                         &hkey);
-    if (GNUNET_OK !=
-        GNUNET_CONTAINER_multihashmap_put (plugin->hm,
-                                           &hkey,
-                                           entry,
-                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-    {
-      GNUNET_free (entry);
-      GNUNET_break (0);
+
+      hash_pkey_and_label(&entry->private_key,
+                          label,
+                          &hkey);
+      if (GNUNET_OK !=
+          GNUNET_CONTAINER_multihashmap_put(plugin->hm,
+                                            &hkey,
+                                            entry,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+        {
+          GNUNET_free(entry);
+          GNUNET_break(0);
+        }
     }
-  }
-  GNUNET_DISK_file_unmap (mh);
-  GNUNET_DISK_file_close (fh);
+  GNUNET_DISK_file_unmap(mh);
+  GNUNET_DISK_file_close(fh);
   return GNUNET_OK;
 }
 
@@ -335,9 +330,9 @@ database_setup (struct Plugin *plugin)
  * @param value a `struct FlatFileEntry`
  */
 static int
-store_and_free_entries (void *cls,
-                        const struct GNUNET_HashCode *key,
-                        void *value)
+store_and_free_entries(void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
 {
   struct GNUNET_DISK_FileHandle *fh = cls;
   struct FlatFileEntry *entry = value;
@@ -346,61 +341,61 @@ store_and_free_entries (void *cls,
   char *record_data_b64;
   ssize_t data_size;
 
-  (void) key;
-  GNUNET_STRINGS_base64_encode (&entry->private_key,
-                                sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                                &zone_private_key);
-  data_size = GNUNET_GNSRECORD_records_get_size (entry->record_count,
-                                                 entry->record_data);
+  (void)key;
+  GNUNET_STRINGS_base64_encode(&entry->private_key,
+                               sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                               &zone_private_key);
+  data_size = GNUNET_GNSRECORD_records_get_size(entry->record_count,
+                                                entry->record_data);
   if (data_size < 0)
-  {
-    GNUNET_break (0);
-    GNUNET_free (zone_private_key);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_free(zone_private_key);
+      return GNUNET_SYSERR;
+    }
   if (data_size >= UINT16_MAX)
-  {
-    GNUNET_break (0);
-    GNUNET_free (zone_private_key);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_free(zone_private_key);
+      return GNUNET_SYSERR;
+    }
   {
     char data[data_size];
     ssize_t ret;
 
-    ret = GNUNET_GNSRECORD_records_serialize (entry->record_count,
-                                              entry->record_data,
-                                              data_size,
-                                              data);
-    if ( (ret < 0) ||
-         (data_size != ret) )
-    {
-      GNUNET_break (0);
-      GNUNET_free (zone_private_key);
-      return GNUNET_SYSERR;
-    }
-    GNUNET_STRINGS_base64_encode (data,
-                                  data_size,
-                                  &record_data_b64);
+    ret = GNUNET_GNSRECORD_records_serialize(entry->record_count,
+                                             entry->record_data,
+                                             data_size,
+                                             data);
+    if ((ret < 0) ||
+        (data_size != ret))
+      {
+        GNUNET_break(0);
+        GNUNET_free(zone_private_key);
+        return GNUNET_SYSERR;
+      }
+    GNUNET_STRINGS_base64_encode(data,
+                                 data_size,
+                                 &record_data_b64);
   }
-  GNUNET_asprintf (&line,
-                   "%s,%llu,%u,%s,%s\n",
-                   zone_private_key,
-                   (unsigned long long) entry->rvalue,
-                   (unsigned int) entry->record_count,
-                   record_data_b64,
-                   entry->label);
-  GNUNET_free (record_data_b64);
-  GNUNET_free (zone_private_key);
-
-  GNUNET_DISK_file_write (fh,
-                          line,
-                          strlen (line));
-
-  GNUNET_free (line);
-  GNUNET_free (entry->label);
-  GNUNET_free (entry->record_data);
-  GNUNET_free (entry);
+  GNUNET_asprintf(&line,
+                  "%s,%llu,%u,%s,%s\n",
+                  zone_private_key,
+                  (unsigned long long)entry->rvalue,
+                  (unsigned int)entry->record_count,
+                  record_data_b64,
+                  entry->label);
+  GNUNET_free(record_data_b64);
+  GNUNET_free(zone_private_key);
+
+  GNUNET_DISK_file_write(fh,
+                         line,
+                         strlen(line));
+
+  GNUNET_free(line);
+  GNUNET_free(entry->label);
+  GNUNET_free(entry->record_data);
+  GNUNET_free(entry);
   return GNUNET_YES;
 }
 
@@ -411,33 +406,33 @@ store_and_free_entries (void *cls,
  * @param plugin the plugin context (state for this module)
  */
 static void
-database_shutdown (struct Plugin *plugin)
+database_shutdown(struct Plugin *plugin)
 {
   struct GNUNET_DISK_FileHandle *fh;
 
-  fh = GNUNET_DISK_file_open (plugin->fn,
-                              GNUNET_DISK_OPEN_CREATE |
-                              GNUNET_DISK_OPEN_TRUNCATE |
-                              GNUNET_DISK_OPEN_READWRITE,
-                              GNUNET_DISK_PERM_USER_WRITE |
-                              GNUNET_DISK_PERM_USER_READ);
+  fh = GNUNET_DISK_file_open(plugin->fn,
+                             GNUNET_DISK_OPEN_CREATE |
+                             GNUNET_DISK_OPEN_TRUNCATE |
+                             GNUNET_DISK_OPEN_READWRITE,
+                             GNUNET_DISK_PERM_USER_WRITE |
+                             GNUNET_DISK_PERM_USER_READ);
   if (NULL == fh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Unable to initialize file: %s.\n"),
-                plugin->fn);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Unable to initialize file: %s.\n"),
+                 plugin->fn);
+      return;
+    }
 
-  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
-                                         &store_and_free_entries,
-                                         fh);
-  GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
+  GNUNET_CONTAINER_multihashmap_iterate(plugin->hm,
+                                        &store_and_free_entries,
+                                        fh);
+  GNUNET_CONTAINER_multihashmap_destroy(plugin->hm);
   /* append 0-terminator */
-  GNUNET_DISK_file_write (fh,
-                          "",
-                          1);
-  GNUNET_DISK_file_close (fh);
+  GNUNET_DISK_file_write(fh,
+                         "",
+                         1);
+  GNUNET_DISK_file_close(fh);
 }
 
 
@@ -453,57 +448,57 @@ database_shutdown (struct Plugin *plugin)
  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
  */
 static int
-namestore_flat_store_records (void *cls,
-                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                              const char *label,
-                              unsigned int rd_count,
-                              const struct GNUNET_GNSRECORD_Data *rd)
+namestore_flat_store_records(void *cls,
+                             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                             const char *label,
+                             unsigned int rd_count,
+                             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Plugin *plugin = cls;
   uint64_t rvalue;
   struct GNUNET_HashCode hkey;
   struct FlatFileEntry *entry;
 
-  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                     UINT64_MAX);
-  hash_pkey_and_label (zone_key,
-                       label,
-                       &hkey);
-  GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm,
-                                            &hkey);
+  rvalue = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
+                                    UINT64_MAX);
+  hash_pkey_and_label(zone_key,
+                      label,
+                      &hkey);
+  GNUNET_CONTAINER_multihashmap_remove_all(plugin->hm,
+                                           &hkey);
   if (0 == rd_count)
-  {
-    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "sqlite",
-                     "Record deleted\n");
-    return GNUNET_OK;
-  }
-  entry = GNUNET_new (struct FlatFileEntry);
-  GNUNET_asprintf (&entry->label,
-                   label,
-                   strlen (label));
-  GNUNET_memcpy (&entry->private_key,
-                 zone_key,
-                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
+    {
+      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
+                      "sqlite",
+                      "Record deleted\n");
+      return GNUNET_OK;
+    }
+  entry = GNUNET_new(struct FlatFileEntry);
+  GNUNET_asprintf(&entry->label,
+                  label,
+                  strlen(label));
+  GNUNET_memcpy(&entry->private_key,
+                zone_key,
+                sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
   entry->rvalue = rvalue;
   entry->record_count = rd_count;
-  entry->record_data = GNUNET_new_array (rd_count,
-                                         struct GNUNET_GNSRECORD_Data);
+  entry->record_data = GNUNET_new_array(rd_count,
+                                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int i = 0; i < rd_count; i++)
-  {
-    entry->record_data[i].expiration_time = rd[i].expiration_time;
-    entry->record_data[i].record_type = rd[i].record_type;
-    entry->record_data[i].flags = rd[i].flags;
-    entry->record_data[i].data_size = rd[i].data_size;
-    entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
-    GNUNET_memcpy ((char*)entry->record_data[i].data,
-                   rd[i].data,
-                   rd[i].data_size);
-  }
-  return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
-                                            &hkey,
-                                            entry,
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    {
+      entry->record_data[i].expiration_time = rd[i].expiration_time;
+      entry->record_data[i].record_type = rd[i].record_type;
+      entry->record_data[i].flags = rd[i].flags;
+      entry->record_data[i].data_size = rd[i].data_size;
+      entry->record_data[i].data = GNUNET_malloc(rd[i].data_size);
+      GNUNET_memcpy((char*)entry->record_data[i].data,
+                    rd[i].data,
+                    rd[i].data_size);
+    }
+  return GNUNET_CONTAINER_multihashmap_put(plugin->hm,
+                                           &hkey,
+                                           entry,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 }
 
 
@@ -518,36 +513,36 @@ namestore_flat_store_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO for no results, else #GNUNET_SYSERR
  */
 static int
-namestore_flat_lookup_records (void *cls,
-                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                               const char *label,
-                               GNUNET_NAMESTORE_RecordIterator iter,
-                               void *iter_cls)
+namestore_flat_lookup_records(void *cls,
+                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                              const char *label,
+                              GNUNET_NAMESTORE_RecordIterator iter,
+                              void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct FlatFileEntry *entry;
   struct GNUNET_HashCode hkey;
 
   if (NULL == zone)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  hash_pkey_and_label (zone,
-                       label,
-                       &hkey);
-  entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
-                                             &hkey);
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  hash_pkey_and_label(zone,
+                      label,
+                      &hkey);
+  entry = GNUNET_CONTAINER_multihashmap_get(plugin->hm,
+                                            &hkey);
 
   if (NULL == entry)
     return GNUNET_NO;
   if (NULL != iter)
-    iter (iter_cls,
-          1, /* zero is illegal */
-          &entry->private_key,
-          entry->label,
-          entry->record_count,
-          entry->record_data);
+    iter(iter_cls,
+         1,  /* zero is illegal */
+         &entry->private_key,
+         entry->label,
+         entry->record_count,
+         entry->record_data);
   return GNUNET_YES;
 }
 
@@ -555,8 +550,7 @@ namestore_flat_lookup_records (void *cls,
 /**
  * Closure for #iterate_zones.
  */
-struct IterateContext
-{
+struct IterateContext {
   /**
    * How many more records should we skip before returning results?
    */
@@ -587,7 +581,6 @@ struct IterateContext
    * Closure for @e iter.
    */
   void *iter_cls;
-
 };
 
 
@@ -600,34 +593,34 @@ struct IterateContext
  * @return #GNUNET_YES to continue the iteration
  */
 static int
-iterate_zones (void *cls,
-               const struct GNUNET_HashCode *key,
-               void *value)
+iterate_zones(void *cls,
+              const struct GNUNET_HashCode *key,
+              void *value)
 {
   struct IterateContext *ic = cls;
   struct FlatFileEntry *entry = value;
 
-  (void) key;
+  (void)key;
   if (0 == ic->limit)
     return GNUNET_NO;
-  if ( (NULL != ic->zone) &&
-       (0 != GNUNET_memcmp (&entry->private_key,
-                     ic->zone)) )
+  if ((NULL != ic->zone) &&
+      (0 != GNUNET_memcmp(&entry->private_key,
+                          ic->zone)))
     return GNUNET_YES;
   ic->pos++;
   if (ic->offset > 0)
-  {
-    ic->offset--;
-    return GNUNET_YES;
-  }
-  ic->iter (ic->iter_cls,
-            ic->pos,
-            (NULL == ic->zone)
-            ? &entry->private_key
-            : ic->zone,
-            entry->label,
-            entry->record_count,
-            entry->record_data);
+    {
+      ic->offset--;
+      return GNUNET_YES;
+    }
+  ic->iter(ic->iter_cls,
+           ic->pos,
+           (NULL == ic->zone)
+           ? &entry->private_key
+           : ic->zone,
+           entry->label,
+           entry->record_count,
+           entry->record_data);
   ic->limit--;
   if (0 == ic->limit)
     return GNUNET_NO;
@@ -648,12 +641,12 @@ iterate_zones (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
  */
 static int
-namestore_flat_iterate_records (void *cls,
-                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                uint64_t serial,
-                                uint64_t limit,
-                                GNUNET_NAMESTORE_RecordIterator iter,
-                                void *iter_cls)
+namestore_flat_iterate_records(void *cls,
+                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                               uint64_t serial,
+                               uint64_t limit,
+                               GNUNET_NAMESTORE_RecordIterator iter,
+                               void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct IterateContext ic;
@@ -664,9 +657,9 @@ namestore_flat_iterate_records (void *cls,
   ic.iter = iter;
   ic.iter_cls = iter_cls;
   ic.zone = zone;
-  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
-                                         &iterate_zones,
-                                         &ic);
+  GNUNET_CONTAINER_multihashmap_iterate(plugin->hm,
+                                        &iterate_zones,
+                                        &ic);
   return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
 }
 
@@ -674,8 +667,7 @@ namestore_flat_iterate_records (void *cls,
 /**
  * Closure for #zone_to_name.
  */
-struct ZoneToNameContext
-{
+struct ZoneToNameContext {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone;
   const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone;
   GNUNET_NAMESTORE_RecordIterator iter;
@@ -686,35 +678,35 @@ struct ZoneToNameContext
 
 
 static int
-zone_to_name (void *cls,
-              const struct GNUNET_HashCode *key,
-              void *value)
+zone_to_name(void *cls,
+             const struct GNUNET_HashCode *key,
+             void *value)
 {
   struct ZoneToNameContext *ztn = cls;
   struct FlatFileEntry *entry = value;
 
-  (void) key;
-  if (0 != GNUNET_memcmp (&entry->private_key,
-                   ztn->zone))
+  (void)key;
+  if (0 != GNUNET_memcmp(&entry->private_key,
+                         ztn->zone))
     return GNUNET_YES;
 
   for (unsigned int i = 0; i < entry->record_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_PKEY != entry->record_data[i].record_type)
-      continue;
-    if (0 == memcmp (ztn->value_zone,
-                     entry->record_data[i].data,
-                     sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
     {
-      ztn->iter (ztn->iter_cls,
-                 i + 1, /* zero is illegal! */
-                 &entry->private_key,
-                 entry->label,
-                 entry->record_count,
-                 entry->record_data);
-      ztn->result_found = GNUNET_YES;
+      if (GNUNET_GNSRECORD_TYPE_PKEY != entry->record_data[i].record_type)
+        continue;
+      if (0 == memcmp(ztn->value_zone,
+                      entry->record_data[i].data,
+                      sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
+        {
+          ztn->iter(ztn->iter_cls,
+                    i + 1, /* zero is illegal! */
+                    &entry->private_key,
+                    entry->label,
+                    entry->record_count,
+                    entry->record_data);
+          ztn->result_found = GNUNET_YES;
+        }
     }
-  }
   return GNUNET_YES;
 }
 
@@ -731,11 +723,11 @@ zone_to_name (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
  */
 static int
-namestore_flat_zone_to_name (void *cls,
-                             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                             const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
-                             GNUNET_NAMESTORE_RecordIterator iter,
-                             void *iter_cls)
+namestore_flat_zone_to_name(void *cls,
+                            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                            const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
+                            GNUNET_NAMESTORE_RecordIterator iter,
+                            void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct ZoneToNameContext ztn = {
@@ -746,12 +738,12 @@ namestore_flat_zone_to_name (void *cls,
     .result_found = GNUNET_NO
   };
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Performing reverse lookup for `%s'\n",
-              GNUNET_GNSRECORD_z2s (value_zone));
-  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
-                                         &zone_to_name,
-                                         &ztn);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Performing reverse lookup for `%s'\n",
+             GNUNET_GNSRECORD_z2s(value_zone));
+  GNUNET_CONTAINER_multihashmap_iterate(plugin->hm,
+                                        &zone_to_name,
+                                        &ztn);
   return ztn.result_found;
 }
 
@@ -763,7 +755,7 @@ namestore_flat_zone_to_name (void *cls,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_namestore_flat_init (void *cls)
+libgnunet_plugin_namestore_flat_init(void *cls)
 {
   static struct Plugin plugin;
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
@@ -771,23 +763,23 @@ libgnunet_plugin_namestore_flat_init (void *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;
-  if (GNUNET_OK != database_setup (&plugin))
-  {
-    database_shutdown (&plugin);
-    return NULL;
-  }
-  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
+  if (GNUNET_OK != database_setup(&plugin))
+    {
+      database_shutdown(&plugin);
+      return NULL;
+    }
+  api = GNUNET_new(struct GNUNET_NAMESTORE_PluginFunctions);
   api->cls = &plugin;
   api->store_records = &namestore_flat_store_records;
   api->iterate_records = &namestore_flat_iterate_records;
   api->zone_to_name = &namestore_flat_zone_to_name;
   api->lookup_records = &namestore_flat_lookup_records;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Flat file database running\n"));
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             _("Flat file database running\n"));
   return api;
 }
 
@@ -799,16 +791,16 @@ libgnunet_plugin_namestore_flat_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_namestore_flat_done (void *cls)
+libgnunet_plugin_namestore_flat_done(void *cls)
 {
   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
 
-  database_shutdown (plugin);
+  database_shutdown(plugin);
   plugin->cfg = NULL;
-  GNUNET_free (api);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Flat file plugin is finished\n");
+  GNUNET_free(api);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Flat file plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/namestore/plugin_namestore_postgres.c b/src/namestore/plugin_namestore_postgres.c
index f2e065882..ac35b01b4 100644
--- a/src/namestore/plugin_namestore_postgres.c
+++ b/src/namestore/plugin_namestore_postgres.c
@@ -1,22 +1,22 @@
- /*
-  * This file is part of GNUnet
-  * Copyright (C) 2009-2013, 2016-2018 GNUnet e.V.
-  *
-  * GNUnet is free software: you can redistribute it and/or modify it
-  * under the terms of the GNU Affero General Public License as published
-  * by the Free Software Foundation, either version 3 of the License,
-  * or (at your option) any later version.
-  *
-  * GNUnet is distributed in the hope that it will be useful, but
-  * WITHOUT ANY WARRANTY; without even the implied warranty of
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  * 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
-  */
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2009-2013, 2016-2018 GNUnet e.V.
+ *
+ * GNUnet is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * GNUnet is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * 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 namestore/plugin_namestore_postgres.c
@@ -31,15 +31,13 @@
 #include "namestore.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "namestore-postgres", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "namestore-postgres", __VA_ARGS__)
 
 
 /**
  * Context for all functions in this plugin.
  */
-struct Plugin
-{
-
+struct Plugin {
   /**
    * Our configuration.
    */
@@ -49,7 +47,6 @@ struct Plugin
    * Native Postgres database handle.
    */
   PGconn *dbh;
-
 };
 
 
@@ -62,136 +59,136 @@ struct Plugin
  * @return #GNUNET_OK on success
  */
 static int
-database_setup (struct Plugin *plugin)
+database_setup(struct Plugin *plugin)
 {
   struct GNUNET_PQ_ExecuteStatement es_temporary =
-    GNUNET_PQ_make_execute ("CREATE TEMPORARY TABLE IF NOT EXISTS ns098records ("
-                            " seq BIGSERIAL PRIMARY KEY,"
-                            " zone_private_key BYTEA NOT NULL DEFAULT '',"
-                            " pkey BYTEA DEFAULT '',"
-                            " rvalue BYTEA NOT NULL DEFAULT '',"
-                            " record_count INTEGER NOT NULL DEFAULT 0,"
-                            " record_data BYTEA NOT NULL DEFAULT '',"
-                            " label TEXT NOT NULL DEFAULT '',"
-                            " CONSTRAINT zl UNIQUE (zone_private_key,label)"
-                            ")"
-                            "WITH OIDS");
+    GNUNET_PQ_make_execute("CREATE TEMPORARY TABLE IF NOT EXISTS ns098records ("
+                           " seq BIGSERIAL PRIMARY KEY,"
+                           " zone_private_key BYTEA NOT NULL DEFAULT '',"
+                           " pkey BYTEA DEFAULT '',"
+                           " rvalue BYTEA NOT NULL DEFAULT '',"
+                           " record_count INTEGER NOT NULL DEFAULT 0,"
+                           " record_data BYTEA NOT NULL DEFAULT '',"
+                           " label TEXT NOT NULL DEFAULT '',"
+                           " CONSTRAINT zl UNIQUE (zone_private_key,label)"
+                           ")"
+                           "WITH OIDS");
   struct GNUNET_PQ_ExecuteStatement es_default =
-    GNUNET_PQ_make_execute ("CREATE TABLE IF NOT EXISTS ns098records ("
-                            " seq BIGSERIAL PRIMARY KEY,"
-                            " zone_private_key BYTEA NOT NULL DEFAULT '',"
-                            " pkey BYTEA DEFAULT '',"
-                            " rvalue BYTEA NOT NULL DEFAULT '',"
-                            " record_count INTEGER NOT NULL DEFAULT 0,"
-                            " record_data BYTEA NOT NULL DEFAULT '',"
-                            " label TEXT NOT NULL DEFAULT '',"
-                            " CONSTRAINT zl UNIQUE (zone_private_key,label)"
-                            ")"
-                            "WITH OIDS");
+    GNUNET_PQ_make_execute("CREATE TABLE IF NOT EXISTS ns098records ("
+                           " seq BIGSERIAL PRIMARY KEY,"
+                           " zone_private_key BYTEA NOT NULL DEFAULT '',"
+                           " pkey BYTEA DEFAULT '',"
+                           " rvalue BYTEA NOT NULL DEFAULT '',"
+                           " record_count INTEGER NOT NULL DEFAULT 0,"
+                           " record_data BYTEA NOT NULL DEFAULT '',"
+                           " label TEXT NOT NULL DEFAULT '',"
+                           " CONSTRAINT zl UNIQUE (zone_private_key,label)"
+                           ")"
+                           "WITH OIDS");
   const struct GNUNET_PQ_ExecuteStatement *cr;
 
-  plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->cfg,
-                                            "namestore-postgres");
+  plugin->dbh = GNUNET_PQ_connect_with_cfg(plugin->cfg,
+                                           "namestore-postgres");
   if (NULL == plugin->dbh)
     return GNUNET_SYSERR;
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
-                                            "namestore-postgres",
-                                            "ASYNC_COMMIT"))
-  {
-    struct GNUNET_PQ_ExecuteStatement es[] = {
-      GNUNET_PQ_make_try_execute ("SET synchronous_commit TO off"),
-      GNUNET_PQ_EXECUTE_STATEMENT_END
-    };
-
-    if (GNUNET_OK !=
-        GNUNET_PQ_exec_statements (plugin->dbh,
-                                   es))
+      GNUNET_CONFIGURATION_get_value_yesno(plugin->cfg,
+                                           "namestore-postgres",
+                                           "ASYNC_COMMIT"))
     {
-      PQfinish (plugin->dbh);
-      plugin->dbh = NULL;
-      return GNUNET_SYSERR;
+      struct GNUNET_PQ_ExecuteStatement es[] = {
+        GNUNET_PQ_make_try_execute("SET synchronous_commit TO off"),
+        GNUNET_PQ_EXECUTE_STATEMENT_END
+      };
+
+      if (GNUNET_OK !=
+          GNUNET_PQ_exec_statements(plugin->dbh,
+                                    es))
+        {
+          PQfinish(plugin->dbh);
+          plugin->dbh = NULL;
+          return GNUNET_SYSERR;
+        }
     }
-  }
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
-                                            "namestore-postgres",
-                                            "TEMPORARY_TABLE"))
-  {
-    cr = &es_temporary;
-  }
+      GNUNET_CONFIGURATION_get_value_yesno(plugin->cfg,
+                                           "namestore-postgres",
+                                           "TEMPORARY_TABLE"))
+    {
+      cr = &es_temporary;
+    }
   else
-  {
-    cr = &es_default;
-  }
+    {
+      cr = &es_default;
+    }
 
   {
     struct GNUNET_PQ_ExecuteStatement es[] = {
       *cr,
-      GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_reverse "
-                                  "ON ns098records (zone_private_key,pkey)"),
-      GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
-                                  "ON ns098records (zone_private_key,seq)"),
-      GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_label "
-                                  "ON ns098records (label)"),
-      GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS zone_label "
-                                  "ON ns098records (zone_private_key,label)"),
+      GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS ir_pkey_reverse "
+                                 "ON ns098records (zone_private_key,pkey)"),
+      GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
+                                 "ON ns098records (zone_private_key,seq)"),
+      GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS ir_label "
+                                 "ON ns098records (label)"),
+      GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS zone_label "
+                                 "ON ns098records (zone_private_key,label)"),
       GNUNET_PQ_EXECUTE_STATEMENT_END
     };
 
     if (GNUNET_OK !=
-        GNUNET_PQ_exec_statements (plugin->dbh,
-                                   es))
-    {
-      PQfinish (plugin->dbh);
-      plugin->dbh = NULL;
-      return GNUNET_SYSERR;
-    }
+        GNUNET_PQ_exec_statements(plugin->dbh,
+                                  es))
+      {
+        PQfinish(plugin->dbh);
+        plugin->dbh = NULL;
+        return GNUNET_SYSERR;
+      }
   }
 
   {
     struct GNUNET_PQ_PreparedStatement ps[] = {
-      GNUNET_PQ_make_prepare ("store_records",
-                              "INSERT INTO ns098records"
-                              " (zone_private_key, pkey, rvalue, record_count, record_data, label)"
-                              " VALUES ($1, $2, $3, $4, $5, $6)"
-                              " ON CONFLICT ON CONSTRAINT zl"
-                              " DO UPDATE"
-                              "    SET pkey=$2,rvalue=$3,record_count=$4,record_data=$5"
-                              "    WHERE ns098records.zone_private_key = $1"
-                              "          AND ns098records.label = $6",
-                              6),
-      GNUNET_PQ_make_prepare ("delete_records",
-                              "DELETE FROM ns098records "
-                              "WHERE zone_private_key=$1 AND label=$2",
-                              2),
-      GNUNET_PQ_make_prepare ("zone_to_name",
-                              "SELECT seq,record_count,record_data,label FROM ns098records"
-                              " WHERE zone_private_key=$1 AND pkey=$2",
-                              2),
-      GNUNET_PQ_make_prepare ("iterate_zone",
-                              "SELECT seq,record_count,record_data,label FROM ns098records "
-                              "WHERE zone_private_key=$1 AND seq > $2 ORDER BY seq ASC LIMIT $3",
-                              3),
-      GNUNET_PQ_make_prepare ("iterate_all_zones",
-                              "SELECT seq,record_count,record_data,label,zone_private_key"
-                              " FROM ns098records WHERE seq > $1 ORDER BY seq ASC LIMIT $2",
-                              2),
-      GNUNET_PQ_make_prepare ("lookup_label",
-                              "SELECT seq,record_count,record_data,label "
-                              "FROM ns098records WHERE zone_private_key=$1 AND label=$2",
-                              2),
+      GNUNET_PQ_make_prepare("store_records",
+                             "INSERT INTO ns098records"
+                             " (zone_private_key, pkey, rvalue, record_count, record_data, label)"
+                             " VALUES ($1, $2, $3, $4, $5, $6)"
+                             " ON CONFLICT ON CONSTRAINT zl"
+                             " DO UPDATE"
+                             "    SET pkey=$2,rvalue=$3,record_count=$4,record_data=$5"
+                             "    WHERE ns098records.zone_private_key = $1"
+                             "          AND ns098records.label = $6",
+                             6),
+      GNUNET_PQ_make_prepare("delete_records",
+                             "DELETE FROM ns098records "
+                             "WHERE zone_private_key=$1 AND label=$2",
+                             2),
+      GNUNET_PQ_make_prepare("zone_to_name",
+                             "SELECT seq,record_count,record_data,label FROM ns098records"
+                             " WHERE zone_private_key=$1 AND pkey=$2",
+                             2),
+      GNUNET_PQ_make_prepare("iterate_zone",
+                             "SELECT seq,record_count,record_data,label FROM ns098records "
+                             "WHERE zone_private_key=$1 AND seq > $2 ORDER BY seq ASC LIMIT $3",
+                             3),
+      GNUNET_PQ_make_prepare("iterate_all_zones",
+                             "SELECT seq,record_count,record_data,label,zone_private_key"
+                             " FROM ns098records WHERE seq > $1 ORDER BY seq ASC LIMIT $2",
+                             2),
+      GNUNET_PQ_make_prepare("lookup_label",
+                             "SELECT seq,record_count,record_data,label "
+                             "FROM ns098records WHERE zone_private_key=$1 AND label=$2",
+                             2),
       GNUNET_PQ_PREPARED_STATEMENT_END
     };
 
     if (GNUNET_OK !=
-        GNUNET_PQ_prepare_statements (plugin->dbh,
-                                      ps))
-    {
-      PQfinish (plugin->dbh);
-      plugin->dbh = NULL;
-      return GNUNET_SYSERR;
-    }
+        GNUNET_PQ_prepare_statements(plugin->dbh,
+                                     ps))
+      {
+        PQfinish(plugin->dbh);
+        plugin->dbh = NULL;
+        return GNUNET_SYSERR;
+      }
   }
 
   return GNUNET_OK;
@@ -210,97 +207,97 @@ database_setup (struct Plugin *plugin)
  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
  */
 static int
-namestore_postgres_store_records (void *cls,
-                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                                  const char *label,
-                                  unsigned int rd_count,
-                                  const struct GNUNET_GNSRECORD_Data *rd)
+namestore_postgres_store_records(void *cls,
+                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                                 const char *label,
+                                 unsigned int rd_count,
+                                 const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
   uint64_t rvalue;
-  uint32_t rd_count32 = (uint32_t) rd_count;
+  uint32_t rd_count32 = (uint32_t)rd_count;
   ssize_t data_size;
 
-  memset (&pkey,
-          0,
-          sizeof (pkey));
-  for (unsigned int i=0;i<rd_count;i++)
+  memset(&pkey,
+         0,
+         sizeof(pkey));
+  for (unsigned int i = 0; i < rd_count; i++)
     if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
+      {
+        GNUNET_break(sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) == rd[i].data_size);
+        GNUNET_memcpy(&pkey,
+                      rd[i].data,
+                      rd[i].data_size);
+        break;
+      }
+  rvalue = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
+                                    UINT64_MAX);
+  data_size = GNUNET_GNSRECORD_records_get_size(rd_count,
+                                                rd);
+  if (data_size < 0)
     {
-      GNUNET_break (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) == rd[i].data_size);
-      GNUNET_memcpy (&pkey,
-                     rd[i].data,
-                     rd[i].data_size);
-      break;
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
     }
-  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                     UINT64_MAX);
-  data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
-                                                 rd);
-  if (data_size < 0)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
   if (data_size >= UINT16_MAX)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   /* if record set is empty, delete existing records */
   if (0 == rd_count)
-  {
-    struct GNUNET_PQ_QueryParam params[] = {
-      GNUNET_PQ_query_param_auto_from_type (zone_key),
-      GNUNET_PQ_query_param_string (label),
-      GNUNET_PQ_query_param_end
-    };
-    enum GNUNET_DB_QueryStatus res;
-
-    res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
-                                              "delete_records",
-                                              params);
-    if ( (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res) &&
-         (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != res) )
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      struct GNUNET_PQ_QueryParam params[] = {
+        GNUNET_PQ_query_param_auto_from_type(zone_key),
+        GNUNET_PQ_query_param_string(label),
+        GNUNET_PQ_query_param_end
+      };
+      enum GNUNET_DB_QueryStatus res;
+
+      res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
+                                               "delete_records",
+                                               params);
+      if ((GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res) &&
+          (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != res))
+        {
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
+                      "postgres",
+                      "Record deleted\n");
+      return GNUNET_OK;
     }
-    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "postgres",
-                     "Record deleted\n");
-    return GNUNET_OK;
-  }
   /* otherwise, UPSERT (i.e. UPDATE if exists, otherwise INSERT) */
   {
     char data[data_size];
     struct GNUNET_PQ_QueryParam params[] = {
-      GNUNET_PQ_query_param_auto_from_type (zone_key),
-      GNUNET_PQ_query_param_auto_from_type (&pkey),
-      GNUNET_PQ_query_param_uint64 (&rvalue),
-      GNUNET_PQ_query_param_uint32 (&rd_count32),
-      GNUNET_PQ_query_param_fixed_size (data, data_size),
-      GNUNET_PQ_query_param_string (label),
+      GNUNET_PQ_query_param_auto_from_type(zone_key),
+      GNUNET_PQ_query_param_auto_from_type(&pkey),
+      GNUNET_PQ_query_param_uint64(&rvalue),
+      GNUNET_PQ_query_param_uint32(&rd_count32),
+      GNUNET_PQ_query_param_fixed_size(data, data_size),
+      GNUNET_PQ_query_param_string(label),
       GNUNET_PQ_query_param_end
     };
     enum GNUNET_DB_QueryStatus res;
     ssize_t ret;
 
-    ret = GNUNET_GNSRECORD_records_serialize (rd_count,
-                                              rd,
-                                              data_size,
-                                              data);
-    if ( (ret < 0) ||
-         (data_size != ret) )
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+    ret = GNUNET_GNSRECORD_records_serialize(rd_count,
+                                             rd,
+                                             data_size,
+                                             data);
+    if ((ret < 0) ||
+        (data_size != ret))
+      {
+        GNUNET_break(0);
+        return GNUNET_SYSERR;
+      }
 
-    res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
-                                              "store_records",
-                                              params);
+    res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
+                                             "store_records",
+                                             params);
     if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res)
       return GNUNET_SYSERR;
   }
@@ -311,8 +308,7 @@ namestore_postgres_store_records (void *cls,
 /**
  * Closure for #parse_result_call_iterator.
  */
-struct ParserContext
-{
+struct ParserContext {
   /**
    * Function to call for each result.
    */
@@ -345,81 +341,81 @@ struct ParserContext
  * @param num_result the number of results in @a result
  */
 static void
-parse_result_call_iterator (void *cls,
-                            PGresult *res,
-                            unsigned int num_results)
+parse_result_call_iterator(void *cls,
+                           PGresult *res,
+                           unsigned int num_results)
 {
   struct ParserContext *pc = cls;
 
   if (NULL == pc->iter)
     return; /* no need to do more work */
-  for (unsigned int i=0;i<num_results;i++)
-  {
-    uint64_t serial;
-    void *data;
-    size_t data_size;
-    uint32_t record_count;
-    char *label;
-    struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
-    struct GNUNET_PQ_ResultSpec rs_with_zone[] = {
-      GNUNET_PQ_result_spec_uint64 ("seq", &serial),
-      GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
-      GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
-      GNUNET_PQ_result_spec_string ("label", &label),
-      GNUNET_PQ_result_spec_auto_from_type ("zone_private_key", &zk),
-      GNUNET_PQ_result_spec_end
-    };
-    struct GNUNET_PQ_ResultSpec rs_without_zone[] = {
-      GNUNET_PQ_result_spec_uint64 ("seq", &serial),
-      GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
-      GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
-      GNUNET_PQ_result_spec_string ("label", &label),
-      GNUNET_PQ_result_spec_end
-    };
-    struct GNUNET_PQ_ResultSpec *rs;
-
-    rs = (NULL == pc->zone_key) ? rs_with_zone : rs_without_zone;
-    if (GNUNET_YES !=
-        GNUNET_PQ_extract_result (res,
-                                  rs,
-                                  i))
-    {
-      GNUNET_break (0);
-      return;
-    }
-
-    if (record_count > 64 * 1024)
-    {
-      /* sanity check, don't stack allocate far too much just
-         because database might contain a large value here */
-      GNUNET_break (0);
-      GNUNET_PQ_cleanup_result (rs);
-      return;
-    }
-
+  for (unsigned int i = 0; i < num_results; i++)
     {
-      struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(record_count)];
+      uint64_t serial;
+      void *data;
+      size_t data_size;
+      uint32_t record_count;
+      char *label;
+      struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
+      struct GNUNET_PQ_ResultSpec rs_with_zone[] = {
+        GNUNET_PQ_result_spec_uint64("seq", &serial),
+        GNUNET_PQ_result_spec_uint32("record_count", &record_count),
+        GNUNET_PQ_result_spec_variable_size("record_data", &data, &data_size),
+        GNUNET_PQ_result_spec_string("label", &label),
+        GNUNET_PQ_result_spec_auto_from_type("zone_private_key", &zk),
+        GNUNET_PQ_result_spec_end
+      };
+      struct GNUNET_PQ_ResultSpec rs_without_zone[] = {
+        GNUNET_PQ_result_spec_uint64("seq", &serial),
+        GNUNET_PQ_result_spec_uint32("record_count", &record_count),
+        GNUNET_PQ_result_spec_variable_size("record_data", &data, &data_size),
+        GNUNET_PQ_result_spec_string("label", &label),
+        GNUNET_PQ_result_spec_end
+      };
+      struct GNUNET_PQ_ResultSpec *rs;
+
+      rs = (NULL == pc->zone_key) ? rs_with_zone : rs_without_zone;
+      if (GNUNET_YES !=
+          GNUNET_PQ_extract_result(res,
+                                   rs,
+                                   i))
+        {
+          GNUNET_break(0);
+          return;
+        }
+
+      if (record_count > 64 * 1024)
+        {
+          /* sanity check, don't stack allocate far too much just
+             because database might contain a large value here */
+          GNUNET_break(0);
+          GNUNET_PQ_cleanup_result(rs);
+          return;
+        }
 
-      GNUNET_assert (0 != serial);
-      if (GNUNET_OK !=
-          GNUNET_GNSRECORD_records_deserialize (data_size,
-                                                data,
-                                                record_count,
-                                                rd))
       {
-        GNUNET_break (0);
-        GNUNET_PQ_cleanup_result (rs);
-        return;
+        struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(record_count)];
+
+        GNUNET_assert(0 != serial);
+        if (GNUNET_OK !=
+            GNUNET_GNSRECORD_records_deserialize(data_size,
+                                                 data,
+                                                 record_count,
+                                                 rd))
+          {
+            GNUNET_break(0);
+            GNUNET_PQ_cleanup_result(rs);
+            return;
+          }
+        pc->iter(pc->iter_cls,
+                 serial,
+                 (NULL == pc->zone_key) ? &zk : pc->zone_key,
+                 label,
+                 record_count,
+                 rd);
       }
-      pc->iter (pc->iter_cls,
-                serial,
-                (NULL == pc->zone_key) ? &zk : pc->zone_key,
-                label,
-                record_count,
-                rd);
+      GNUNET_PQ_cleanup_result(rs);
     }
-    GNUNET_PQ_cleanup_result (rs);
-  }
   pc->limit -= num_results;
 }
 
@@ -435,34 +431,34 @@ parse_result_call_iterator (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO for no results, else #GNUNET_SYSERR
  */
 static int
-namestore_postgres_lookup_records (void *cls,
-                                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                   const char *label,
-                                   GNUNET_NAMESTORE_RecordIterator iter,
-                                   void *iter_cls)
+namestore_postgres_lookup_records(void *cls,
+                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                                  const char *label,
+                                  GNUNET_NAMESTORE_RecordIterator iter,
+                                  void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_PQ_QueryParam params[] = {
-    GNUNET_PQ_query_param_auto_from_type (zone),
-    GNUNET_PQ_query_param_string (label),
+    GNUNET_PQ_query_param_auto_from_type(zone),
+    GNUNET_PQ_query_param_string(label),
     GNUNET_PQ_query_param_end
   };
   struct ParserContext pc;
   enum GNUNET_DB_QueryStatus res;
 
   if (NULL == zone)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   pc.iter = iter;
   pc.iter_cls = iter_cls;
   pc.zone_key = zone;
-  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
-                                              "lookup_label",
-                                              params,
-                                              &parse_result_call_iterator,
-                                              &pc);
+  res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
+                                             "lookup_label",
+                                             params,
+                                             &parse_result_call_iterator,
+                                             &pc);
   if (res < 0)
     return GNUNET_SYSERR;
   if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
@@ -484,12 +480,12 @@ namestore_postgres_lookup_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
  */
 static int
-namestore_postgres_iterate_records (void *cls,
-                                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                    uint64_t serial,
-                                    uint64_t limit,
-                                    GNUNET_NAMESTORE_RecordIterator iter,
-                                    void *iter_cls)
+namestore_postgres_iterate_records(void *cls,
+                                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                                   uint64_t serial,
+                                   uint64_t limit,
+                                   GNUNET_NAMESTORE_RecordIterator iter,
+                                   void *iter_cls)
 {
   struct Plugin *plugin = cls;
   enum GNUNET_DB_QueryStatus res;
@@ -500,39 +496,39 @@ namestore_postgres_iterate_records (void *cls,
   pc.zone_key = zone;
   pc.limit = limit;
   if (NULL == zone)
-  {
-    struct GNUNET_PQ_QueryParam params_without_zone[] = {
-      GNUNET_PQ_query_param_uint64 (&serial),
-      GNUNET_PQ_query_param_uint64 (&limit),
-      GNUNET_PQ_query_param_end
-    };
-
-    res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
-                                                "iterate_all_zones",
-                                                params_without_zone,
-                                                &parse_result_call_iterator,
-                                                &pc);
-  }
+    {
+      struct GNUNET_PQ_QueryParam params_without_zone[] = {
+        GNUNET_PQ_query_param_uint64(&serial),
+        GNUNET_PQ_query_param_uint64(&limit),
+        GNUNET_PQ_query_param_end
+      };
+
+      res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
+                                                 "iterate_all_zones",
+                                                 params_without_zone,
+                                                 &parse_result_call_iterator,
+                                                 &pc);
+    }
   else
-  {
-    struct GNUNET_PQ_QueryParam params_with_zone[] = {
-      GNUNET_PQ_query_param_auto_from_type (zone),
-      GNUNET_PQ_query_param_uint64 (&serial),
-      GNUNET_PQ_query_param_uint64 (&limit),
-      GNUNET_PQ_query_param_end
-    };
-
-    res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
-                                                "iterate_zone",
-                                                params_with_zone,
-                                                &parse_result_call_iterator,
-                                                &pc);
-  }
+    {
+      struct GNUNET_PQ_QueryParam params_with_zone[] = {
+        GNUNET_PQ_query_param_auto_from_type(zone),
+        GNUNET_PQ_query_param_uint64(&serial),
+        GNUNET_PQ_query_param_uint64(&limit),
+        GNUNET_PQ_query_param_end
+      };
+
+      res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
+                                                 "iterate_zone",
+                                                 params_with_zone,
+                                                 &parse_result_call_iterator,
+                                                 &pc);
+    }
   if (res < 0)
     return GNUNET_SYSERR;
 
-  if ( (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res) ||
-       (pc.limit > 0) )
+  if ((GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res) ||
+      (pc.limit > 0))
     return GNUNET_NO;
   return GNUNET_OK;
 }
@@ -550,15 +546,15 @@ namestore_postgres_iterate_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
  */
 static int
-namestore_postgres_zone_to_name (void *cls,
-                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                 const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
-                                 GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
+namestore_postgres_zone_to_name(void *cls,
+                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                                const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
+                                GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_PQ_QueryParam params[] = {
-    GNUNET_PQ_query_param_auto_from_type (zone),
-    GNUNET_PQ_query_param_auto_from_type (value_zone),
+    GNUNET_PQ_query_param_auto_from_type(zone),
+    GNUNET_PQ_query_param_auto_from_type(value_zone),
     GNUNET_PQ_query_param_end
   };
   enum GNUNET_DB_QueryStatus res;
@@ -567,11 +563,11 @@ namestore_postgres_zone_to_name (void *cls,
   pc.iter = iter;
   pc.iter_cls = iter_cls;
   pc.zone_key = zone;
-  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
-                                              "zone_to_name",
-                                              params,
-                                              &parse_result_call_iterator,
-                                              &pc);
+  res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
+                                             "zone_to_name",
+                                             params,
+                                             &parse_result_call_iterator,
+                                             &pc);
   if (res < 0)
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -585,9 +581,9 @@ namestore_postgres_zone_to_name (void *cls,
  * @param plugin the plugin context (state for this module)
  */
 static void
-database_shutdown (struct Plugin *plugin)
+database_shutdown(struct Plugin *plugin)
 {
-  PQfinish (plugin->dbh);
+  PQfinish(plugin->dbh);
   plugin->dbh = NULL;
 }
 
@@ -599,7 +595,7 @@ database_shutdown (struct Plugin *plugin)
  * @return NULL on error, othrewise the plugin context
  */
 void *
-libgnunet_plugin_namestore_postgres_init (void *cls)
+libgnunet_plugin_namestore_postgres_init(void *cls)
 {
   static struct Plugin plugin;
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
@@ -607,21 +603,21 @@ libgnunet_plugin_namestore_postgres_init (void *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;
-  if (GNUNET_OK != database_setup (&plugin))
-  {
-    database_shutdown (&plugin);
-    return NULL;
-  }
-  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
+  if (GNUNET_OK != database_setup(&plugin))
+    {
+      database_shutdown(&plugin);
+      return NULL;
+    }
+  api = GNUNET_new(struct GNUNET_NAMESTORE_PluginFunctions);
   api->cls = &plugin;
   api->store_records = &namestore_postgres_store_records;
   api->iterate_records = &namestore_postgres_iterate_records;
   api->zone_to_name = &namestore_postgres_zone_to_name;
   api->lookup_records = &namestore_postgres_lookup_records;
-  LOG (GNUNET_ERROR_TYPE_INFO,
-       "Postgres namestore plugin running\n");
+  LOG(GNUNET_ERROR_TYPE_INFO,
+      "Postgres namestore plugin running\n");
   return api;
 }
 
@@ -633,16 +629,16 @@ libgnunet_plugin_namestore_postgres_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_namestore_postgres_done (void *cls)
+libgnunet_plugin_namestore_postgres_done(void *cls)
 {
   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
 
-  database_shutdown (plugin);
+  database_shutdown(plugin);
   plugin->cfg = NULL;
-  GNUNET_free (api);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Postgres namestore plugin is finished\n");
+  GNUNET_free(api);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Postgres namestore plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/namestore/plugin_namestore_sqlite.c b/src/namestore/plugin_namestore_sqlite.c
index e4bfcde16..ba031217d 100644
--- a/src/namestore/plugin_namestore_sqlite.c
+++ b/src/namestore/plugin_namestore_sqlite.c
@@ -50,17 +50,15 @@
  * a failure of the command 'cmd' on file 'filename'
  * with the message given by strerror(errno).
  */
-#define LOG_SQLITE(db, level, cmd) do { GNUNET_log_from (level, "namestore-sqlite", _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db->dbh)); } while(0)
+#define LOG_SQLITE(db, level, cmd) do { GNUNET_log_from(level, "namestore-sqlite", _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db->dbh)); } while (0)
 
-#define LOG(kind,...) GNUNET_log_from (kind, "namestore-sqlite", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "namestore-sqlite", __VA_ARGS__)
 
 
 /**
  * Context for all functions in this plugin.
  */
-struct Plugin
-{
-
+struct Plugin {
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 
   /**
@@ -114,123 +112,123 @@ struct Plugin
  * @return #GNUNET_OK on success
  */
 static int
-database_setup (struct Plugin *plugin)
+database_setup(struct Plugin *plugin)
 {
   char *sqlite_filename;
   struct GNUNET_SQ_ExecuteStatement es[] = {
-    GNUNET_SQ_make_try_execute ("PRAGMA temp_store=MEMORY"),
-    GNUNET_SQ_make_try_execute ("PRAGMA synchronous=NORMAL"),
-    GNUNET_SQ_make_try_execute ("PRAGMA legacy_file_format=OFF"),
-    GNUNET_SQ_make_try_execute ("PRAGMA auto_vacuum=INCREMENTAL"),
-    GNUNET_SQ_make_try_execute ("PRAGMA encoding=\"UTF-8\""),
-    GNUNET_SQ_make_try_execute ("PRAGMA locking_mode=EXCLUSIVE"),
-    GNUNET_SQ_make_try_execute ("PRAGMA journal_mode=WAL"),
-    GNUNET_SQ_make_try_execute ("PRAGMA page_size=4092"),
-    GNUNET_SQ_make_execute ("CREATE TABLE IF NOT EXISTS ns098records ("
-                            " uid INTEGER PRIMARY KEY,"
-                            " zone_private_key BLOB NOT NULL,"
-                            " pkey BLOB,"
-                            " rvalue INT8 NOT NULL,"
-                            " record_count INT NOT NULL,"
-                            " record_data BLOB NOT NULL,"
-                            " label TEXT NOT NULL"
-                            ")"),
-    GNUNET_SQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_reverse "
-                                "ON ns098records (zone_private_key,pkey)"),
-    GNUNET_SQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
-                                "ON ns098records (zone_private_key,uid)"),
+    GNUNET_SQ_make_try_execute("PRAGMA temp_store=MEMORY"),
+    GNUNET_SQ_make_try_execute("PRAGMA synchronous=NORMAL"),
+    GNUNET_SQ_make_try_execute("PRAGMA legacy_file_format=OFF"),
+    GNUNET_SQ_make_try_execute("PRAGMA auto_vacuum=INCREMENTAL"),
+    GNUNET_SQ_make_try_execute("PRAGMA encoding=\"UTF-8\""),
+    GNUNET_SQ_make_try_execute("PRAGMA locking_mode=EXCLUSIVE"),
+    GNUNET_SQ_make_try_execute("PRAGMA journal_mode=WAL"),
+    GNUNET_SQ_make_try_execute("PRAGMA page_size=4092"),
+    GNUNET_SQ_make_execute("CREATE TABLE IF NOT EXISTS ns098records ("
+                           " uid INTEGER PRIMARY KEY,"
+                           " zone_private_key BLOB NOT NULL,"
+                           " pkey BLOB,"
+                           " rvalue INT8 NOT NULL,"
+                           " record_count INT NOT NULL,"
+                           " record_data BLOB NOT NULL,"
+                           " label TEXT NOT NULL"
+                           ")"),
+    GNUNET_SQ_make_try_execute("CREATE INDEX IF NOT EXISTS ir_pkey_reverse "
+                               "ON ns098records (zone_private_key,pkey)"),
+    GNUNET_SQ_make_try_execute("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
+                               "ON ns098records (zone_private_key,uid)"),
     GNUNET_SQ_EXECUTE_STATEMENT_END
   };
   struct GNUNET_SQ_PrepareStatement ps[] = {
-    GNUNET_SQ_make_prepare ("INSERT INTO ns098records "
-                            "(zone_private_key,pkey,rvalue,record_count,record_data,label)"
-                            " VALUES (?, ?, ?, ?, ?, ?)",
-                            &plugin->store_records),
-    GNUNET_SQ_make_prepare ("DELETE FROM ns098records "
-                            "WHERE zone_private_key=? AND label=?",
-                            &plugin->delete_records),
-    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
-                            " FROM ns098records"
-                            " WHERE zone_private_key=? AND pkey=?",
-                            &plugin->zone_to_name),
-    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
-                            " FROM ns098records"
-                            " WHERE zone_private_key=? AND uid > ?"
-                            " ORDER BY uid ASC"
-                            " LIMIT ?",
-                            &plugin->iterate_zone),
-    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label,zone_private_key"
-                            " FROM ns098records"
-                            " WHERE uid > ?"
-                            " ORDER BY uid ASC"
-                            " LIMIT ?",
-                            &plugin->iterate_all_zones),
-    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
-                            " FROM ns098records"
-                            " WHERE zone_private_key=? AND label=?",
-                            &plugin->lookup_label),
+    GNUNET_SQ_make_prepare("INSERT INTO ns098records "
+                           "(zone_private_key,pkey,rvalue,record_count,record_data,label)"
+                           " VALUES (?, ?, ?, ?, ?, ?)",
+                           &plugin->store_records),
+    GNUNET_SQ_make_prepare("DELETE FROM ns098records "
+                           "WHERE zone_private_key=? AND label=?",
+                           &plugin->delete_records),
+    GNUNET_SQ_make_prepare("SELECT uid,record_count,record_data,label"
+                           " FROM ns098records"
+                           " WHERE zone_private_key=? AND pkey=?",
+                           &plugin->zone_to_name),
+    GNUNET_SQ_make_prepare("SELECT uid,record_count,record_data,label"
+                           " FROM ns098records"
+                           " WHERE zone_private_key=? AND uid > ?"
+                           " ORDER BY uid ASC"
+                           " LIMIT ?",
+                           &plugin->iterate_zone),
+    GNUNET_SQ_make_prepare("SELECT uid,record_count,record_data,label,zone_private_key"
+                           " FROM ns098records"
+                           " WHERE uid > ?"
+                           " ORDER BY uid ASC"
+                           " LIMIT ?",
+                           &plugin->iterate_all_zones),
+    GNUNET_SQ_make_prepare("SELECT uid,record_count,record_data,label"
+                           " FROM ns098records"
+                           " WHERE zone_private_key=? AND label=?",
+                           &plugin->lookup_label),
     GNUNET_SQ_PREPARE_END
   };
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
-                                               "namestore-sqlite",
-                                               "FILENAME",
-                                               &sqlite_filename))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               "namestore-sqlite",
-                               "FILENAME");
-    return GNUNET_SYSERR;
-  }
-  if (GNUNET_OK !=
-      GNUNET_DISK_file_test (sqlite_filename))
-  {
-    if (GNUNET_OK !=
-        GNUNET_DISK_directory_create_for_file (sqlite_filename))
+      GNUNET_CONFIGURATION_get_value_filename(plugin->cfg,
+                                              "namestore-sqlite",
+                                              "FILENAME",
+                                              &sqlite_filename))
     {
-      GNUNET_break (0);
-      GNUNET_free (sqlite_filename);
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+                                "namestore-sqlite",
+                                "FILENAME");
       return GNUNET_SYSERR;
     }
-  }
+  if (GNUNET_OK !=
+      GNUNET_DISK_file_test(sqlite_filename))
+    {
+      if (GNUNET_OK !=
+          GNUNET_DISK_directory_create_for_file(sqlite_filename))
+        {
+          GNUNET_break(0);
+          GNUNET_free(sqlite_filename);
+          return GNUNET_SYSERR;
+        }
+    }
   /* sqlite_filename should be UTF-8-encoded. If it isn't, it's a bug */
   plugin->fn = sqlite_filename;
 
   /* Open database and precompile statements */
   if (SQLITE_OK !=
-      sqlite3_open (plugin->fn,
-                    &plugin->dbh))
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Unable to initialize SQLite: %s.\n"),
-         sqlite3_errmsg (plugin->dbh));
-    return GNUNET_SYSERR;
-  }
-  GNUNET_break (SQLITE_OK ==
-                sqlite3_busy_timeout (plugin->dbh,
-                                      BUSY_TIMEOUT_MS));
+      sqlite3_open(plugin->fn,
+                   &plugin->dbh))
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Unable to initialize SQLite: %s.\n"),
+          sqlite3_errmsg(plugin->dbh));
+      return GNUNET_SYSERR;
+    }
+  GNUNET_break(SQLITE_OK ==
+               sqlite3_busy_timeout(plugin->dbh,
+                                    BUSY_TIMEOUT_MS));
   if (GNUNET_OK !=
-      GNUNET_SQ_exec_statements (plugin->dbh,
-                                 es))
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Failed to setup database at `%s'\n"),
-         plugin->fn);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_SQ_exec_statements(plugin->dbh,
+                                es))
+    {
+      GNUNET_break(0);
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Failed to setup database at `%s'\n"),
+          plugin->fn);
+      return GNUNET_SYSERR;
+    }
 
   if (GNUNET_OK !=
-      GNUNET_SQ_prepare (plugin->dbh,
-                         ps))
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Failed to setup database at `%s'\n"),
-         plugin->fn);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_SQ_prepare(plugin->dbh,
+                        ps))
+    {
+      GNUNET_break(0);
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Failed to setup database at `%s'\n"),
+          plugin->fn);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -241,54 +239,54 @@ database_setup (struct Plugin *plugin)
  * @param plugin the plugin context (state for this module)
  */
 static void
-database_shutdown (struct Plugin *plugin)
+database_shutdown(struct Plugin *plugin)
 {
   int result;
   sqlite3_stmt *stmt;
 
   if (NULL != plugin->store_records)
-    sqlite3_finalize (plugin->store_records);
+    sqlite3_finalize(plugin->store_records);
   if (NULL != plugin->delete_records)
-    sqlite3_finalize (plugin->delete_records);
+    sqlite3_finalize(plugin->delete_records);
   if (NULL != plugin->iterate_zone)
-    sqlite3_finalize (plugin->iterate_zone);
+    sqlite3_finalize(plugin->iterate_zone);
   if (NULL != plugin->iterate_all_zones)
-    sqlite3_finalize (plugin->iterate_all_zones);
+    sqlite3_finalize(plugin->iterate_all_zones);
   if (NULL != plugin->zone_to_name)
-    sqlite3_finalize (plugin->zone_to_name);
+    sqlite3_finalize(plugin->zone_to_name);
   if (NULL != plugin->lookup_label)
-    sqlite3_finalize (plugin->lookup_label);
-  result = sqlite3_close (plugin->dbh);
+    sqlite3_finalize(plugin->lookup_label);
+  result = sqlite3_close(plugin->dbh);
   if (result == SQLITE_BUSY)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Tried to close sqlite without finalizing all prepared statements.\n"));
-    stmt = sqlite3_next_stmt (plugin->dbh,
-                              NULL);
-    while (NULL != stmt)
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "sqlite",
-                       "Closing statement %p\n",
-                       stmt);
-      result = sqlite3_finalize (stmt);
-      if (result != SQLITE_OK)
-        GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                         "sqlite",
-                         "Failed to close statement %p: %d\n",
-                         stmt,
-                         result);
-      stmt = sqlite3_next_stmt (plugin->dbh,
-                                NULL);
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Tried to close sqlite without finalizing all prepared statements.\n"));
+      stmt = sqlite3_next_stmt(plugin->dbh,
+                               NULL);
+      while (NULL != stmt)
+        {
+          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
+                          "sqlite",
+                          "Closing statement %p\n",
+                          stmt);
+          result = sqlite3_finalize(stmt);
+          if (result != SQLITE_OK)
+            GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING,
+                            "sqlite",
+                            "Failed to close statement %p: %d\n",
+                            stmt,
+                            result);
+          stmt = sqlite3_next_stmt(plugin->dbh,
+                                   NULL);
+        }
+      result = sqlite3_close(plugin->dbh);
     }
-    result = sqlite3_close (plugin->dbh);
-  }
   if (SQLITE_OK != result)
-    LOG_SQLITE (plugin,
-                GNUNET_ERROR_TYPE_ERROR,
-                "sqlite3_close");
+    LOG_SQLITE(plugin,
+               GNUNET_ERROR_TYPE_ERROR,
+               "sqlite3_close");
 
-  GNUNET_free_non_null (plugin->fn);
+  GNUNET_free_non_null(plugin->fn);
 }
 
 
@@ -304,11 +302,11 @@ database_shutdown (struct Plugin *plugin)
  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
  */
 static int
-namestore_sqlite_store_records (void *cls,
-                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                                const char *label,
-                                unsigned int rd_count,
-                                const struct GNUNET_GNSRECORD_Data *rd)
+namestore_sqlite_store_records(void *cls,
+                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                               const char *label,
+                               unsigned int rd_count,
+                               const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct Plugin *plugin = cls;
   int n;
@@ -316,121 +314,122 @@ namestore_sqlite_store_records (void *cls,
   uint64_t rvalue;
   ssize_t data_size;
 
-  memset (&pkey,
-          0,
-          sizeof (pkey));
-  for (unsigned int i=0;i<rd_count;i++)
+  memset(&pkey,
+         0,
+         sizeof(pkey));
+  for (unsigned int i = 0; i < rd_count; i++)
     if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
-    {
-      GNUNET_break (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) ==
-                    rd[i].data_size);
-      GNUNET_memcpy (&pkey,
-                     rd[i].data,
+      {
+        GNUNET_break(sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) ==
                      rd[i].data_size);
-      break;
-    }
-  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                     UINT64_MAX);
-  data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
-                                                 rd);
+        GNUNET_memcpy(&pkey,
+                      rd[i].data,
+                      rd[i].data_size);
+        break;
+      }
+  rvalue = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
+                                    UINT64_MAX);
+  data_size = GNUNET_GNSRECORD_records_get_size(rd_count,
+                                                rd);
   if (data_size < 0)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   if (data_size > 64 * 65536)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   {
     /* First delete 'old' records */
     char data[data_size];
     struct GNUNET_SQ_QueryParam dparams[] = {
-      GNUNET_SQ_query_param_auto_from_type (zone_key),
-      GNUNET_SQ_query_param_string (label),
+      GNUNET_SQ_query_param_auto_from_type(zone_key),
+      GNUNET_SQ_query_param_string(label),
       GNUNET_SQ_query_param_end
     };
     ssize_t ret;
 
-    ret = GNUNET_GNSRECORD_records_serialize (rd_count,
-                                              rd,
-                                              data_size,
-                                              data);
-    if ( (ret < 0) ||
-         (data_size != ret) )
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+    ret = GNUNET_GNSRECORD_records_serialize(rd_count,
+                                             rd,
+                                             data_size,
+                                             data);
+    if ((ret < 0) ||
+        (data_size != ret))
+      {
+        GNUNET_break(0);
+        return GNUNET_SYSERR;
+      }
     if (GNUNET_OK !=
-        GNUNET_SQ_bind (plugin->delete_records,
-                        dparams))
-    {
-      LOG_SQLITE (plugin,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_bind_XXXX");
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->delete_records);
-      return GNUNET_SYSERR;
-
-    }
-    n = sqlite3_step (plugin->delete_records);
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->delete_records);
+        GNUNET_SQ_bind(plugin->delete_records,
+                       dparams))
+      {
+        LOG_SQLITE(plugin,
+                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                   "sqlite3_bind_XXXX");
+        GNUNET_SQ_reset(plugin->dbh,
+                        plugin->delete_records);
+        return GNUNET_SYSERR;
+      }
+    n = sqlite3_step(plugin->delete_records);
+    GNUNET_SQ_reset(plugin->dbh,
+                    plugin->delete_records);
 
     if (0 != rd_count)
-    {
-      uint32_t rd_count32 = (uint32_t) rd_count;
-      struct GNUNET_SQ_QueryParam sparams[] = {
-        GNUNET_SQ_query_param_auto_from_type (zone_key),
-        GNUNET_SQ_query_param_auto_from_type (&pkey),
-        GNUNET_SQ_query_param_uint64 (&rvalue),
-        GNUNET_SQ_query_param_uint32 (&rd_count32),
-        GNUNET_SQ_query_param_fixed_size (data, data_size),
-        GNUNET_SQ_query_param_string (label),
-        GNUNET_SQ_query_param_end
-      };
-
-      if (GNUNET_OK !=
-          GNUNET_SQ_bind (plugin->store_records,
-                          sparams))
       {
-        LOG_SQLITE (plugin,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                    "sqlite3_bind_XXXX");
-        GNUNET_SQ_reset (plugin->dbh,
-                         plugin->store_records);
-        return GNUNET_SYSERR;
+        uint32_t rd_count32 = (uint32_t)rd_count;
+        struct GNUNET_SQ_QueryParam sparams[] = {
+          GNUNET_SQ_query_param_auto_from_type(zone_key),
+          GNUNET_SQ_query_param_auto_from_type(&pkey),
+          GNUNET_SQ_query_param_uint64(&rvalue),
+          GNUNET_SQ_query_param_uint32(&rd_count32),
+          GNUNET_SQ_query_param_fixed_size(data, data_size),
+          GNUNET_SQ_query_param_string(label),
+          GNUNET_SQ_query_param_end
+        };
+
+        if (GNUNET_OK !=
+            GNUNET_SQ_bind(plugin->store_records,
+                           sparams))
+          {
+            LOG_SQLITE(plugin,
+                       GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                       "sqlite3_bind_XXXX");
+            GNUNET_SQ_reset(plugin->dbh,
+                            plugin->store_records);
+            return GNUNET_SYSERR;
+          }
+        n = sqlite3_step(plugin->store_records);
+        GNUNET_SQ_reset(plugin->dbh,
+                        plugin->store_records);
       }
-      n = sqlite3_step (plugin->store_records);
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->store_records);
-    }
   }
   switch (n)
-  {
+    {
     case SQLITE_DONE:
       if (0 != rd_count)
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "sqlite",
-                         "Record stored\n");
+        GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
+                        "sqlite",
+                        "Record stored\n");
       else
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "sqlite",
-                         "Record deleted\n");
+        GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
+                        "sqlite",
+                        "Record deleted\n");
       return GNUNET_OK;
+
     case SQLITE_BUSY:
-      LOG_SQLITE (plugin,
-                  GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_step");
+      LOG_SQLITE(plugin,
+                 GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                 "sqlite3_step");
       return GNUNET_NO;
+
     default:
-      LOG_SQLITE (plugin,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_step");
+      LOG_SQLITE(plugin,
+                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                 "sqlite3_step");
       return GNUNET_SYSERR;
-  }
+    }
 }
 
 
@@ -448,108 +447,108 @@ namestore_sqlite_store_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
  */
 static int
-get_records_and_call_iterator (struct Plugin *plugin,
-                               sqlite3_stmt *stmt,
-                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                               uint64_t limit,
-                               GNUNET_NAMESTORE_RecordIterator iter,
-                               void *iter_cls)
+get_records_and_call_iterator(struct Plugin *plugin,
+                              sqlite3_stmt *stmt,
+                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                              uint64_t limit,
+                              GNUNET_NAMESTORE_RecordIterator iter,
+                              void *iter_cls)
 {
   int ret;
   int sret;
 
   ret = GNUNET_OK;
-  for (uint64_t i = 0;i<limit;i++)
-  {
-    sret = sqlite3_step (stmt);
-
-    if (SQLITE_DONE == sret)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Iteration done (no results)\n");
-      ret = GNUNET_NO;
-      break;
-    }
-    if (SQLITE_ROW != sret)
+  for (uint64_t i = 0; i < limit; i++)
     {
-      LOG_SQLITE (plugin,
-                  GNUNET_ERROR_TYPE_ERROR,
-                  "sqlite_step");
-      ret = GNUNET_SYSERR;
-      break;
-    }
-
-    {
-      uint64_t seq;
-      uint32_t record_count;
-      size_t data_size;
-      void *data;
-      char *label;
-      struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
-      struct GNUNET_SQ_ResultSpec rs[] = {
-        GNUNET_SQ_result_spec_uint64 (&seq),
-        GNUNET_SQ_result_spec_uint32 (&record_count),
-        GNUNET_SQ_result_spec_variable_size (&data,
-                                             &data_size),
-        GNUNET_SQ_result_spec_string (&label),
-        GNUNET_SQ_result_spec_end
-      };
-      struct GNUNET_SQ_ResultSpec rsx[] = {
-        GNUNET_SQ_result_spec_uint64 (&seq),
-        GNUNET_SQ_result_spec_uint32 (&record_count),
-        GNUNET_SQ_result_spec_variable_size (&data,
-                                             &data_size),
-        GNUNET_SQ_result_spec_string (&label),
-        GNUNET_SQ_result_spec_auto_from_type (&zk),
-        GNUNET_SQ_result_spec_end
-      };
-
-      ret = GNUNET_SQ_extract_result (stmt,
-                                      (NULL == zone_key)
-                                      ? rsx
-                                      : rs);
-      if ( (GNUNET_OK != ret) ||
-           (record_count > 64 * 1024) )
-      {
-        /* sanity check, don't stack allocate far too much just
-           because database might contain a large value here */
-        GNUNET_break (0);
-        ret = GNUNET_SYSERR;
-        break;
-      }
-      else
-      {
-        struct GNUNET_GNSRECORD_Data rd[record_count];
+      sret = sqlite3_step(stmt);
 
-        GNUNET_assert (0 != seq);
-        if (GNUNET_OK !=
-            GNUNET_GNSRECORD_records_deserialize (data_size,
-                                                  data,
-                                                  record_count,
-                                                  rd))
+      if (SQLITE_DONE == sret)
         {
-          GNUNET_break (0);
-          ret = GNUNET_SYSERR;
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Iteration done (no results)\n");
+          ret = GNUNET_NO;
           break;
         }
-        else
+      if (SQLITE_ROW != sret)
         {
-          if (NULL != zone_key)
-            zk = *zone_key;
-          if (NULL != iter)
-            iter (iter_cls,
-                  seq,
-                  &zk,
-                  label,
-                  record_count,
-                  rd);
+          LOG_SQLITE(plugin,
+                     GNUNET_ERROR_TYPE_ERROR,
+                     "sqlite_step");
+          ret = GNUNET_SYSERR;
+          break;
         }
+
+      {
+        uint64_t seq;
+        uint32_t record_count;
+        size_t data_size;
+        void *data;
+        char *label;
+        struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
+        struct GNUNET_SQ_ResultSpec rs[] = {
+          GNUNET_SQ_result_spec_uint64(&seq),
+          GNUNET_SQ_result_spec_uint32(&record_count),
+          GNUNET_SQ_result_spec_variable_size(&data,
+                                              &data_size),
+          GNUNET_SQ_result_spec_string(&label),
+          GNUNET_SQ_result_spec_end
+        };
+        struct GNUNET_SQ_ResultSpec rsx[] = {
+          GNUNET_SQ_result_spec_uint64(&seq),
+          GNUNET_SQ_result_spec_uint32(&record_count),
+          GNUNET_SQ_result_spec_variable_size(&data,
+                                              &data_size),
+          GNUNET_SQ_result_spec_string(&label),
+          GNUNET_SQ_result_spec_auto_from_type(&zk),
+          GNUNET_SQ_result_spec_end
+        };
+
+        ret = GNUNET_SQ_extract_result(stmt,
+                                       (NULL == zone_key)
+                                       ? rsx
+                                       : rs);
+        if ((GNUNET_OK != ret) ||
+            (record_count > 64 * 1024))
+          {
+            /* sanity check, don't stack allocate far too much just
+               because database might contain a large value here */
+            GNUNET_break(0);
+            ret = GNUNET_SYSERR;
+            break;
+          }
+        else
+          {
+            struct GNUNET_GNSRECORD_Data rd[record_count];
+
+            GNUNET_assert(0 != seq);
+            if (GNUNET_OK !=
+                GNUNET_GNSRECORD_records_deserialize(data_size,
+                                                     data,
+                                                     record_count,
+                                                     rd))
+              {
+                GNUNET_break(0);
+                ret = GNUNET_SYSERR;
+                break;
+              }
+            else
+              {
+                if (NULL != zone_key)
+                  zk = *zone_key;
+                if (NULL != iter)
+                  iter(iter_cls,
+                       seq,
+                       &zk,
+                       label,
+                       record_count,
+                       rd);
+              }
+          }
+        GNUNET_SQ_cleanup_result(rs);
       }
-      GNUNET_SQ_cleanup_result (rs);
     }
-  }
-  GNUNET_SQ_reset (plugin->dbh,
-                   stmt);
+  GNUNET_SQ_reset(plugin->dbh,
+                  stmt);
   return ret;
 }
 
@@ -565,40 +564,40 @@ get_records_and_call_iterator (struct Plugin *plugin,
  * @return #GNUNET_OK on success, #GNUNET_NO for no results, else #GNUNET_SYSERR
  */
 static int
-namestore_sqlite_lookup_records (void *cls,
-                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                 const char *label,
-                                 GNUNET_NAMESTORE_RecordIterator iter,
-                                 void *iter_cls)
+namestore_sqlite_lookup_records(void *cls,
+                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                                const char *label,
+                                GNUNET_NAMESTORE_RecordIterator iter,
+                                void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_auto_from_type (zone),
-    GNUNET_SQ_query_param_string (label),
+    GNUNET_SQ_query_param_auto_from_type(zone),
+    GNUNET_SQ_query_param_string(label),
     GNUNET_SQ_query_param_end
   };
 
   if (NULL == zone)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->lookup_label,
-                      params))
-  {
-    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                "sqlite3_bind_XXXX");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->lookup_label);
-    return GNUNET_SYSERR;
-  }
-  return get_records_and_call_iterator (plugin,
-                                        plugin->lookup_label,
-                                        zone,
-                                        1,
-                                        iter,
-                                        iter_cls);
+      GNUNET_SQ_bind(plugin->lookup_label,
+                     params))
+    {
+      LOG_SQLITE(plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                 "sqlite3_bind_XXXX");
+      GNUNET_SQ_reset(plugin->dbh,
+                      plugin->lookup_label);
+      return GNUNET_SYSERR;
+    }
+  return get_records_and_call_iterator(plugin,
+                                       plugin->lookup_label,
+                                       zone,
+                                       1,
+                                       iter,
+                                       iter_cls);
 }
 
 
@@ -615,57 +614,57 @@ namestore_sqlite_lookup_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
  */
 static int
-namestore_sqlite_iterate_records (void *cls,
-                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                                  uint64_t serial,
-                                  uint64_t limit,
-                                  GNUNET_NAMESTORE_RecordIterator iter,
-                                  void *iter_cls)
+namestore_sqlite_iterate_records(void *cls,
+                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                                 uint64_t serial,
+                                 uint64_t limit,
+                                 GNUNET_NAMESTORE_RecordIterator iter,
+                                 void *iter_cls)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
   int err;
 
   if (NULL == zone)
-  {
-    struct GNUNET_SQ_QueryParam params[] = {
-      GNUNET_SQ_query_param_uint64 (&serial),
-      GNUNET_SQ_query_param_uint64 (&limit),
-      GNUNET_SQ_query_param_end
-    };
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_uint64(&serial),
+        GNUNET_SQ_query_param_uint64(&limit),
+        GNUNET_SQ_query_param_end
+      };
 
-    stmt = plugin->iterate_all_zones;
-    err = GNUNET_SQ_bind (stmt,
-                          params);
-  }
+      stmt = plugin->iterate_all_zones;
+      err = GNUNET_SQ_bind(stmt,
+                           params);
+    }
   else
-  {
-    struct GNUNET_SQ_QueryParam params[] = {
-      GNUNET_SQ_query_param_auto_from_type (zone),
-      GNUNET_SQ_query_param_uint64 (&serial),
-      GNUNET_SQ_query_param_uint64 (&limit),
-      GNUNET_SQ_query_param_end
-    };
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_auto_from_type(zone),
+        GNUNET_SQ_query_param_uint64(&serial),
+        GNUNET_SQ_query_param_uint64(&limit),
+        GNUNET_SQ_query_param_end
+      };
 
-    stmt = plugin->iterate_zone;
-    err = GNUNET_SQ_bind (stmt,
-                          params);
-  }
+      stmt = plugin->iterate_zone;
+      err = GNUNET_SQ_bind(stmt,
+                           params);
+    }
   if (GNUNET_OK != err)
-  {
-    LOG_SQLITE (plugin,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                "sqlite3_bind_XXXX");
-    GNUNET_SQ_reset (plugin->dbh,
-                     stmt);
-    return GNUNET_SYSERR;
-  }
-  return get_records_and_call_iterator (plugin,
-                                        stmt,
-                                        zone,
-                                        limit,
-                                        iter,
-                                        iter_cls);
+    {
+      LOG_SQLITE(plugin,
+                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                 "sqlite3_bind_XXXX");
+      GNUNET_SQ_reset(plugin->dbh,
+                      stmt);
+      return GNUNET_SYSERR;
+    }
+  return get_records_and_call_iterator(plugin,
+                                       stmt,
+                                       zone,
+                                       limit,
+                                       iter,
+                                       iter_cls);
 }
 
 
@@ -681,39 +680,39 @@ namestore_sqlite_iterate_records (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
  */
 static int
-namestore_sqlite_zone_to_name (void *cls,
-                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                               const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
-                               GNUNET_NAMESTORE_RecordIterator iter,
-                               void *iter_cls)
+namestore_sqlite_zone_to_name(void *cls,
+                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                              const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
+                              GNUNET_NAMESTORE_RecordIterator iter,
+                              void *iter_cls)
 {
   struct Plugin *plugin = cls;
   struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_auto_from_type (zone),
-    GNUNET_SQ_query_param_auto_from_type (value_zone),
+    GNUNET_SQ_query_param_auto_from_type(zone),
+    GNUNET_SQ_query_param_auto_from_type(value_zone),
     GNUNET_SQ_query_param_end
   };
 
   if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->zone_to_name,
-                      params))
-  {
-    LOG_SQLITE (plugin,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                "sqlite3_bind_XXXX");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->zone_to_name);
-    return GNUNET_SYSERR;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Performing reverse lookup for `%s'\n",
-       GNUNET_GNSRECORD_z2s (value_zone));
-  return get_records_and_call_iterator (plugin,
-                                        plugin->zone_to_name,
-                                        zone,
-                                        1,
-                                        iter,
-                                        iter_cls);
+      GNUNET_SQ_bind(plugin->zone_to_name,
+                     params))
+    {
+      LOG_SQLITE(plugin,
+                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                 "sqlite3_bind_XXXX");
+      GNUNET_SQ_reset(plugin->dbh,
+                      plugin->zone_to_name);
+      return GNUNET_SYSERR;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Performing reverse lookup for `%s'\n",
+      GNUNET_GNSRECORD_z2s(value_zone));
+  return get_records_and_call_iterator(plugin,
+                                       plugin->zone_to_name,
+                                       zone,
+                                       1,
+                                       iter,
+                                       iter_cls);
 }
 
 
@@ -724,7 +723,7 @@ namestore_sqlite_zone_to_name (void *cls,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_namestore_sqlite_init (void *cls)
+libgnunet_plugin_namestore_sqlite_init(void *cls)
 {
   static struct Plugin plugin;
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
@@ -732,23 +731,23 @@ libgnunet_plugin_namestore_sqlite_init (void *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;
-  if (GNUNET_OK != database_setup (&plugin))
-  {
-    database_shutdown (&plugin);
-    return NULL;
-  }
-  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
+  if (GNUNET_OK != database_setup(&plugin))
+    {
+      database_shutdown(&plugin);
+      return NULL;
+    }
+  api = GNUNET_new(struct GNUNET_NAMESTORE_PluginFunctions);
   api->cls = &plugin;
   api->store_records = &namestore_sqlite_store_records;
   api->iterate_records = &namestore_sqlite_iterate_records;
   api->zone_to_name = &namestore_sqlite_zone_to_name;
   api->lookup_records = &namestore_sqlite_lookup_records;
-  LOG (GNUNET_ERROR_TYPE_INFO,
-       _("Sqlite database running\n"));
+  LOG(GNUNET_ERROR_TYPE_INFO,
+      _("Sqlite database running\n"));
   return api;
 }
 
@@ -760,16 +759,16 @@ libgnunet_plugin_namestore_sqlite_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_namestore_sqlite_done (void *cls)
+libgnunet_plugin_namestore_sqlite_done(void *cls)
 {
   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
 
-  database_shutdown (plugin);
+  database_shutdown(plugin);
   plugin->cfg = NULL;
-  GNUNET_free (api);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "sqlite plugin is finished\n");
+  GNUNET_free(api);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "sqlite plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/namestore/plugin_rest_namestore.c b/src/namestore/plugin_rest_namestore.c
index 1d8c180fb..42fbf8347 100644
--- a/src/namestore/plugin_rest_namestore.c
+++ b/src/namestore/plugin_rest_namestore.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 Philippe Buschmann
@@ -87,16 +87,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 default namestore ego
  */
-struct EgoEntry
-{
+struct EgoEntry {
   /**
    * DLL
    */
@@ -126,8 +124,7 @@ struct EgoEntry
 /**
  * The request handle
  */
-struct RequestHandle
-{
+struct RequestHandle {
   /**
    * Records to store
    */
@@ -244,61 +241,61 @@ struct RequestHandle
  * @param handle Handle to clean up
  */
 static void
-cleanup_handle (void *cls)
+cleanup_handle(void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct EgoEntry *ego_tmp;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
   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->record_name)
-    GNUNET_free (handle->record_name);
+    GNUNET_free(handle->record_name);
   if (NULL != handle->url)
-    GNUNET_free (handle->url);
+    GNUNET_free(handle->url);
   if (NULL != handle->emsg)
-    GNUNET_free (handle->emsg);
+    GNUNET_free(handle->emsg);
   if (NULL != handle->rd)
-  {
-    for (int i = 0; i < handle->rd_count; i++)
     {
-      if (NULL != handle->rd[i].data)
-        GNUNET_free ((void *) handle->rd[i].data);
+      for (int i = 0; i < handle->rd_count; i++)
+        {
+          if (NULL != handle->rd[i].data)
+            GNUNET_free((void *)handle->rd[i].data);
+        }
+      GNUNET_free(handle->rd);
     }
-    GNUNET_free (handle->rd);
-  }
   if (NULL != handle->timeout_task)
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
+    GNUNET_SCHEDULER_cancel(handle->timeout_task);
   if (NULL != handle->list_it)
-    GNUNET_NAMESTORE_zone_iteration_stop (handle->list_it);
+    GNUNET_NAMESTORE_zone_iteration_stop(handle->list_it);
   if (NULL != handle->add_qe)
-    GNUNET_NAMESTORE_cancel (handle->add_qe);
+    GNUNET_NAMESTORE_cancel(handle->add_qe);
   if (NULL != handle->identity_handle)
-    GNUNET_IDENTITY_disconnect (handle->identity_handle);
+    GNUNET_IDENTITY_disconnect(handle->identity_handle);
   if (NULL != handle->ns_handle)
-  {
-    GNUNET_NAMESTORE_disconnect (handle->ns_handle);
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(handle->ns_handle);
+    }
 
   for (ego_entry = handle->ego_head; NULL != ego_entry;)
-  {
-    ego_tmp = ego_entry;
-    ego_entry = ego_entry->next;
-    GNUNET_free (ego_tmp->identifier);
-    GNUNET_free (ego_tmp->keystring);
-    GNUNET_free (ego_tmp);
-  }
+    {
+      ego_tmp = ego_entry;
+      ego_entry = ego_entry->next;
+      GNUNET_free(ego_tmp->identifier);
+      GNUNET_free(ego_tmp->keystring);
+      GNUNET_free(ego_tmp);
+    }
 
   if (NULL != handle->resp_object)
-  {
-    json_decref (handle->resp_object);
-  }
+    {
+      json_decref(handle->resp_object);
+    }
 
-  GNUNET_free (handle);
+  GNUNET_free(handle);
 }
 
 
@@ -308,26 +305,26 @@ 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->emsg)
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_ERROR_UNKNOWN);
+    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_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);
 }
 
 
@@ -341,19 +338,20 @@ do_error (void *cls)
  * @return EgoEntry or NULL if not found
  */
 struct EgoEntry *
-get_egoentry_namestore (struct RequestHandle *handle, char *name)
+get_egoentry_namestore(struct RequestHandle *handle, char *name)
 {
   struct EgoEntry *ego_entry;
+
   if (NULL != name)
-  {
-    for (ego_entry = handle->ego_head; NULL != ego_entry;
-         ego_entry = ego_entry->next)
     {
-      if (0 != strcasecmp (name, ego_entry->identifier))
-        continue;
-      return ego_entry;
+      for (ego_entry = handle->ego_head; NULL != ego_entry;
+           ego_entry = ego_entry->next)
+        {
+          if (0 != strcasecmp(name, ego_entry->identifier))
+            continue;
+          return ego_entry;
+        }
     }
-  }
   return NULL;
 }
 
@@ -364,11 +362,12 @@ get_egoentry_namestore (struct RequestHandle *handle, char *name)
  * @param cls the `struct RequestHandle`
  */
 static void
-namestore_iteration_error (void *cls)
+namestore_iteration_error(void *cls)
 {
   struct RequestHandle *handle = cls;
-  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-  GNUNET_SCHEDULER_add_now (&do_error, handle);
+
+  handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+  GNUNET_SCHEDULER_add_now(&do_error, handle);
   return;
 }
 
@@ -381,27 +380,27 @@ namestore_iteration_error (void *cls)
  * @param emsg the error message (can be NULL)
  */
 static void
-create_finished (void *cls, int32_t success, const char *emsg)
+create_finished(void *cls, int32_t success, const char *emsg)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
   handle->add_qe = NULL;
   if (GNUNET_YES != success)
-  {
-    if (NULL != emsg)
     {
-      handle->emsg = GNUNET_strdup (emsg);
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
+      if (NULL != emsg)
+        {
+          handle->emsg = GNUNET_strdup(emsg);
+          GNUNET_SCHEDULER_add_now(&do_error, handle);
+          return;
+        }
+      handle->emsg = GNUNET_strdup("Error storing records");
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
       return;
     }
-    handle->emsg = GNUNET_strdup ("Error storing records");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  resp = GNUNET_REST_create_response (NULL);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+  resp = GNUNET_REST_create_response(NULL);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
@@ -413,34 +412,34 @@ create_finished (void *cls, int32_t success, const char *emsg)
  * @param emsg the error message (can be NULL)
  */
 static void
-del_finished (void *cls, int32_t success, const char *emsg)
+del_finished(void *cls, int32_t success, const char *emsg)
 {
   struct RequestHandle *handle = cls;
 
   handle->add_qe = NULL;
   if (GNUNET_NO == success)
-  {
-    handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup ("No record found");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->response_code = MHD_HTTP_NOT_FOUND;
+      handle->emsg = GNUNET_strdup("No record found");
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
   if (GNUNET_SYSERR == success)
-  {
-    if (NULL != emsg)
     {
-      handle->emsg = GNUNET_strdup (emsg);
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
+      if (NULL != emsg)
+        {
+          handle->emsg = GNUNET_strdup(emsg);
+          GNUNET_SCHEDULER_add_now(&do_error, handle);
+          return;
+        }
+      handle->emsg = GNUNET_strdup("Deleting record failed");
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
       return;
     }
-    handle->emsg = GNUNET_strdup ("Deleting record failed");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->proc (handle->proc_cls,
-                GNUNET_REST_create_response (NULL),
-                MHD_HTTP_NO_CONTENT);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+  handle->proc(handle->proc_cls,
+               GNUNET_REST_create_response(NULL),
+               MHD_HTTP_NO_CONTENT);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
@@ -451,7 +450,7 @@ del_finished (void *cls, int32_t success, const char *emsg)
  * @param cls the `struct RequestHandle`
  */
 static void
-namestore_list_finished (void *cls)
+namestore_list_finished(void *cls)
 {
   struct RequestHandle *handle = cls;
   char *result_str;
@@ -460,14 +459,14 @@ namestore_list_finished (void *cls)
   handle->list_it = NULL;
 
   if (NULL == handle->resp_object)
-    handle->resp_object = json_array ();
-
-  result_str = json_dumps (handle->resp_object, 0);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
-  resp = GNUNET_REST_create_response (result_str);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free_non_null (result_str);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
+    handle->resp_object = json_array();
+
+  result_str = json_dumps(handle->resp_object, 0);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  resp = GNUNET_REST_create_response(result_str);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_free_non_null(result_str);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle, handle);
 }
 
 
@@ -477,22 +476,22 @@ namestore_list_finished (void *cls)
  * @param handle the RequestHandle
  */
 static void
-namestore_list_iteration (void *cls,
-                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                          const char *rname,
-                          unsigned int rd_len,
-                          const struct GNUNET_GNSRECORD_Data *rd)
+namestore_list_iteration(void *cls,
+                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                         const char *rname,
+                         unsigned int rd_len,
+                         const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RequestHandle *handle = cls;
   json_t *record_obj;
 
   if (NULL == handle->resp_object)
-    handle->resp_object = json_array ();
-  record_obj = GNUNET_JSON_from_gnsrecord (rname,
-                                           rd,
-                                           rd_len);
-  json_array_append_new (handle->resp_object, record_obj);
-  GNUNET_NAMESTORE_zone_iterator_next (handle->list_it, 1);
+    handle->resp_object = json_array();
+  record_obj = GNUNET_JSON_from_gnsrecord(rname,
+                                          rd,
+                                          rd_len);
+  json_array_append_new(handle->resp_object, record_obj);
+  GNUNET_NAMESTORE_zone_iterator_next(handle->list_it, 1);
 }
 
 
@@ -504,9 +503,9 @@ namestore_list_iteration (void *cls,
  * @param cls the RequestHandle
  */
 void
-namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
-               const char *url,
-               void *cls)
+namestore_get(struct GNUNET_REST_RequestHandle *con_handle,
+              const char *url,
+              void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -516,75 +515,77 @@ namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
   ego_entry = NULL;
 
   // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
-  {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-    ego_entry = get_egoentry_namestore (handle, egoname);
-
-    if (NULL == ego_entry)
+  if (strlen(GNUNET_REST_API_NS_NAMESTORE) < strlen(handle->url))
     {
-      handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
-      return;
+      egoname = &handle->url[strlen(GNUNET_REST_API_NS_NAMESTORE) + 1];
+      ego_entry = get_egoentry_namestore(handle, egoname);
+
+      if (NULL == ego_entry)
+        {
+          handle->response_code = MHD_HTTP_NOT_FOUND;
+          handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+          GNUNET_SCHEDULER_add_now(&do_error, handle);
+          return;
+        }
     }
-  }
   if (NULL != ego_entry)
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
 
   handle->list_it =
-    GNUNET_NAMESTORE_zone_iteration_start (handle->ns_handle,
-                                           handle->zone_pkey,
-                                           &namestore_iteration_error,
-                                           handle,
-                                           &namestore_list_iteration,
-                                           handle,
-                                           &namestore_list_finished,
-                                           handle);
+    GNUNET_NAMESTORE_zone_iteration_start(handle->ns_handle,
+                                          handle->zone_pkey,
+                                          &namestore_iteration_error,
+                                          handle,
+                                          &namestore_list_iteration,
+                                          handle,
+                                          &namestore_list_finished,
+                                          handle);
   if (NULL == handle->list_it)
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
 }
 
 
 static void
-ns_lookup_error_cb (void *cls)
+ns_lookup_error_cb(void *cls)
 {
   struct RequestHandle *handle = cls;
-  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-  GNUNET_SCHEDULER_add_now (&do_error, handle);
+
+  handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+  GNUNET_SCHEDULER_add_now(&do_error, handle);
 }
 
 
 static void
-ns_lookup_cb (void *cls,
-              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-              const char *label,
-              unsigned int rd_count,
-              const struct GNUNET_GNSRECORD_Data *rd)
+ns_lookup_cb(void *cls,
+             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+             const char *label,
+             unsigned int rd_count,
+             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_GNSRECORD_Data rd_new[rd_count + handle->rd_count];
+
   for (int i = 0; i < rd_count; i++)
     rd_new[i] = rd[i];
   for (int j = 0; j < handle->rd_count; j++)
     rd_new[rd_count + j] = handle->rd[j];
-  handle->add_qe = GNUNET_NAMESTORE_records_store (handle->ns_handle,
-                                                   handle->zone_pkey,
-                                                   handle->record_name,
-                                                   rd_count + handle->rd_count,
-                                                   rd_new,
-                                                   &create_finished,
-                                                   handle);
+  handle->add_qe = GNUNET_NAMESTORE_records_store(handle->ns_handle,
+                                                  handle->zone_pkey,
+                                                  handle->record_name,
+                                                  rd_count + handle->rd_count,
+                                                  rd_new,
+                                                  &create_finished,
+                                                  handle);
   if (NULL == handle->add_qe)
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
 }
 
 
@@ -596,9 +597,9 @@ ns_lookup_cb (void *cls,
  * @param cls the RequestHandle
  */
 void
-namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
-               const char *url,
-               void *cls)
+namestore_add(struct GNUNET_REST_RequestHandle *con_handle,
+              const char *url,
+              void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -609,67 +610,67 @@ namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
   char term_data[handle->rest_handle->data_size + 1];
 
   if (0 >= handle->rest_handle->data_size)
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DATA);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_NO_DATA);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
   term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy (term_data,
-                 handle->rest_handle->data,
-                 handle->rest_handle->data_size);
-  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
+  GNUNET_memcpy(term_data,
+                handle->rest_handle->data,
+                handle->rest_handle->data_size);
+  data_js = json_loads(term_data, JSON_DECODE_ANY, &err);
   struct GNUNET_JSON_Specification gnsspec[] =
-    {GNUNET_JSON_spec_gnsrecord (&handle->rd, &handle->rd_count, &handle->record_name), GNUNET_JSON_spec_end ()};
-  if (GNUNET_OK != GNUNET_JSON_parse (data_js, gnsspec, NULL, NULL))
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    json_decref (data_js);
-    return;
-  }
-  GNUNET_JSON_parse_free (gnsspec);
-  if (0 >= strlen (handle->record_name))
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    json_decref (data_js);
-    return;
-  }
-  json_decref (data_js);
+  { GNUNET_JSON_spec_gnsrecord(&handle->rd, &handle->rd_count, &handle->record_name), GNUNET_JSON_spec_end() };
+  if (GNUNET_OK != GNUNET_JSON_parse(data_js, gnsspec, NULL, NULL))
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      json_decref(data_js);
+      return;
+    }
+  GNUNET_JSON_parse_free(gnsspec);
+  if (0 >= strlen(handle->record_name))
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      json_decref(data_js);
+      return;
+    }
+  json_decref(data_js);
 
   egoname = NULL;
   ego_entry = NULL;
 
   // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
-  {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-    ego_entry = get_egoentry_namestore (handle, egoname);
-
-    if (NULL == ego_entry)
+  if (strlen(GNUNET_REST_API_NS_NAMESTORE) < strlen(handle->url))
     {
-      handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
-      return;
+      egoname = &handle->url[strlen(GNUNET_REST_API_NS_NAMESTORE) + 1];
+      ego_entry = get_egoentry_namestore(handle, egoname);
+
+      if (NULL == ego_entry)
+        {
+          handle->response_code = MHD_HTTP_NOT_FOUND;
+          handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+          GNUNET_SCHEDULER_add_now(&do_error, handle);
+          return;
+        }
     }
-  }
   if (NULL != ego_entry)
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  handle->add_qe = GNUNET_NAMESTORE_records_lookup (handle->ns_handle,
-                                                    handle->zone_pkey,
-                                                    handle->record_name,
-                                                    &ns_lookup_error_cb,
-                                                    handle,
-                                                    &ns_lookup_cb,
-                                                    handle);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
+  handle->add_qe = GNUNET_NAMESTORE_records_lookup(handle->ns_handle,
+                                                   handle->zone_pkey,
+                                                   handle->record_name,
+                                                   &ns_lookup_error_cb,
+                                                   handle,
+                                                   &ns_lookup_cb,
+                                                   handle);
   if (NULL == handle->add_qe)
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
 }
 
 
@@ -681,9 +682,9 @@ namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
  * @param cls the RequestHandle
  */
 void
-namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
-                  const char *url,
-                  void *cls)
+namestore_delete(struct GNUNET_REST_RequestHandle *con_handle,
+                 const char *url,
+                 void *cls)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_HashCode key;
@@ -694,46 +695,46 @@ namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
   ego_entry = NULL;
 
   // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
-  {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-    ego_entry = get_egoentry_namestore (handle, egoname);
-
-    if (NULL == ego_entry)
+  if (strlen(GNUNET_REST_API_NS_NAMESTORE) < strlen(handle->url))
     {
-      handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
-      return;
+      egoname = &handle->url[strlen(GNUNET_REST_API_NS_NAMESTORE) + 1];
+      ego_entry = get_egoentry_namestore(handle, egoname);
+
+      if (NULL == ego_entry)
+        {
+          handle->response_code = MHD_HTTP_NOT_FOUND;
+          handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+          GNUNET_SCHEDULER_add_now(&do_error, handle);
+          return;
+        }
     }
-  }
   if (NULL != ego_entry)
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
 
-  GNUNET_CRYPTO_hash ("record_name", strlen ("record_name"), &key);
+  GNUNET_CRYPTO_hash("record_name", strlen("record_name"), &key);
   if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->record_name = GNUNET_strdup (
-    GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key));
-
-  handle->add_qe = GNUNET_NAMESTORE_records_store (handle->ns_handle,
-                                                   handle->zone_pkey,
-                                                   handle->record_name,
-                                                   0,
-                                                   NULL,
-                                                   &del_finished,
-                                                   handle);
+      GNUNET_CONTAINER_multihashmap_contains(con_handle->url_param_map, &key))
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+  handle->record_name = GNUNET_strdup(
+    GNUNET_CONTAINER_multihashmap_get(con_handle->url_param_map, &key));
+
+  handle->add_qe = GNUNET_NAMESTORE_records_store(handle->ns_handle,
+                                                  handle->zone_pkey,
+                                                  handle->record_name,
+                                                  0,
+                                                  NULL,
+                                                  &del_finished,
+                                                  handle);
   if (NULL == handle->add_qe)
-  {
-    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
 }
 
 
@@ -745,18 +746,18 @@ namestore_delete (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;
 }
 
@@ -767,22 +768,22 @@ 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_NAMESTORE, &namestore_get},
-     {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add},
-     {MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete},
-     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &options_cont},
-     GNUNET_REST_HANDLER_END};
+  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get },
+    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add },
+    { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete },
+    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &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);
+    }
 }
 
 
@@ -818,32 +819,32 @@ init_cont (struct RequestHandle *handle)
  *                   must thus no longer be used
  */
 static void
-id_connect_cb (void *cls,
-               struct GNUNET_IDENTITY_Ego *ego,
-               void **ctx,
-               const char *name)
+id_connect_cb(void *cls,
+              struct GNUNET_IDENTITY_Ego *ego,
+              void **ctx,
+              const char *name)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 
   if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
-  {
-    handle->state = ID_REST_STATE_POST_INIT;
-    init_cont (handle);
-    return;
-  }
+    {
+      handle->state = ID_REST_STATE_POST_INIT;
+      init_cont(handle);
+      return;
+    }
   if (ID_REST_STATE_INIT == handle->state)
-  {
-    ego_entry = GNUNET_new (struct EgoEntry);
-    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
-    ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
-    ego_entry->ego = ego;
-    GNUNET_asprintf (&ego_entry->identifier, "%s", name);
-    GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head,
-                                      handle->ego_tail,
-                                      ego_entry);
-  }
+    {
+      ego_entry = GNUNET_new(struct EgoEntry);
+      GNUNET_IDENTITY_ego_get_public_key(ego, &pk);
+      ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string(&pk);
+      ego_entry->ego = ego;
+      GNUNET_asprintf(&ego_entry->identifier, "%s", name);
+      GNUNET_CONTAINER_DLL_insert_tail(handle->ego_head,
+                                       handle->ego_tail,
+                                       ego_entry);
+    }
 }
 
 
@@ -859,11 +860,11 @@ id_connect_cb (void *cls,
  * @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_UNIT_FOREVER_REL;
@@ -872,18 +873,18 @@ rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
   handle->rest_handle = rest_handle;
   handle->zone_pkey = NULL;
 
-  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->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->ns_handle = GNUNET_NAMESTORE_connect (cfg);
+  handle->ns_handle = GNUNET_NAMESTORE_connect(cfg);
   handle->identity_handle =
-    GNUNET_IDENTITY_connect (cfg, &id_connect_cb, handle);
+    GNUNET_IDENTITY_connect(cfg, &id_connect_cb, handle);
   handle->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
+    GNUNET_SCHEDULER_add_delayed(handle->timeout, &do_error, handle);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 }
 
 
@@ -894,7 +895,7 @@ rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_rest_namestore_init (void *cls)
+libgnunet_plugin_rest_namestore_init(void *cls)
 {
   static struct Plugin plugin;
   struct GNUNET_REST_Plugin *api;
@@ -902,21 +903,21 @@ libgnunet_plugin_rest_namestore_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_NAMESTORE;
   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, _ ("Namestore 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, _("Namestore REST API initialized\n"));
   return api;
 }
 
@@ -928,15 +929,16 @@ libgnunet_plugin_rest_namestore_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_rest_namestore_done (void *cls)
+libgnunet_plugin_rest_namestore_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, "Namestore REST plugin is finished\n");
+  GNUNET_free_non_null(allow_methods);
+  GNUNET_free(api);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Namestore REST plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/namestore/test_common.c b/src/namestore/test_common.c
index 6d9761701..d88d1feb9 100644
--- a/src/namestore/test_common.c
+++ b/src/namestore/test_common.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 namestore/test_common.c
  * @brief common functions for testcase setup
@@ -26,36 +26,36 @@
  * test if we can load the plugin @a name.
  */
 static int
-TNC_test_plugin (const char *cfg_name)
+TNC_test_plugin(const char *cfg_name)
 {
   char *database;
   char *db_lib_name;
   struct GNUNET_NAMESTORE_PluginFunctions *db;
   struct GNUNET_CONFIGURATION_Handle *cfg;
 
-  cfg = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfg_name))
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return GNUNET_SYSERR;
-  }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                          "namestore",
-                                                          "database",
-                                                          &database))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database);
-  GNUNET_free (database);
-  db = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg);
+  cfg = GNUNET_CONFIGURATION_create();
+  if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg, cfg_name))
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return GNUNET_SYSERR;
+    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                         "namestore",
+                                                         "database",
+                                                         &database))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_asprintf(&db_lib_name, "libgnunet_plugin_namestore_%s", database);
+  GNUNET_free(database);
+  db = GNUNET_PLUGIN_load(db_lib_name, (void *)cfg);
   if (NULL != db)
-    GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, db));
-  GNUNET_free (db_lib_name);
-  GNUNET_CONFIGURATION_destroy (cfg);
+    GNUNET_break(NULL == GNUNET_PLUGIN_unload(db_lib_name, db));
+  GNUNET_free(db_lib_name);
+  GNUNET_CONFIGURATION_destroy(cfg);
   if (NULL == db)
     return GNUNET_NO;
   return GNUNET_YES;
@@ -68,13 +68,13 @@ TNC_test_plugin (const char *cfg_name)
  */
 #define SETUP_CFG(plugin_name, cfg_name)                                    \
   do                                                                        \
-  {                                                                         \
-    plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);    \
-    GNUNET_asprintf (&cfg_name, "test_namestore_api_%s.conf", plugin_name); \
-    if (! TNC_test_plugin (cfg_name))                                       \
-    {                                                                       \
-      GNUNET_free (cfg_name);                                               \
-      return 77;                                                            \
-    }                                                                       \
-    GNUNET_DISK_purge_cfg_dir (cfg_name, "GNUNET_TEST_HOME");               \
-  } while (0)
+    {                                                                         \
+      plugin_name = GNUNET_TESTING_get_testname_from_underscore(argv[0]);    \
+      GNUNET_asprintf(&cfg_name, "test_namestore_api_%s.conf", plugin_name); \
+      if (!TNC_test_plugin(cfg_name))                                       \
+        {                                                                       \
+          GNUNET_free(cfg_name);                                               \
+          return 77;                                                            \
+        }                                                                       \
+      GNUNET_DISK_purge_cfg_dir(cfg_name, "GNUNET_TEST_HOME");               \
+    } while (0)
diff --git a/src/namestore/test_namestore_api_lookup_nick.c b/src/namestore/test_namestore_api_lookup_nick.c
index 392a2521d..130f9bc1e 100644
--- a/src/namestore/test_namestore_api_lookup_nick.c
+++ b/src/namestore/test_namestore_api_lookup_nick.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 namestore/test_namestore_api_lookup_nick.c
  * @brief testcase for namestore_api.c: NICK records
@@ -34,7 +34,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
 
@@ -55,20 +55,20 @@ static const char * name = "d";
 
 
 static void
-cleanup ()
+cleanup()
 {
-  GNUNET_free_non_null ((void *)rd_orig.data);
+  GNUNET_free_non_null((void *)rd_orig.data);
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -79,32 +79,32 @@ cleanup ()
  * @param tc scheduler context
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-lookup_it (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+lookup_it(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   nsqe = NULL;
   int c;
@@ -112,222 +112,221 @@ lookup_it (void *cls,
   int found_nick = GNUNET_NO;
 
   if (0 != GNUNET_memcmp(privkey, zone))
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-    return;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
   if (NULL == label)
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-    return;
-  }
-
-  if (0 != strcmp (label, name))
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-    return;
-  }
-
-  if (2 != rd_count)
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-    return;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
-  for (c = 0; c < rd_count; c++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
+  if (0 != strcmp(label, name))
     {
-      if (rd[c].data_size != strlen(TEST_NICK)+1)
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_PRIVATE))
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      if (0 != strcmp(rd[c].data, TEST_NICK))
-      {
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      found_nick = GNUNET_YES;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
     }
-    else
+
+  if (2 != rd_count)
     {
-      if (rd[c].record_type != TEST_RECORD_TYPE)
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      if (rd[c].data_size != TEST_RECORD_DATALEN)
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      if (0 != memcmp (rd[c].data, rd_orig.data, TEST_RECORD_DATALEN))
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      if (rd[c].flags != rd->flags)
-      {
-        GNUNET_break(0);
-        GNUNET_SCHEDULER_cancel (endbadly_task);
-        endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-        return;
-      }
-      found_record = GNUNET_YES;
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
     }
 
-  }
+  for (c = 0; c < rd_count; c++)
+    {
+      if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
+        {
+          if (rd[c].data_size != strlen(TEST_NICK) + 1)
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_PRIVATE))
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          if (0 != strcmp(rd[c].data, TEST_NICK))
+            {
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          found_nick = GNUNET_YES;
+        }
+      else
+        {
+          if (rd[c].record_type != TEST_RECORD_TYPE)
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          if (rd[c].data_size != TEST_RECORD_DATALEN)
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          if (0 != memcmp(rd[c].data, rd_orig.data, TEST_RECORD_DATALEN))
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          if (rd[c].flags != rd->flags)
+            {
+              GNUNET_break(0);
+              GNUNET_SCHEDULER_cancel(endbadly_task);
+              endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+              return;
+            }
+          found_record = GNUNET_YES;
+        }
+    }
 
   /* Done */
   if ((GNUNET_YES == found_nick) && (GNUNET_YES == found_record))
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-    GNUNET_SCHEDULER_add_now (&end, NULL );
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+      GNUNET_SCHEDULER_add_now(&end, NULL);
+    }
   else
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL );
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+    }
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   const char *name = cls;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   if (GNUNET_OK != success)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
   /* Lookup */
-  nsqe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                          privkey,
-                                          name,
-                                          &fail_cb,
-                                          NULL,
-                                          &lookup_it,
-                                          NULL);
+  nsqe = GNUNET_NAMESTORE_records_lookup(nsh,
+                                         privkey,
+                                         name,
+                                         &fail_cb,
+                                         NULL,
+                                         &lookup_it,
+                                         NULL);
 }
 
 
 static void
-nick_cont (void *cls, int32_t success, const char *emsg)
+nick_cont(void *cls, int32_t success, const char *emsg)
 {
   const char *name = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Nick added : %s\n",
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Nick added : %s\n",
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   rd_orig.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
   rd_orig.record_type = TEST_RECORD_TYPE;
   rd_orig.data_size = TEST_RECORD_DATALEN;
-  rd_orig.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd_orig.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd_orig.flags = 0;
-  memset ((char *) rd_orig.data, 'a', TEST_RECORD_DATALEN);
+  memset((char *)rd_orig.data, 'a', TEST_RECORD_DATALEN);
 
-  nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
-                                      1, &rd_orig, &put_cont, (void *) name);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, name,
+                                        1, &rd_orig, &put_cont, (void *)name);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-
-  nsqe = GNUNET_NAMESTORE_set_nick (nsh,
-                                    privkey,
-                                    TEST_NICK,
-                                    &nick_cont,
-                                    (void *) name);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+
+  nsqe = GNUNET_NAMESTORE_set_nick(nsh,
+                                   privkey,
+                                   TEST_NICK,
+                                   &nick_cont,
+                                   (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 }
 
 #include "test_common.c"
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-lookup-nick",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-lookup-nick",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_lookup_private.c b/src/namestore/test_namestore_api_lookup_private.c
index cf9bfc20c..a387720a0 100644
--- a/src/namestore/test_namestore_api_lookup_private.c
+++ b/src/namestore/test_namestore_api_lookup_private.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 namestore/test_namestore_api_store.c
  * @brief testcase for namestore_api.c: store a record
@@ -32,7 +32,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
 
@@ -51,19 +51,19 @@ static const char * name = "d";
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -73,152 +73,152 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   endbadly_task = NULL;
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-lookup_it (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+lookup_it(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   nsqe = NULL;
 
-  if (0 != GNUNET_memcmp (privkey,
-                   zone))
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+  if (0 != GNUNET_memcmp(privkey,
+                         zone))
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
 
   if (NULL == label)
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  if (0 != strcmp (label, name))
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  if (0 != strcmp(label, name))
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
   if (1 != rd_count)
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
   /* Done */
-  GNUNET_SCHEDULER_cancel (endbadly_task);
+  GNUNET_SCHEDULER_cancel(endbadly_task);
   endbadly_task = NULL;
-  GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   const char *name = cls;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   if (GNUNET_OK != success)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
   /* Lookup */
-  nsqe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                          privkey,
-                                          name,
-                                          &fail_cb,
-                                          NULL,
-                                          &lookup_it,
-                                          NULL);
+  nsqe = GNUNET_NAMESTORE_records_lookup(nsh,
+                                         privkey,
+                                         name,
+                                         &fail_cb,
+                                         NULL,
+                                         &lookup_it,
+                                         NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
 
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd.flags = 0;
-  memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         1,
-                                         &rd,
-                                         &put_cont,
-                                         (void *) name);
+  memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        1,
+                                        &rd,
+                                        &put_cont,
+                                        (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 
-  GNUNET_free ((void *)rd.data);
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -226,7 +226,7 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
@@ -234,16 +234,16 @@ main (int argc, char *argv[])
   SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-lookup-private",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-lookup-private",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_lookup_public.c b/src/namestore/test_namestore_api_lookup_public.c
index 460be0a18..01f07eb39 100644
--- a/src/namestore/test_namestore_api_lookup_public.c
+++ b/src/namestore/test_namestore_api_lookup_public.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 namestore/test_namestore_api.c
  * @brief testcase for namestore_api.c: store a record and perform a lookup
@@ -33,7 +33,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -54,24 +54,24 @@ static struct GNUNET_NAMECACHE_QueueEntry *ncqe;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != nch)
-  {
-    GNUNET_NAMECACHE_disconnect (nch);
-    nch = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_disconnect(nch);
+      nch = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -81,145 +81,145 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
   if (NULL != ncqe)
-  {
-    GNUNET_NAMECACHE_cancel (ncqe);
-    ncqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMECACHE_cancel(ncqe);
+      ncqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-rd_decrypt_cb (void *cls,
-               unsigned int rd_count,
-               const struct GNUNET_GNSRECORD_Data *rd)
+rd_decrypt_cb(void *cls,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   char rd_cmp_data[TEST_RECORD_DATALEN];
 
-  GNUNET_assert (1 == rd_count);
-  GNUNET_assert (NULL != rd);
+  GNUNET_assert(1 == rd_count);
+  GNUNET_assert(NULL != rd);
 
-  memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN);
+  memset(rd_cmp_data, 'a', TEST_RECORD_DATALEN);
 
-  GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type);
-  GNUNET_assert (TEST_RECORD_DATALEN == rd[0].data_size);
-  GNUNET_assert (0 == memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN));
+  GNUNET_assert(TEST_RECORD_TYPE == rd[0].record_type);
+  GNUNET_assert(TEST_RECORD_DATALEN == rd[0].data_size);
+  GNUNET_assert(0 == memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN));
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Block was decrypted successfully \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Block was decrypted successfully \n");
 
-        GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-name_lookup_proc (void *cls,
-                  const struct GNUNET_GNSRECORD_Block *block)
+name_lookup_proc(void *cls,
+                 const struct GNUNET_GNSRECORD_Block *block)
 {
   const char *name = cls;
 
   ncqe = NULL;
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
 
   if (endbadly_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
 
   if (NULL == block)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore returned no block\n"));
-    if (endbadly_task != NULL)
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task =  GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Namestore returned block, decrypting \n");
-  GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
-                &pubkey, name, &rd_decrypt_cb, (void *) name));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore returned no block\n"));
+      if (endbadly_task != NULL)
+        GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Namestore returned block, decrypting \n");
+  GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
+                                                            &pubkey, name, &rd_decrypt_cb, (void *)name));
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   const char *name = cls;
   struct GNUNET_HashCode derived_hash;
   struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   /* Create derived hash */
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
-  GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
+  GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash);
 
-  ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash,
-                                        &name_lookup_proc, (void *) name);
+  ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
+                                       &name_lookup_proc, (void *)name);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
   const char * name = "dummy.dummy.gnunet";
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
 
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd.flags = 0;
-  memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  nch = GNUNET_NAMECACHE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  GNUNET_break (NULL != nch);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
-                                      1, &rd, &put_cont, (void *) name);
+  memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  nch = GNUNET_NAMECACHE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  GNUNET_break(NULL != nch);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, name,
+                                        1, &rd, &put_cont, (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 
-  GNUNET_free ((void *)rd.data);
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -227,24 +227,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_lookup_shadow.c b/src/namestore/test_namestore_api_lookup_shadow.c
index 1938054d4..d25cdcdbb 100644
--- a/src/namestore/test_namestore_api_lookup_shadow.c
+++ b/src/namestore/test_namestore_api_lookup_shadow.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 namestore/test_namestore_api_lookup_shadow.c
  * @brief testcase for namestore_api.c: store a shadow record and perform a lookup
@@ -35,7 +35,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -56,24 +56,24 @@ static struct GNUNET_NAMECACHE_QueueEntry *ncqe;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != nch)
-  {
-    GNUNET_NAMECACHE_disconnect (nch);
-    nch = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_disconnect(nch);
+      nch = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -83,178 +83,178 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
   if (NULL != ncqe)
-  {
-    GNUNET_NAMECACHE_cancel (ncqe);
-    ncqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMECACHE_cancel(ncqe);
+      ncqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-rd_decrypt_cb (void *cls,
-               unsigned int rd_count,
-               const struct GNUNET_GNSRECORD_Data *rd)
+rd_decrypt_cb(void *cls,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   char rd_cmp_data[TEST_RECORD_DATALEN];
 
   if (1 != rd_count)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
   if (NULL == rd)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
-  memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN);
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
+  memset(rd_cmp_data, 'a', TEST_RECORD_DATALEN);
 
   if (TEST_RECORD_TYPE != rd[0].record_type)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
   if (TEST_RECORD_DATALEN != rd[0].data_size)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
-  if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
+  if (0 != memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
   if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
+      return;
+    }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Block was decrypted successfully \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Block was decrypted successfully \n");
 
-        GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-name_lookup_proc (void *cls,
-                  const struct GNUNET_GNSRECORD_Block *block)
+name_lookup_proc(void *cls,
+                 const struct GNUNET_GNSRECORD_Block *block)
 {
   const char *name = cls;
 
   ncqe = NULL;
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
 
   if (endbadly_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
 
   if (NULL == block)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore returned no block\n"));
-    if (endbadly_task != NULL)
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task =  GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Namestore returned block, decrypting \n");
-  GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
-                &pubkey, name, &rd_decrypt_cb, (void *) name));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore returned no block\n"));
+      if (endbadly_task != NULL)
+        GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Namestore returned block, decrypting \n");
+  GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
+                                                            &pubkey, name, &rd_decrypt_cb, (void *)name));
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   const char *name = cls;
   struct GNUNET_HashCode derived_hash;
   struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   /* Create derived hash */
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
-  GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
+  GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash);
 
-  ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash,
-                                        &name_lookup_proc, (void *) name);
+  ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
+                                       &name_lookup_proc, (void *)name);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
   const char * name = "dummy.dummy.gnunet";
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd.flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD;
-  memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  nch = GNUNET_NAMECACHE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  GNUNET_break (NULL != nch);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         1,
-                                         &rd,
-                                         &put_cont,
-                                         (void *) name);
+  memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  nch = GNUNET_NAMECACHE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  GNUNET_break(NULL != nch);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        1,
+                                        &rd,
+                                        &put_cont,
+                                        (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
-  GNUNET_free ((void *)rd.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -262,24 +262,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-lookup-shadow",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-lookup-shadow",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_lookup_shadow_filter.c b/src/namestore/test_namestore_api_lookup_shadow_filter.c
index 3d1dbfacf..d8d6b8a29 100644
--- a/src/namestore/test_namestore_api_lookup_shadow_filter.c
+++ b/src/namestore/test_namestore_api_lookup_shadow_filter.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 namestore/test_namestore_api_lookup_shadow_filter.c
  * @brief testcase for namestore_api.c: store a record with short expiration
@@ -37,8 +37,8 @@
 #define TEST_RECORD_DATA 'a'
 #define TEST_SHADOW_RECORD_DATA 'b'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
-#define EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
+#define EXPIRATION GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
 
@@ -70,24 +70,24 @@ static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != nch)
-  {
-    GNUNET_NAMECACHE_disconnect (nch);
-    nch = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_disconnect(nch);
+      nch = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -97,239 +97,240 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != delayed_lookup_task)
-  {
-    GNUNET_SCHEDULER_cancel (delayed_lookup_task);
-    delayed_lookup_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(delayed_lookup_task);
+      delayed_lookup_task = NULL;
+    }
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
   if (NULL != ncqe)
-  {
-    GNUNET_NAMECACHE_cancel (ncqe);
-    ncqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMECACHE_cancel(ncqe);
+      ncqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-rd_decrypt_cb (void *cls,
-               unsigned int rd_count,
-               const struct GNUNET_GNSRECORD_Data *rd)
+rd_decrypt_cb(void *cls,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data *expected_rd = cls;
   char rd_cmp_data[TEST_RECORD_DATALEN];
 
   if (1 != rd_count)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
-  if (NULL == rd)
-  {
-    GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    GNUNET_break (0);
-    return;
-  }
-  if (expected_rd == &records[0])
-  {
-    /* Expecting active record */
-    memset (rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
-    if (TEST_RECORD_TYPE != rd[0].record_type)
-    {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
-    }
-    if (TEST_RECORD_DATALEN != rd[0].data_size)
     {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
       return;
     }
-    if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
+  if (NULL == rd)
     {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      GNUNET_break(0);
       return;
     }
-    if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))
+  if (expected_rd == &records[0])
     {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
+      /* Expecting active record */
+      memset(rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
+      if (TEST_RECORD_TYPE != rd[0].record_type)
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (TEST_RECORD_DATALEN != rd[0].data_size)
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (0 != memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Block was decrypted successfully with active record\n");
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Block was decrypted successfully with active record\n");
-  }
   if (expected_rd == &records[1])
-  {
-    /* Expecting shadow record  but without shadow flag*/
-    memset (rd_cmp_data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
-    if (TEST_RECORD_TYPE != rd[0].record_type)
     {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
+      /* Expecting shadow record  but without shadow flag*/
+      memset(rd_cmp_data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
+      if (TEST_RECORD_TYPE != rd[0].record_type)
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (TEST_RECORD_DATALEN != rd[0].data_size)
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (0 != memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))
+        {
+          GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+          GNUNET_break(0);
+          return;
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 "Block was decrypted successfully with former shadow record \n");
+      GNUNET_SCHEDULER_add_now(&end, NULL);
     }
-    if (TEST_RECORD_DATALEN != rd[0].data_size)
-    {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
-    }
-    if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN))
-    {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
-    }
-    if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags))
-    {
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-      GNUNET_break (0);
-      return;
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Block was decrypted successfully with former shadow record \n");
-    GNUNET_SCHEDULER_add_now (&end, NULL );
-  }
 }
 
 
 static void
-name_lookup_active_proc (void *cls,
-                  const struct GNUNET_GNSRECORD_Block *block)
+name_lookup_active_proc(void *cls,
+                        const struct GNUNET_GNSRECORD_Block *block)
 {
   struct GNUNET_GNSRECORD_Data *expected_rd = cls;
-  GNUNET_assert (NULL != expected_rd);
+
+  GNUNET_assert(NULL != expected_rd);
 
   ncqe = NULL;
   ncqe_shadow = NULL;
   if (endbadly_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
 
   if (NULL == block)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore returned no block\n"));
-    if (endbadly_task != NULL)
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task =  GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Namestore returned block, decrypting \n");
-  GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
-                &pubkey, TEST_NAME, &rd_decrypt_cb, expected_rd));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore returned no block\n"));
+      if (endbadly_task != NULL)
+        GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Namestore returned block, decrypting \n");
+  GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
+                                                            &pubkey, TEST_NAME, &rd_decrypt_cb, expected_rd));
 }
 
 
 static void
-name_lookup_shadow (void *cls)
+name_lookup_shadow(void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Performing lookup for shadow record \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Performing lookup for shadow record \n");
   delayed_lookup_task = NULL;
-  ncqe_shadow = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash,
-      &name_lookup_active_proc, &records[1]);
+  ncqe_shadow = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
+                                              &name_lookup_active_proc, &records[1]);
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   nsqe = NULL;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              TEST_NAME,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             TEST_NAME,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
   /* Create derived hash */
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
-  GNUNET_GNSRECORD_query_from_public_key (&pubkey, TEST_NAME, &derived_hash);
-
-  if (0 == GNUNET_TIME_absolute_get_remaining(record_expiration).rel_value_us )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Test to too long to store records, cannot run test!\n");
-    GNUNET_SCHEDULER_add_now (&end, NULL );
-    return;
-  }
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
+  GNUNET_GNSRECORD_query_from_public_key(&pubkey, TEST_NAME, &derived_hash);
+
+  if (0 == GNUNET_TIME_absolute_get_remaining(record_expiration).rel_value_us)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Test to too long to store records, cannot run test!\n");
+      GNUNET_SCHEDULER_add_now(&end, NULL);
+      return;
+    }
   /* Lookup active record now */
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Performing lookup for active record \n");
-  ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash,
-                                        &name_lookup_active_proc, &records[0]);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Performing lookup for active record \n");
+  ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
+                                       &name_lookup_active_proc, &records[0]);
 
-  delayed_lookup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (EXPIRATION, 2), &name_lookup_shadow, NULL);
+  delayed_lookup_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(EXPIRATION, 2), &name_lookup_shadow, NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
-
-  record_expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(),
-                                                EXPIRATION);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
+
+  record_expiration = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
+                                               EXPIRATION);
   records[0].expiration_time = record_expiration.abs_value_us;
   records[0].record_type = TEST_RECORD_TYPE;
   records[0].data_size = TEST_RECORD_DATALEN;
-  records[0].data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  records[0].data = GNUNET_malloc(TEST_RECORD_DATALEN);
   records[0].flags = GNUNET_GNSRECORD_RF_NONE;
-  memset ((char *) records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
+  memset((char *)records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
 
   records[1].expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
   records[1].record_type = TEST_RECORD_TYPE;
   records[1].data_size = TEST_RECORD_DATALEN;
-  records[1].data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  records[1].data = GNUNET_malloc(TEST_RECORD_DATALEN);
   records[1].flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD;
-  memset ((char *) records[1].data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  nch = GNUNET_NAMECACHE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  GNUNET_break (NULL != nch);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, TEST_NAME,
-                                      2, records, &put_cont, NULL);
+  memset((char *)records[1].data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  nch = GNUNET_NAMECACHE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  GNUNET_break(NULL != nch);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, TEST_NAME,
+                                        2, records, &put_cont, NULL);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 
-  GNUNET_free ((void *) records[0].data);
-  GNUNET_free ((void *) records[1].data);
+  GNUNET_free((void *)records[0].data);
+  GNUNET_free((void *)records[1].data);
 }
 
 
@@ -337,24 +338,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-lookup-shadow-filter",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-lookup-shadow-filter",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_monitoring.c b/src/namestore/test_namestore_api_monitoring.c
index 8fbeb6479..f1ee980cc 100644
--- a/src/namestore/test_namestore_api_monitoring.c
+++ b/src/namestore/test_namestore_api_monitoring.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 namestore/test_namestore_api_monitoring.c
  * @brief testcase for zone monitoring functionality: monitor first, then add records
@@ -31,7 +31,7 @@
 
 
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle * nsh;
@@ -62,63 +62,63 @@ struct GNUNET_NAMESTORE_QueueEntry * ns_ops[3];
 
 
 static void
-do_shutdown ()
+do_shutdown()
 {
   if (NULL != zm)
-  {
-    GNUNET_NAMESTORE_zone_monitor_stop (zm);
-    zm = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_monitor_stop(zm);
+      zm = NULL;
+    }
   if (NULL != ns_ops[0])
-  {
-        GNUNET_NAMESTORE_cancel(ns_ops[0]);
-        ns_ops[0] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[0]);
+      ns_ops[0] = NULL;
+    }
   if (NULL != ns_ops[1])
-  {
-        GNUNET_NAMESTORE_cancel(ns_ops[1]);
-        ns_ops[1] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[1]);
+      ns_ops[1] = NULL;
+    }
   if (NULL != ns_ops[2])
-  {
-        GNUNET_NAMESTORE_cancel(ns_ops[2]);
-        ns_ops[2] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[2]);
+      ns_ops[2] = NULL;
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   GNUNET_free_non_null(s_name_1);
   GNUNET_free_non_null(s_name_2);
   GNUNET_free_non_null(s_name_3);
 
   if (s_rd_1 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (s_rd_2 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (s_rd_3 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
 
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (NULL != privkey2)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
 }
 
 
@@ -128,218 +128,218 @@ do_shutdown ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
-  do_shutdown ();
+  do_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  do_shutdown ();
+  do_shutdown();
   res = 0;
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-           const char *name,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+          const char *name,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   static int returned_records;
   static int fail = GNUNET_NO;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Comparing results name %s\n",
-              name);
-  if (0 != GNUNET_memcmp (zone_key,
-                   privkey))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Monitoring returned wrong zone key\n");
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  if (0 == strcmp (name, s_name_1))
-  {
-    if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Comparing results name %s\n",
+             name);
+  if (0 != GNUNET_memcmp(zone_key,
+                         privkey))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Monitoring returned wrong zone key\n");
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  if (0 == strcmp(name, s_name_1))
     {
-      GNUNET_break (0);
-        fail = GNUNET_YES;
+      if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+        {
+          GNUNET_break(0);
+          fail = GNUNET_YES;
+        }
     }
-  }
-  else if (0 == strcmp (name, s_name_2))
-  {
-    if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
+  else if (0 == strcmp(name, s_name_2))
     {
-      GNUNET_break (0);
-        fail = GNUNET_YES;
+      if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
+        {
+          GNUNET_break(0);
+          fail = GNUNET_YES;
+        }
     }
-  }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Invalid name %s\n",
-                name);
-    GNUNET_break (0);
-    fail = GNUNET_YES;
-  }
-  GNUNET_NAMESTORE_zone_monitor_next (zm,
-                                      1);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Invalid name %s\n",
+                 name);
+      GNUNET_break(0);
+      fail = GNUNET_YES;
+    }
+  GNUNET_NAMESTORE_zone_monitor_next(zm,
+                                     1);
   if (2 == ++returned_records)
-  {
-    if (endbadly_task != NULL)
     {
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-      endbadly_task = NULL;
+      if (endbadly_task != NULL)
+        {
+          GNUNET_SCHEDULER_cancel(endbadly_task);
+          endbadly_task = NULL;
+        }
+      if (GNUNET_YES == fail)
+        GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      else
+        GNUNET_SCHEDULER_add_now(&end, NULL);
     }
-    if (GNUNET_YES == fail)
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    else
-        GNUNET_SCHEDULER_add_now (&end, NULL);
-  }
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   static int c = 0;
   char *label = cls;
 
-  if (0 == strcmp (label, s_name_1))
+  if (0 == strcmp(label, s_name_1))
     ns_ops[0] = NULL;
-  else if (0 == strcmp (label, s_name_2))
+  else if (0 == strcmp(label, s_name_2))
     ns_ops[1] = NULL;
-  else if (0 == strcmp (label, s_name_3))
+  else if (0 == strcmp(label, s_name_3))
     ns_ops[2] = NULL;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Created record %u: `%s'\n",
-                c,
-                label);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Created record %u: `%s'\n",
+                 c,
+                 label);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create record `%s'\n",
-                label);
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly,
-                                              NULL);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create record `%s'\n",
+                 label);
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly,
+                                               NULL);
+    }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data *rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data, 'a', 50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data, 'a', 50);
+    }
   return rd;
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-sync_cb (void *cls)
+sync_cb(void *cls)
 {
   /* do nothing */
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   res = 1;
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
 
   /* Start monitoring */
-  zm = GNUNET_NAMESTORE_zone_monitor_start (cfg,
-                                            privkey,
-                                            GNUNET_YES,
-                                            &fail_cb,
-                                            NULL,
-                                            &zone_proc,
-                                            NULL,
-                                            &sync_cb,
-                                            NULL);
+  zm = GNUNET_NAMESTORE_zone_monitor_start(cfg,
+                                           privkey,
+                                           GNUNET_YES,
+                                           &fail_cb,
+                                           NULL,
+                                           &zone_proc,
+                                           NULL,
+                                           &sync_cb,
+                                           NULL);
   if (NULL == zm)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create zone monitor\n");
-    GNUNET_break (0);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &endbadly, NULL);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create zone monitor\n");
+      GNUNET_break(0);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, &endbadly, NULL);
   /* Connect to namestore */
-  nsh = GNUNET_NAMESTORE_connect (cfg);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
   if (NULL == nsh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connect to namestore\n");
-    GNUNET_break (0);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connect to namestore\n");
+      GNUNET_break(0);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
 
-  privkey2 = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey2 != NULL);
+  privkey2 = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey2 != NULL);
 
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
   /* name in different zone */
   GNUNET_asprintf(&s_name_3, "dummy3");
   s_rd_3 = create_record(1);
-  GNUNET_assert (NULL != (ns_ops[2] =
-                          GNUNET_NAMESTORE_records_store (nsh,
-                                                          privkey2,
-                                                          s_name_3,
-                                                          1,
-                                                          s_rd_3,
-                                                          &put_cont,
-                                                          s_name_3)));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 1\n");
+  GNUNET_assert(NULL != (ns_ops[2] =
+                           GNUNET_NAMESTORE_records_store(nsh,
+                                                          privkey2,
+                                                          s_name_3,
+                                                          1,
+                                                          s_rd_3,
+                                                          &put_cont,
+                                                          s_name_3)));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 1\n");
   GNUNET_asprintf(&s_name_1, "dummy1");
   s_rd_1 = create_record(1);
-  GNUNET_assert (NULL != (ns_ops[0] =
-                          GNUNET_NAMESTORE_records_store (nsh,
+  GNUNET_assert(NULL != (ns_ops[0] =
+                           GNUNET_NAMESTORE_records_store(nsh,
                                                           privkey,
                                                           s_name_1,
                                                           1,
@@ -348,11 +348,11 @@ run (void *cls,
                                                           s_name_1)));
 
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 2 \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created record 2 \n");
   GNUNET_asprintf(&s_name_2, "dummy2");
   s_rd_2 = create_record(1);
-  GNUNET_assert (NULL != (ns_ops[1] =
-                          GNUNET_NAMESTORE_records_store (nsh,
+  GNUNET_assert(NULL != (ns_ops[1] =
+                           GNUNET_NAMESTORE_records_store(nsh,
                                                           privkey,
                                                           s_name_2,
                                                           1,
@@ -366,25 +366,25 @@ run (void *cls,
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-monitoring",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-monitoring",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_monitoring_existing.c b/src/namestore/test_namestore_api_monitoring_existing.c
index e54046c85..97432b2a2 100644
--- a/src/namestore/test_namestore_api_monitoring_existing.c
+++ b/src/namestore/test_namestore_api_monitoring_existing.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 namestore/test_namestore_api_monitoring_existing.c
  * @brief testcase for zone monitoring functionality: add records first, then monitor
@@ -30,7 +30,7 @@
 #define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
 
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
 
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
@@ -67,311 +67,311 @@ struct GNUNET_NAMESTORE_QueueEntry * ns_ops[3];
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   endbadly_task = NULL;
-  GNUNET_break (0);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_break(0);
+  GNUNET_SCHEDULER_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != zm)
-  {
-    GNUNET_NAMESTORE_zone_monitor_stop (zm);
-    zm = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_monitor_stop(zm);
+      zm = NULL;
+    }
   if (NULL != ns_ops[0])
-  {
-    GNUNET_NAMESTORE_cancel(ns_ops[0]);
-    ns_ops[0] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[0]);
+      ns_ops[0] = NULL;
+    }
   if (NULL != ns_ops[1])
-  {
-    GNUNET_NAMESTORE_cancel(ns_ops[1]);
-    ns_ops[1] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[1]);
+      ns_ops[1] = NULL;
+    }
   if (NULL != ns_ops[2])
-  {
-    GNUNET_NAMESTORE_cancel(ns_ops[2]);
-    ns_ops[2] = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(ns_ops[2]);
+      ns_ops[2] = NULL;
+    }
   if (NULL != endbadly_task)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != s_rd_1)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (NULL != s_rd_2)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (NULL != s_rd_3)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (NULL != privkey2)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-           const char *name,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+          const char *name,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   static int returned_records;
   static int fail = GNUNET_NO;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Comparing results name %s\n",
-              name);
-  if (0 != GNUNET_memcmp (zone_key,
-                   privkey))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Monitoring returned wrong zone key\n");
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-
-  if (0 == strcmp (name,
-                   s_name_1))
-  {
-    if (GNUNET_YES !=
-        GNUNET_GNSRECORD_records_cmp (rd,
-                                      s_rd_1))
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Comparing results name %s\n",
+             name);
+  if (0 != GNUNET_memcmp(zone_key,
+                         privkey))
     {
-      GNUNET_break (0);
-      fail = GNUNET_YES;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Monitoring returned wrong zone key\n");
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
     }
-  }
-  else if (0 == strcmp (name,
-                        s_name_2))
-  {
-    if (GNUNET_YES !=
-        GNUNET_GNSRECORD_records_cmp (rd,
-                                      s_rd_2))
+
+  if (0 == strcmp(name,
+                  s_name_1))
     {
-      GNUNET_break (0);
-      fail = GNUNET_YES;
+      if (GNUNET_YES !=
+          GNUNET_GNSRECORD_records_cmp(rd,
+                                       s_rd_1))
+        {
+          GNUNET_break(0);
+          fail = GNUNET_YES;
+        }
+    }
+  else if (0 == strcmp(name,
+                       s_name_2))
+    {
+      if (GNUNET_YES !=
+          GNUNET_GNSRECORD_records_cmp(rd,
+                                       s_rd_2))
+        {
+          GNUNET_break(0);
+          fail = GNUNET_YES;
+        }
     }
-  }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Invalid name %s\n",
-                name);
-    GNUNET_break (0);
-    fail = GNUNET_YES;
-  }
-  GNUNET_NAMESTORE_zone_monitor_next (zm,
-                                      1);
-  if (2 == ++returned_records)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    if (GNUNET_YES == fail)
     {
-      GNUNET_break (0);
-      res = 1;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Invalid name %s\n",
+                 name);
+      GNUNET_break(0);
+      fail = GNUNET_YES;
     }
-    else
+  GNUNET_NAMESTORE_zone_monitor_next(zm,
+                                     1);
+  if (2 == ++returned_records)
     {
-      res = 0;
+      GNUNET_SCHEDULER_shutdown();
+      if (GNUNET_YES == fail)
+        {
+          GNUNET_break(0);
+          res = 1;
+        }
+      else
+        {
+          res = 0;
+        }
     }
-  }
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-sync_cb (void *cls)
+sync_cb(void *cls)
 {
   /* do nothing */
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   static int c = 0;
   const char *label = cls;
 
-  if (0 == strcmp (label,
-                   s_name_1))
+  if (0 == strcmp(label,
+                  s_name_1))
     ns_ops[0] = NULL;
-  else if (0 == strcmp (label,
-                        s_name_2))
+  else if (0 == strcmp(label,
+                       s_name_2))
     ns_ops[1] = NULL;
-  else if (0 == strcmp (label,
-                        s_name_3))
+  else if (0 == strcmp(label,
+                       s_name_3))
     ns_ops[2] = NULL;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Created record %u: `%s'\n",
-                c,
-                label);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Created record %u: `%s'\n",
+                 c,
+                 label);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to created records\n");
-    GNUNET_break (0);
-    res = 1;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-
-  if (3 == c)
-  {
-    /* Start monitoring */
-    zm = GNUNET_NAMESTORE_zone_monitor_start (cfg,
-                                              privkey,
-                                              GNUNET_YES,
-                                              &fail_cb,
-                                              NULL,
-                                              &zone_proc,
-                                              NULL,
-                                              &sync_cb,
-                                              NULL);
-    if (NULL == zm)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to create zone monitor\n");
-      GNUNET_break (0);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to created records\n");
+      GNUNET_break(0);
       res = 1;
-      GNUNET_SCHEDULER_shutdown ();
+      GNUNET_SCHEDULER_shutdown();
       return;
     }
-  }
+
+  if (3 == c)
+    {
+      /* Start monitoring */
+      zm = GNUNET_NAMESTORE_zone_monitor_start(cfg,
+                                               privkey,
+                                               GNUNET_YES,
+                                               &fail_cb,
+                                               NULL,
+                                               &zone_proc,
+                                               NULL,
+                                               &sync_cb,
+                                               NULL);
+      if (NULL == zm)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Failed to create zone monitor\n");
+          GNUNET_break(0);
+          res = 1;
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+    }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data *rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data,
-            'a',
-            50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data,
+             'a',
+             50);
+    }
   return rd;
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *mycfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *mycfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   res = 1;
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (NULL != privkey);
-  privkey2 = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (NULL != privkey2);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(NULL != privkey);
+  privkey2 = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(NULL != privkey2);
 
   cfg = mycfg;
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
   /* Connect to namestore */
-  nsh = GNUNET_NAMESTORE_connect (cfg);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
   if (NULL == nsh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Connect to namestore failed\n");
-    GNUNET_break (0);
-    endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly,
-                                              NULL);
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Connect to namestore failed\n");
+      GNUNET_break(0);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly,
+                                               NULL);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
   /* name in different zone */
   s_name_3 = "dummy3";
   s_rd_3 = create_record(1);
-  GNUNET_assert (NULL != (ns_ops[2] =
-                          GNUNET_NAMESTORE_records_store (nsh,
+  GNUNET_assert(NULL != (ns_ops[2] =
+                           GNUNET_NAMESTORE_records_store(nsh,
                                                           privkey2,
                                                           s_name_3,
                                                           1,
                                                           s_rd_3,
                                                           &put_cont,
-                                                          (void *) s_name_3)));
+                                                          (void *)s_name_3)));
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 1\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 1\n");
   s_name_1 = "dummy1";
-  s_rd_1 = create_record (1);
-  GNUNET_assert (NULL != (ns_ops[0] =
-                          GNUNET_NAMESTORE_records_store (nsh,
-                                                          privkey,
-                                                          s_name_1,
-                                                          1,
-                                                          s_rd_1,
-                                                          &put_cont,
-                                                          (void *) s_name_1)));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 2 \n");
+  s_rd_1 = create_record(1);
+  GNUNET_assert(NULL != (ns_ops[0] =
+                           GNUNET_NAMESTORE_records_store(nsh,
+                                                          privkey,
+                                                          s_name_1,
+                                                          1,
+                                                          s_rd_1,
+                                                          &put_cont,
+                                                          (void *)s_name_1)));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 2 \n");
   s_name_2 = "dummy2";
-  s_rd_2 = create_record (1);
-  GNUNET_assert (NULL != (ns_ops[1] =
-                          GNUNET_NAMESTORE_records_store (nsh,
+  s_rd_2 = create_record(1);
+  GNUNET_assert(NULL != (ns_ops[1] =
+                           GNUNET_NAMESTORE_records_store(nsh,
                                                           privkey,
                                                           s_name_2,
                                                           1,
                                                           s_rd_2,
                                                           &put_cont,
-                                                          (void *) s_name_2)));
+                                                          (void *)s_name_2)));
 }
 
 
@@ -379,26 +379,26 @@ run (void *cls,
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-monitoring-existing",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    GNUNET_break (0);
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-monitoring-existing",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      GNUNET_break(0);
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_remove.c b/src/namestore/test_namestore_api_remove.c
index 4c3d55efc..b2334667e 100644
--- a/src/namestore/test_namestore_api_remove.c
+++ b/src/namestore/test_namestore_api_remove.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 namestore/test_namestore_api.c
  * @brief testcase for namestore_api.c to: remove record
@@ -32,7 +32,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -51,19 +51,19 @@ static struct GNUNET_NAMESTORE_QueueEntry *nsqe;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -73,127 +73,127 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-remove_cont (void *cls,
-             int32_t success,
-             const char *emsg)
+remove_cont(void *cls,
+            int32_t success,
+            const char *emsg)
 {
   nsqe = NULL;
   if (GNUNET_YES != success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Records could not be removed: `%s'\n"),
-                emsg);
-    if (NULL != endbadly_task)
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task =  GNUNET_SCHEDULER_add_now (&endbadly,
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Records could not be removed: `%s'\n"),
+                 emsg);
+      if (NULL != endbadly_task)
+        GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly,
                                                NULL);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Records were removed, perform lookup\n");
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Records were removed, perform lookup\n");
   removed = GNUNET_YES;
   if (NULL != endbadly_task)
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-  GNUNET_SCHEDULER_add_now (&end, NULL);
+    GNUNET_SCHEDULER_cancel(endbadly_task);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   const char *name = cls;
 
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
   nsqe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    GNUNET_break (0);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Namestore could not store record: `%s'\n",
-                emsg);
-    if (endbadly_task != NULL)
-      GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task =  GNUNET_SCHEDULER_add_now (&endbadly, NULL);
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         0, NULL,
-                                         &remove_cont, (void *) name);
+    {
+      GNUNET_break(0);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Namestore could not store record: `%s'\n",
+                 emsg);
+      if (endbadly_task != NULL)
+        GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        0, NULL,
+                                        &remove_cont, (void *)name);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
   const char * name = "dummy.dummy.gnunet";
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
 
   removed = GNUNET_NO;
 
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd.flags = 0;
-  memset ((char *) rd.data,
-          'a',
-          TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         1,
-                                         &rd,
-                                         &put_cont,
-                                         (void *) name);
+  memset((char *)rd.data,
+         'a',
+         TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        1,
+                                        &rd,
+                                        &put_cont,
+                                        (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
-  GNUNET_free ((void *)rd.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -201,24 +201,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-remove",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-remove",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_remove_not_existing_record.c b/src/namestore/test_namestore_api_remove_not_existing_record.c
index c8110fe6b..fee06e3af 100644
--- a/src/namestore/test_namestore_api_remove_not_existing_record.c
+++ b/src/namestore/test_namestore_api_remove_not_existing_record.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 namestore/test_namestore_api_remove_not_existing_record.c
  * @brief testcase for namestore_api.c
@@ -31,7 +31,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -48,19 +48,19 @@ static struct GNUNET_NAMESTORE_QueueEntry *nsqe;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -70,85 +70,87 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
   nsqe = NULL;
   if (endbadly_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   switch (success)
-  {
+    {
     case GNUNET_NO:
       /* We expected GNUNET_NO, since record was not found */
-      GNUNET_SCHEDULER_add_now (&end, NULL);
+      GNUNET_SCHEDULER_add_now(&end, NULL);
       break;
+
     case GNUNET_OK:
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Namestore could remove non-existing record: `%s'\n",
-                  (NULL !=emsg) ? emsg : "");
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Namestore could remove non-existing record: `%s'\n",
+                 (NULL != emsg) ? emsg : "");
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
       break;
+
     case GNUNET_SYSERR:
     default:
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Namestore failed: `%s'\n",
-                  (NULL !=emsg) ? emsg : "");
-      GNUNET_SCHEDULER_add_now (&endbadly, NULL);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Namestore failed: `%s'\n",
+                 (NULL != emsg) ? emsg : "");
+      GNUNET_SCHEDULER_add_now(&endbadly, NULL);
       break;
-  }
+    }
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   const char * name = "dummy.dummy.gnunet";
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
-                                         0, NULL,
-                                         &put_cont, (void *) name);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, name,
+                                        0, NULL,
+                                        &put_cont, (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 }
 
 
@@ -156,24 +158,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-remove-non-existing-record",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-remove-non-existing-record",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_store.c b/src/namestore/test_namestore_api_store.c
index 0dbad8ce3..622227471 100644
--- a/src/namestore/test_namestore_api_store.c
+++ b/src/namestore/test_namestore_api_store.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 namestore/test_namestore_api_store.c
  * @brief testcase for namestore_api.c: store a record
@@ -32,7 +32,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -49,19 +49,19 @@ static struct GNUNET_NAMESTORE_QueueEntry *nsqe;
 
 
 static void
-cleanup ()
+cleanup()
 {
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -71,80 +71,80 @@ cleanup ()
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
-  cleanup ();
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
+  cleanup();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
-  cleanup ();
+  cleanup();
   res = 0;
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   const char *name = cls;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
-  GNUNET_SCHEDULER_cancel (endbadly_task);
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_SCHEDULER_cancel(endbadly_task);
   endbadly_task = NULL;
-  GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
   const char * name = "dummy.dummy.gnunet";
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly, NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly, NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
 
 
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
   rd.flags = 0;
-  memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         1,
-                                         &rd,
-                                         &put_cont,
-                                         (void *) name);
+  memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        1,
+                                        &rd,
+                                        &put_cont,
+                                        (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
-  GNUNET_free ((void *)rd.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -152,24 +152,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_store_update.c b/src/namestore/test_namestore_api_store_update.c
index b1c0770ae..5e9885b3e 100644
--- a/src/namestore/test_namestore_api_store_update.c
+++ b/src/namestore/test_namestore_api_store_update.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 namestore/test_namestore_api_store_update.c
  * @brief testcase for namestore_api.c: store a record, update it and perform a lookup
@@ -39,7 +39,7 @@
 
 #define TEST_RECORD_DATA2 'b'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -69,217 +69,217 @@ static const char *name = "dummy";
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
-  GNUNET_break (0);
+  GNUNET_break(0);
   endbadly_task = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != endbadly_task)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   if (NULL != nsqe)
-  {
-    GNUNET_NAMESTORE_cancel (nsqe);
-    nsqe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(nsqe);
+      nsqe = NULL;
+    }
   if (NULL != ncqe)
-  {
-    GNUNET_NAMECACHE_cancel (ncqe);
-    ncqe = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_cancel(ncqe);
+      ncqe = NULL;
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
   if (NULL != nch)
-  {
-    GNUNET_NAMECACHE_disconnect (nch);
-    nch = NULL;
-  }
+    {
+      GNUNET_NAMECACHE_disconnect(nch);
+      nch = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg);
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg);
 
 
 static void
-rd_decrypt_cb (void *cls,
-               unsigned int rd_count,
-               const struct GNUNET_GNSRECORD_Data *rd)
+rd_decrypt_cb(void *cls,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data rd_new;
 
-  GNUNET_assert (1 == rd_count);
-  GNUNET_assert (NULL != rd);
+  GNUNET_assert(1 == rd_count);
+  GNUNET_assert(NULL != rd);
 
   if (GNUNET_NO == update_performed)
-  {
-    char rd_cmp_data[TEST_RECORD_DATALEN];
-
-    memset (rd_cmp_data,
-            TEST_RECORD_DATA,
-            TEST_RECORD_DATALEN);
-    GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type);
-    GNUNET_assert (TEST_RECORD_DATALEN == rd[0].data_size);
-    GNUNET_assert (0 == memcmp (&rd_cmp_data,
+    {
+      char rd_cmp_data[TEST_RECORD_DATALEN];
+
+      memset(rd_cmp_data,
+             TEST_RECORD_DATA,
+             TEST_RECORD_DATALEN);
+      GNUNET_assert(TEST_RECORD_TYPE == rd[0].record_type);
+      GNUNET_assert(TEST_RECORD_DATALEN == rd[0].data_size);
+      GNUNET_assert(0 == memcmp(&rd_cmp_data,
                                 rd[0].data,
                                 TEST_RECORD_DATALEN));
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Block was decrypted successfully, updating record \n");
-
-    rd_new.flags = GNUNET_GNSRECORD_RF_NONE;
-    rd_new.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
-    rd_new.record_type = TEST_RECORD_TYPE;
-    rd_new.data_size = TEST_RECORD_DATALEN2;
-    rd_new.data = GNUNET_malloc (TEST_RECORD_DATALEN2);
-    memset ((char *) rd_new.data,
-            TEST_RECORD_DATA2,
-            TEST_RECORD_DATALEN2);
-
-    nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                           privkey,
-                                           name,
-                                           1,
-                                           &rd_new,
-                                           &put_cont,
-                                           (void *) name);
-    update_performed = GNUNET_YES;
-  }
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Block was decrypted successfully, updating record \n");
+
+      rd_new.flags = GNUNET_GNSRECORD_RF_NONE;
+      rd_new.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
+      rd_new.record_type = TEST_RECORD_TYPE;
+      rd_new.data_size = TEST_RECORD_DATALEN2;
+      rd_new.data = GNUNET_malloc(TEST_RECORD_DATALEN2);
+      memset((char *)rd_new.data,
+             TEST_RECORD_DATA2,
+             TEST_RECORD_DATALEN2);
+
+      nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                            privkey,
+                                            name,
+                                            1,
+                                            &rd_new,
+                                            &put_cont,
+                                            (void *)name);
+      update_performed = GNUNET_YES;
+    }
   else
-  {
-    char rd_cmp_data[TEST_RECORD_DATALEN2];
-
-    memset (rd_cmp_data,
-            TEST_RECORD_DATA2,
-            TEST_RECORD_DATALEN2);
-    GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type);
-    GNUNET_assert (TEST_RECORD_DATALEN2 == rd[0].data_size);
-    GNUNET_assert (0 == memcmp (&rd_cmp_data,
+    {
+      char rd_cmp_data[TEST_RECORD_DATALEN2];
+
+      memset(rd_cmp_data,
+             TEST_RECORD_DATA2,
+             TEST_RECORD_DATALEN2);
+      GNUNET_assert(TEST_RECORD_TYPE == rd[0].record_type);
+      GNUNET_assert(TEST_RECORD_DATALEN2 == rd[0].data_size);
+      GNUNET_assert(0 == memcmp(&rd_cmp_data,
                                 rd[0].data,
                                 TEST_RECORD_DATALEN2));
-    GNUNET_SCHEDULER_shutdown ();
-    res = 0;
-  }
+      GNUNET_SCHEDULER_shutdown();
+      res = 0;
+    }
 }
 
 
 static void
-name_lookup_proc (void *cls,
-                  const struct GNUNET_GNSRECORD_Block *block)
+name_lookup_proc(void *cls,
+                 const struct GNUNET_GNSRECORD_Block *block)
 {
   const char *name = cls;
 
   ncqe = NULL;
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
   if (NULL == block)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Namecache returned no block for `%s'\n"),
-                name);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Namecache returned block, decrypting \n");
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_GNSRECORD_block_decrypt (block,
-                                                 &pubkey,
-                                                 name,
-                                                 &rd_decrypt_cb,
-                                                 (void *) name));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namecache returned no block for `%s'\n"),
+                 name);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Namecache returned block, decrypting \n");
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_GNSRECORD_block_decrypt(block,
+                                               &pubkey,
+                                               name,
+                                               &rd_decrypt_cb,
+                                               (void *)name));
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   const char *name = cls;
   struct GNUNET_HashCode derived_hash;
 
   nsqe = NULL;
-  GNUNET_assert (NULL != cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_assert(NULL != cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
   /* Create derived hash */
-  GNUNET_GNSRECORD_query_from_private_key (privkey,
-                                           name,
-                                           &derived_hash);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Looking in namecache for `%s'\n",
-              GNUNET_h2s (&derived_hash));
-  ncqe = GNUNET_NAMECACHE_lookup_block (nch,
-                                        &derived_hash,
-                                        &name_lookup_proc, (void *) name);
+  GNUNET_GNSRECORD_query_from_private_key(privkey,
+                                          name,
+                                          &derived_hash);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Looking in namecache for `%s'\n",
+             GNUNET_h2s(&derived_hash));
+  ncqe = GNUNET_NAMECACHE_lookup_block(nch,
+                                       &derived_hash,
+                                       &name_lookup_proc, (void *)name);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_GNSRECORD_Data rd;
 
   update_performed = GNUNET_NO;
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
   rd.flags = GNUNET_GNSRECORD_RF_NONE;
   rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
   rd.record_type = TEST_RECORD_TYPE;
   rd.data_size = TEST_RECORD_DATALEN;
-  rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
-  memset ((char *) rd.data,
-          TEST_RECORD_DATA,
-          TEST_RECORD_DATALEN);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  nch = GNUNET_NAMECACHE_connect (cfg);
-  GNUNET_break (NULL != nch);
-  nsqe = GNUNET_NAMESTORE_records_store (nsh,
-                                         privkey,
-                                         name,
-                                         1,
-                                         &rd,
-                                         &put_cont,
-                                         (void *) name);
+  rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
+  memset((char *)rd.data,
+         TEST_RECORD_DATA,
+         TEST_RECORD_DATALEN);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  nch = GNUNET_NAMECACHE_connect(cfg);
+  GNUNET_break(NULL != nch);
+  nsqe = GNUNET_NAMESTORE_records_store(nsh,
+                                        privkey,
+                                        name,
+                                        1,
+                                        &rd,
+                                        &put_cont,
+                                        (void *)name);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
-  GNUNET_free ((void *)rd.data);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
+  GNUNET_free((void *)rd.data);
 }
 
 
@@ -287,25 +287,25 @@ run (void *cls,
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-store-update",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-store-update",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_zone_iteration.c b/src/namestore/test_namestore_api_zone_iteration.c
index 94331f89e..62686403a 100644
--- a/src/namestore/test_namestore_api_zone_iteration.c
+++ b/src/namestore/test_namestore_api_zone_iteration.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 namestore/test_namestore_api_zone_iteration.c
  * @brief testcase for zone iteration functionality: iterate all zones
@@ -30,7 +30,7 @@
 #define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
 
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle * nsh;
@@ -67,268 +67,268 @@ static struct GNUNET_GNSRECORD_Data *s_rd_3;
  * @param tc scheduler context
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   endbadly_task = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != zi)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zi);
-    zi = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zi);
+      zi = NULL;
+    }
   if (NULL != endbadly_task)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (NULL != privkey2)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
-  GNUNET_free_non_null (s_name_1);
-  GNUNET_free_non_null (s_name_2);
-  GNUNET_free_non_null (s_name_3);
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
+  GNUNET_free_non_null(s_name_1);
+  GNUNET_free_non_null(s_name_2);
+  GNUNET_free_non_null(s_name_3);
   if (NULL != s_rd_1)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (NULL != s_rd_2)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (NULL != s_rd_3)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
 }
 
 
 static void
-zone_end (void *cls)
+zone_end(void *cls)
 {
-  GNUNET_break (3 == returned_records);
+  GNUNET_break(3 == returned_records);
   if (3 == returned_records)
-  {
-    res = 0; /* Last iteraterator callback, we are done */
-    zi = NULL;
-  }
+    {
+      res = 0; /* Last iteraterator callback, we are done */
+      zi = NULL;
+    }
   else
     res = 1;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received last result, iteration done after receing %u results\n",
-              returned_records);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received last result, iteration done after receing %u results\n",
+             returned_records);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   int failed = GNUNET_NO;
 
-  GNUNET_assert (NULL != zone);
-  if (0 == GNUNET_memcmp (zone,
-                   privkey))
-  {
-    if (0 == strcmp (label, s_name_1))
+  GNUNET_assert(NULL != zone);
+  if (0 == GNUNET_memcmp(zone,
+                         privkey))
     {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+      if (0 == strcmp(label, s_name_1))
         {
-          failed = GNUNET_YES;
-          GNUNET_break (0);
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
+        }
+      else if (0 == strcmp(label, s_name_2))
+        {
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Received invalid record count\n");
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
         }
-      }
       else
-      {
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
-    }
-    else if (0 == strcmp (label, s_name_2))
-    {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
         {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Comparing result failed: got name `%s' for first zone\n",
+                     label);
           failed = GNUNET_YES;
-          GNUNET_break (0);
+          GNUNET_break(0);
         }
-      }
-      else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Received invalid record count\n");
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
     }
-    else
+  else if (0 == GNUNET_memcmp(zone,
+                              privkey2))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Comparing result failed: got name `%s' for first zone\n",
-                  label);
-      failed = GNUNET_YES;
-      GNUNET_break (0);
-    }
-  }
-  else if (0 == GNUNET_memcmp (zone,
-                        privkey2))
-  {
-    if (0 == strcmp (label, s_name_3))
-    {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
+      if (0 == strcmp(label, s_name_3))
         {
-          failed = GNUNET_YES;
-          GNUNET_break (0);
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Received invalid record count\n");
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
         }
-      }
       else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Received invalid record count\n");
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Comparing result failed: got name `%s' for first zone\n",
+                     label);
+          failed = GNUNET_YES;
+          GNUNET_break(0);
+        }
     }
-    else
+  else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Comparing result failed: got name `%s' for first zone\n",
-                  label);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received invalid zone\n");
       failed = GNUNET_YES;
-      GNUNET_break (0);
+      GNUNET_break(0);
     }
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received invalid zone\n");
-    failed = GNUNET_YES;
-    GNUNET_break (0);
-  }
 
   if (failed == GNUNET_NO)
-  {
-    returned_records ++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Telling namestore to send the next result\n");
-    GNUNET_NAMESTORE_zone_iterator_next (zi,
-                                         1);
-  }
+    {
+      returned_records++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Telling namestore to send the next result\n");
+      GNUNET_NAMESTORE_zone_iterator_next(zi,
+                                          1);
+    }
   else
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    res = 1;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      res = 1;
+    }
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   static int c = 0;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Created record %u \n",
-                c);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Created record %u \n",
+                 c);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to created records: `%s'\n",
-                emsg);
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    res = 1;
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to created records: `%s'\n",
+                 emsg);
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      res = 1;
+      return;
+    }
 
   if (c == 3)
-  {
-    res = 1;
-    returned_records = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "All records created, starting iteration over all zones \n");
-    zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                                NULL,
-                                                &fail_cb,
-                                                NULL,
-                                                &zone_proc,
-                                                NULL,
-                                                &zone_end,
-                                                NULL);
-    if (zi == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to create zone iterator\n");
-      GNUNET_break (0);
-      GNUNET_SCHEDULER_shutdown ();
       res = 1;
-      return;
+      returned_records = 0;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "All records created, starting iteration over all zones \n");
+      zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                                 NULL,
+                                                 &fail_cb,
+                                                 NULL,
+                                                 &zone_proc,
+                                                 NULL,
+                                                 &zone_end,
+                                                 NULL);
+      if (zi == NULL)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Failed to create zone iterator\n");
+          GNUNET_break(0);
+          GNUNET_SCHEDULER_shutdown();
+          res = 1;
+          return;
+        }
     }
-  }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data * rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data, 'a', 50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data, 'a', 50);
+    }
   return rd;
 }
 
@@ -339,128 +339,128 @@ create_record (unsigned int count)
  * start the actual tests by filling the zone.
  */
 static void
-empty_zone_proc (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                 const char *label,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+empty_zone_proc(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                const char *label,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
   if (NULL != zone)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected empty zone but received zone private key\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    res = 1;
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected empty zone but received zone private key\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      res = 1;
+      return;
+    }
   if ((NULL != label) || (NULL != rd) || (0 != rd_count))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected no zone content but received data\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    res = 1;
-    return;
-  }
-  GNUNET_assert (0);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected no zone content but received data\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      res = 1;
+      return;
+    }
+  GNUNET_assert(0);
 }
 
 
 static void
-empty_zone_end (void *cls)
+empty_zone_end(void *cls)
 {
   char *hostkey_file;
 
   zi = NULL;
-  GNUNET_asprintf (&hostkey_file,
-                   "zonefiles%s%s",
-                   DIR_SEPARATOR_STR,
-                   "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using zonekey file `%s' \n",
-              hostkey_file);
+  GNUNET_asprintf(&hostkey_file,
+                  "zonefiles%s%s",
+                  DIR_SEPARATOR_STR,
+                  "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using zonekey file `%s' \n",
+             hostkey_file);
   privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
-  GNUNET_free (hostkey_file);
-  GNUNET_assert (privkey != NULL);
-
-  GNUNET_asprintf (&hostkey_file,
-                   "zonefiles%s%s",
-                   DIR_SEPARATOR_STR,
-                   "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using zonekey file `%s' \n",
-              hostkey_file);
+  GNUNET_free(hostkey_file);
+  GNUNET_assert(privkey != NULL);
+
+  GNUNET_asprintf(&hostkey_file,
+                  "zonefiles%s%s",
+                  DIR_SEPARATOR_STR,
+                  "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using zonekey file `%s' \n",
+             hostkey_file);
   privkey2 = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
-  GNUNET_free (hostkey_file);
-  GNUNET_assert (privkey2 != NULL);
+  GNUNET_free(hostkey_file);
+  GNUNET_assert(privkey2 != NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
 
   GNUNET_asprintf(&s_name_1, "dummy1");
   s_rd_1 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey,
-                                  s_name_1,
-                                  1, s_rd_1,
-                                  &put_cont,
-                                  NULL);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 2 \n");
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey,
+                                 s_name_1,
+                                 1, s_rd_1,
+                                 &put_cont,
+                                 NULL);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 2 \n");
   GNUNET_asprintf(&s_name_2, "dummy2");
   s_rd_2 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey,
-                                  s_name_2,
-                                  1, s_rd_2,
-                                  &put_cont,
-                                  NULL);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey,
+                                 s_name_2,
+                                 1, s_rd_2,
+                                 &put_cont,
+                                 NULL);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
   /* name in different zone */
   GNUNET_asprintf(&s_name_3, "dummy3");
   s_rd_3 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey2,
-                                  s_name_3,
-                                  1,
-                                  s_rd_3,
-                                  &put_cont,
-                                  NULL);
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey2,
+                                 s_name_3,
+                                 1,
+                                 s_rd_3,
+                                 &put_cont,
+                                 NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
+
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
   /* first, iterate over empty namestore */
-  zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                              NULL,
-                                              &fail_cb,
-                                              NULL,
-                                              &empty_zone_proc,
-                                              nsh,
-                                              &empty_zone_end,
-                                              NULL);
+  zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                             NULL,
+                                             &fail_cb,
+                                             NULL,
+                                             &empty_zone_proc,
+                                             nsh,
+                                             &empty_zone_end,
+                                             NULL);
   if (NULL == zi)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create zone iterator\n");
-    GNUNET_break (0);
-    res = 1;
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create zone iterator\n");
+      GNUNET_break(0);
+      res = 1;
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
@@ -468,24 +468,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-zone-iteration",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-zone-iteration",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_zone_iteration_nick.c b/src/namestore/test_namestore_api_zone_iteration_nick.c
index 069c6d831..739e71c05 100644
--- a/src/namestore/test_namestore_api_zone_iteration_nick.c
+++ b/src/namestore/test_namestore_api_zone_iteration_nick.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 namestore/test_namestore_api_zone_iteration.c
  * @brief testcase for zone iteration functionality: iterate all zones
@@ -32,7 +32,7 @@
 #define ZONE_NICK_1 "nick1"
 #define ZONE_NICK_2 "nick2"
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle * nsh;
@@ -69,266 +69,266 @@ static struct GNUNET_NAMESTORE_QueueEntry *nsqe;
  * @param tc scheduler context
  */
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != zi)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zi);
-    zi = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zi);
+      zi = NULL;
+    }
   if (nsh != NULL)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
-  GNUNET_free_non_null (s_name_1);
-  GNUNET_free_non_null (s_name_2);
-  GNUNET_free_non_null (s_name_3);
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
+  GNUNET_free_non_null(s_name_1);
+  GNUNET_free_non_null(s_name_2);
+  GNUNET_free_non_null(s_name_3);
 
   if (s_rd_1 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (s_rd_2 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (s_rd_3 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
 
   if (privkey != NULL)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (privkey2 != NULL)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
 }
 
 
 static int
-check_zone_1 (const char *label, unsigned int rd_count,
-              const struct GNUNET_GNSRECORD_Data *rd)
+check_zone_1(const char *label, unsigned int rd_count,
+             const struct GNUNET_GNSRECORD_Data *rd)
 {
-  for (unsigned int c = 0; c< rd_count ; c++)
-  {
-    if ( (rd[c].record_type == GNUNET_GNSRECORD_TYPE_NICK) &&
-         (0 != strcmp (rd[c].data, ZONE_NICK_1)) )
+  for (unsigned int c = 0; c < rd_count; c++)
     {
-      GNUNET_break (0);
-      return GNUNET_YES;
+      if ((rd[c].record_type == GNUNET_GNSRECORD_TYPE_NICK) &&
+          (0 != strcmp(rd[c].data, ZONE_NICK_1)))
+        {
+          GNUNET_break(0);
+          return GNUNET_YES;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
 
 static int
-check_zone_2 (const char *label,
-              unsigned int rd_count,
-              const struct GNUNET_GNSRECORD_Data *rd)
+check_zone_2(const char *label,
+             unsigned int rd_count,
+             const struct GNUNET_GNSRECORD_Data *rd)
 {
-  for (unsigned int c = 0; c< rd_count ; c++)
-  {
-    if ( (rd[c].record_type == GNUNET_GNSRECORD_TYPE_NICK) &&
-         (0 != strcmp (rd[c].data, ZONE_NICK_2)) )
+  for (unsigned int c = 0; c < rd_count; c++)
     {
-      GNUNET_break (0);
-      return GNUNET_YES;
+      if ((rd[c].record_type == GNUNET_GNSRECORD_TYPE_NICK) &&
+          (0 != strcmp(rd[c].data, ZONE_NICK_2)))
+        {
+          GNUNET_break(0);
+          return GNUNET_YES;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
 
 static void
-zone_proc_end (void *cls)
+zone_proc_end(void *cls)
 {
   zi = NULL;
   res = 0;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received last result, iteration done after receing %u results\n",
-              returned_records);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received last result, iteration done after receing %u results\n",
+             returned_records);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   int failed = GNUNET_NO;
 
-  GNUNET_assert (NULL != zone);
-  if (0 == GNUNET_memcmp (zone, privkey))
-  {
-    failed = check_zone_1 (label, rd_count, rd);
-    if (GNUNET_YES == failed)
-      GNUNET_break (0);
-  }
-  else if (0 == GNUNET_memcmp (zone, privkey2))
-  {
-    failed = check_zone_2 (label, rd_count, rd);
-    if (GNUNET_YES == failed)
-      GNUNET_break (0);
-  }
+  GNUNET_assert(NULL != zone);
+  if (0 == GNUNET_memcmp(zone, privkey))
+    {
+      failed = check_zone_1(label, rd_count, rd);
+      if (GNUNET_YES == failed)
+        GNUNET_break(0);
+    }
+  else if (0 == GNUNET_memcmp(zone, privkey2))
+    {
+      failed = check_zone_2(label, rd_count, rd);
+      if (GNUNET_YES == failed)
+        GNUNET_break(0);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received invalid zone\n");
-    failed = GNUNET_YES;
-    GNUNET_break (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received invalid zone\n");
+      failed = GNUNET_YES;
+      GNUNET_break(0);
+    }
 
   if (failed == GNUNET_NO)
-  {
-    returned_records ++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Telling namestore to send the next result\n");
-    GNUNET_NAMESTORE_zone_iterator_next (zi,
-                                         1);
-  }
+    {
+      returned_records++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Telling namestore to send the next result\n");
+      GNUNET_NAMESTORE_zone_iterator_next(zi,
+                                          1);
+    }
   else
-  {
-    GNUNET_break (0);
-    res = 1;
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_break(0);
+      res = 1;
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   static int c = 0;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record %u \n", c);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created record %u \n", c);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to created records: `%s'\n",
-                emsg);
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to created records: `%s'\n",
+                 emsg);
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
 
   if (c == 3)
-  {
-    res = 1;
-    returned_records = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All records created, starting iteration over all zones \n");
-    zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                                NULL,
-                                                &fail_cb,
-                                                NULL,
-                                                &zone_proc,
-                                                NULL,
-                                                &zone_proc_end,
-                                                NULL);
-    if (zi == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to create zone iterator\n");
-      GNUNET_break (0);
-      GNUNET_SCHEDULER_shutdown ();
-      return;
+      res = 1;
+      returned_records = 0;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "All records created, starting iteration over all zones \n");
+      zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                                 NULL,
+                                                 &fail_cb,
+                                                 NULL,
+                                                 &zone_proc,
+                                                 NULL,
+                                                 &zone_proc_end,
+                                                 NULL);
+      if (zi == NULL)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to create zone iterator\n");
+          GNUNET_break(0);
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
     }
-  }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data * rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data, 'a', 50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data, 'a', 50);
+    }
   return rd;
 }
 
 
 static void
-nick_2_cont (void *cls,
-             int32_t success,
-             const char *emsg)
+nick_2_cont(void *cls,
+            int32_t success,
+            const char *emsg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Nick added : %s\n",
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Nick added : %s\n",
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
 
   GNUNET_asprintf(&s_name_1, "dummy1");
   s_rd_1 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh, privkey, s_name_1,
-                                  1, s_rd_1,
-                                  &put_cont, NULL);
+  GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_1,
+                                 1, s_rd_1,
+                                 &put_cont, NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 2 \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 2 \n");
   GNUNET_asprintf(&s_name_2, "dummy2");
   s_rd_2 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh, privkey, s_name_2,
-                                  1, s_rd_2, &put_cont, NULL);
+  GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_2,
+                                 1, s_rd_2, &put_cont, NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
 
   /* name in different zone */
   GNUNET_asprintf(&s_name_3, "dummy3");
   s_rd_3 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh, privkey2, s_name_3,
-                                  1, s_rd_3,
-                                  &put_cont, NULL);
+  GNUNET_NAMESTORE_records_store(nsh, privkey2, s_name_3,
+                                 1, s_rd_3,
+                                 &put_cont, NULL);
 }
 
 
 static void
-nick_1_cont (void *cls, int32_t success, const char *emsg)
+nick_1_cont(void *cls, int32_t success, const char *emsg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Nick 1 added : %s\n",
-              (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Nick 1 added : %s\n",
+             (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 
-  nsqe = GNUNET_NAMESTORE_set_nick (nsh, privkey2, ZONE_NICK_2, &nick_2_cont, &privkey2);
+  nsqe = GNUNET_NAMESTORE_set_nick(nsh, privkey2, ZONE_NICK_2, &nick_2_cont, &privkey2);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 }
 
 
@@ -338,70 +338,69 @@ nick_1_cont (void *cls, int32_t success, const char *emsg)
  * start the actual tests by filling the zone.
  */
 static void
-empty_zone_proc (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                 const char *label,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+empty_zone_proc(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                const char *label,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
 
   if (NULL != zone)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected empty zone but received zone private key\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected empty zone but received zone private key\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   if ((NULL != label) || (NULL != rd) || (0 != rd_count))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected no zone content but received data\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_assert (0);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected no zone content but received data\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_assert(0);
 }
 
 
 static void
-empty_zone_end (void *cls)
+empty_zone_end(void *cls)
 {
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
   zi = NULL;
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  privkey2 = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey2 != NULL);
-
-  nsqe = GNUNET_NAMESTORE_set_nick (nsh,
-                                    privkey,
-                                    ZONE_NICK_1,
-                                    &nick_1_cont,
-                                    &privkey);
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  privkey2 = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey2 != NULL);
+
+  nsqe = GNUNET_NAMESTORE_set_nick(nsh,
+                                   privkey,
+                                   ZONE_NICK_1,
+                                   &nick_1_cont,
+                                   &privkey);
   if (NULL == nsqe)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Namestore cannot store no block\n"));
-  }
-
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Namestore cannot store no block\n"));
+    }
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
   /* first, iterate over empty namestore */
   zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
-                                             NULL,
+                                             NULL,
                                              &fail_cb,
                                              NULL,
                                              &empty_zone_proc,
@@ -409,12 +408,12 @@ run (void *cls,
                                              &empty_zone_end,
                                              nsh);
   if (NULL == zi)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create zone iterator\n");
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create zone iterator\n");
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
@@ -422,24 +421,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-zone-iteration-nick",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-zone-iteration-nick",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
index e3c6d698a..924e1eb1e 100644
--- a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
+++ b/src/namestore/test_namestore_api_zone_iteration_specific_zone.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 namestore/test_namestore_api_zone_iteration_specific_zone.c
  * @brief testcase for zone iteration functionality: iterate over a specific zone
@@ -31,7 +31,7 @@
 #define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
 
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle * nsh;
@@ -67,246 +67,246 @@ static struct GNUNET_GNSRECORD_Data *s_rd_3;
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
   endbadly_task = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != zi)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zi);
-    zi = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zi);
+      zi = NULL;
+    }
   if (NULL != endbadly_task)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (NULL != privkey2)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
-  GNUNET_free_non_null (s_name_1);
-  GNUNET_free_non_null (s_name_2);
-  GNUNET_free_non_null (s_name_3);
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
+  GNUNET_free_non_null(s_name_1);
+  GNUNET_free_non_null(s_name_2);
+  GNUNET_free_non_null(s_name_3);
   if (s_rd_1 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (s_rd_2 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (s_rd_3 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
   if (nsh != NULL)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
   zi = NULL;
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   int failed = GNUNET_NO;
 
-  GNUNET_assert (NULL != zone);
-  if (0 == GNUNET_memcmp (zone,
-                   privkey))
-  {
-    if (0 == strcmp (label, s_name_1))
+  GNUNET_assert(NULL != zone);
+  if (0 == GNUNET_memcmp(zone,
+                         privkey))
     {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp (rd, s_rd_1))
+      if (0 == strcmp(label, s_name_1))
         {
-          failed = GNUNET_YES;
-          GNUNET_break (0);
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
+        }
+      else if (0 == strcmp(label, s_name_2))
+        {
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Received invalid record count\n");
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
         }
-      }
       else
-      {
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
-    }
-    else if (0 == strcmp (label, s_name_2))
-    {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
         {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Comparing result failed: got name `%s' for first zone\n",
+                     label);
           failed = GNUNET_YES;
-          GNUNET_break (0);
+          GNUNET_break(0);
         }
-      }
-      else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Received invalid record count\n");
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
     }
-    else
+  else if (0 == GNUNET_memcmp(zone, privkey2))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Comparing result failed: got name `%s' for first zone\n",
-                  label);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received data for not requested zone\n");
       failed = GNUNET_YES;
-      GNUNET_break (0);
+      GNUNET_break(0);
     }
-  }
-  else if (0 == GNUNET_memcmp (zone, privkey2))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received data for not requested zone\n");
-    failed = GNUNET_YES;
-    GNUNET_break (0);
-  }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received invalid zone\n");
-    failed = GNUNET_YES;
-    GNUNET_break (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received invalid zone\n");
+      failed = GNUNET_YES;
+      GNUNET_break(0);
+    }
   if (failed == GNUNET_NO)
-  {
-    returned_records ++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Telling namestore to send the next result\n");
-    GNUNET_NAMESTORE_zone_iterator_next (zi,
-                                         1);
-  }
+    {
+      returned_records++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Telling namestore to send the next result\n");
+      GNUNET_NAMESTORE_zone_iterator_next(zi,
+                                          1);
+    }
   else
-  {
-    GNUNET_break (0);
-    res = 2;
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_break(0);
+      res = 2;
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
 static void
-zone_proc_end (void *cls)
+zone_proc_end(void *cls)
 {
   zi = NULL;
-  GNUNET_break (2 == returned_records);
+  GNUNET_break(2 == returned_records);
   if (2 == returned_records)
-  {
-    res = 0; /* Last iteraterator callback, we are done */
-  }
+    {
+      res = 0; /* Last iteraterator callback, we are done */
+    }
   else
-  {
-    res = 1;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received last result, iteration done after receing %u results\n",
-              returned_records);
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      res = 1;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received last result, iteration done after receing %u results\n",
+             returned_records);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   static int c = 0;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Created record %u \n", c);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Created record %u \n", c);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to created records: `%s'\n",
-                emsg);
-    GNUNET_break (0);
-    res = 2;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-
-  if (c == 3)
-  {
-    res = 1;
-    returned_records = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "All records created, starting iteration over all zones \n");
-    zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
-                                               privkey,
-                                               &fail_cb,
-                                               NULL,
-                                               &zone_proc,
-                                               NULL,
-                                               &zone_proc_end,
-                                               NULL);
-    if (zi == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to create zone iterator\n");
-      GNUNET_break (0);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to created records: `%s'\n",
+                 emsg);
+      GNUNET_break(0);
       res = 2;
-      GNUNET_SCHEDULER_shutdown ();
+      GNUNET_SCHEDULER_shutdown();
       return;
     }
-  }
+
+  if (c == 3)
+    {
+      res = 1;
+      returned_records = 0;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "All records created, starting iteration over all zones \n");
+      zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                                 privkey,
+                                                 &fail_cb,
+                                                 NULL,
+                                                 &zone_proc,
+                                                 NULL,
+                                                 &zone_proc_end,
+                                                 NULL);
+      if (zi == NULL)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Failed to create zone iterator\n");
+          GNUNET_break(0);
+          res = 2;
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+    }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data *rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data, 'a', 50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data, 'a', 50);
+    }
   return rd;
 }
 
@@ -317,114 +317,114 @@ create_record (unsigned int count)
  * start the actual tests by filling the zone.
  */
 static void
-empty_zone_proc (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                 const char *label,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+empty_zone_proc(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                const char *label,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
   if (NULL != zone)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected empty zone but received zone private key\n"));
-    GNUNET_break (0);
-    res = 2;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected empty zone but received zone private key\n"));
+      GNUNET_break(0);
+      res = 2;
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   if ((NULL != label) || (NULL != rd) || (0 != rd_count))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected no zone content but received data\n"));
-    GNUNET_break (0);
-    res = 2;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_assert (0);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected no zone content but received data\n"));
+      GNUNET_break(0);
+      res = 2;
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_assert(0);
 }
 
 
 static void
-empty_zone_proc_end (void *cls)
+empty_zone_proc_end(void *cls)
 {
   zi = NULL;
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey != NULL);
-  privkey2 = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (privkey2 != NULL);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 1\n");
-  GNUNET_asprintf (&s_name_1,
-                   "dummy1");
-  s_rd_1 = create_record (1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey,
-                                  s_name_1,
-                                  1,
-                                  s_rd_1,
-                                  &put_cont,
-                                  NULL);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 2 \n");
-  GNUNET_asprintf (&s_name_2,
-                   "dummy2");
-  s_rd_2 = create_record (1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey,
-                                  s_name_2,
-                                  1,
-                                  s_rd_2,
-                                  &put_cont,
-                                  NULL);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey != NULL);
+  privkey2 = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(privkey2 != NULL);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 1\n");
+  GNUNET_asprintf(&s_name_1,
+                  "dummy1");
+  s_rd_1 = create_record(1);
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey,
+                                 s_name_1,
+                                 1,
+                                 s_rd_1,
+                                 &put_cont,
+                                 NULL);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 2 \n");
+  GNUNET_asprintf(&s_name_2,
+                  "dummy2");
+  s_rd_2 = create_record(1);
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey,
+                                 s_name_2,
+                                 1,
+                                 s_rd_2,
+                                 &put_cont,
+                                 NULL);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
 
   /* name in different zone */
-  GNUNET_asprintf (&s_name_3,
-                   "dummy3");
-  s_rd_3 = create_record (1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey2,
-                                  s_name_3,
-                                  1, s_rd_3,
-                                  &put_cont,
-                                  NULL);
+  GNUNET_asprintf(&s_name_3,
+                  "dummy3");
+  s_rd_3 = create_record(1);
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey2,
+                                 s_name_3,
+                                 1, s_rd_3,
+                                 &put_cont,
+                                 NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
   /* first, iterate over empty namestore */
-  zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                              NULL,
-                                              &fail_cb,
-                                              NULL,
-                                              &empty_zone_proc,
-                                              nsh,
-                                              &empty_zone_proc_end,
-                                              nsh);
+  zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                             NULL,
+                                             &fail_cb,
+                                             NULL,
+                                             &empty_zone_proc,
+                                             nsh,
+                                             &empty_zone_proc_end,
+                                             nsh);
   if (NULL == zi)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create zone iterator\n");
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create zone iterator\n");
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
@@ -432,24 +432,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-zone-iteration-specific-zone",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-zone-iteration-specific-zone",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_namestore_api_zone_iteration_stop.c b/src/namestore/test_namestore_api_zone_iteration_stop.c
index 28f424b23..89007c82c 100644
--- a/src/namestore/test_namestore_api_zone_iteration_stop.c
+++ b/src/namestore/test_namestore_api_zone_iteration_stop.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 namestore/test_namestore_api_zone_iteration_stop.c
  * @brief testcase for zone iteration functionality: stop iterating of zones
@@ -29,8 +29,8 @@
 
 #define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
-#define WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
+#define WAIT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2)
 
 static struct GNUNET_NAMESTORE_Handle * nsh;
 
@@ -63,257 +63,257 @@ static struct GNUNET_GNSRECORD_Data *s_rd_3;
  * @param cls handle to use to re-connect.
  */
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != zi)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (zi);
-    zi = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(zi);
+      zi = NULL;
+    }
   if (nsh != NULL)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
-  GNUNET_free_non_null (s_name_1);
-  GNUNET_free_non_null (s_name_2);
-  GNUNET_free_non_null (s_name_3);
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
+  GNUNET_free_non_null(s_name_1);
+  GNUNET_free_non_null(s_name_2);
+  GNUNET_free_non_null(s_name_3);
   if (s_rd_1 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_1->data);
-    GNUNET_free (s_rd_1);
-  }
+    {
+      GNUNET_free((void *)s_rd_1->data);
+      GNUNET_free(s_rd_1);
+    }
   if (s_rd_2 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_2->data);
-    GNUNET_free (s_rd_2);
-  }
+    {
+      GNUNET_free((void *)s_rd_2->data);
+      GNUNET_free(s_rd_2);
+    }
   if (s_rd_3 != NULL)
-  {
-    GNUNET_free ((void *)s_rd_3->data);
-    GNUNET_free (s_rd_3);
-  }
+    {
+      GNUNET_free((void *)s_rd_3->data);
+      GNUNET_free(s_rd_3);
+    }
   if (privkey != NULL)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (privkey2 != NULL)
-  {
-    GNUNET_free (privkey2);
-    privkey2 = NULL;
-  }
+    {
+      GNUNET_free(privkey2);
+      privkey2 = NULL;
+    }
 }
 
 
 static void
-delayed_end (void *cls)
+delayed_end(void *cls)
 {
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-fail_cb (void *cls)
+fail_cb(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-zone_proc (void *cls,
-           const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-           const char *label,
-           unsigned int rd_count,
-           const struct GNUNET_GNSRECORD_Data *rd)
+zone_proc(void *cls,
+          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+          const char *label,
+          unsigned int rd_count,
+          const struct GNUNET_GNSRECORD_Data *rd)
 {
   int failed = GNUNET_NO;
 
-  GNUNET_assert (NULL != zone);
-  if (0 == GNUNET_memcmp (zone, privkey))
-  {
-    if (0 == strcmp (label, s_name_1))
+  GNUNET_assert(NULL != zone);
+  if (0 == GNUNET_memcmp(zone, privkey))
     {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+      if (0 == strcmp(label, s_name_1))
         {
-          failed = GNUNET_YES;
-          GNUNET_break (0);
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
+        }
+      else if (0 == strcmp(label, s_name_2))
+        {
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Received invalid record count\n");
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
         }
-      }
       else
-      {
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
-    }
-    else if (0 == strcmp (label, s_name_2))
-    {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
         {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Comparing result failed: got name `%s' for first zone\n", label);
           failed = GNUNET_YES;
-          GNUNET_break (0);
+          GNUNET_break(0);
         }
-      }
-      else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Received invalid record count\n");
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
-    }
-    else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Comparing result failed: got name `%s' for first zone\n", label);
-      failed = GNUNET_YES;
-      GNUNET_break (0);
     }
-  }
-  else if (0 == GNUNET_memcmp (zone, privkey2))
-  {
-    if (0 == strcmp (label, s_name_3))
+  else if (0 == GNUNET_memcmp(zone, privkey2))
     {
-      if (rd_count == 1)
-      {
-        if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
+      if (0 == strcmp(label, s_name_3))
         {
-          failed = GNUNET_YES;
-          GNUNET_break (0);
+          if (rd_count == 1)
+            {
+              if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
+                {
+                  failed = GNUNET_YES;
+                  GNUNET_break(0);
+                }
+            }
+          else
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Received invalid record count\n");
+              failed = GNUNET_YES;
+              GNUNET_break(0);
+            }
         }
-      }
       else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Received invalid record count\n");
-        failed = GNUNET_YES;
-        GNUNET_break (0);
-      }
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Comparing result failed: got name `%s' for first zone\n", label);
+          failed = GNUNET_YES;
+          GNUNET_break(0);
+        }
     }
-    else
+  else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Comparing result failed: got name `%s' for first zone\n", label);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received invalid zone\n");
       failed = GNUNET_YES;
-      GNUNET_break (0);
+      GNUNET_break(0);
     }
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received invalid zone\n");
-    failed = GNUNET_YES;
-    GNUNET_break (0);
-  }
   if (failed == GNUNET_NO)
-  {
-    if (1 == returned_records)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Telling namestore to stop zone iteration\n");
-      GNUNET_NAMESTORE_zone_iteration_stop (zi);
-      zi = NULL;
-      res = 0;
-      GNUNET_SCHEDULER_add_delayed (WAIT,
-                                    &delayed_end,
-                                    NULL);
-      return;
+      if (1 == returned_records)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Telling namestore to stop zone iteration\n");
+          GNUNET_NAMESTORE_zone_iteration_stop(zi);
+          zi = NULL;
+          res = 0;
+          GNUNET_SCHEDULER_add_delayed(WAIT,
+                                       &delayed_end,
+                                       NULL);
+          return;
+        }
+      returned_records++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Telling namestore to send the next result\n");
+      GNUNET_NAMESTORE_zone_iterator_next(zi,
+                                          1);
     }
-    returned_records ++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Telling namestore to send the next result\n");
-    GNUNET_NAMESTORE_zone_iterator_next (zi,
-                                         1);
-  }
   else
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
 static void
-zone_proc_end (void *cls)
+zone_proc_end(void *cls)
 {
-  GNUNET_break (1 <= returned_records);
+  GNUNET_break(1 <= returned_records);
   if (1 >= returned_records)
     res = 1; /* Last iteraterator callback, we are done */
   else
     res = 0;
   zi = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received last result, iteration done after receing %u results\n",
-              returned_records);
-  GNUNET_SCHEDULER_add_now (&end, NULL);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received last result, iteration done after receing %u results\n",
+             returned_records);
+  GNUNET_SCHEDULER_add_now(&end, NULL);
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+put_cont(void *cls, int32_t success, const char *emsg)
 {
   static int c = 0;
 
   if (success == GNUNET_OK)
-  {
-    c++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record %u \n", c);
-  }
+    {
+      c++;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Created record %u \n", c);
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to created records: `%s'\n",
-                emsg);
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to created records: `%s'\n",
+                 emsg);
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
 
   if (c == 3)
-  {
-    res = 1;
-    returned_records = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "All records created, starting iteration over all zones \n");
-    zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                                NULL,
-                                                &fail_cb,
-                                                NULL,
-                                                &zone_proc,
-                                                NULL,
-                                                &zone_proc_end,
-                                                NULL);
-    if (zi == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to create zone iterator\n");
-      GNUNET_break (0);
-      GNUNET_SCHEDULER_shutdown ();
-      return;
+      res = 1;
+      returned_records = 0;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "All records created, starting iteration over all zones \n");
+      zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                                 NULL,
+                                                 &fail_cb,
+                                                 NULL,
+                                                 &zone_proc,
+                                                 NULL,
+                                                 &zone_proc_end,
+                                                 NULL);
+      if (zi == NULL)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Failed to create zone iterator\n");
+          GNUNET_break(0);
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
     }
-  }
 }
 
 
 static struct GNUNET_GNSRECORD_Data *
-create_record (unsigned int count)
+create_record(unsigned int count)
 {
   struct GNUNET_GNSRECORD_Data *rd;
 
-  rd = GNUNET_new_array (count,
-                         struct GNUNET_GNSRECORD_Data);
+  rd = GNUNET_new_array(count,
+                        struct GNUNET_GNSRECORD_Data);
   for (unsigned int c = 0; c < count; c++)
-  {
-    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us;
-    rd[c].record_type = TEST_RECORD_TYPE;
-    rd[c].data_size = 50;
-    rd[c].data = GNUNET_malloc(50);
-    rd[c].flags = 0;
-    memset ((char *) rd[c].data, 'a', 50);
-  }
+    {
+      rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
+      rd[c].record_type = TEST_RECORD_TYPE;
+      rd[c].data_size = 50;
+      rd[c].data = GNUNET_malloc(50);
+      rd[c].flags = 0;
+      memset((char *)rd[c].data, 'a', 50);
+    }
   return rd;
 }
 
@@ -324,86 +324,85 @@ create_record (unsigned int count)
  * start the actual tests by filling the zone.
  */
 static void
-empty_zone_proc (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                 const char *label,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+empty_zone_proc(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                const char *label,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
-
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
   if (NULL != zone)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected empty zone but received zone private key\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected empty zone but received zone private key\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   if ((NULL != label) || (NULL != rd) || (0 != rd_count))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Expected no zone content but received data\n"));
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_assert (0);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Expected no zone content but received data\n"));
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_assert(0);
 }
 
 
 static void
-empty_zone_proc_end (void *cls)
+empty_zone_proc_end(void *cls)
 {
   char *hostkey_file;
 
-  GNUNET_assert (nsh == cls);
+  GNUNET_assert(nsh == cls);
   zi = NULL;
   GNUNET_asprintf(&hostkey_file,
                   "zonefiles%s%s",
                   DIR_SEPARATOR_STR,
                   "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using zonekey file `%s' \n",
-              hostkey_file);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using zonekey file `%s' \n",
+             hostkey_file);
   privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
-  GNUNET_free (hostkey_file);
-  GNUNET_assert (privkey != NULL);
-
-  GNUNET_asprintf (&hostkey_file,
-                   "zonefiles%s%s",
-                   DIR_SEPARATOR_STR,
-                   "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using zonekey file `%s'\n",
-              hostkey_file);
+  GNUNET_free(hostkey_file);
+  GNUNET_assert(privkey != NULL);
+
+  GNUNET_asprintf(&hostkey_file,
+                  "zonefiles%s%s",
+                  DIR_SEPARATOR_STR,
+                  "HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Using zonekey file `%s'\n",
+             hostkey_file);
   privkey2 = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
-  GNUNET_free (hostkey_file);
-  GNUNET_assert (privkey2 != NULL);
+  GNUNET_free(hostkey_file);
+  GNUNET_assert(privkey2 != NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 1\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 1\n");
 
   GNUNET_asprintf(&s_name_1,
                   "dummy1");
   s_rd_1 = create_record(1);
   GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_1,
-                1, s_rd_1, &put_cont, NULL);
+                                 1, s_rd_1, &put_cont, NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 2 \n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 2 \n");
   GNUNET_asprintf(&s_name_2,
                   "dummy2");
   s_rd_2 = create_record(1);
-  GNUNET_NAMESTORE_records_store (nsh,
-                                  privkey,
-                                  s_name_2,
-                                  1,
-                                  s_rd_2,
-                                  &put_cont, NULL);
+  GNUNET_NAMESTORE_records_store(nsh,
+                                 privkey,
+                                 s_name_2,
+                                 1,
+                                 s_rd_2,
+                                 &put_cont, NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Created record 3\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Created record 3\n");
 
   /* name in different zone */
   GNUNET_asprintf(&s_name_3, "dummy3");
@@ -418,30 +417,30 @@ empty_zone_proc_end (void *cls)
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
+  nsh = GNUNET_NAMESTORE_connect(cfg);
+  GNUNET_break(NULL != nsh);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
   /* first, iterate over empty namestore */
-  zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                              NULL,
-                                              &fail_cb,
-                                              NULL,
-                                              &empty_zone_proc,
-                                              nsh,
-                                              &empty_zone_proc_end,
-                                              nsh);
+  zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                             NULL,
+                                             &fail_cb,
+                                             NULL,
+                                             &empty_zone_proc,
+                                             nsh,
+                                             &empty_zone_proc_end,
+                                             nsh);
   if (NULL == zi)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to create zone iterator\n");
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to create zone iterator\n");
+      GNUNET_break(0);
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 
 
@@ -449,24 +448,24 @@ run (void *cls,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  SETUP_CFG (plugin_name, cfg_name);
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-zone-iteration-stop",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-zone-iteration-stop",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
 
   return res;
 }
diff --git a/src/namestore/test_namestore_api_zone_to_name.c b/src/namestore/test_namestore_api_zone_to_name.c
index cb580572e..0c02c9a52 100644
--- a/src/namestore/test_namestore_api_zone_to_name.c
+++ b/src/namestore/test_namestore_api_zone_to_name.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 namestore/test_namestore_api_zone_to_name.c
  * @brief testcase for zone to name translation
@@ -35,7 +35,7 @@
 
 #define TEST_RECORD_DATA 'a'
 
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
 
 
 static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -61,180 +61,180 @@ static struct GNUNET_NAMESTORE_QueueEntry *qe;
  * @param cls handle to use to re-connect.
  */
 static void
-endbadly (void *cls)
+endbadly(void *cls)
 {
-  (void) cls;
-  GNUNET_SCHEDULER_shutdown ();
+  (void)cls;
+  GNUNET_SCHEDULER_shutdown();
   res = 1;
 }
 
 
 static void
-end (void *cls)
+end(void *cls)
 {
   if (NULL != qe)
-  {
-    GNUNET_NAMESTORE_cancel (qe);
-    qe = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_cancel(qe);
+      qe = NULL;
+    }
   if (NULL != endbadly_task)
-  {
-    GNUNET_SCHEDULER_cancel (endbadly_task);
-    endbadly_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(endbadly_task);
+      endbadly_task = NULL;
+    }
   if (NULL != privkey)
-  {
-    GNUNET_free (privkey);
-    privkey = NULL;
-  }
+    {
+      GNUNET_free(privkey);
+      privkey = NULL;
+    }
   if (NULL != nsh)
-  {
-    GNUNET_NAMESTORE_disconnect (nsh);
-    nsh = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(nsh);
+      nsh = NULL;
+    }
 }
 
 
 static void
-zone_to_name_proc (void *cls,
-                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                   const char *n,
-                   unsigned int rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd)
+zone_to_name_proc(void *cls,
+                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                  const char *n,
+                  unsigned int rd_count,
+                  const struct GNUNET_GNSRECORD_Data *rd)
 {
   int fail = GNUNET_NO;
 
   qe = NULL;
-  if ( (NULL == zone_key) &&
-       (NULL == n) &&
-       (0 == rd_count) &&
-       (NULL == rd) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "No result found\n");
-    res = 1;
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Result found: `%s'\n",
-                n);
-    if ( (NULL == n) ||
-         (0 != strcmp (n,
-                       s_name)))
+  if ((NULL == zone_key) &&
+      (NULL == n) &&
+      (0 == rd_count) &&
+      (NULL == rd))
     {
-      fail = GNUNET_YES;
-      GNUNET_break (0);
-    }
-    if (1 != rd_count)
-    {
-      fail = GNUNET_YES;
-      GNUNET_break (0);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "No result found\n");
+      res = 1;
     }
-    if ( (NULL == zone_key) ||
-         (0 != GNUNET_memcmp (zone_key,
-                       privkey)))
+  else
     {
-      fail = GNUNET_YES;
-      GNUNET_break (0);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Result found: `%s'\n",
+                 n);
+      if ((NULL == n) ||
+          (0 != strcmp(n,
+                       s_name)))
+        {
+          fail = GNUNET_YES;
+          GNUNET_break(0);
+        }
+      if (1 != rd_count)
+        {
+          fail = GNUNET_YES;
+          GNUNET_break(0);
+        }
+      if ((NULL == zone_key) ||
+          (0 != GNUNET_memcmp(zone_key,
+                              privkey)))
+        {
+          fail = GNUNET_YES;
+          GNUNET_break(0);
+        }
+      if (fail == GNUNET_NO)
+        res = 0;
+      else
+        res = 1;
     }
-    if (fail == GNUNET_NO)
-      res = 0;
-    else
-      res = 1;
-  }
-  GNUNET_SCHEDULER_add_now (&end,
-                            NULL);
+  GNUNET_SCHEDULER_add_now(&end,
+                           NULL);
 }
 
 
 static void
-error_cb (void *cls)
+error_cb(void *cls)
 {
-  (void) cls;
+  (void)cls;
   qe = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Not found!\n");
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Not found!\n");
+  GNUNET_SCHEDULER_shutdown();
   res = 2;
 }
 
 
 static void
-put_cont (void *cls,
-          int32_t success,
-          const char *emsg)
+put_cont(void *cls,
+         int32_t success,
+         const char *emsg)
 {
   char *name = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Name store added record for `%s': %s\n",
-              name,
-              (success == GNUNET_OK) ? "SUCCESS" : emsg);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Name store added record for `%s': %s\n",
+             name,
+             (success == GNUNET_OK) ? "SUCCESS" : emsg);
   if (success == GNUNET_OK)
-  {
-    res = 0;
-
-    qe = GNUNET_NAMESTORE_zone_to_name (nsh,
-                                        privkey,
-                                        &s_zone_value,
-                                        &error_cb,
-                                        NULL,
-                                        &zone_to_name_proc,
-                                        NULL);
-  }
+    {
+      res = 0;
+
+      qe = GNUNET_NAMESTORE_zone_to_name(nsh,
+                                         privkey,
+                                         &s_zone_value,
+                                         &error_cb,
+                                         NULL,
+                                         &zone_to_name_proc,
+                                         NULL);
+    }
   else
-  {
-    res = 1;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to put records for name `%s'\n",
-                name);
-    GNUNET_SCHEDULER_add_now (&end,
-                              NULL);
-  }
+    {
+      res = 1;
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to put records for name `%s'\n",
+                 name);
+      GNUNET_SCHEDULER_add_now(&end,
+                               NULL);
+    }
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
-  (void) cls;
-  (void) peer;
-  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                &endbadly,
-                                                NULL);
-  GNUNET_SCHEDULER_add_shutdown (&end,
-                                 NULL);
-  GNUNET_asprintf (&s_name, "dummy");
-  privkey = GNUNET_CRYPTO_ecdsa_key_create ();
-  GNUNET_assert (NULL != privkey);
+  (void)cls;
+  (void)peer;
+  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                               &endbadly,
+                                               NULL);
+  GNUNET_SCHEDULER_add_shutdown(&end,
+                                NULL);
+  GNUNET_asprintf(&s_name, "dummy");
+  privkey = GNUNET_CRYPTO_ecdsa_key_create();
+  GNUNET_assert(NULL != privkey);
   /* get public key */
-  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
-                                      &pubkey);
+  GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
+                                     &pubkey);
 
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              &s_zone_value,
-                              sizeof (s_zone_value));
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             &s_zone_value,
+                             sizeof(s_zone_value));
   {
     struct GNUNET_GNSRECORD_Data rd;
 
     rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
     rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
-    rd.data_size = sizeof (s_zone_value);
+    rd.data_size = sizeof(s_zone_value);
     rd.data = &s_zone_value;
     rd.flags = 0;
 
-    nsh = GNUNET_NAMESTORE_connect (cfg);
-    GNUNET_break (NULL != nsh);
-    GNUNET_NAMESTORE_records_store (nsh,
-                                    privkey,
-                                    s_name,
-                                    1,
-                                    &rd,
-                                    &put_cont,
-                                    NULL);
+    nsh = GNUNET_NAMESTORE_connect(cfg);
+    GNUNET_break(NULL != nsh);
+    GNUNET_NAMESTORE_records_store(nsh,
+                                   privkey,
+                                   s_name,
+                                   1,
+                                   &rd,
+                                   &put_cont,
+                                   NULL);
   }
 }
 
@@ -243,26 +243,26 @@ run (void *cls,
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   const char *plugin_name;
   char *cfg_name;
 
-  (void) argc;
-  SETUP_CFG (plugin_name, cfg_name);
+  (void)argc;
+  SETUP_CFG(plugin_name, cfg_name);
   res = 1;
   if (0 !=
-      GNUNET_TESTING_peer_run ("test-namestore-api-zone-to-name",
-                               cfg_name,
-                               &run,
-                               NULL))
-  {
-    res = 1;
-  }
-  GNUNET_DISK_purge_cfg_dir (cfg_name,
-                             "GNUNET_TEST_HOME");
-  GNUNET_free (cfg_name);
+      GNUNET_TESTING_peer_run("test-namestore-api-zone-to-name",
+                              cfg_name,
+                              &run,
+                              NULL))
+    {
+      res = 1;
+    }
+  GNUNET_DISK_purge_cfg_dir(cfg_name,
+                            "GNUNET_TEST_HOME");
+  GNUNET_free(cfg_name);
   return res;
 }
 
diff --git a/src/namestore/test_plugin_namestore.c b/src/namestore/test_plugin_namestore.c
index b4ed4c70d..8fb30b651 100644
--- a/src/namestore/test_plugin_namestore.c
+++ b/src/namestore/test_plugin_namestore.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 namestore/test_plugin_namestore.c
  * @brief Test for the namestore plugins
@@ -45,13 +45,13 @@ static const char *plugin_name;
  * @param api api to unload
  */
 static void
-unload_plugin (struct GNUNET_NAMESTORE_PluginFunctions *api)
+unload_plugin(struct GNUNET_NAMESTORE_PluginFunctions *api)
 {
   char *libname;
 
-  GNUNET_asprintf (&libname, "libgnunet_plugin_namestore_%s", plugin_name);
-  GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api));
-  GNUNET_free (libname);
+  GNUNET_asprintf(&libname, "libgnunet_plugin_namestore_%s", plugin_name);
+  GNUNET_break(NULL == GNUNET_PLUGIN_unload(libname, api));
+  GNUNET_free(libname);
 }
 
 
@@ -62,33 +62,33 @@ unload_plugin (struct GNUNET_NAMESTORE_PluginFunctions *api)
  * @return NULL on error
  */
 static struct GNUNET_NAMESTORE_PluginFunctions *
-load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
+load_plugin(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_NAMESTORE_PluginFunctions *ret;
   char *libname;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _ ("Loading `%s' namestore plugin\n"),
-              plugin_name);
-  GNUNET_asprintf (&libname, "libgnunet_plugin_namestore_%s", plugin_name);
-  if (NULL == (ret = GNUNET_PLUGIN_load (libname, (void *) cfg)))
-  {
-    fprintf (stderr, "Failed to load plugin `%s'!\n", plugin_name);
-    GNUNET_free (libname);
-    return NULL;
-  }
-  GNUNET_free (libname);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             _("Loading `%s' namestore plugin\n"),
+             plugin_name);
+  GNUNET_asprintf(&libname, "libgnunet_plugin_namestore_%s", plugin_name);
+  if (NULL == (ret = GNUNET_PLUGIN_load(libname, (void *)cfg)))
+    {
+      fprintf(stderr, "Failed to load plugin `%s'!\n", plugin_name);
+      GNUNET_free(libname);
+      return NULL;
+    }
+  GNUNET_free(libname);
   return ret;
 }
 
 
 static void
-test_record (void *cls,
-             uint64_t seq,
-             const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
-             const char *label,
-             unsigned int rd_count,
-             const struct GNUNET_GNSRECORD_Data *rd)
+test_record(void *cls,
+            uint64_t seq,
+            const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
+            const char *label,
+            unsigned int rd_count,
+            const struct GNUNET_GNSRECORD_Data *rd)
 {
   int *idp = cls;
   int id = *idp;
@@ -96,106 +96,106 @@ test_record (void *cls,
   char tname[64];
   unsigned int trd_count = 1 + (id % 1024);
 
-  GNUNET_snprintf (tname, sizeof (tname), "a%u", (unsigned int) id);
-  GNUNET_assert (trd_count == rd_count);
+  GNUNET_snprintf(tname, sizeof(tname), "a%u", (unsigned int)id);
+  GNUNET_assert(trd_count == rd_count);
   for (unsigned int i = 0; i < trd_count; i++)
-  {
-    GNUNET_assert (rd[i].data_size == id % 10);
-    GNUNET_assert (0 == memcmp ("Hello World", rd[i].data, id % 10));
-    GNUNET_assert (rd[i].record_type == TEST_RECORD_TYPE);
-    GNUNET_assert (rd[i].flags == 0);
-  }
-  memset (&tzone_private_key, (id % 241), sizeof (tzone_private_key));
-  GNUNET_assert (0 == strcmp (label, tname));
-  GNUNET_assert (0 == GNUNET_memcmp (&tzone_private_key, private_key));
+    {
+      GNUNET_assert(rd[i].data_size == id % 10);
+      GNUNET_assert(0 == memcmp("Hello World", rd[i].data, id % 10));
+      GNUNET_assert(rd[i].record_type == TEST_RECORD_TYPE);
+      GNUNET_assert(rd[i].flags == 0);
+    }
+  memset(&tzone_private_key, (id % 241), sizeof(tzone_private_key));
+  GNUNET_assert(0 == strcmp(label, tname));
+  GNUNET_assert(0 == GNUNET_memcmp(&tzone_private_key, private_key));
 }
 
 
 static void
-get_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+get_record(struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 {
-  GNUNET_assert (
+  GNUNET_assert(
     GNUNET_OK ==
-    nsp->iterate_records (nsp->cls, NULL, 0, 1, &test_record, &id));
+    nsp->iterate_records(nsp->cls, NULL, 0, 1, &test_record, &id));
 }
 
 
 static void
-put_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+put_record(struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
 {
   struct GNUNET_CRYPTO_EcdsaPrivateKey zone_private_key;
   char label[64];
   unsigned int rd_count = 1 + (id % 1024);
-  struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
+  struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];
   struct GNUNET_CRYPTO_EcdsaSignature signature;
 
-  GNUNET_snprintf (label, sizeof (label), "a%u", (unsigned int) id);
+  GNUNET_snprintf(label, sizeof(label), "a%u", (unsigned int)id);
   for (unsigned int i = 0; i < rd_count; i++)
-  {
-    rd[i].data = "Hello World";
-    rd[i].data_size = id % 10;
-    rd[i].expiration_time =
-      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES).abs_value_us;
-    rd[i].record_type = TEST_RECORD_TYPE;
-    rd[i].flags = 0;
-  }
-  memset (&zone_private_key, (id % 241), sizeof (zone_private_key));
-  memset (&signature, (id % 243), sizeof (signature));
-  GNUNET_assert (
+    {
+      rd[i].data = "Hello World";
+      rd[i].data_size = id % 10;
+      rd[i].expiration_time =
+        GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES).abs_value_us;
+      rd[i].record_type = TEST_RECORD_TYPE;
+      rd[i].flags = 0;
+    }
+  memset(&zone_private_key, (id % 241), sizeof(zone_private_key));
+  memset(&signature, (id % 243), sizeof(signature));
+  GNUNET_assert(
     GNUNET_OK ==
-    nsp->store_records (nsp->cls, &zone_private_key, label, rd_count, rd));
+    nsp->store_records(nsp->cls, &zone_private_key, label, rd_count, rd));
 }
 
 
 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)
 {
   struct GNUNET_NAMESTORE_PluginFunctions *nsp;
 
   ok = 0;
-  nsp = load_plugin (cfg);
+  nsp = load_plugin(cfg);
   if (NULL == nsp)
-  {
-    fprintf (
-      stderr,
-      "%s",
-      "Failed to initialize namestore.  Database likely not setup, skipping test.\n");
-    return;
-  }
-  put_record (nsp, 1);
-  get_record (nsp, 1);
-
-  unload_plugin (nsp);
+    {
+      fprintf(
+        stderr,
+        "%s",
+        "Failed to initialize namestore.  Database likely not setup, skipping test.\n");
+      return;
+    }
+  put_record(nsp, 1);
+  get_record(nsp, 1);
+
+  unload_plugin(nsp);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   char cfg_name[PATH_MAX];
-  char *const xargv[] = {"test-plugin-namestore", "-c", cfg_name, NULL};
-  struct GNUNET_GETOPT_CommandLineOption options[] = {GNUNET_GETOPT_OPTION_END};
-
-  GNUNET_log_setup ("test-plugin-namestore", "WARNING", NULL);
-  plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
-  GNUNET_snprintf (cfg_name,
-                   sizeof (cfg_name),
-                   "test_plugin_namestore_%s.conf",
-                   plugin_name);
-  GNUNET_DISK_purge_cfg_dir (cfg_name, "GNUNET_TMP");
-  GNUNET_PROGRAM_run ((sizeof (xargv) / sizeof (char *)) - 1,
-                      xargv,
-                      "test-plugin-namestore",
-                      "nohelp",
-                      options,
-                      &run,
-                      NULL);
-  GNUNET_DISK_purge_cfg_dir (cfg_name, "GNUNET_TMP");
+  char *const xargv[] = { "test-plugin-namestore", "-c", cfg_name, NULL };
+  struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END };
+
+  GNUNET_log_setup("test-plugin-namestore", "WARNING", NULL);
+  plugin_name = GNUNET_TESTING_get_testname_from_underscore(argv[0]);
+  GNUNET_snprintf(cfg_name,
+                  sizeof(cfg_name),
+                  "test_plugin_namestore_%s.conf",
+                  plugin_name);
+  GNUNET_DISK_purge_cfg_dir(cfg_name, "GNUNET_TMP");
+  GNUNET_PROGRAM_run((sizeof(xargv) / sizeof(char *)) - 1,
+                     xargv,
+                     "test-plugin-namestore",
+                     "nohelp",
+                     options,
+                     &run,
+                     NULL);
+  GNUNET_DISK_purge_cfg_dir(cfg_name, "GNUNET_TMP");
   if (ok != 0)
-    fprintf (stderr, "Missed some testcases: %d\n", ok);
+    fprintf(stderr, "Missed some testcases: %d\n", ok);
   return ok;
 }