uncrustify as demanded.

1 files changed, 400 insertions, 401 deletions

diff --git a/src/zonemaster/gnunet-service-zonemaster.c b/src/zonemaster/gnunet-service-zonemaster.c
index 079013b6c..0d78471aa 100644
--- a/src/zonemaster/gnunet-service-zonemaster.c
+++ b/src/zonemaster/gnunet-service-zonemaster.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 zonemaster/gnunet-service-zonemaster.c
@@ -31,7 +31,7 @@
 #include "gnunet_statistics_service.h"
 
 
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
+#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util", syscall, filename)
 
 
 /**
@@ -73,7 +73,7 @@
  * The upper bound for the zone iteration interval
  * (per record).
  */
-#define MAXIMUM_ZONE_ITERATION_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
+#define MAXIMUM_ZONE_ITERATION_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
 
 /**
  * The factor the current zone iteration interval is divided by for each
@@ -90,8 +90,7 @@
 /**
  * Handle for DHT PUT activity triggered from the namestore monitor.
  */
-struct DhtPutActivity
-{
+struct DhtPutActivity {
   /**
    * Kept in a DLL.
    */
@@ -241,49 +240,49 @@ static int cache_keys;
  * @param tc unused
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
   struct DhtPutActivity *ma;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Shutting down!\n");
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Shutting down!\n");
   while (NULL != (ma = it_head))
-  {
-    GNUNET_DHT_put_cancel (ma->ph);
-    dht_queue_length--;
-    GNUNET_CONTAINER_DLL_remove (it_head,
-                                 it_tail,
-                                 ma);
-    dht_queue_length--;
-    GNUNET_free (ma);
-  }
+    {
+      GNUNET_DHT_put_cancel(ma->ph);
+      dht_queue_length--;
+      GNUNET_CONTAINER_DLL_remove(it_head,
+                                  it_tail,
+                                  ma);
+      dht_queue_length--;
+      GNUNET_free(ma);
+    }
   if (NULL != statistics)
-  {
-    GNUNET_STATISTICS_destroy (statistics,
-                               GNUNET_NO);
-    statistics = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(statistics,
+                                GNUNET_NO);
+      statistics = NULL;
+    }
   if (NULL != zone_publish_task)
-  {
-    GNUNET_SCHEDULER_cancel (zone_publish_task);
-    zone_publish_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(zone_publish_task);
+      zone_publish_task = NULL;
+    }
   if (NULL != namestore_iter)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (namestore_iter);
-    namestore_iter = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(namestore_iter);
+      namestore_iter = NULL;
+    }
   if (NULL != namestore_handle)
-  {
-    GNUNET_NAMESTORE_disconnect (namestore_handle);
-    namestore_handle = NULL;
-  }
+    {
+      GNUNET_NAMESTORE_disconnect(namestore_handle);
+      namestore_handle = NULL;
+    }
   if (NULL != dht_handle)
-  {
-    GNUNET_DHT_disconnect (dht_handle);
-    dht_handle = NULL;
-  }
+    {
+      GNUNET_DHT_disconnect(dht_handle);
+      dht_handle = NULL;
+    }
 }
 
 
@@ -293,15 +292,15 @@ shutdown_task (void *cls)
  * @param cls NULL
  */
 static void
-publish_zone_namestore_next (void *cls)
+publish_zone_namestore_next(void *cls)
 {
-  (void) cls;
+  (void)cls;
   zone_publish_task = NULL;
-  GNUNET_assert (NULL != namestore_iter);
-  GNUNET_assert (0 == ns_iteration_left);
+  GNUNET_assert(NULL != namestore_iter);
+  GNUNET_assert(0 == ns_iteration_left);
   ns_iteration_left = NS_BLOCK_SIZE;
-  GNUNET_NAMESTORE_zone_iterator_next (namestore_iter,
-                                       NS_BLOCK_SIZE);
+  GNUNET_NAMESTORE_zone_iterator_next(namestore_iter,
+                                      NS_BLOCK_SIZE);
 }
 
 
@@ -311,54 +310,54 @@ publish_zone_namestore_next (void *cls)
  * @param cls NULL
  */
 static void
-publish_zone_dht_start (void *cls);
+publish_zone_dht_start(void *cls);
 
 
 /**
  * Calculate #target_iteration_velocity_per_record.
  */
 static void
