1 files changed, 410 insertions, 418 deletions

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;
 }