-calculate_put_interval ()
+calculate_put_interval()
 {
   if (0 == num_public_records)
-  {
-    /**
-     * If no records are known (startup) or none present
-     * we can safely set the interval to the value for a single
-     * record
-     */
-    target_iteration_velocity_per_record = zone_publish_time_window;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                "No records in namestore database.\n");
-  }
+    {
+      /**
+       * If no records are known (startup) or none present
+       * we can safely set the interval to the value for a single
+       * record
+       */
+      target_iteration_velocity_per_record = zone_publish_time_window;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                 "No records in namestore database.\n");
+    }
   else
-  {
-    last_min_relative_record_time
-      = GNUNET_TIME_relative_min (last_min_relative_record_time,
-                                  min_relative_record_time);
-    zone_publish_time_window
-      = GNUNET_TIME_relative_min (GNUNET_TIME_relative_divide (last_min_relative_record_time,
-                                                               PUBLISH_OPS_PER_EXPIRATION),
-                                  zone_publish_time_window_default);
-    target_iteration_velocity_per_record
-      = GNUNET_TIME_relative_divide (zone_publish_time_window,
-                                     last_num_public_records);
-  }
+    {
+      last_min_relative_record_time
+        = GNUNET_TIME_relative_min(last_min_relative_record_time,
+                                   min_relative_record_time);
+      zone_publish_time_window
+        = GNUNET_TIME_relative_min(GNUNET_TIME_relative_divide(last_min_relative_record_time,
+                                                               PUBLISH_OPS_PER_EXPIRATION),
+                                   zone_publish_time_window_default);
+      target_iteration_velocity_per_record
+        = GNUNET_TIME_relative_divide(zone_publish_time_window,
+                                      last_num_public_records);
+    }
   target_iteration_velocity_per_record
-    = GNUNET_TIME_relative_min (target_iteration_velocity_per_record,
-                                MAXIMUM_ZONE_ITERATION_INTERVAL);
-  GNUNET_STATISTICS_set (statistics,
-                         "Minimum relative record expiration (in μs)",
-                         last_min_relative_record_time.rel_value_us,
-                         GNUNET_NO);
-  GNUNET_STATISTICS_set (statistics,
-                         "Zone publication time window (in μs)",
-                         zone_publish_time_window.rel_value_us,
-                         GNUNET_NO);
-  GNUNET_STATISTICS_set (statistics,
-                         "Target zone iteration velocity (μs)",
-                         target_iteration_velocity_per_record.rel_value_us,
-                         GNUNET_NO);
+    = GNUNET_TIME_relative_min(target_iteration_velocity_per_record,
+                               MAXIMUM_ZONE_ITERATION_INTERVAL);
+  GNUNET_STATISTICS_set(statistics,
+                        "Minimum relative record expiration (in μs)",
+                        last_min_relative_record_time.rel_value_us,
+                        GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "Zone publication time window (in μs)",
+                        zone_publish_time_window.rel_value_us,
+                        GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "Target zone iteration velocity (μs)",
+                        target_iteration_velocity_per_record.rel_value_us,
+                        GNUNET_NO);
 }
 
 
@@ -370,7 +369,7 @@ calculate_put_interval ()
  * @param cnt how many records were processed since the last call?
  */
 static void
-update_velocity (unsigned int cnt)
+update_velocity(unsigned int cnt)
 {
   struct GNUNET_TIME_Relative delta;
   unsigned long long pct = 0;
@@ -378,88 +377,88 @@ update_velocity (unsigned int cnt)
   if (0 == cnt)
     return;
   /* How fast were we really? */
-  delta = GNUNET_TIME_absolute_get_duration (last_put_100);
+  delta = GNUNET_TIME_absolute_get_duration(last_put_100);
   delta.rel_value_us /= cnt;
-  last_put_100 = GNUNET_TIME_absolute_get ();
+  last_put_100 = GNUNET_TIME_absolute_get();
 
   /* calculate expected frequency */
-  if ( (num_public_records > last_num_public_records) &&
-       (GNUNET_NO == first_zone_iteration) )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Last record count was lower than current record count.  Reducing interval.\n");
-    last_num_public_records = num_public_records * LATE_ITERATION_SPEEDUP_FACTOR;
-    calculate_put_interval ();
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Desired global zone iteration interval is %s/record!\n",
-              GNUNET_STRINGS_relative_time_to_string (target_iteration_velocity_per_record,
-                                                      GNUNET_YES));
+  if ((num_public_records > last_num_public_records) &&
+      (GNUNET_NO == first_zone_iteration))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Last record count was lower than current record count.  Reducing interval.\n");
+      last_num_public_records = num_public_records * LATE_ITERATION_SPEEDUP_FACTOR;
+      calculate_put_interval();
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Desired global zone iteration interval is %s/record!\n",
+             GNUNET_STRINGS_relative_time_to_string(target_iteration_velocity_per_record,
+                                                    GNUNET_YES));
 
   /* Tell statistics actual vs. desired speed */
-  GNUNET_STATISTICS_set (statistics,
-                         "Current zone iteration velocity (μs/record)",
-                         delta.rel_value_us,
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "Current zone iteration velocity (μs/record)",
+                        delta.rel_value_us,
+                        GNUNET_NO);
   /* update "sub_delta" based on difference, taking
      previous sub_delta into account! */
   if (target_iteration_velocity_per_record.rel_value_us > delta.rel_value_us)
-  {
-    /* We were too fast, reduce sub_delta! */
-    struct GNUNET_TIME_Relative corr;
-
-    corr = GNUNET_TIME_relative_subtract (target_iteration_velocity_per_record,
-                                          delta);
-    if (sub_delta.rel_value_us > delta.rel_value_us)
     {
-      /* Reduce sub_delta by corr */
-      sub_delta = GNUNET_TIME_relative_subtract (sub_delta,
-                                                 corr);
-    }
-    else
-    {
-      /* We're doing fine with waiting the full time, this
-         should theoretically only happen if we run at
-         infinite speed. */
-      sub_delta = GNUNET_TIME_UNIT_ZERO;
+      /* We were too fast, reduce sub_delta! */
+      struct GNUNET_TIME_Relative corr;
+
+      corr = GNUNET_TIME_relative_subtract(target_iteration_velocity_per_record,
+                                           delta);
+      if (sub_delta.rel_value_us > delta.rel_value_us)
+        {
+          /* Reduce sub_delta by corr */
+          sub_delta = GNUNET_TIME_relative_subtract(sub_delta,
+                                                    corr);
+        }
+      else
+        {
+          /* We're doing fine with waiting the full time, this
+             should theoretically only happen if we run at
+             infinite speed. */
+          sub_delta = GNUNET_TIME_UNIT_ZERO;
+        }
     }
-  }
   else if (target_iteration_velocity_per_record.rel_value_us < delta.rel_value_us)
-  {
-    /* We were too slow, increase sub_delta! */
-    struct GNUNET_TIME_Relative corr;
-
-    corr = GNUNET_TIME_relative_subtract (delta,
-                                          target_iteration_velocity_per_record);
-    sub_delta = GNUNET_TIME_relative_add (sub_delta,
-                                          corr);
-    if (sub_delta.rel_value_us > target_iteration_velocity_per_record.rel_value_us)
     {
-      /* CPU overload detected, we cannot go at desired speed,
-         as this would mean using a negative delay. */
-      /* compute how much faster we would want to be for
-         the desired velocity */
-      if (0 == target_iteration_velocity_per_record.rel_value_us)
-        pct = UINT64_MAX; /* desired speed is infinity ... */
-      else
-        pct = (sub_delta.rel_value_us -
-               target_iteration_velocity_per_record.rel_value_us) * 100LLU
-          / target_iteration_velocity_per_record.rel_value_us;
-      sub_delta = target_iteration_velocity_per_record;
+      /* We were too slow, increase sub_delta! */
+      struct GNUNET_TIME_Relative corr;
+
+      corr = GNUNET_TIME_relative_subtract(delta,
+                                           target_iteration_velocity_per_record);
+      sub_delta = GNUNET_TIME_relative_add(sub_delta,
+                                           corr);
+      if (sub_delta.rel_value_us > target_iteration_velocity_per_record.rel_value_us)
+        {
+          /* CPU overload detected, we cannot go at desired speed,
+             as this would mean using a negative delay. */
+          /* compute how much faster we would want to be for
+             the desired velocity */
+          if (0 == target_iteration_velocity_per_record.rel_value_us)
+            pct = UINT64_MAX; /* desired speed is infinity ... */
+          else
+            pct = (sub_delta.rel_value_us -
+                   target_iteration_velocity_per_record.rel_value_us) * 100LLU
+                  / target_iteration_velocity_per_record.rel_value_us;
+          sub_delta = target_iteration_velocity_per_record;
+        }
     }
-  }
-  GNUNET_STATISTICS_set (statistics,
-                         "# size of the DHT queue (it)",
-                         dht_queue_length,
-                         GNUNET_NO);
-  GNUNET_STATISTICS_set (statistics,
-                         "% speed increase needed for target velocity",
-                         pct,
-                         GNUNET_NO);
-  GNUNET_STATISTICS_set (statistics,
-                         "# records processed in current iteration",
-                         num_public_records,
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "# size of the DHT queue (it)",
+                        dht_queue_length,
+                        GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "% speed increase needed for target velocity",
+                        pct,
+                        GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "# records processed in current iteration",
+                        num_public_records,
+                        GNUNET_NO);
 }
 
 
@@ -468,34 +467,34 @@ update_velocity (unsigned int cnt)
  * by calling #publish_zone_namestore_next(), and if so with what delay.
  */
 static void
-check_zone_namestore_next ()
+check_zone_namestore_next()
 {
   struct GNUNET_TIME_Relative delay;
 
   if (0 != ns_iteration_left)
     return; /* current NAMESTORE iteration not yet done */
-  update_velocity (put_cnt);
+  update_velocity(put_cnt);
   put_cnt = 0;
-  delay = GNUNET_TIME_relative_subtract (target_iteration_velocity_per_record,
-                                         sub_delta);
+  delay = GNUNET_TIME_relative_subtract(target_iteration_velocity_per_record,
+                                        sub_delta);
   /* We delay *once* per #NS_BLOCK_SIZE, so we need to multiply the
      per-record delay calculated so far with the #NS_BLOCK_SIZE */
-  GNUNET_STATISTICS_set (statistics,
-                         "Current artificial NAMESTORE delay (μs/record)",
-                         delay.rel_value_us,
-                         GNUNET_NO);
-  delay = GNUNET_TIME_relative_multiply (delay,
-                                         NS_BLOCK_SIZE);
+  GNUNET_STATISTICS_set(statistics,
+                        "Current artificial NAMESTORE delay (μs/record)",
+                        delay.rel_value_us,
+                        GNUNET_NO);
+  delay = GNUNET_TIME_relative_multiply(delay,
+                                        NS_BLOCK_SIZE);
   /* make sure we do not overshoot because of the #NS_BLOCK_SIZE factor */
-  delay = GNUNET_TIME_relative_min (MAXIMUM_ZONE_ITERATION_INTERVAL,
-                                    delay);
+  delay = GNUNET_TIME_relative_min(MAXIMUM_ZONE_ITERATION_INTERVAL,
+                                   delay);
   /* no delays on first iteration */
   if (GNUNET_YES == first_zone_iteration)
     delay = GNUNET_TIME_UNIT_ZERO;
-  GNUNET_assert (NULL == zone_publish_task);
-  zone_publish_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                    &publish_zone_namestore_next,
-                                                    NULL);
+  GNUNET_assert(NULL == zone_publish_task);
+  zone_publish_task = GNUNET_SCHEDULER_add_delayed(delay,
+                                                   &publish_zone_namestore_next,
+                                                   NULL);
 }
 
 
@@ -505,17 +504,17 @@ check_zone_namestore_next ()
  * @param cls a `struct DhtPutActivity`
  */
 static void
-dht_put_continuation (void *cls)
+dht_put_continuation(void *cls)
 {
   struct DhtPutActivity *ma = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "PUT complete\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "PUT complete\n");
   dht_queue_length--;
-  GNUNET_CONTAINER_DLL_remove (it_head,
-                               it_tail,
-                               ma);
-  GNUNET_free (ma);
+  GNUNET_CONTAINER_DLL_remove(it_head,
+                              it_tail,
+                              ma);
+  GNUNET_free(ma);
 }
 
 
@@ -530,32 +529,32 @@ dht_put_continuation (void *cls)
  * @return number of records written to @a rd_public
  */
 static unsigned int
-convert_records_for_export (const struct GNUNET_GNSRECORD_Data *rd,
-                            unsigned int rd_count,
-                            struct GNUNET_GNSRECORD_Data *rd_public)
+convert_records_for_export(const struct GNUNET_GNSRECORD_Data *rd,
+                           unsigned int rd_count,
+                           struct GNUNET_GNSRECORD_Data *rd_public)
 {
   struct GNUNET_TIME_Absolute now;
   unsigned int rd_public_count;
 
   rd_public_count = 0;
-  now = GNUNET_TIME_absolute_get ();
-  for (unsigned int i=0;i<rd_count;i++)
-  {
-    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE))
-      continue;
-    if ( (0 == (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
-         (rd[i].expiration_time < now.abs_value_us) )
-      continue;  /* record already expired, skip it */
-    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+  now = GNUNET_TIME_absolute_get();
+  for (unsigned int i = 0; i < rd_count; i++)
     {
-      /* GNUNET_GNSRECORD_block_create will convert to absolute time;
-         we just need to adjust our iteration frequency */
-      min_relative_record_time.rel_value_us =
-        GNUNET_MIN (rd[i].expiration_time,
-                    min_relative_record_time.rel_value_us);
+      if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE))
+        continue;
+      if ((0 == (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
+          (rd[i].expiration_time < now.abs_value_us))
+        continue; /* record already expired, skip it */
+      if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
+        {
+          /* GNUNET_GNSRECORD_block_create will convert to absolute time;
+             we just need to adjust our iteration frequency */
+          min_relative_record_time.rel_value_us =
+            GNUNET_MIN(rd[i].expiration_time,
+                       min_relative_record_time.rel_value_us);
+        }
+      rd_public[rd_public_count++] = rd[i];
     }
-    rd_public[rd_public_count++] = rd[i];
-  }
   return rd_public_count;
 }
 
@@ -571,11 +570,11 @@ convert_records_for_export (const struct GNUNET_GNSRECORD_Data *rd,
  * @return DHT PUT handle, NULL on error
  */
 static struct GNUNET_DHT_PutHandle *
-perform_dht_put (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
-                 const char *label,
-                 const struct GNUNET_GNSRECORD_Data *rd_public,
-                 unsigned int rd_public_count,
-                 struct DhtPutActivity *ma)
+perform_dht_put(const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+                const char *label,
+                const struct GNUNET_GNSRECORD_Data *rd_public,
+                unsigned int rd_public_count,
+                struct DhtPutActivity *ma)
 {
   struct GNUNET_GNSRECORD_Block *block;
   struct GNUNET_HashCode query;
@@ -583,53 +582,53 @@ perform_dht_put (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
   size_t block_size;
   struct GNUNET_DHT_PutHandle *ret;
 
-  expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_public_count,
-                                                        rd_public);
+  expire = GNUNET_GNSRECORD_record_get_expiration_time(rd_public_count,
+                                                       rd_public);
   if (cache_keys)
-    block = GNUNET_GNSRECORD_block_create2 (key,
-                                            expire,
-                                            label,
-                                            rd_public,
-                                            rd_public_count);
-  else
-    block = GNUNET_GNSRECORD_block_create (key,
+    block = GNUNET_GNSRECORD_block_create2(key,
                                            expire,
                                            label,
                                            rd_public,
                                            rd_public_count);
+  else
+    block = GNUNET_GNSRECORD_block_create(key,
+                                          expire,
+                                          label,
+                                          rd_public,
+                                          rd_public_count);
   if (NULL == block)
-  {
-    GNUNET_break (0);
-    return NULL; /* whoops */
-  }
-  block_size = ntohl (block->purpose.size)
-    + sizeof (struct GNUNET_CRYPTO_EcdsaSignature)
-    + sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
-  GNUNET_GNSRECORD_query_from_private_key (key,
-                                           label,
-                                           &query);
-  GNUNET_STATISTICS_update (statistics,
-                            "DHT put operations initiated",
-                            1,
-                            GNUNET_NO);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Storing %u record(s) for label `%s' in DHT with expiration `%s' under key %s\n",
-              rd_public_count,
-              label,
-              GNUNET_STRINGS_absolute_time_to_string (expire),
-              GNUNET_h2s (&query));
+    {
+      GNUNET_break(0);
+      return NULL; /* whoops */
+    }
+  block_size = ntohl(block->purpose.size)
+               + sizeof(struct GNUNET_CRYPTO_EcdsaSignature)
+               + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
+  GNUNET_GNSRECORD_query_from_private_key(key,
+                                          label,
+                                          &query);
+  GNUNET_STATISTICS_update(statistics,
+                           "DHT put operations initiated",
+                           1,
+                           GNUNET_NO);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Storing %u record(s) for label `%s' in DHT with expiration `%s' under key %s\n",
+             rd_public_count,
+             label,
+             GNUNET_STRINGS_absolute_time_to_string(expire),
+             GNUNET_h2s(&query));
   num_public_records++;
-  ret = GNUNET_DHT_put (dht_handle,
-                        &query,
-                        DHT_GNS_REPLICATION_LEVEL,
-                        GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
-                        block_size,
-                        block,
-                        expire,
-                        &dht_put_continuation,
-                        ma);
-  GNUNET_free (block);
+  ret = GNUNET_DHT_put(dht_handle,
+                       &query,
+                       DHT_GNS_REPLICATION_LEVEL,
+                       GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                       GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
+                       block_size,
+                       block,
+                       expire,
+                       &dht_put_continuation,
+                       ma);
+  GNUNET_free(block);
   return ret;
 }
 
@@ -640,22 +639,22 @@ perform_dht_put (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
  * @param cls NULL
  */
 static void
-zone_iteration_error (void *cls)
+zone_iteration_error(void *cls)
 {
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got disconnected from namestore database, retrying.\n");
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got disconnected from namestore database, retrying.\n");
   namestore_iter = NULL;
   /* We end up here on error/disconnect/shutdown, so potentially
      while a zone publish task or a DHT put is still running; hence
      we need to cancel those. */
   if (NULL != zone_publish_task)
-  {
-    GNUNET_SCHEDULER_cancel (zone_publish_task);
-    zone_publish_task = NULL;
-  }
-  zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start,
-                                                NULL);
+    {
+      GNUNET_SCHEDULER_cancel(zone_publish_task);
+      zone_publish_task = NULL;
+    }
+  zone_publish_task = GNUNET_SCHEDULER_add_now(&publish_zone_dht_start,
+                                               NULL);
 }
 
 
@@ -665,42 +664,42 @@ zone_iteration_error (void *cls)
  * @param cls NULL
  */
 static void
-zone_iteration_finished (void *cls)
+zone_iteration_finished(void *cls)
 {
-  (void) cls;
+  (void)cls;
   /* we're done with one iteration, calculate when to do the next one */
   namestore_iter = NULL;
   last_num_public_records = num_public_records;
   first_zone_iteration = GNUNET_NO;
   last_min_relative_record_time = min_relative_record_time;
-  calculate_put_interval ();
+  calculate_put_interval();
   /* reset for next iteration */
   min_relative_record_time
     = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Zone iteration finished. Adjusted zone iteration interval to %s\n",
-              GNUNET_STRINGS_relative_time_to_string (target_iteration_velocity_per_record,
-                                                      GNUNET_YES));
-  GNUNET_STATISTICS_set (statistics,
-                         "Target zone iteration velocity (μs)",
-                         target_iteration_velocity_per_record.rel_value_us,
-                         GNUNET_NO);
-  GNUNET_STATISTICS_set (statistics,
-                         "Number of public records in DHT",
-                         last_num_public_records,
-                         GNUNET_NO);
-  GNUNET_assert (NULL == zone_publish_task);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Zone iteration finished. Adjusted zone iteration interval to %s\n",
+             GNUNET_STRINGS_relative_time_to_string(target_iteration_velocity_per_record,
+                                                    GNUNET_YES));
+  GNUNET_STATISTICS_set(statistics,
+                        "Target zone iteration velocity (μs)",
+                        target_iteration_velocity_per_record.rel_value_us,
+                        GNUNET_NO);
+  GNUNET_STATISTICS_set(statistics,
+                        "Number of public records in DHT",
+                        last_num_public_records,
+                        GNUNET_NO);
+  GNUNET_assert(NULL == zone_publish_task);
   if (0 == last_num_public_records)
-  {
-    zone_publish_task = GNUNET_SCHEDULER_add_delayed (target_iteration_velocity_per_record,
-                                                      &publish_zone_dht_start,
-                                                      NULL);
-  }
+    {
+      zone_publish_task = GNUNET_SCHEDULER_add_delayed(target_iteration_velocity_per_record,
+                                                       &publish_zone_dht_start,
+                                                       NULL);
+    }
   else
-  {
-    zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start,
-                                                  NULL);
-  }
+    {
+      zone_publish_task = GNUNET_SCHEDULER_add_now(&publish_zone_dht_start,
+                                                   NULL);
+    }
 }
 
 
@@ -714,67 +713,67 @@ zone_iteration_finished (void *cls)
  * @param rd the record data
  */
 static void
-put_gns_record (void *cls,
-                const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
-                const char *label,
-                unsigned int rd_count,
-                const struct GNUNET_GNSRECORD_Data *rd)
+put_gns_record(void *cls,
+               const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+               const char *label,
+               unsigned int rd_count,
+               const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct GNUNET_GNSRECORD_Data rd_public[rd_count];
   unsigned int rd_public_count;
   struct DhtPutActivity *ma;
 
-  (void) cls;
+  (void)cls;
   ns_iteration_left--;
-  rd_public_count = convert_records_for_export (rd,
-                                                rd_count,
-                                                rd_public);
+  rd_public_count = convert_records_for_export(rd,
+                                               rd_count,
+                                               rd_public);
   if (0 == rd_public_count)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Record set empty, moving to next record set\n");
-    check_zone_namestore_next ();
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Record set empty, moving to next record set\n");
+      check_zone_namestore_next();
+      return;
+    }
   /* We got a set of records to publish */
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting DHT PUT\n");
-  ma = GNUNET_new (struct DhtPutActivity);
-  ma->start_date = GNUNET_TIME_absolute_get ();
-  ma->ph = perform_dht_put (key,
-                            label,
-                            rd_public,
-                            rd_public_count,
-                            ma);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting DHT PUT\n");
+  ma = GNUNET_new(struct DhtPutActivity);
+  ma->start_date = GNUNET_TIME_absolute_get();
+  ma->ph = perform_dht_put(key,
+                           label,
+                           rd_public,
+                           rd_public_count,
+                           ma);
   put_cnt++;
   if (0 == put_cnt % DELTA_INTERVAL)
-    update_velocity (DELTA_INTERVAL);
-  check_zone_namestore_next ();
+    update_velocity(DELTA_INTERVAL);
+  check_zone_namestore_next();
   if (NULL == ma->ph)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Could not perform DHT PUT, is the DHT running?\n");
-    GNUNET_free (ma);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Could not perform DHT PUT, is the DHT running?\n");
+      GNUNET_free(ma);
+      return;
+    }
   dht_queue_length++;
-  GNUNET_CONTAINER_DLL_insert_tail (it_head,
-                                    it_tail,
-                                    ma);
+  GNUNET_CONTAINER_DLL_insert_tail(it_head,
+                                   it_tail,
+                                   ma);
   if (dht_queue_length > DHT_QUEUE_LIMIT)
-  {
-    ma = it_head;
-    GNUNET_CONTAINER_DLL_remove (it_head,
-                                 it_tail,
-                                 ma);
-    GNUNET_DHT_put_cancel (ma->ph);
-    dht_queue_length--;
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "DHT PUT unconfirmed after %s, aborting PUT\n",
-                GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (ma->start_date),
+    {
+      ma = it_head;
+      GNUNET_CONTAINER_DLL_remove(it_head,
+                                  it_tail,
+                                  ma);
+      GNUNET_DHT_put_cancel(ma->ph);
+      dht_queue_length--;
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "DHT PUT unconfirmed after %s, aborting PUT\n",
+                 GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(ma->start_date),
                                                         GNUNET_YES));
-    GNUNET_free (ma);
-  }
+      GNUNET_free(ma);
+    }
 }
 
 
@@ -784,30 +783,30 @@ put_gns_record (void *cls,
  * @param cls NULL
  */
 static void
-publish_zone_dht_start (void *cls)
+publish_zone_dht_start(void *cls)
 {
-  (void) cls;
+  (void)cls;
   zone_publish_task = NULL;
-  GNUNET_STATISTICS_update (statistics,
-                            "Full zone iterations launched",
-                            1,
-                            GNUNET_NO);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting DHT zone update!\n");
+  GNUNET_STATISTICS_update(statistics,
+                           "Full zone iterations launched",
+                           1,
+                           GNUNET_NO);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting DHT zone update!\n");
   /* start counting again */
   num_public_records = 0;
-  GNUNET_assert (NULL == namestore_iter);
+  GNUNET_assert(NULL == namestore_iter);
   ns_iteration_left = 1;
   namestore_iter
-    = GNUNET_NAMESTORE_zone_iteration_start (namestore_handle,
-                                             NULL, /* All zones */
-                                             &zone_iteration_error,
-                                             NULL,
-                                             &put_gns_record,
-                                             NULL,
-                                             &zone_iteration_finished,
-                                             NULL);
-  GNUNET_assert (NULL != namestore_iter);
+    = GNUNET_NAMESTORE_zone_iteration_start(namestore_handle,
+                                            NULL,  /* All zones */
+                                            &zone_iteration_error,
+                                            NULL,
+                                            &put_gns_record,
+                                            NULL,
+                                            &zone_iteration_finished,
+                                            NULL);
+  GNUNET_assert(NULL != namestore_iter);
 }
 
 
@@ -819,77 +818,77 @@ publish_zone_dht_start (void *cls)
  * @param c configuration to use
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *c,
-     struct GNUNET_SERVICE_Handle *service)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *c,
+    struct GNUNET_SERVICE_Handle *service)
 {
   unsigned long long max_parallel_bg_queries = 128;
 
-  (void) cls;
-  (void) service;
-  last_put_100 = GNUNET_TIME_absolute_get (); /* first time! */
+  (void)cls;
+  (void)service;
+  last_put_100 = GNUNET_TIME_absolute_get();  /* first time! */
   min_relative_record_time
     = GNUNET_TIME_UNIT_FOREVER_REL;
   target_iteration_velocity_per_record = INITIAL_ZONE_ITERATION_INTERVAL;
-  namestore_handle = GNUNET_NAMESTORE_connect (c);
+  namestore_handle = GNUNET_NAMESTORE_connect(c);
   if (NULL == namestore_handle)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to connect to the namestore!\n"));
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  cache_keys = GNUNET_CONFIGURATION_get_value_yesno (c,
-                                                     "namestore",
-                                                     "CACHE_KEYS");
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to connect to the namestore!\n"));
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  cache_keys = GNUNET_CONFIGURATION_get_value_yesno(c,
+                                                    "namestore",
+                                                    "CACHE_KEYS");
   zone_publish_time_window_default = GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY;
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_time (c,
-                                           "zonemaster",
-                                           "ZONE_PUBLISH_TIME_WINDOW",
-                                           &zone_publish_time_window_default))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Time window for zone iteration: %s\n",
-                GNUNET_STRINGS_relative_time_to_string (zone_publish_time_window,
+      GNUNET_CONFIGURATION_get_value_time(c,
+                                          "zonemaster",
+                                          "ZONE_PUBLISH_TIME_WINDOW",
+                                          &zone_publish_time_window_default))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Time window for zone iteration: %s\n",
+                 GNUNET_STRINGS_relative_time_to_string(zone_publish_time_window,
                                                         GNUNET_YES));
-  }
+    }
   zone_publish_time_window = zone_publish_time_window_default;
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number (c,
-                                             "zonemaster",
-                                             "MAX_PARALLEL_BACKGROUND_QUERIES",
-                                             &max_parallel_bg_queries))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Number of allowed parallel background queries: %llu\n",
-                max_parallel_bg_queries);
-  }
+      GNUNET_CONFIGURATION_get_value_number(c,
+                                            "zonemaster",
+                                            "MAX_PARALLEL_BACKGROUND_QUERIES",
+                                            &max_parallel_bg_queries))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Number of allowed parallel background queries: %llu\n",
+                 max_parallel_bg_queries);
+    }
   if (0 == max_parallel_bg_queries)
     max_parallel_bg_queries = 1;
-  dht_handle = GNUNET_DHT_connect (c,
-                                   (unsigned int) max_parallel_bg_queries);
+  dht_handle = GNUNET_DHT_connect(c,
+                                  (unsigned int)max_parallel_bg_queries);
   if (NULL == dht_handle)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not connect to DHT!\n"));
-    GNUNET_SCHEDULER_add_now (&shutdown_task,
-                              NULL);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not connect to DHT!\n"));
+      GNUNET_SCHEDULER_add_now(&shutdown_task,
+                               NULL);
+      return;
+    }
 
   /* Schedule periodic put for our records. */
   first_zone_iteration = GNUNET_YES;
-  statistics = GNUNET_STATISTICS_create ("zonemaster",
-                                         c);
-  GNUNET_STATISTICS_set (statistics,
-                         "Target zone iteration velocity (μs)",
-                         target_iteration_velocity_per_record.rel_value_us,
-                         GNUNET_NO);
-  zone_publish_task = GNUNET_SCHEDULER_add_now (&publish_zone_dht_start,
-                                                NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 NULL);
+  statistics = GNUNET_STATISTICS_create("zonemaster",
+                                        c);
+  GNUNET_STATISTICS_set(statistics,
+                        "Target zone iteration velocity (μs)",
+                        target_iteration_velocity_per_record.rel_value_us,
+                        GNUNET_NO);
+  zone_publish_task = GNUNET_SCHEDULER_add_now(&publish_zone_dht_start,
+                                               NULL);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+                                NULL);
 }
 
 
@@ -897,13 +896,13 @@ run (void *cls,
  * Define "main" method using service macro.
  */
 GNUNET_SERVICE_MAIN
-("zonemaster",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- NULL,
- NULL,
- NULL,
- GNUNET_MQ_handler_end());
+  ("zonemaster",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  NULL,
+  NULL,
+  NULL,
+  GNUNET_MQ_handler_end());
 
 
 /* end of gnunet-service-zonemaster.c */