uncrustify as demanded.

136 files changed, 27884 insertions, 27827 deletions

diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c
index bdac43b77..562eed01b 100644
--- a/src/util/bandwidth.c
+++ b/src/util/bandwidth.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 util/bandwidth.c
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-bandwidth", __VA_ARGS__)
 
 /**
  * Create a new bandwidth value.
@@ -36,11 +36,11 @@
  * @return the new bandwidth value
  */
 struct GNUNET_BANDWIDTH_Value32NBO
-GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
+GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
 {
   struct GNUNET_BANDWIDTH_Value32NBO ret;
 
-  ret.value__ = htonl (bytes_per_second);
+  ret.value__ = htonl(bytes_per_second);
   return ret;
 }
 
@@ -53,11 +53,11 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
  * @return the min of b1 and b2
  */
 struct GNUNET_BANDWIDTH_Value32NBO
-GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1,
-                            struct GNUNET_BANDWIDTH_Value32NBO b2)
+GNUNET_BANDWIDTH_value_min(struct GNUNET_BANDWIDTH_Value32NBO b1,
+                           struct GNUNET_BANDWIDTH_Value32NBO b2)
 {
-  return GNUNET_BANDWIDTH_value_init (
-    GNUNET_MIN (ntohl (b1.value__), ntohl (b2.value__)));
+  return GNUNET_BANDWIDTH_value_init(
+    GNUNET_MIN(ntohl(b1.value__), ntohl(b2.value__)));
 }
 
 
@@ -69,11 +69,11 @@ GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1,
  * @return the min of b1 and b2
  */
 struct GNUNET_BANDWIDTH_Value32NBO
-GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1,
-                            struct GNUNET_BANDWIDTH_Value32NBO b2)
+GNUNET_BANDWIDTH_value_max(struct GNUNET_BANDWIDTH_Value32NBO b1,
+                           struct GNUNET_BANDWIDTH_Value32NBO b2)
 {
-  return GNUNET_BANDWIDTH_value_init (
-    GNUNET_MAX (ntohl (b1.value__), ntohl (b2.value__)));
+  return GNUNET_BANDWIDTH_value_init(
+    GNUNET_MAX(ntohl(b1.value__), ntohl(b2.value__)));
 }
 
 
@@ -85,10 +85,10 @@ GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1,
  * @return the sum of b1 and b2
  */
 struct GNUNET_BANDWIDTH_Value32NBO
-GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1,
-                            struct GNUNET_BANDWIDTH_Value32NBO b2)
+GNUNET_BANDWIDTH_value_sum(struct GNUNET_BANDWIDTH_Value32NBO b1,
+                           struct GNUNET_BANDWIDTH_Value32NBO b2)
 {
-  return GNUNET_BANDWIDTH_value_init (ntohl (b1.value__) + ntohl (b2.value__));
+  return GNUNET_BANDWIDTH_value_init(ntohl(b1.value__) + ntohl(b2.value__));
 }
 
 
@@ -101,18 +101,18 @@ GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1,
  * @return number of bytes available at bps until deadline
  */
 uint64_t
-GNUNET_BANDWIDTH_value_get_available_until (
+GNUNET_BANDWIDTH_value_get_available_until(
   struct GNUNET_BANDWIDTH_Value32NBO bps,
   struct GNUNET_TIME_Relative deadline)
 {
   uint64_t b;
 
-  b = ntohl (bps.value__);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Bandwidth has %llu bytes available until deadline in %s\n",
-       (unsigned long long) ((b * deadline.rel_value_us + 500000LL) /
-                             1000000LL),
-       GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES));
+  b = ntohl(bps.value__);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Bandwidth has %llu bytes available until deadline in %s\n",
+      (unsigned long long)((b * deadline.rel_value_us + 500000LL) /
+                           1000000LL),
+      GNUNET_STRINGS_relative_time_to_string(deadline, GNUNET_YES));
   return (b * deadline.rel_value_us + 500000LL) / 1000000LL;
 }
 
@@ -126,24 +126,24 @@ GNUNET_BANDWIDTH_value_get_available_until (
  * @return how long it would take
  */
 struct GNUNET_TIME_Relative
-GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps,
-                                      uint64_t size)
+GNUNET_BANDWIDTH_value_get_delay_for(struct GNUNET_BANDWIDTH_Value32NBO bps,
+                                     uint64_t size)
 {
   uint64_t b;
   struct GNUNET_TIME_Relative ret;
 
-  b = ntohl (bps.value__);
+  b = ntohl(bps.value__);
   if (0 == b)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Bandwidth suggests delay of infinity (zero bandwidth)\n");
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Bandwidth suggests delay of infinity (zero bandwidth)\n");
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
   ret.rel_value_us = size * 1000LL * 1000LL / b;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Bandwidth suggests delay of %s for %llu bytes of traffic\n",
-       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES),
-       (unsigned long long) size);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Bandwidth suggests delay of %s for %llu bytes of traffic\n",
+      GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES),
+      (unsigned long long)size);
   return ret;
 }
 
@@ -154,17 +154,17 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps,
  * @param cls the `struct GNUNET_BANDWIDTH_Tracker`
  */
 static void
-excess_trigger (void *cls)
+excess_trigger(void *cls)
 {
   struct GNUNET_BANDWIDTH_Tracker *av = cls;
 
   av->excess_task = NULL;
   if (NULL != av->excess_cb)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Notifying application about excess bandwidth\n");
-    av->excess_cb (av->excess_cb_cls);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Notifying application about excess bandwidth\n");
+      av->excess_cb(av->excess_cb_cls);
+    }
 }
 
 
@@ -172,7 +172,7 @@ excess_trigger (void *cls)
  * Recalculate when we might need to call the excess callback.
  */
 static void
-update_excess (struct GNUNET_BANDWIDTH_Tracker *av)
+update_excess(struct GNUNET_BANDWIDTH_Tracker *av)
 {
   struct GNUNET_TIME_Relative delay;
   struct GNUNET_TIME_Absolute now;
@@ -184,53 +184,53 @@ update_excess (struct GNUNET_BANDWIDTH_Tracker *av)
 
   if (NULL == av->excess_cb)
     return; /* nothing to do */
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   delta_time = now.abs_value_us - av->last_update__.abs_value_us;
   delta_avail =
-    (delta_time * ((unsigned long long) av->available_bytes_per_s__) +
+    (delta_time * ((unsigned long long)av->available_bytes_per_s__) +
      500000LL) /
     1000000LL;
   current_consumption = av->consumption_since_last_update__ - delta_avail;
   if (current_consumption > av->consumption_since_last_update__)
-  {
-    /* integer underflow, cap! */
-    current_consumption = INT64_MIN;
-  }
+    {
+      /* integer underflow, cap! */
+      current_consumption = INT64_MIN;
+    }
   /* negative current_consumption means that we have savings */
-  max_carry = ((uint64_t) av->available_bytes_per_s__) * av->max_carry_s__;
+  max_carry = ((uint64_t)av->available_bytes_per_s__) * av->max_carry_s__;
   if (max_carry < GNUNET_MAX_MESSAGE_SIZE)
     max_carry = GNUNET_MAX_MESSAGE_SIZE;
   if (max_carry > INT64_MAX)
     max_carry = INT64_MAX;
   left_bytes = current_consumption + max_carry;
   if (left_bytes < current_consumption)
-  {
-    /* integer overflow, cap! */
-    left_bytes = INT64_MAX;
-  }
+    {
+      /* integer overflow, cap! */
+      left_bytes = INT64_MAX;
+    }
   /* left_bytes now contains the number of bytes needed until
      we have more savings than allowed */
   if (left_bytes < 0)
-  {
-    /* having excess already */
-    delay = GNUNET_TIME_UNIT_ZERO;
-  }
+    {
+      /* having excess already */
+      delay = GNUNET_TIME_UNIT_ZERO;
+    }
   else
-  {
-    double factor = 1.0 * left_bytes / (double) av->available_bytes_per_s__;
-    delay =
-      GNUNET_TIME_relative_saturating_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                                (unsigned long long) factor);
-  }
-  GNUNET_log (
+    {
+      double factor = 1.0 * left_bytes / (double)av->available_bytes_per_s__;
+      delay =
+        GNUNET_TIME_relative_saturating_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                                 (unsigned long long)factor);
+    }
+  GNUNET_log(
     GNUNET_ERROR_TYPE_DEBUG,
     "At %llu bps it will take us %s for %lld bytes to reach excess threshold\n",
-    (unsigned long long) av->available_bytes_per_s__,
-    GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_NO),
-    (long long) left_bytes);
+    (unsigned long long)av->available_bytes_per_s__,
+    GNUNET_STRINGS_relative_time_to_string(delay, GNUNET_NO),
+    (long long)left_bytes);
   if (NULL != av->excess_task)
-    GNUNET_SCHEDULER_cancel (av->excess_task);
-  av->excess_task = GNUNET_SCHEDULER_add_delayed (delay, &excess_trigger, av);
+    GNUNET_SCHEDULER_cancel(av->excess_task);
+  av->excess_task = GNUNET_SCHEDULER_add_delayed(delay, &excess_trigger, av);
 }
 
 
@@ -256,7 +256,7 @@ update_excess (struct GNUNET_BANDWIDTH_Tracker *av)
  * @param excess_cb_cls closure for @a excess_cb
  */
 void
-GNUNET_BANDWIDTH_tracker_init2 (
+GNUNET_BANDWIDTH_tracker_init2(
   struct GNUNET_BANDWIDTH_Tracker *av,
   GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb,
   void *update_cb_cls,
@@ -268,17 +268,17 @@ GNUNET_BANDWIDTH_tracker_init2 (
   av->update_cb = update_cb;
   av->update_cb_cls = update_cb_cls;
   av->consumption_since_last_update__ = 0;
-  av->last_update__ = GNUNET_TIME_absolute_get ();
-  av->available_bytes_per_s__ = ntohl (bytes_per_second_limit.value__);
+  av->last_update__ = GNUNET_TIME_absolute_get();
+  av->available_bytes_per_s__ = ntohl(bytes_per_second_limit.value__);
   av->max_carry_s__ = max_carry_s;
   av->excess_cb = excess_cb;
   av->excess_cb_cls = excess_cb_cls;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p initialized with %u Bps and max carry %u\n",
-       av,
-       (unsigned int) av->available_bytes_per_s__,
-       (unsigned int) max_carry_s);
-  update_excess (av);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Tracker %p initialized with %u Bps and max carry %u\n",
+      av,
+      (unsigned int)av->available_bytes_per_s__,
+      (unsigned int)max_carry_s);
+  update_excess(av);
 }
 
 
@@ -299,20 +299,20 @@ GNUNET_BANDWIDTH_tracker_init2 (
  *        may accumulate before it expires
  */
 void
-GNUNET_BANDWIDTH_tracker_init (
+GNUNET_BANDWIDTH_tracker_init(
   struct GNUNET_BANDWIDTH_Tracker *av,
   GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb,
   void *update_cb_cls,
   struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit,
   uint32_t max_carry_s)
 {
-  GNUNET_BANDWIDTH_tracker_init2 (av,
-                                  update_cb,
-                                  update_cb_cls,
-                                  bytes_per_second_limit,
-                                  max_carry_s,
-                                  NULL,
-                                  NULL);
+  GNUNET_BANDWIDTH_tracker_init2(av,
+                                 update_cb,
+                                 update_cb_cls,
+                                 bytes_per_second_limit,
+                                 max_carry_s,
+                                 NULL,
+                                 NULL);
 }
 
 
@@ -322,10 +322,10 @@ GNUNET_BANDWIDTH_tracker_init (
  * @param av the respective trackers
  */
 void
-GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av)
+GNUNET_BANDWIDTH_tracker_notification_stop(struct GNUNET_BANDWIDTH_Tracker *av)
 {
   if (NULL != av->excess_task)
-    GNUNET_SCHEDULER_cancel (av->excess_task);
+    GNUNET_SCHEDULER_cancel(av->excess_task);
   av->excess_task = NULL;
   av->excess_cb = NULL;
   av->excess_cb_cls = NULL;
@@ -341,7 +341,7 @@ GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av)
  * @param av tracker to update
  */
 static void
-update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
+update_tracker(struct GNUNET_BANDWIDTH_Tracker *av)
 {
   struct GNUNET_TIME_Absolute now;
   uint64_t delta_time;
@@ -349,39 +349,39 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
   uint64_t left_bytes;
   uint64_t max_carry;
 
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   delta_time = now.abs_value_us - av->last_update__.abs_value_us;
   delta_avail =
-    (delta_time * ((unsigned long long) av->available_bytes_per_s__) +
+    (delta_time * ((unsigned long long)av->available_bytes_per_s__) +
      500000LL) /
     1000000LL;
   av->consumption_since_last_update__ -= delta_avail;
   av->last_update__ = now;
   if (av->consumption_since_last_update__ < 0)
-  {
-    left_bytes = -av->consumption_since_last_update__;
-    max_carry =
-      ((unsigned long long) av->available_bytes_per_s__) * av->max_carry_s__;
-    if (max_carry < GNUNET_MAX_MESSAGE_SIZE)
-      max_carry = GNUNET_MAX_MESSAGE_SIZE;
-    if (max_carry > INT64_MAX)
-      max_carry = INT64_MAX;
-    if (max_carry > left_bytes)
-      av->consumption_since_last_update__ = -left_bytes;
-    else
-      av->consumption_since_last_update__ = -max_carry;
-  }
-#if ! defined(GNUNET_CULL_LOGGING)
+    {
+      left_bytes = -av->consumption_since_last_update__;
+      max_carry =
+        ((unsigned long long)av->available_bytes_per_s__) * av->max_carry_s__;
+      if (max_carry < GNUNET_MAX_MESSAGE_SIZE)
+        max_carry = GNUNET_MAX_MESSAGE_SIZE;
+      if (max_carry > INT64_MAX)
+        max_carry = INT64_MAX;
+      if (max_carry > left_bytes)
+        av->consumption_since_last_update__ = -left_bytes;
+      else
+        av->consumption_since_last_update__ = -max_carry;
+    }
+#if !defined(GNUNET_CULL_LOGGING)
   {
     struct GNUNET_TIME_Relative delta;
 
     delta.rel_value_us = delta_time;
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Tracker %p updated, consumption at %lld at %u Bps, last update was %s ago\n",
-         av,
-         (long long) av->consumption_since_last_update__,
-         (unsigned int) av->available_bytes_per_s__,
-         GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
+    LOG(GNUNET_ERROR_TYPE_DEBUG,
+        "Tracker %p updated, consumption at %lld at %u Bps, last update was %s ago\n",
+        av,
+        (long long)av->consumption_since_last_update__,
+        (unsigned int)av->available_bytes_per_s__,
+        GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_YES));
   }
 #endif
 }
@@ -399,48 +399,48 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
  * @return #GNUNET_YES if this consumption is above the limit
  */
 int
-GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
-                                  ssize_t size)
+GNUNET_BANDWIDTH_tracker_consume(struct GNUNET_BANDWIDTH_Tracker *av,
+                                 ssize_t size)
 {
   int64_t nc;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p consumes %d bytes\n",
-       av,
-       (int) size);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Tracker %p consumes %d bytes\n",
+      av,
+      (int)size);
   if (size > 0)
-  {
-    nc = av->consumption_since_last_update__ + size;
-    if (nc < av->consumption_since_last_update__)
     {
-      /* integer overflow, very bad */
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      nc = av->consumption_since_last_update__ + size;
+      if (nc < av->consumption_since_last_update__)
+        {
+          /* integer overflow, very bad */
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      av->consumption_since_last_update__ = nc;
+      update_tracker(av);
+      update_excess(av);
+      if (av->consumption_since_last_update__ > 0)
+        {
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Tracker %p consumption %llu bytes above limit\n",
+              av,
+              (unsigned long long)av->consumption_since_last_update__);
+          return GNUNET_YES;
+        }
     }
-    av->consumption_since_last_update__ = nc;
-    update_tracker (av);
-    update_excess (av);
-    if (av->consumption_since_last_update__ > 0)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Tracker %p consumption %llu bytes above limit\n",
-           av,
-           (unsigned long long) av->consumption_since_last_update__);
-      return GNUNET_YES;
-    }
-  }
   else
-  {
-    nc = av->consumption_since_last_update__ + size;
-    if (nc > av->consumption_since_last_update__)
     {
-      /* integer underflow, very bad */
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      nc = av->consumption_since_last_update__ + size;
+      if (nc > av->consumption_since_last_update__)
+        {
+          /* integer underflow, very bad */
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      av->consumption_since_last_update__ = nc;
+      update_excess(av);
     }
-    av->consumption_since_last_update__ = nc;
-    update_excess (av);
-  }
   return GNUNET_NO;
 }
 
@@ -455,34 +455,34 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
  * @return time in ms to wait for consumption to be OK
  */
 struct GNUNET_TIME_Relative
-GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
-                                    size_t size)
+GNUNET_BANDWIDTH_tracker_get_delay(struct GNUNET_BANDWIDTH_Tracker *av,
+                                   size_t size)
 {
   struct GNUNET_TIME_Relative ret;
   int64_t bytes_needed;
 
   if (0 == av->available_bytes_per_s__)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av);
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
-  update_tracker (av);
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av);
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
+  update_tracker(av);
   bytes_needed = size + av->consumption_since_last_update__;
   if (bytes_needed <= 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Tracker %p delay for %u bytes is zero\n",
-         av,
-         (unsigned int) size);
-    return GNUNET_TIME_UNIT_ZERO;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Tracker %p delay for %u bytes is zero\n",
+          av,
+          (unsigned int)size);
+      return GNUNET_TIME_UNIT_ZERO;
+    }
   ret.rel_value_us = (1000LL * 1000LL * bytes_needed) /
-                     (unsigned long long) av->available_bytes_per_s__;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p delay for %u bytes is %s\n",
-       av,
-       (unsigned int) size,
-       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+                     (unsigned long long)av->available_bytes_per_s__;
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Tracker %p delay for %u bytes is %s\n",
+      av,
+      (unsigned int)size,
+      GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
   return ret;
 }
 
@@ -495,24 +495,24 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
  * @return number of bytes available for consumption right now
  */
 int64_t
-GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av)
+GNUNET_BANDWIDTH_tracker_get_available(struct GNUNET_BANDWIDTH_Tracker *av)
 {
   struct GNUNET_BANDWIDTH_Value32NBO bps;
   uint64_t avail;
   int64_t used;
 
-  update_tracker (av);
-  bps = GNUNET_BANDWIDTH_value_init (av->available_bytes_per_s__);
+  update_tracker(av);
+  bps = GNUNET_BANDWIDTH_value_init(av->available_bytes_per_s__);
   avail =
-    GNUNET_BANDWIDTH_value_get_available_until (bps,
-                                                GNUNET_TIME_absolute_get_duration (
-                                                  av->last_update__));
+    GNUNET_BANDWIDTH_value_get_available_until(bps,
+                                               GNUNET_TIME_absolute_get_duration(
+                                                 av->last_update__));
   used = av->consumption_since_last_update__;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p available bandwidth is %lld bytes\n",
-       av,
-       (long long) (int64_t) (avail - used));
-  return (int64_t) (avail - used);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Tracker %p available bandwidth is %lld bytes\n",
+      av,
+      (long long)(int64_t)(avail - used));
+  return (int64_t)(avail - used);
 }
 
 
@@ -523,26 +523,26 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av)
  * @param bytes_per_second_limit new limit to assume
  */
 void
-GNUNET_BANDWIDTH_tracker_update_quota (
+GNUNET_BANDWIDTH_tracker_update_quota(
   struct GNUNET_BANDWIDTH_Tracker *av,
   struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
 {
   uint32_t old_limit;
   uint32_t new_limit;
 
-  new_limit = ntohl (bytes_per_second_limit.value__);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p bandwidth changed to %u Bps\n",
-       av,
-       (unsigned int) new_limit);
-  update_tracker (av);
+  new_limit = ntohl(bytes_per_second_limit.value__);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Tracker %p bandwidth changed to %u Bps\n",
+      av,
+      (unsigned int)new_limit);
+  update_tracker(av);
   old_limit = av->available_bytes_per_s__;
   av->available_bytes_per_s__ = new_limit;
   if (NULL != av->update_cb)
-    av->update_cb (av->update_cb_cls);
+    av->update_cb(av->update_cb_cls);
   if (old_limit > new_limit)
-    update_tracker (av); /* maximum excess might be less now */
-  update_excess (av);
+    update_tracker(av);  /* maximum excess might be less now */
+  update_excess(av);
 }
 
 
diff --git a/src/util/benchmark.c b/src/util/benchmark.c
index caf6cd64a..c01b7a515 100644
--- a/src/util/benchmark.c
+++ b/src/util/benchmark.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file util/benchmark.c
@@ -47,109 +47,109 @@ static pthread_once_t key_once = PTHREAD_ONCE_INIT;
  * @param bd the benchmark data
  */
 static void
-write_benchmark_data (struct BenchmarkData *bd)
+write_benchmark_data(struct BenchmarkData *bd)
 {
   struct GNUNET_DISK_FileHandle *fh;
-  pid_t pid = getpid ();
-  pid_t tid = syscall (SYS_gettid);
+  pid_t pid = getpid();
+  pid_t tid = syscall(SYS_gettid);
   char *benchmark_dir;
   char *s;
 
-  benchmark_dir = getenv ("GNUNET_BENCHMARK_DIR");
+  benchmark_dir = getenv("GNUNET_BENCHMARK_DIR");
 
   if (NULL == benchmark_dir)
     return;
 
-  if (GNUNET_OK != GNUNET_DISK_directory_create (benchmark_dir))
-  {
-    GNUNET_break (0);
-    return;
-  }
+  if (GNUNET_OK != GNUNET_DISK_directory_create(benchmark_dir))
+    {
+      GNUNET_break(0);
+      return;
+    }
 
-  GNUNET_asprintf (&s, "%s/gnunet-benchmark-ops-%s-%llu-%llu.txt",
-                   benchmark_dir,
-                   (pid == tid) ? "main" : "thread",
-                   (unsigned long long) pid,
-                   (unsigned long long) tid);
-
-  fh = GNUNET_DISK_file_open (s,
-                              (GNUNET_DISK_OPEN_WRITE |
-                               GNUNET_DISK_OPEN_TRUNCATE |
-                               GNUNET_DISK_OPEN_CREATE),
-                              (GNUNET_DISK_PERM_USER_READ |
-                               GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_assert (NULL != fh);
-  GNUNET_free (s);
+  GNUNET_asprintf(&s, "%s/gnunet-benchmark-ops-%s-%llu-%llu.txt",
+                  benchmark_dir,
+                  (pid == tid) ? "main" : "thread",
+                  (unsigned long long)pid,
+                  (unsigned long long)tid);
+
+  fh = GNUNET_DISK_file_open(s,
+                             (GNUNET_DISK_OPEN_WRITE |
+                              GNUNET_DISK_OPEN_TRUNCATE |
+                              GNUNET_DISK_OPEN_CREATE),
+                             (GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_assert(NULL != fh);
+  GNUNET_free(s);
 
 #define WRITE_BENCHMARK_OP(opname) do { \
-  GNUNET_asprintf (&s, "op " #opname " count %llu time_us %llu\n", \
-                   (unsigned long long) bd->opname##_count, \
-                   (unsigned long long) bd->opname##_time.rel_value_us); \
-  GNUNET_assert (GNUNET_SYSERR != GNUNET_DISK_file_write_blocking (fh, s, strlen (s))); \
-  GNUNET_free (s); \
-} while (0)
-
-  WRITE_BENCHMARK_OP (ecc_ecdh);
-  WRITE_BENCHMARK_OP (ecdh_eddsa);
-  WRITE_BENCHMARK_OP (ecdhe_key_create);
-  WRITE_BENCHMARK_OP (ecdhe_key_get_public);
-  WRITE_BENCHMARK_OP (ecdsa_ecdh);
-  WRITE_BENCHMARK_OP (ecdsa_key_create);
-  WRITE_BENCHMARK_OP (ecdsa_key_get_public);
-  WRITE_BENCHMARK_OP (ecdsa_sign);
-  WRITE_BENCHMARK_OP (ecdsa_verify);
-  WRITE_BENCHMARK_OP (eddsa_ecdh);
-  WRITE_BENCHMARK_OP (eddsa_key_create);
-  WRITE_BENCHMARK_OP (eddsa_key_get_public);
-  WRITE_BENCHMARK_OP (eddsa_sign);
-  WRITE_BENCHMARK_OP (eddsa_verify);
-  WRITE_BENCHMARK_OP (hash);
-  WRITE_BENCHMARK_OP (hash_context_finish);
-  WRITE_BENCHMARK_OP (hash_context_read);
-  WRITE_BENCHMARK_OP (hash_context_start);
-  WRITE_BENCHMARK_OP (hkdf);
-  WRITE_BENCHMARK_OP (rsa_blind);
-  WRITE_BENCHMARK_OP (rsa_private_key_create);
-  WRITE_BENCHMARK_OP (rsa_private_key_get_public);
-  WRITE_BENCHMARK_OP (rsa_sign_blinded);
-  WRITE_BENCHMARK_OP (rsa_unblind);
-  WRITE_BENCHMARK_OP (rsa_verify);
+      GNUNET_asprintf(&s, "op " #opname " count %llu time_us %llu\n", \
+                      (unsigned long long)bd->opname ## _count, \
+                      (unsigned long long)bd->opname ## _time.rel_value_us); \
+      GNUNET_assert(GNUNET_SYSERR != GNUNET_DISK_file_write_blocking(fh, s, strlen(s))); \
+      GNUNET_free(s); \
+  } while (0)
+
+  WRITE_BENCHMARK_OP(ecc_ecdh);
+  WRITE_BENCHMARK_OP(ecdh_eddsa);
+  WRITE_BENCHMARK_OP(ecdhe_key_create);
+  WRITE_BENCHMARK_OP(ecdhe_key_get_public);
+  WRITE_BENCHMARK_OP(ecdsa_ecdh);
+  WRITE_BENCHMARK_OP(ecdsa_key_create);
+  WRITE_BENCHMARK_OP(ecdsa_key_get_public);
+  WRITE_BENCHMARK_OP(ecdsa_sign);
+  WRITE_BENCHMARK_OP(ecdsa_verify);
+  WRITE_BENCHMARK_OP(eddsa_ecdh);
+  WRITE_BENCHMARK_OP(eddsa_key_create);
+  WRITE_BENCHMARK_OP(eddsa_key_get_public);
+  WRITE_BENCHMARK_OP(eddsa_sign);
+  WRITE_BENCHMARK_OP(eddsa_verify);
+  WRITE_BENCHMARK_OP(hash);
+  WRITE_BENCHMARK_OP(hash_context_finish);
+  WRITE_BENCHMARK_OP(hash_context_read);
+  WRITE_BENCHMARK_OP(hash_context_start);
+  WRITE_BENCHMARK_OP(hkdf);
+  WRITE_BENCHMARK_OP(rsa_blind);
+  WRITE_BENCHMARK_OP(rsa_private_key_create);
+  WRITE_BENCHMARK_OP(rsa_private_key_get_public);
+  WRITE_BENCHMARK_OP(rsa_sign_blinded);
+  WRITE_BENCHMARK_OP(rsa_unblind);
+  WRITE_BENCHMARK_OP(rsa_verify);
 
 #undef WRITE_BENCHMARK_OP
 
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
 
-  GNUNET_asprintf (&s, "%s/gnunet-benchmark-urls-%s-%llu-%llu.txt",
-                   benchmark_dir,
-                   (pid == tid) ? "main" : "thread",
-                   (unsigned long long) pid,
-                   (unsigned long long) tid);
+  GNUNET_asprintf(&s, "%s/gnunet-benchmark-urls-%s-%llu-%llu.txt",
+                  benchmark_dir,
+                  (pid == tid) ? "main" : "thread",
+                  (unsigned long long)pid,
+                  (unsigned long long)tid);
 
-  fh = GNUNET_DISK_file_open (s,
-                              (GNUNET_DISK_OPEN_WRITE |
-                               GNUNET_DISK_OPEN_TRUNCATE |
-                               GNUNET_DISK_OPEN_CREATE),
-                              (GNUNET_DISK_PERM_USER_READ |
-                               GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_assert (NULL != fh);
-  GNUNET_free (s);
+  fh = GNUNET_DISK_file_open(s,
+                             (GNUNET_DISK_OPEN_WRITE |
+                              GNUNET_DISK_OPEN_TRUNCATE |
+                              GNUNET_DISK_OPEN_CREATE),
+                             (GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_assert(NULL != fh);
+  GNUNET_free(s);
 
   for (unsigned int i = 0; i < bd->urd_len; i++)
-  {
-    struct UrlRequestData *urd = &bd->urd[i];
-    GNUNET_asprintf (&s, "url %s status %u count %llu time_us %llu time_us_max %llu bytes_sent %llu bytes_received %llu\n",
-                     urd->request_url,
-                     urd->status,
-                     (unsigned long long) urd->count,
-                     (unsigned long long) urd->time.rel_value_us,
-                     (unsigned long long) urd->time_max.rel_value_us,
-                     (unsigned long long) urd->bytes_sent,
-                     (unsigned long long) urd->bytes_received);
-    GNUNET_assert (GNUNET_SYSERR != GNUNET_DISK_file_write_blocking (fh, s, strlen (s)));
-    GNUNET_free (s);
-  }
+    {
+      struct UrlRequestData *urd = &bd->urd[i];
+      GNUNET_asprintf(&s, "url %s status %u count %llu time_us %llu time_us_max %llu bytes_sent %llu bytes_received %llu\n",
+                      urd->request_url,
+                      urd->status,
+                      (unsigned long long)urd->count,
+                      (unsigned long long)urd->time.rel_value_us,
+                      (unsigned long long)urd->time_max.rel_value_us,
+                      (unsigned long long)urd->bytes_sent,
+                      (unsigned long long)urd->bytes_received);
+      GNUNET_assert(GNUNET_SYSERR != GNUNET_DISK_file_write_blocking(fh, s, strlen(s)));
+      GNUNET_free(s);
+    }
 
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
 }
 
 
@@ -157,13 +157,13 @@ write_benchmark_data (struct BenchmarkData *bd)
  * Called when the main thread exits and benchmark data for it was created.
  */
 static void
-main_thread_destructor ()
+main_thread_destructor()
 {
   struct BenchmarkData *bd;
 
-  bd = pthread_getspecific (key);
+  bd = pthread_getspecific(key);
   if (NULL != bd)
-    write_benchmark_data (bd);
+    write_benchmark_data(bd);
 }
 
 
@@ -173,16 +173,16 @@ main_thread_destructor ()
  * @param cls closure
  */
 static void
-thread_destructor (void *cls)
+thread_destructor(void *cls)
 {
   struct BenchmarkData *bd = cls;
 
   // main thread will be handled by atexit
-  if (getpid () == (pid_t) syscall (SYS_gettid))
+  if (getpid() == (pid_t)syscall(SYS_gettid))
     return;
-  
-  GNUNET_assert (NULL != bd);
-  write_benchmark_data (bd);
+
+  GNUNET_assert(NULL != bd);
+  write_benchmark_data(bd);
 }
 
 
@@ -190,9 +190,9 @@ thread_destructor (void *cls)
  * Initialize the thread-local variable key for benchmark data.
  */
 static void
-make_key ()
+make_key()
 {
-  (void) pthread_key_create (&key, &thread_destructor);
+  (void)pthread_key_create(&key, &thread_destructor);
 }
 
 
@@ -203,22 +203,22 @@ make_key ()
  * @return benchmark data for the current thread
  */
 struct BenchmarkData *
-get_benchmark_data (void)
+get_benchmark_data(void)
 {
   struct BenchmarkData *bd;
 
-  (void) pthread_once (&key_once, &make_key);
+  (void)pthread_once(&key_once, &make_key);
 
-  if (NULL == (bd = pthread_getspecific (key)))
-  {
-    bd = GNUNET_new (struct BenchmarkData);
-    (void) pthread_setspecific (key, bd);
-    if (getpid () == (pid_t) syscall (SYS_gettid))
+  if (NULL == (bd = pthread_getspecific(key)))
     {
-      // We're the main thread!
-      atexit (main_thread_destructor);
+      bd = GNUNET_new(struct BenchmarkData);
+      (void)pthread_setspecific(key, bd);
+      if (getpid() == (pid_t)syscall(SYS_gettid))
+        {
+          // We're the main thread!
+          atexit(main_thread_destructor);
+        }
     }
-  }
   return bd;
 }
 
@@ -233,53 +233,53 @@ get_benchmark_data (void)
  * @param status http status code
  */
 struct UrlRequestData *
-get_url_benchmark_data (char *url, unsigned int status)
+get_url_benchmark_data(char *url, unsigned int status)
 {
   char trunc[MAX_BENCHMARK_URL_LEN];
   struct BenchmarkData *bd;
 
   if (NULL == url)
-  {
-    /* Should not happen unless curl barfs */
-    GNUNET_break (0);
-    url = "<empty>";
-  }
+    {
+      /* Should not happen unless curl barfs */
+      GNUNET_break(0);
+      url = "<empty>";
+    }
 
-  memcpy (trunc, url, MAX_BENCHMARK_URL_LEN);
+  memcpy(trunc, url, MAX_BENCHMARK_URL_LEN);
   trunc[MAX_BENCHMARK_URL_LEN - 1] = 0;
 
   /* We're not interested in what's after the query string */
-  for (size_t i = 0; i < strlen (trunc); i++)
-  {
-    if (trunc[i] == '?')
+  for (size_t i = 0; i < strlen(trunc); i++)
     {
-      trunc[i] = 0;
-      break;
+      if (trunc[i] == '?')
+        {
+          trunc[i] = 0;
+          break;
+        }
     }
-  }
 
-  bd = get_benchmark_data ();
+  bd = get_benchmark_data();
 
-  GNUNET_assert (bd->urd_len <= bd->urd_capacity);
+  GNUNET_assert(bd->urd_len <= bd->urd_capacity);
 
   for (unsigned int i = 0; i < bd->urd_len; i++)
-  {
-    if ( (0 == strcmp (trunc, bd->urd[i].request_url)) &&
-         (bd->urd[i].status == status) )
-      return &bd->urd[i];
-  }
+    {
+      if ((0 == strcmp(trunc, bd->urd[i].request_url)) &&
+          (bd->urd[i].status == status))
+        return &bd->urd[i];
+    }
 
   {
     struct UrlRequestData urd = { 0 };
 
-    memcpy (&urd.request_url, trunc, MAX_BENCHMARK_URL_LEN);
+    memcpy(&urd.request_url, trunc, MAX_BENCHMARK_URL_LEN);
     urd.status = status;
 
     if (bd->urd_len == bd->urd_capacity)
-    {
-      bd->urd_capacity = 2 * (bd->urd_capacity + 1);
-      bd->urd = GNUNET_realloc (bd->urd, bd->urd_capacity * sizeof (struct UrlRequestData));
-    }
+      {
+        bd->urd_capacity = 2 * (bd->urd_capacity + 1);
+        bd->urd = GNUNET_realloc(bd->urd, bd->urd_capacity * sizeof(struct UrlRequestData));
+      }
 
     bd->urd[bd->urd_len++] = urd;
     return &bd->urd[bd->urd_len - 1];
diff --git a/src/util/benchmark.h b/src/util/benchmark.h
index 4148ac655..6816b47af 100644
--- a/src/util/benchmark.h
+++ b/src/util/benchmark.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 util/benchmark.h
@@ -37,18 +37,18 @@
 
 #if ENABLE_BENCHMARK
 #define BENCHMARK_START(opname) \
-    struct GNUNET_TIME_Absolute _benchmark_##opname##_start = GNUNET_TIME_absolute_get ()
+  struct GNUNET_TIME_Absolute _benchmark_ ## opname ## _start = GNUNET_TIME_absolute_get()
 #define BENCHMARK_END(opname) do { \
-  { \
-    struct GNUNET_TIME_Absolute _benchmark_##opname##_end = GNUNET_TIME_absolute_get (); \
-    struct BenchmarkData *bd = get_benchmark_data (); \
-    bd->opname##_count++; \
-    bd->opname##_time = \
-        GNUNET_TIME_relative_add (bd->opname##_time, \
-                                  GNUNET_TIME_absolute_get_difference (_benchmark_##opname##_start, \
-                                                                       _benchmark_##opname##_end)); \
-  } \
-} while (0)
+      { \
+        struct GNUNET_TIME_Absolute _benchmark_ ## opname ## _end = GNUNET_TIME_absolute_get(); \
+        struct BenchmarkData *bd = get_benchmark_data(); \
+        bd->opname ## _count++; \
+        bd->opname ## _time = \
+          GNUNET_TIME_relative_add(bd->opname ## _time, \
+                                   GNUNET_TIME_absolute_get_difference(_benchmark_ ## opname ## _start, \
+                                                                       _benchmark_ ## opname ## _end)); \
+      } \
+  } while (0)
 #else
 #define BENCHMARK_START(opname) do { } while (0)
 #define BENCHMARK_END(opname) do { } while (0)
@@ -58,8 +58,7 @@
 /**
  * Struct for benchmark data for one URL.
  */
-struct UrlRequestData
-{
+struct UrlRequestData {
   /**
    * Request URL, truncated (but 0-terminated).
    */
@@ -69,7 +68,7 @@ struct UrlRequestData
    * HTTP status code.
    */
   unsigned int status;
-  
+
   /**
    * How often was the URL requested?
    */
@@ -102,39 +101,38 @@ struct UrlRequestData
 };
 
 #define GNUNET_DECLARE_BENCHMARK_OP(opname) \
-    uint64_t opname##_count; \
-    struct GNUNET_TIME_Relative opname##_time
+  uint64_t opname ## _count; \
+  struct GNUNET_TIME_Relative opname ## _time
 
 /**
  * Thread-local struct for benchmarking data.
  */
-struct BenchmarkData
-{
-  GNUNET_DECLARE_BENCHMARK_OP (ecc_ecdh);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdh_eddsa);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdhe_key_create);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdhe_key_get_public);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_ecdh);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_key_create);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_key_get_public);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_sign);
-  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_verify);
-  GNUNET_DECLARE_BENCHMARK_OP (eddsa_ecdh);
-  GNUNET_DECLARE_BENCHMARK_OP (eddsa_key_create);
-  GNUNET_DECLARE_BENCHMARK_OP (eddsa_key_get_public);
-  GNUNET_DECLARE_BENCHMARK_OP (eddsa_sign);
-  GNUNET_DECLARE_BENCHMARK_OP (eddsa_verify);
-  GNUNET_DECLARE_BENCHMARK_OP (hash);
-  GNUNET_DECLARE_BENCHMARK_OP (hash_context_finish);
-  GNUNET_DECLARE_BENCHMARK_OP (hash_context_read);
-  GNUNET_DECLARE_BENCHMARK_OP (hash_context_start);
-  GNUNET_DECLARE_BENCHMARK_OP (hkdf);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_blind);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_private_key_create);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_private_key_get_public);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_sign_blinded);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_unblind);
-  GNUNET_DECLARE_BENCHMARK_OP (rsa_verify);
+struct BenchmarkData {
+  GNUNET_DECLARE_BENCHMARK_OP(ecc_ecdh);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdh_eddsa);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdhe_key_create);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdhe_key_get_public);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdsa_ecdh);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdsa_key_create);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdsa_key_get_public);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdsa_sign);
+  GNUNET_DECLARE_BENCHMARK_OP(ecdsa_verify);
+  GNUNET_DECLARE_BENCHMARK_OP(eddsa_ecdh);
+  GNUNET_DECLARE_BENCHMARK_OP(eddsa_key_create);
+  GNUNET_DECLARE_BENCHMARK_OP(eddsa_key_get_public);
+  GNUNET_DECLARE_BENCHMARK_OP(eddsa_sign);
+  GNUNET_DECLARE_BENCHMARK_OP(eddsa_verify);
+  GNUNET_DECLARE_BENCHMARK_OP(hash);
+  GNUNET_DECLARE_BENCHMARK_OP(hash_context_finish);
+  GNUNET_DECLARE_BENCHMARK_OP(hash_context_read);
+  GNUNET_DECLARE_BENCHMARK_OP(hash_context_start);
+  GNUNET_DECLARE_BENCHMARK_OP(hkdf);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_blind);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_private_key_create);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_private_key_get_public);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_sign_blinded);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_unblind);
+  GNUNET_DECLARE_BENCHMARK_OP(rsa_verify);
 
   struct UrlRequestData *urd;
 
@@ -153,7 +151,7 @@ struct BenchmarkData
  * @return benchmark data for the current thread
  */
 struct BenchmarkData *
-get_benchmark_data (void);
+get_benchmark_data(void);
 
 /**
  * Get benchmark data for a URL.  If the URL is too long, it's truncated
@@ -165,6 +163,6 @@ get_benchmark_data (void);
  * @param status http status code
  */
 struct UrlRequestData *
-get_url_benchmark_data (char *url, unsigned int status);
+get_url_benchmark_data(char *url, unsigned int status);
 
 #endif  /* BENCHMARK_H_ */
diff --git a/src/util/bio.c b/src/util/bio.c
index 1df249e40..5cbeee084 100644
--- a/src/util/bio.c
+++ b/src/util/bio.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 util/bio.c
  * @brief functions for buffering IO
@@ -25,7 +25,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-bio", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-bio", __VA_ARGS__)
 
 #ifndef PATH_MAX
 /**
@@ -50,8 +50,7 @@
 /**
  * Handle for buffered reading.
  */
-struct GNUNET_BIO_ReadHandle
-{
+struct GNUNET_BIO_ReadHandle {
   /**
    * Underlying file abstraction.
    */
@@ -91,16 +90,16 @@ struct GNUNET_BIO_ReadHandle
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_BIO_ReadHandle *
-GNUNET_BIO_read_open (const char *fn)
+GNUNET_BIO_read_open(const char *fn)
 {
   struct GNUNET_DISK_FileHandle *fd;
   struct GNUNET_BIO_ReadHandle *h;
 
-  fd = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  fd = GNUNET_DISK_file_open(fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
   if (NULL == fd)
     return NULL;
-  h = GNUNET_malloc (sizeof (struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
-  h->buffer = (char *) &h[1];
+  h = GNUNET_malloc(sizeof(struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
+  h->buffer = (char *)&h[1];
   h->size = BIO_BUFFER_SIZE;
   h->fd = fd;
   return h;
@@ -116,7 +115,7 @@ GNUNET_BIO_read_open (const char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
+GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
 {
   int err;
 
@@ -124,9 +123,9 @@ GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
   if (emsg != NULL)
     *emsg = h->emsg;
   else
-    GNUNET_free_non_null (h->emsg);
-  GNUNET_DISK_file_close (h->fd);
-  GNUNET_free (h);
+    GNUNET_free_non_null(h->emsg);
+  GNUNET_DISK_file_close(h->fd);
+  GNUNET_free(h);
   return err;
 }
 
@@ -141,10 +140,10 @@ GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
-                 const char *what,
-                 void *result,
-                 size_t len)
+GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h,
+                const char *what,
+                void *result,
+                size_t len)
 {
   char *dst = result;
   size_t min;
@@ -155,41 +154,42 @@ GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
     return GNUNET_SYSERR;
   pos = 0;
   do
-  {
-    /* first, use buffer */
-    min = h->have - h->pos;
-    if (min > 0)
-    {
-      if (min > len - pos)
-        min = len - pos;
-      GNUNET_memcpy (&dst[pos], &h->buffer[h->pos], min);
-      h->pos += min;
-      pos += min;
-    }
-    if (pos == len)
-      return GNUNET_OK; /* done! */
-    GNUNET_assert (((off_t) h->have) == h->pos);
-    /* fill buffer */
-    ret = GNUNET_DISK_file_read (h->fd, h->buffer, h->size);
-    if (-1 == ret)
-    {
-      GNUNET_asprintf (&h->emsg,
-                       _ ("Error reading `%s': %s"),
-                       what,
-                       strerror (errno));
-      return GNUNET_SYSERR;
-    }
-    if (0 == ret)
     {
-      GNUNET_asprintf (&h->emsg,
-                       _ ("Error reading `%s': %s"),
-                       what,
-                       _ ("End of file"));
-      return GNUNET_SYSERR;
+      /* first, use buffer */
+      min = h->have - h->pos;
+      if (min > 0)
+        {
+          if (min > len - pos)
+            min = len - pos;
+          GNUNET_memcpy(&dst[pos], &h->buffer[h->pos], min);
+          h->pos += min;
+          pos += min;
+        }
+      if (pos == len)
+        return GNUNET_OK; /* done! */
+      GNUNET_assert(((off_t)h->have) == h->pos);
+      /* fill buffer */
+      ret = GNUNET_DISK_file_read(h->fd, h->buffer, h->size);
+      if (-1 == ret)
+        {
+          GNUNET_asprintf(&h->emsg,
+                          _("Error reading `%s': %s"),
+                          what,
+                          strerror(errno));
+          return GNUNET_SYSERR;
+        }
+      if (0 == ret)
+        {
+          GNUNET_asprintf(&h->emsg,
+                          _("Error reading `%s': %s"),
+                          what,
+                          _("End of file"));
+          return GNUNET_SYSERR;
+        }
+      h->pos = 0;
+      h->have = ret;
     }
-    h->pos = 0;
-    h->have = ret;
-  } while (pos < len); /* should always be true */
+  while (pos < len);   /* should always be true */
   return GNUNET_OK;
 }
 
@@ -205,16 +205,16 @@ GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h,
-                    const char *file,
-                    int line,
-                    void *result,
-                    size_t len)
+GNUNET_BIO_read_fn(struct GNUNET_BIO_ReadHandle *h,
+                   const char *file,
+                   int line,
+                   void *result,
+                   size_t len)
 {
   char what[PATH_MAX + 1024];
 
-  GNUNET_snprintf (what, sizeof (what), "%s:%d", file, line);
-  return GNUNET_BIO_read (h, what, result, len);
+  GNUNET_snprintf(what, sizeof(what), "%s:%d", file, line);
+  return GNUNET_BIO_read(h, what, result, len);
 }
 
 
@@ -229,45 +229,45 @@ GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
-                        const char *what,
-                        char **result,
-                        size_t max_length)
+GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h,
+                       const char *what,
+                       char **result,
+                       size_t max_length)
 {
   char *buf;
   uint32_t big;
 
-  if (GNUNET_OK != GNUNET_BIO_read_int32 (h, &big))
-  {
-    GNUNET_free_non_null (h->emsg);
-    GNUNET_asprintf (&h->emsg, _ ("Error reading length of string `%s'"), what);
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_OK != GNUNET_BIO_read_int32(h, &big))
+    {
+      GNUNET_free_non_null(h->emsg);
+      GNUNET_asprintf(&h->emsg, _("Error reading length of string `%s'"), what);
+      return GNUNET_SYSERR;
+    }
   if (0 == big)
-  {
-    *result = NULL;
-    return GNUNET_OK;
-  }
+    {
+      *result = NULL;
+      return GNUNET_OK;
+    }
   if (big > max_length)
-  {
-    GNUNET_asprintf (&h->emsg,
-                     _ ("String `%s' longer than allowed (%u > %u)"),
-                     what,
-                     big,
-                     max_length);
-    return GNUNET_SYSERR;
-  }
-  buf = GNUNET_malloc (big);
+    {
+      GNUNET_asprintf(&h->emsg,
+                      _("String `%s' longer than allowed (%u > %u)"),
+                      what,
+                      big,
+                      max_length);
+      return GNUNET_SYSERR;
+    }
+  buf = GNUNET_malloc(big);
   *result = buf;
   buf[--big] = '\0';
   if (0 == big)
     return GNUNET_OK;
-  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, big))
-  {
-    GNUNET_free (buf);
-    *result = NULL;
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_OK != GNUNET_BIO_read(h, what, buf, big))
+    {
+      GNUNET_free(buf);
+      *result = NULL;
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -281,44 +281,44 @@ GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
-                           const char *what,
-                           struct GNUNET_CONTAINER_MetaData **result)
+GNUNET_BIO_read_meta_data(struct GNUNET_BIO_ReadHandle *h,
+                          const char *what,
+                          struct GNUNET_CONTAINER_MetaData **result)
 {
   uint32_t size;
   char *buf;
   struct GNUNET_CONTAINER_MetaData *meta;
 
-  if (GNUNET_OK != GNUNET_BIO_read_int32 (h, (int32_t *) &size))
+  if (GNUNET_OK != GNUNET_BIO_read_int32(h, (int32_t *)&size))
     return GNUNET_SYSERR;
   if (size == 0)
-  {
-    *result = NULL;
-    return GNUNET_OK;
-  }
+    {
+      *result = NULL;
+      return GNUNET_OK;
+    }
   if (size > MAX_META_DATA)
-  {
-    GNUNET_asprintf (&h->emsg,
-                     _ ("Serialized metadata `%s' larger than allowed (%u>%u)"),
-                     what,
-                     size,
-                     MAX_META_DATA);
-    return GNUNET_SYSERR;
-  }
-  buf = GNUNET_malloc (size);
-  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
-  {
-    GNUNET_free (buf);
-    return GNUNET_SYSERR;
-  }
-  meta = GNUNET_CONTAINER_meta_data_deserialize (buf, size);
+    {
+      GNUNET_asprintf(&h->emsg,
+                      _("Serialized metadata `%s' larger than allowed (%u>%u)"),
+                      what,
+                      size,
+                      MAX_META_DATA);
+      return GNUNET_SYSERR;
+    }
+  buf = GNUNET_malloc(size);
+  if (GNUNET_OK != GNUNET_BIO_read(h, what, buf, size))
+    {
+      GNUNET_free(buf);
+      return GNUNET_SYSERR;
+    }
+  meta = GNUNET_CONTAINER_meta_data_deserialize(buf, size);
   if (NULL == meta)
-  {
-    GNUNET_free (buf);
-    GNUNET_asprintf (&h->emsg, _ ("Metadata `%s' failed to deserialize"), what);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (buf);
+    {
+      GNUNET_free(buf);
+      GNUNET_asprintf(&h->emsg, _("Metadata `%s' failed to deserialize"), what);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(buf);
   *result = meta;
   return GNUNET_OK;
 }
@@ -334,16 +334,16 @@ GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
-                         const char *file,
-                         int line,
-                         int32_t *i)
+GNUNET_BIO_read_int32__(struct GNUNET_BIO_ReadHandle *h,
+                        const char *file,
+                        int line,
+                        int32_t *i)
 {
   int32_t big;
 
-  if (GNUNET_OK != GNUNET_BIO_read_fn (h, file, line, &big, sizeof (int32_t)))
+  if (GNUNET_OK != GNUNET_BIO_read_fn(h, file, line, &big, sizeof(int32_t)))
     return GNUNET_SYSERR;
-  *i = ntohl (big);
+  *i = ntohl(big);
   return GNUNET_OK;
 }
 
@@ -358,16 +358,16 @@ GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h,
-                         const char *file,
-                         int line,
-                         int64_t *i)
+GNUNET_BIO_read_int64__(struct GNUNET_BIO_ReadHandle *h,
+                        const char *file,
+                        int line,
+                        int64_t *i)
 {
   int64_t big;
 
-  if (GNUNET_OK != GNUNET_BIO_read_fn (h, file, line, &big, sizeof (int64_t)))
+  if (GNUNET_OK != GNUNET_BIO_read_fn(h, file, line, &big, sizeof(int64_t)))
     return GNUNET_SYSERR;
-  *i = GNUNET_ntohll (big);
+  *i = GNUNET_ntohll(big);
   return GNUNET_OK;
 }
 
@@ -375,8 +375,7 @@ GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h,
 /**
  * Handle for buffered writing.
  */
-struct GNUNET_BIO_WriteHandle
-{
+struct GNUNET_BIO_WriteHandle {
   /**
    * Underlying file handle.
    */
@@ -406,21 +405,21 @@ struct GNUNET_BIO_WriteHandle
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_BIO_WriteHandle *
-GNUNET_BIO_write_open (const char *fn)
+GNUNET_BIO_write_open(const char *fn)
 {
   struct GNUNET_DISK_FileHandle *fd;
   struct GNUNET_BIO_WriteHandle *h;
 
   fd =
-    GNUNET_DISK_file_open (fn,
-                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE |
-                             GNUNET_DISK_OPEN_CREATE,
-                           GNUNET_DISK_PERM_USER_READ |
-                             GNUNET_DISK_PERM_USER_WRITE);
+    GNUNET_DISK_file_open(fn,
+                          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE |
+                          GNUNET_DISK_OPEN_CREATE,
+                          GNUNET_DISK_PERM_USER_READ |
+                          GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == fd)
     return NULL;
-  h = GNUNET_malloc (sizeof (struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
-  h->buffer = (char *) &h[1];
+  h = GNUNET_malloc(sizeof(struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
+  h->buffer = (char *)&h[1];
   h->size = BIO_BUFFER_SIZE;
   h->fd = fd;
   return h;
@@ -434,14 +433,14 @@ GNUNET_BIO_write_open (const char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
+GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
 {
   int ret;
 
   ret = GNUNET_SYSERR;
-  if ((NULL != h->fd) && (GNUNET_OK == (ret = GNUNET_BIO_flush (h))))
-    GNUNET_DISK_file_close (h->fd);
-  GNUNET_free (h);
+  if ((NULL != h->fd) && (GNUNET_OK == (ret = GNUNET_BIO_flush(h))))
+    GNUNET_DISK_file_close(h->fd);
+  GNUNET_free(h);
   return ret;
 }
 
@@ -454,17 +453,17 @@ GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
  *           the file is closed
  */
 int
-GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
+GNUNET_BIO_flush(struct GNUNET_BIO_WriteHandle *h)
 {
   ssize_t ret;
 
-  ret = GNUNET_DISK_file_write (h->fd, h->buffer, h->have);
-  if (ret != (ssize_t) h->have)
-  {
-    GNUNET_DISK_file_close (h->fd);
-    h->fd = NULL;
-    return GNUNET_SYSERR; /* error */
-  }
+  ret = GNUNET_DISK_file_write(h->fd, h->buffer, h->have);
+  if (ret != (ssize_t)h->have)
+    {
+      GNUNET_DISK_file_close(h->fd);
+      h->fd = NULL;
+      return GNUNET_SYSERR; /* error */
+    }
   h->have = 0;
   return GNUNET_OK;
 }
@@ -479,9 +478,9 @@ GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
-                  const void *buffer,
-                  size_t n)
+GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h,
+                 const void *buffer,
+                 size_t n)
 {
   const char *src = buffer;
   size_t min;
@@ -491,21 +490,22 @@ GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
     return GNUNET_SYSERR;
   pos = 0;
   do
-  {
-    /* first, just use buffer */
-    min = h->size - h->have;
-    if (min > n - pos)
-      min = n - pos;
-    GNUNET_memcpy (&h->buffer[h->have], &src[pos], min);
-    pos += min;
-    h->have += min;
-    if (pos == n)
-      return GNUNET_OK; /* done */
-    GNUNET_assert (h->have == h->size);
-    if (GNUNET_OK != GNUNET_BIO_flush (h))
-      return GNUNET_SYSERR; /* error */
-  } while (pos < n); /* should always be true */
-  GNUNET_break (0);
+    {
+      /* first, just use buffer */
+      min = h->size - h->have;
+      if (min > n - pos)
+        min = n - pos;
+      GNUNET_memcpy(&h->buffer[h->have], &src[pos], min);
+      pos += min;
+      h->have += min;
+      if (pos == n)
+        return GNUNET_OK; /* done */
+      GNUNET_assert(h->have == h->size);
+      if (GNUNET_OK != GNUNET_BIO_flush(h))
+        return GNUNET_SYSERR; /* error */
+    }
+  while (pos < n);   /* should always be true */
+  GNUNET_break(0);
   return GNUNET_OK;
 }
 
@@ -518,15 +518,15 @@ GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *s)
+GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
 {
   uint32_t slen;
 
-  slen = (uint32_t) ((s == NULL) ? 0 : strlen (s) + 1);
-  if (GNUNET_OK != GNUNET_BIO_write_int32 (h, slen))
+  slen = (uint32_t)((s == NULL) ? 0 : strlen(s) + 1);
+  if (GNUNET_OK != GNUNET_BIO_write_int32(h, slen))
     return GNUNET_SYSERR;
   if (0 != slen)
-    return GNUNET_BIO_write (h, s, slen - 1);
+    return GNUNET_BIO_write(h, s, slen - 1);
   return GNUNET_OK;
 }
 
@@ -539,32 +539,32 @@ GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *s)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
-                            const struct GNUNET_CONTAINER_MetaData *m)
+GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h,
+                           const struct GNUNET_CONTAINER_MetaData *m)
 {
   ssize_t size;
   char *buf;
 
   if (m == NULL)
-    return GNUNET_BIO_write_int32 (h, 0);
+    return GNUNET_BIO_write_int32(h, 0);
   buf = NULL;
-  size = GNUNET_CONTAINER_meta_data_serialize (
+  size = GNUNET_CONTAINER_meta_data_serialize(
     m,
     &buf,
     MAX_META_DATA,
     GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (size == -1)
-  {
-    GNUNET_free (buf);
-    return GNUNET_SYSERR;
-  }
-  if ((GNUNET_OK != GNUNET_BIO_write_int32 (h, (uint32_t) size)) ||
-      (GNUNET_OK != GNUNET_BIO_write (h, buf, size)))
-  {
-    GNUNET_free (buf);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (buf);
+    {
+      GNUNET_free(buf);
+      return GNUNET_SYSERR;
+    }
+  if ((GNUNET_OK != GNUNET_BIO_write_int32(h, (uint32_t)size)) ||
+      (GNUNET_OK != GNUNET_BIO_write(h, buf, size)))
+    {
+      GNUNET_free(buf);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(buf);
   return GNUNET_OK;
 }
 
@@ -577,12 +577,12 @@ GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, int32_t i)
+GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
 {
   int32_t big;
 
-  big = htonl (i);
-  return GNUNET_BIO_write (h, &big, sizeof (int32_t));
+  big = htonl(i);
+  return GNUNET_BIO_write(h, &big, sizeof(int32_t));
 }
 
 
@@ -594,12 +594,12 @@ GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, int32_t i)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h, int64_t i)
+GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, int64_t i)
 {
   int64_t big;
 
-  big = GNUNET_htonll (i);
-  return GNUNET_BIO_write (h, &big, sizeof (int64_t));
+  big = GNUNET_htonll(i);
+  return GNUNET_BIO_write(h, &big, sizeof(int64_t));
 }
 
 
diff --git a/src/util/client.c b/src/util/client.c
index 313cc23af..e3585af2e 100644
--- a/src/util/client.c
+++ b/src/util/client.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 util/client.c
@@ -33,7 +33,7 @@
 #include "gnunet_socks.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-client",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-client", __VA_ARGS__)
 
 /**
  * Timeout we use on TCP connect before trying another
@@ -41,7 +41,7 @@
  * is this value divided by the number of address families.
  * Default is 5s.
  */
-#define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
 
 
 
@@ -55,9 +55,7 @@ struct ClientState;
  * During connect, we try multiple possible IP addresses
  * to find out which one might work.
  */
-struct AddressProbe
-{
-
+struct AddressProbe {
   /**
    * This is a linked list.
    */
@@ -98,9 +96,7 @@ struct AddressProbe
 /**
  * Internal state for a client connected to a GNUnet service.
  */
-struct ClientState
-{
-
+struct ClientState {
   /**
    * The connection handle, NULL if not live
    */
@@ -200,7 +196,6 @@ struct ClientState
    * deferred.
    */
   int in_destroy;
-
 };
 
 
@@ -210,7 +205,7 @@ struct ClientState
  * @param cls the `struct ClientState` to try to connect to the service
  */
 static void
-start_connect (void *cls);
+start_connect(void *cls);
 
 
 /**
@@ -220,26 +215,26 @@ start_connect (void *cls);
  * @param cstate the connection we tried to establish
  */
 static void
-connect_fail_continuation (struct ClientState *cstate)
+connect_fail_continuation(struct ClientState *cstate)
 {
-  GNUNET_break (NULL == cstate->ap_head);
-  GNUNET_break (NULL == cstate->ap_tail);
-  GNUNET_break (NULL == cstate->dns_active);
-  GNUNET_break (NULL == cstate->sock);
-  GNUNET_assert (NULL == cstate->send_task);
-  GNUNET_assert (NULL == cstate->recv_task);
+  GNUNET_break(NULL == cstate->ap_head);
+  GNUNET_break(NULL == cstate->ap_tail);
+  GNUNET_break(NULL == cstate->dns_active);
+  GNUNET_break(NULL == cstate->sock);
+  GNUNET_assert(NULL == cstate->send_task);
+  GNUNET_assert(NULL == cstate->recv_task);
   // GNUNET_assert (NULL == cstate->proxy_handshake);
 
-  cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
-       cstate->service_name,
-       GNUNET_STRINGS_relative_time_to_string (cstate->back_off,
-                                               GNUNET_YES));
+  cstate->back_off = GNUNET_TIME_STD_BACKOFF(cstate->back_off);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n",
+      cstate->service_name,
+      GNUNET_STRINGS_relative_time_to_string(cstate->back_off,
+                                             GNUNET_YES));
   cstate->retry_task
-    = GNUNET_SCHEDULER_add_delayed (cstate->back_off,
-                                    &start_connect,
-                                    cstate);
+    = GNUNET_SCHEDULER_add_delayed(cstate->back_off,
+                                   &start_connect,
+                                   cstate);
 }
 
 
@@ -249,7 +244,7 @@ connect_fail_continuation (struct ClientState *cstate)
  * @param cls the `struct ClientState` with the `msg` to transmit
  */
 static void
-transmit_ready (void *cls)
+transmit_ready(void *cls)
 {
   struct ClientState *cstate = cls;
   ssize_t ret;
@@ -260,55 +255,56 @@ transmit_ready (void *cls)
   cstate->send_task = NULL;
   if (GNUNET_YES == cstate->in_destroy)
     return;
-  pos = (const char *) cstate->msg;
-  len = ntohs (cstate->msg->size);
-  GNUNET_assert (cstate->msg_off < len);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "message of type %u trying to send with socket %p (MQ: %p\n",
-       ntohs(cstate->msg->type),
-       cstate->sock,
-       cstate->mq);
-
- RETRY:
-  ret = GNUNET_NETWORK_socket_send (cstate->sock,
-                                    &pos[cstate->msg_off],
-                                    len - cstate->msg_off);
+  pos = (const char *)cstate->msg;
+  len = ntohs(cstate->msg->size);
+  GNUNET_assert(cstate->msg_off < len);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "message of type %u trying to send with socket %p (MQ: %p\n",
+      ntohs(cstate->msg->type),
+      cstate->sock,
+      cstate->mq);
+
+RETRY:
+  ret = GNUNET_NETWORK_socket_send(cstate->sock,
+                                   &pos[cstate->msg_off],
+                                   len - cstate->msg_off);
   if (-1 == ret)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Error during sending message of type %u\n",
-         ntohs(cstate->msg->type));
-    if (EINTR == errno){
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Retrying message of type %u\n",
-           ntohs(cstate->msg->type));
-      goto RETRY;
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Error during sending message of type %u\n",
+          ntohs(cstate->msg->type));
+      if (EINTR == errno)
+        {
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Retrying message of type %u\n",
+              ntohs(cstate->msg->type));
+          goto RETRY;
+        }
+      GNUNET_MQ_inject_error(cstate->mq,
+                             GNUNET_MQ_ERROR_WRITE);
+      return;
     }
-    GNUNET_MQ_inject_error (cstate->mq,
-                            GNUNET_MQ_ERROR_WRITE);
-    return;
-  }
   notify_in_flight = (0 == cstate->msg_off);
   cstate->msg_off += ret;
   if (cstate->msg_off < len)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "rescheduling message of type %u\n",
-         ntohs(cstate->msg->type));
-    cstate->send_task
-      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        cstate->sock,
-                                        &transmit_ready,
-                                        cstate);
-    if (notify_in_flight)
-      GNUNET_MQ_impl_send_in_flight (cstate->mq);
-    return;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "sending message of type %u successful\n",
-       ntohs(cstate->msg->type));
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "rescheduling message of type %u\n",
+          ntohs(cstate->msg->type));
+      cstate->send_task
+        = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                         cstate->sock,
+                                         &transmit_ready,
+                                         cstate);
+      if (notify_in_flight)
+        GNUNET_MQ_impl_send_in_flight(cstate->mq);
+      return;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "sending message of type %u successful\n",
+      ntohs(cstate->msg->type));
   cstate->msg = NULL;
-  GNUNET_MQ_impl_send_continue (cstate->mq);
+  GNUNET_MQ_impl_send_continue(cstate->mq);
 }
 
 
@@ -323,20 +319,20 @@ transmit_ready (void *cls)
  *     #GNUNET_SYSERR to stop further processing due to error
  */
 static int
-recv_message (void *cls,
-              const struct GNUNET_MessageHeader *msg)
+recv_message(void *cls,
+             const struct GNUNET_MessageHeader *msg)
 {
   struct ClientState *cstate = cls;
 
   if (GNUNET_YES == cstate->in_destroy)
     return GNUNET_NO;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received message of type %u and size %u from %s\n",
-       ntohs (msg->type),
-       ntohs (msg->size),
-       cstate->service_name);
-  GNUNET_MQ_inject_message (cstate->mq,
-                            msg);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received message of type %u and size %u from %s\n",
+      ntohs(msg->type),
+      ntohs(msg->size),
+      cstate->service_name);
+  GNUNET_MQ_inject_message(cstate->mq,
+                           msg);
   if (GNUNET_YES == cstate->in_destroy)
     return GNUNET_NO;
   return GNUNET_OK;
@@ -349,20 +345,20 @@ recv_message (void *cls,
  * @param cstate handle of the client state to process
  */
 static void
-cancel_aps (struct ClientState *cstate)
+cancel_aps(struct ClientState *cstate)
 {
   struct AddressProbe *pos;
 
   while (NULL != (pos = cstate->ap_head))
-  {
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_NETWORK_socket_close (pos->sock));
-    GNUNET_SCHEDULER_cancel (pos->task);
-    GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
-                                 cstate->ap_tail,
-                                 pos);
-    GNUNET_free (pos);
-  }
+    {
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_NETWORK_socket_close(pos->sock));
+      GNUNET_SCHEDULER_cancel(pos->task);
+      GNUNET_CONTAINER_DLL_remove(cstate->ap_head,
+                                  cstate->ap_tail,
+                                  pos);
+      GNUNET_free(pos);
+    }
 }
 
 
@@ -374,51 +370,51 @@ cancel_aps (struct ClientState *cstate)
  * @param impl_state our `struct ClientState`
  */
 static void
-connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq,
-                                void *impl_state)
+connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq,
+                               void *impl_state)
 {
   struct ClientState *cstate = impl_state;
 
-  (void) mq;
+  (void)mq;
   if (NULL != cstate->dns_active)
-  {
-    GNUNET_RESOLVER_request_cancel (cstate->dns_active);
-    cstate->dns_active = NULL;
-  }
+    {
+      GNUNET_RESOLVER_request_cancel(cstate->dns_active);
+      cstate->dns_active = NULL;
+    }
   if (NULL != cstate->send_task)
-  {
-    GNUNET_SCHEDULER_cancel (cstate->send_task);
-    cstate->send_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(cstate->send_task);
+      cstate->send_task = NULL;
+    }
   if (NULL != cstate->retry_task)
-  {
-    GNUNET_SCHEDULER_cancel (cstate->retry_task);
-    cstate->retry_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(cstate->retry_task);
+      cstate->retry_task = NULL;
+    }
   if (GNUNET_SYSERR == cstate->in_destroy)
-  {
-    /* defer destruction */
-    cstate->in_destroy = GNUNET_YES;
-    cstate->mq = NULL;
-    return;
-  }
+    {
+      /* defer destruction */
+      cstate->in_destroy = GNUNET_YES;
+      cstate->mq = NULL;
+      return;
+    }
   if (NULL != cstate->recv_task)
-  {
-    GNUNET_SCHEDULER_cancel (cstate->recv_task);
-    cstate->recv_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(cstate->recv_task);
+      cstate->recv_task = NULL;
+    }
   if (NULL != cstate->sock)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "destroying socket: %p\n",
-         cstate->sock);
-    GNUNET_NETWORK_socket_close (cstate->sock);
-  }
-  cancel_aps (cstate);
-  GNUNET_free (cstate->service_name);
-  GNUNET_free_non_null (cstate->hostname);
-  GNUNET_MST_destroy (cstate->mst);
-  GNUNET_free (cstate);
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "destroying socket: %p\n",
+          cstate->sock);
+      GNUNET_NETWORK_socket_close(cstate->sock);
+    }
+  cancel_aps(cstate);
+  GNUNET_free(cstate->service_name);
+  GNUNET_free_non_null(cstate->hostname);
+  GNUNET_MST_destroy(cstate->mst);
+  GNUNET_free(cstate);
 }
 
 
@@ -428,39 +424,39 @@ connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq,
  * @param cls `struct ClientState` with connection to read from
  */
 static void
-receive_ready (void *cls)
+receive_ready(void *cls)
 {
   struct ClientState *cstate = cls;
   int ret;
 
   cstate->recv_task = NULL;
   cstate->in_destroy = GNUNET_SYSERR;
-  ret = GNUNET_MST_read (cstate->mst,
-                         cstate->sock,
-                         GNUNET_NO,
-                         GNUNET_NO);
+  ret = GNUNET_MST_read(cstate->mst,
+                        cstate->sock,
+                        GNUNET_NO,
+                        GNUNET_NO);
   if (GNUNET_SYSERR == ret)
-  {
-    if (NULL != cstate->mq)
-      GNUNET_MQ_inject_error (cstate->mq,
-                              GNUNET_MQ_ERROR_READ);
-    if (GNUNET_YES == cstate->in_destroy)
-      connection_client_destroy_impl (cstate->mq,
-                                      cstate);
-    return;
-  }
+    {
+      if (NULL != cstate->mq)
+        GNUNET_MQ_inject_error(cstate->mq,
+                               GNUNET_MQ_ERROR_READ);
+      if (GNUNET_YES == cstate->in_destroy)
+        connection_client_destroy_impl(cstate->mq,
+                                       cstate);
+      return;
+    }
   if (GNUNET_YES == cstate->in_destroy)
-  {
-    connection_client_destroy_impl (cstate->mq,
-                                    cstate);
-    return;
-  }
+    {
+      connection_client_destroy_impl(cstate->mq,
+                                     cstate);
+      return;
+    }
   cstate->in_destroy = GNUNET_NO;
   cstate->recv_task
-    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                     cstate->sock,
-                                     &receive_ready,
-                                     cstate);
+    = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                    cstate->sock,
+                                    &receive_ready,
+                                    cstate);
 }
 
 
@@ -470,23 +466,23 @@ receive_ready (void *cls)
  * @param cstate the connection we tried to establish
  */
 static void
-connect_success_continuation (struct ClientState *cstate)
+connect_success_continuation(struct ClientState *cstate)
 {
-  GNUNET_assert (NULL == cstate->recv_task);
+  GNUNET_assert(NULL == cstate->recv_task);
   cstate->recv_task
-    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                     cstate->sock,
-                                     &receive_ready,
-                                     cstate);
+    = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                    cstate->sock,
+                                    &receive_ready,
+                                    cstate);
   if (NULL != cstate->msg)
-  {
-    GNUNET_assert (NULL == cstate->send_task);
-    cstate->send_task
-      = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        cstate->sock,
-                                        &transmit_ready,
-                                        cstate);
-  }
+    {
+      GNUNET_assert(NULL == cstate->send_task);
+      cstate->send_task
+        = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                         cstate->sock,
+                                         &transmit_ready,
+                                         cstate);
+    }
 }
 
 
@@ -498,8 +494,8 @@ connect_success_continuation (struct ClientState *cstate)
  * @return NULL on error, socket connected to UNIX otherwise
  */
 static struct GNUNET_NETWORK_Handle *
-try_unixpath (const char *service_name,
-              const struct GNUNET_CONFIGURATION_Handle *cfg)
+try_unixpath(const char *service_name,
+             const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
 #if AF_UNIX
   struct GNUNET_NETWORK_Handle *sock;
@@ -508,67 +504,67 @@ try_unixpath (const char *service_name,
 
   unixpath = NULL;
   if ((GNUNET_OK ==
-       GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                service_name,
-                                                "UNIXPATH",
-                                                &unixpath)) &&
-      (0 < strlen (unixpath)))
-  {
-    /* We have a non-NULL unixpath, need to validate it */
-    if (strlen (unixpath) >= sizeof (s_un.sun_path))
+       GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                               service_name,
+                                               "UNIXPATH",
+                                               &unixpath)) &&
+      (0 < strlen(unixpath)))
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _("UNIXPATH `%s' too long, maximum length is %llu\n"),
-           unixpath,
-           (unsigned long long) sizeof (s_un.sun_path));
-      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _("Using `%s' instead\n"),
-           unixpath);
-      if (NULL == unixpath)
-        return NULL;
-    }
-    memset (&s_un,
-            0,
-            sizeof (s_un));
-    s_un.sun_family = AF_UNIX;
-    GNUNET_strlcpy (s_un.sun_path,
-                    unixpath,
-                    sizeof (s_un.sun_path));
+      /* We have a non-NULL unixpath, need to validate it */
+      if (strlen(unixpath) >= sizeof(s_un.sun_path))
+        {
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+              unixpath,
+              (unsigned long long)sizeof(s_un.sun_path));
+          unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath);
+          LOG(GNUNET_ERROR_TYPE_INFO,
+              _("Using `%s' instead\n"),
+              unixpath);
+          if (NULL == unixpath)
+            return NULL;
+        }
+      memset(&s_un,
+             0,
+             sizeof(s_un));
+      s_un.sun_family = AF_UNIX;
+      GNUNET_strlcpy(s_un.sun_path,
+                     unixpath,
+                     sizeof(s_un.sun_path));
 #ifdef LINUX
-    {
-      int abstract;
-
-      abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                       "TESTING",
-                                                       "USE_ABSTRACT_SOCKETS");
-      if (GNUNET_YES == abstract)
-        s_un.sun_path[0] = '\0';
-    }
+      {
+        int abstract;
+
+        abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg,
+                                                        "TESTING",
+                                                        "USE_ABSTRACT_SOCKETS");
+        if (GNUNET_YES == abstract)
+          s_un.sun_path[0] = '\0';
+      }
 #endif
 #if HAVE_SOCKADDR_UN_SUN_LEN
-    s_un.sun_len = (u_char) sizeof (struct sockaddr_un);
+      s_un.sun_len = (u_char)sizeof(struct sockaddr_un);
 #endif
-    sock = GNUNET_NETWORK_socket_create (AF_UNIX,
-                                         SOCK_STREAM,
-                                         0);
-    if ( (NULL != sock) &&
-         ( (GNUNET_OK ==
-            GNUNET_NETWORK_socket_connect (sock,
-                                           (struct sockaddr *) &s_un,
-                                           sizeof (s_un))) ||
-           (EINPROGRESS == errno) ) )
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Successfully connected to unixpath `%s'!\n",
-           unixpath);
-      GNUNET_free (unixpath);
-      return sock;
+      sock = GNUNET_NETWORK_socket_create(AF_UNIX,
+                                          SOCK_STREAM,
+                                          0);
+      if ((NULL != sock) &&
+          ((GNUNET_OK ==
+            GNUNET_NETWORK_socket_connect(sock,
+                                          (struct sockaddr *)&s_un,
+                                          sizeof(s_un))) ||
+           (EINPROGRESS == errno)))
+        {
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Successfully connected to unixpath `%s'!\n",
+              unixpath);
+          GNUNET_free(unixpath);
+          return sock;
+        }
+      if (NULL != sock)
+        GNUNET_NETWORK_socket_close(sock);
     }
-    if (NULL != sock)
-      GNUNET_NETWORK_socket_close (sock);
-  }
-  GNUNET_free_non_null (unixpath);
+  GNUNET_free_non_null(unixpath);
 #endif
   return NULL;
 }
@@ -581,7 +577,7 @@ try_unixpath (const char *service_name,
  * @param cls the `struct AddressProbe *` with the address that we are probing
  */
 static void
-connect_probe_continuation (void *cls)
+connect_probe_continuation(void *cls)
 {
   struct AddressProbe *ap = cls;
   struct ClientState *cstate = ap->cstate;
@@ -590,40 +586,40 @@ connect_probe_continuation (void *cls)
   socklen_t len;
 
   ap->task = NULL;
-  GNUNET_assert (NULL != ap->sock);
-  GNUNET_CONTAINER_DLL_remove (cstate->ap_head,
-                               cstate->ap_tail,
-                               ap);
-  len = sizeof (error);
+  GNUNET_assert(NULL != ap->sock);
+  GNUNET_CONTAINER_DLL_remove(cstate->ap_head,
+                              cstate->ap_tail,
+                              ap);
+  len = sizeof(error);
   error = 0;
-  tc = GNUNET_SCHEDULER_get_task_context ();
-  if ( (0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
-       (GNUNET_OK !=
-        GNUNET_NETWORK_socket_getsockopt (ap->sock,
-                                          SOL_SOCKET,
-                                          SO_ERROR,
-                                          &error,
-                                          &len)) ||
-       (0 != error) )
-  {
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_NETWORK_socket_close (ap->sock));
-    GNUNET_free (ap);
-    if ( (NULL == cstate->ap_head) &&
-         //      (NULL == cstate->proxy_handshake) &&
-         (NULL == cstate->dns_active) )
-      connect_fail_continuation (cstate);
-    return;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Connection to `%s' succeeded!\n",
-       cstate->service_name);
+  tc = GNUNET_SCHEDULER_get_task_context();
+  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
+      (GNUNET_OK !=
+       GNUNET_NETWORK_socket_getsockopt(ap->sock,
+                                        SOL_SOCKET,
+                                        SO_ERROR,
+                                        &error,
+                                        &len)) ||
+      (0 != error))
+    {
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_NETWORK_socket_close(ap->sock));
+      GNUNET_free(ap);
+      if ((NULL == cstate->ap_head) &&
+          //     (NULL == cstate->proxy_handshake) &&
+          (NULL == cstate->dns_active))
+        connect_fail_continuation(cstate);
+      return;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Connection to `%s' succeeded!\n",
+      cstate->service_name);
   /* trigger jobs that waited for the connection */
-  GNUNET_assert (NULL == cstate->sock);
+  GNUNET_assert(NULL == cstate->sock);
   cstate->sock = ap->sock;
-  GNUNET_free (ap);
-  cancel_aps (cstate);
-  connect_success_continuation (cstate);
+  GNUNET_free(ap);
+  cancel_aps(cstate);
+  connect_success_continuation(cstate);
 }
 
 
@@ -636,80 +632,82 @@ connect_probe_continuation (void *cls)
  * @param addrlen length of @a addr
  */
 static void
-try_connect_using_address (void *cls,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+try_connect_using_address(void *cls,
+                          const struct sockaddr *addr,
+                          socklen_t addrlen)
 {
   struct ClientState *cstate = cls;
   struct AddressProbe *ap;
 
   if (NULL == addr)
-  {
-    cstate->dns_active = NULL;
-    if ( (NULL == cstate->ap_head) &&
-         //  (NULL == cstate->proxy_handshake) &&
-         (NULL == cstate->sock) )
-      connect_fail_continuation (cstate);
-    return;
-  }
+    {
+      cstate->dns_active = NULL;
+      if ((NULL == cstate->ap_head) &&
+          //  (NULL == cstate->proxy_handshake) &&
+          (NULL == cstate->sock))
+        connect_fail_continuation(cstate);
+      return;
+    }
   if (NULL != cstate->sock)
     return;                     /* already connected */
   /* try to connect */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Trying to connect using address `%s:%u'\n",
-       GNUNET_a2s (addr,
-                   addrlen),
-       cstate->port);
-  ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
-  ap->addr = (const struct sockaddr *) &ap[1];
-  GNUNET_memcpy (&ap[1],
-                 addr,
-                 addrlen);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to connect using address `%s:%u'\n",
+      GNUNET_a2s(addr,
+                 addrlen),
+      cstate->port);
+  ap = GNUNET_malloc(sizeof(struct AddressProbe) + addrlen);
+  ap->addr = (const struct sockaddr *)&ap[1];
+  GNUNET_memcpy(&ap[1],
+                addr,
+                addrlen);
   ap->addrlen = addrlen;
   ap->cstate = cstate;
 
   switch (ap->addr->sa_family)
-  {
-  case AF_INET:
-    ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port);
-    break;
-  case AF_INET6:
-    ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port);
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_free (ap);
-    return;                     /* not supported by us */
-  }
-  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
-                                           SOCK_STREAM,
-                                           0);
+    {
+    case AF_INET:
+      ((struct sockaddr_in *)ap->addr)->sin_port = htons(cstate->port);
+      break;
+
+    case AF_INET6:
+      ((struct sockaddr_in6 *)ap->addr)->sin6_port = htons(cstate->port);
+      break;
+
+    default:
+      GNUNET_break(0);
+      GNUNET_free(ap);
+      return;                   /* not supported by us */
+    }
+  ap->sock = GNUNET_NETWORK_socket_create(ap->addr->sa_family,
+                                          SOCK_STREAM,
+                                          0);
   if (NULL == ap->sock)
-  {
-    GNUNET_free (ap);
-    return;                     /* not supported by OS */
-  }
-  if ( (GNUNET_OK !=
-        GNUNET_NETWORK_socket_connect (ap->sock,
-                                       ap->addr,
-                                       ap->addrlen)) &&
-       (EINPROGRESS != errno) )
-  {
-    /* maybe refused / unsupported address, try next */
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO,
-                         "connect");
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_NETWORK_socket_close (ap->sock));
-    GNUNET_free (ap);
-    return;
-  }
-  GNUNET_CONTAINER_DLL_insert (cstate->ap_head,
-                               cstate->ap_tail,
-                               ap);
-  ap->task = GNUNET_SCHEDULER_add_write_net (CONNECT_RETRY_TIMEOUT,
-                                             ap->sock,
-                                             &connect_probe_continuation,
-                                             ap);
+    {
+      GNUNET_free(ap);
+      return;                   /* not supported by OS */
+    }
+  if ((GNUNET_OK !=
+       GNUNET_NETWORK_socket_connect(ap->sock,
+                                     ap->addr,
+                                     ap->addrlen)) &&
+      (EINPROGRESS != errno))
+    {
+      /* maybe refused / unsupported address, try next */
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO,
+                          "connect");
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_NETWORK_socket_close(ap->sock));
+      GNUNET_free(ap);
+      return;
+    }
+  GNUNET_CONTAINER_DLL_insert(cstate->ap_head,
+                              cstate->ap_tail,
+                              ap);
+  ap->task = GNUNET_SCHEDULER_add_write_net(CONNECT_RETRY_TIMEOUT,
+                                            ap->sock,
+                                            &connect_probe_continuation,
+                                            ap);
 }
 
 
@@ -722,55 +720,56 @@ try_connect_using_address (void *cls,
  * @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not
  */
 static int
-test_service_configuration (const char *service_name,
-                            const struct GNUNET_CONFIGURATION_Handle *cfg)
+test_service_configuration(const char *service_name,
+                           const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int ret = GNUNET_SYSERR;
   char *hostname = NULL;
   unsigned long long port;
+
 #if AF_UNIX
   char *unixpath = NULL;
 
   if ((GNUNET_OK ==
-       GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                service_name,
-                                                "UNIXPATH",
-                                                &unixpath)) &&
-      (0 < strlen (unixpath)))
+       GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                               service_name,
+                                               "UNIXPATH",
+                                               &unixpath)) &&
+      (0 < strlen(unixpath)))
     ret = GNUNET_OK;
   else if ((GNUNET_OK ==
-            GNUNET_CONFIGURATION_have_value (cfg,
-                                             service_name,
-                                             "UNIXPATH")))
-  {
-    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                               service_name,
-                               "UNIXPATH",
-                               _("not a valid filename"));
-    return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
-  }
-  GNUNET_free_non_null (unixpath);
+            GNUNET_CONFIGURATION_have_value(cfg,
+                                            service_name,
+                                            "UNIXPATH")))
+    {
+      GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
+                                service_name,
+                                "UNIXPATH",
+                                _("not a valid filename"));
+      return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */
+    }
+  GNUNET_free_non_null(unixpath);
 #endif
 
-  if ( (GNUNET_YES ==
-        GNUNET_CONFIGURATION_have_value (cfg,
-                                         service_name,
-                                         "PORT")) &&
-       (GNUNET_OK ==
-        GNUNET_CONFIGURATION_get_value_number (cfg,
-                                               service_name,
-                                               "PORT",
-                                               &port)) &&
-       (port <= 65535) &&
-       (0 != port) &&
-       (GNUNET_OK ==
-        GNUNET_CONFIGURATION_get_value_string (cfg,
-                                               service_name,
-                                               "HOSTNAME",
-                                               &hostname)) &&
-       (0 != strlen (hostname)) )
+  if ((GNUNET_YES ==
+       GNUNET_CONFIGURATION_have_value(cfg,
+                                       service_name,
+                                       "PORT")) &&
+      (GNUNET_OK ==
+       GNUNET_CONFIGURATION_get_value_number(cfg,
+                                             service_name,
+                                             "PORT",
+                                             &port)) &&
+      (port <= 65535) &&
+      (0 != port) &&
+      (GNUNET_OK ==
+       GNUNET_CONFIGURATION_get_value_string(cfg,
+                                             service_name,
+                                             "HOSTNAME",
+                                             &hostname)) &&
+      (0 != strlen(hostname)))
     ret = GNUNET_OK;
-  GNUNET_free_non_null (hostname);
+  GNUNET_free_non_null(hostname);
   return ret;
 }
 
@@ -781,7 +780,7 @@ test_service_configuration (const char *service_name,
  * @param cls the `struct ClientState` to try to connect to the service
  */
 static void
-start_connect (void *cls)
+start_connect(void *cls)
 {
   struct ClientState *cstate = cls;
 
@@ -789,41 +788,41 @@ start_connect (void *cls)
 #if 0
   /* Never use a local source if a proxy is configured */
   if (GNUNET_YES ==
-      GNUNET_SOCKS_check_service (cstate->service_name,
-                                  cstate->cfg))
-  {
-    socks_connect (cstate);
-    return;
-  }
+      GNUNET_SOCKS_check_service(cstate->service_name,
+                                 cstate->cfg))
+    {
+      socks_connect(cstate);
+      return;
+    }
 #endif
 
-  if ( (0 == (cstate->attempts++ % 2)) ||
-       (0 == cstate->port) ||
-       (NULL == cstate->hostname) )
-  {
-    /* on even rounds, try UNIX first, or always
-       if we do not have a DNS name and TCP port. */
-    cstate->sock = try_unixpath (cstate->service_name,
-                                 cstate->cfg);
-    if (NULL != cstate->sock)
+  if ((0 == (cstate->attempts++ % 2)) ||
+      (0 == cstate->port) ||
+      (NULL == cstate->hostname))
     {
-      connect_success_continuation (cstate);
+      /* on even rounds, try UNIX first, or always
+         if we do not have a DNS name and TCP port. */
+      cstate->sock = try_unixpath(cstate->service_name,
+                                  cstate->cfg);
+      if (NULL != cstate->sock)
+        {
+          connect_success_continuation(cstate);
+          return;
+        }
+    }
+  if ((NULL == cstate->hostname) ||
+      (0 == cstate->port))
+    {
+      /* All options failed. Boo! */
+      connect_fail_continuation(cstate);
       return;
     }
-  }
-  if ( (NULL == cstate->hostname) ||
-       (0 == cstate->port) )
-  {
-    /* All options failed. Boo! */
-    connect_fail_continuation (cstate);
-    return;
-  }
   cstate->dns_active
-    = GNUNET_RESOLVER_ip_get (cstate->hostname,
-                              AF_UNSPEC,
-                              CONNECT_RETRY_TIMEOUT,
-                              &try_connect_using_address,
-                              cstate);
+    = GNUNET_RESOLVER_ip_get(cstate->hostname,
+                             AF_UNSPEC,
+                             CONNECT_RETRY_TIMEOUT,
+                             &try_connect_using_address,
+                             cstate);
 }
 
 
@@ -835,30 +834,30 @@ start_connect (void *cls)
  * @param impl_state our `struct ClientState`
  */
 static void
-connection_client_send_impl (struct GNUNET_MQ_Handle *mq,
-                             const struct GNUNET_MessageHeader *msg,
-                             void *impl_state)
+connection_client_send_impl(struct GNUNET_MQ_Handle *mq,
+                            const struct GNUNET_MessageHeader *msg,
+                            void *impl_state)
 {
   struct ClientState *cstate = impl_state;
 
-  (void) mq;
+  (void)mq;
   /* only one message at a time allowed */
-  GNUNET_assert (NULL == cstate->msg);
-  GNUNET_assert (NULL == cstate->send_task);
+  GNUNET_assert(NULL == cstate->msg);
+  GNUNET_assert(NULL == cstate->send_task);
   cstate->msg = msg;
   cstate->msg_off = 0;
   if (NULL == cstate->sock)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "message of type %u waiting for socket\n",
-         ntohs(msg->type));
-    return; /* still waiting for connection */
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "message of type %u waiting for socket\n",
+          ntohs(msg->type));
+      return; /* still waiting for connection */
+    }
   cstate->send_task
-    = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      cstate->sock,
-                                      &transmit_ready,
-                                      cstate);
+    = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                     cstate->sock,
+                                     &transmit_ready,
+                                     cstate);
 }
 
 
@@ -869,20 +868,20 @@ connection_client_send_impl (struct GNUNET_MQ_Handle *mq,
  * @param impl_state our `struct ClientState`
  */
 static void
-connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq,
-                               void *impl_state)
+connection_client_cancel_impl(struct GNUNET_MQ_Handle *mq,
+                              void *impl_state)
 {
   struct ClientState *cstate = impl_state;
 
-  (void) mq;
-  GNUNET_assert (NULL != cstate->msg);
-  GNUNET_assert (0 == cstate->msg_off);
+  (void)mq;
+  GNUNET_assert(NULL != cstate->msg);
+  GNUNET_assert(0 == cstate->msg_off);
   cstate->msg = NULL;
   if (NULL != cstate->send_task)
-  {
-    GNUNET_SCHEDULER_cancel (cstate->send_task);
-    cstate->send_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(cstate->send_task);
+      cstate->send_task = NULL;
+    }
 }
 
 
@@ -898,57 +897,57 @@ connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq,
  * @return the message queue, NULL on error
  */
 struct GNUNET_MQ_Handle *
-GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                       const char *service_name,
-                       const struct GNUNET_MQ_MessageHandler *handlers,
-                       GNUNET_MQ_ErrorHandler error_handler,
-                       void *error_handler_cls)
+GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                      const char *service_name,
+                      const struct GNUNET_MQ_MessageHandler *handlers,
+                      GNUNET_MQ_ErrorHandler error_handler,
+                      void *error_handler_cls)
 {
   struct ClientState *cstate;
 
   if (GNUNET_OK !=
-      test_service_configuration (service_name,
-                                  cfg))
+      test_service_configuration(service_name,
+                                 cfg))
     return NULL;
-  cstate = GNUNET_new (struct ClientState);
-  cstate->service_name = GNUNET_strdup (service_name);
+  cstate = GNUNET_new(struct ClientState);
+  cstate->service_name = GNUNET_strdup(service_name);
   cstate->cfg = cfg;
-  cstate->retry_task = GNUNET_SCHEDULER_add_now (&start_connect,
-                                                 cstate);
-  cstate->mst = GNUNET_MST_create (&recv_message,
-                                   cstate);
+  cstate->retry_task = GNUNET_SCHEDULER_add_now(&start_connect,
+                                                cstate);
+  cstate->mst = GNUNET_MST_create(&recv_message,
+                                  cstate);
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_have_value (cfg,
-                                       service_name,
-                                       "PORT"))
-  {
-    if (! ( (GNUNET_OK !=
-             GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                    service_name,
-                                                    "PORT",
-                                                    &cstate->port)) ||
-            (cstate->port > 65535) ||
-            (GNUNET_OK !=
-             GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                    service_name,
-                                                    "HOSTNAME",
-                                                    &cstate->hostname)) ) &&
-        (0 == strlen (cstate->hostname)) )
+      GNUNET_CONFIGURATION_have_value(cfg,
+                                      service_name,
+                                      "PORT"))
     {
-      GNUNET_free (cstate->hostname);
-      cstate->hostname = NULL;
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _("Need a non-empty hostname for service `%s'.\n"),
-           service_name);
+      if (!((GNUNET_OK !=
+             GNUNET_CONFIGURATION_get_value_number(cfg,
+                                                   service_name,
+                                                   "PORT",
+                                                   &cstate->port)) ||
+            (cstate->port > 65535) ||
+            (GNUNET_OK !=
+             GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                   service_name,
+                                                   "HOSTNAME",
+                                                   &cstate->hostname))) &&
+          (0 == strlen(cstate->hostname)))
+        {
+          GNUNET_free(cstate->hostname);
+          cstate->hostname = NULL;
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _("Need a non-empty hostname for service `%s'.\n"),
+              service_name);
+        }
     }
-  }
-  cstate->mq = GNUNET_MQ_queue_for_callbacks (&connection_client_send_impl,
-                                              &connection_client_destroy_impl,
-                                              &connection_client_cancel_impl,
-                                              cstate,
-                                              handlers,
-                                              error_handler,
-                                              error_handler_cls);
+  cstate->mq = GNUNET_MQ_queue_for_callbacks(&connection_client_send_impl,
+                                             &connection_client_destroy_impl,
+                                             &connection_client_cancel_impl,
+                                             cstate,
+                                             handlers,
+                                             error_handler,
+                                             error_handler_cls);
   return cstate->mq;
 }
 
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c
index 94890a7f4..fd5af7a91 100644
--- a/src/util/common_allocation.c
+++ b/src/util/common_allocation.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 util/common_allocation.c
@@ -33,10 +33,10 @@
 #endif
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-common-allocation", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)
+  GNUNET_log_from_strerror(kind, "util-common-allocation", syscall)
 
 #ifndef INT_MAX
 #define INT_MAX 0x7FFFFFFF
@@ -63,19 +63,19 @@ static LONG mem_used = 0;
  * @return pointer to size bytes of memory
  */
 void *
-GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
+GNUNET_xmalloc_(size_t size, const char *filename, int linenumber)
 {
   void *ret;
 
   /* As a security precaution, we generally do not allow very large
    * allocations using the default 'GNUNET_malloc()' macro */
-  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
-  ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
+  GNUNET_assert_at(size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
+  ret = GNUNET_xmalloc_unchecked_(size, filename, linenumber);
   if (NULL == ret)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
-    GNUNET_assert (0);
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "malloc");
+      GNUNET_assert(0);
+    }
   return ret;
 }
 
@@ -95,23 +95,23 @@ GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
  * @return allocated memory, never NULL
  */
 void **
-GNUNET_xnew_array_2d_ (size_t n,
-                       size_t m,
-                       size_t elementSize,
-                       const char *filename,
-                       int linenumber)
+GNUNET_xnew_array_2d_(size_t n,
+                      size_t m,
+                      size_t elementSize,
+                      const char *filename,
+                      int linenumber)
 {
   /* use char pointer internally to avoid void pointer arithmetic warnings */
-  char **ret = GNUNET_xmalloc_ (n * sizeof (void *) + /* 1. dim header */
-                                  n * m * elementSize, /* element data */
-                                filename,
-                                linenumber);
+  char **ret = GNUNET_xmalloc_(n * sizeof(void *) +   /* 1. dim header */
+                               n * m * elementSize,    /* element data */
+                               filename,
+                               linenumber);
 
   for (size_t i = 0; i < n; i++)
-    ret[i] = (char *) ret + /* base address */
-             n * sizeof (void *) + /* skip 1. dim header */
+    ret[i] = (char *)ret +  /* base address */
+             n * sizeof(void *) +  /* skip 1. dim header */
              i * m * elementSize; /* skip to 2. dim row header */
-  return (void **) ret;
+  return (void **)ret;
 }
 
 
@@ -131,34 +131,34 @@ GNUNET_xnew_array_2d_ (size_t n,
  * @return allocated memory, never NULL
  */
 void ***
-GNUNET_xnew_array_3d_ (size_t n,
-                       size_t m,
-                       size_t o,
-                       size_t elementSize,
-                       const char *filename,
-                       int linenumber)
+GNUNET_xnew_array_3d_(size_t n,
+                      size_t m,
+                      size_t o,
+                      size_t elementSize,
+                      const char *filename,
+                      int linenumber)
 {
   /* use char pointer internally to avoid void pointer arithmetic warnings */
-  char ***ret = GNUNET_xmalloc_ (n * sizeof (void **) + /* 1. dim header */
-                                   n * m * sizeof (void *) + /* 2. dim header */
-                                   n * m * o * elementSize, /* element data */
-                                 filename,
-                                 linenumber);
+  char ***ret = GNUNET_xmalloc_(n * sizeof(void **) +   /* 1. dim header */
+                                n * m * sizeof(void *) +     /* 2. dim header */
+                                n * m * o * elementSize,    /* element data */
+                                filename,
+                                linenumber);
 
   for (size_t i = 0; i < n; i++)
-  {
-    /* need to cast to (char *) temporarily for byte level acuracy */
-    ret[i] = (char **) ((char *) ret + /* base address */
-                        n * sizeof (void **) + /* skip 1. dim header */
-                        i * m * sizeof (void *)); /* skip to 2. dim header */
-    for (size_t j = 0; j < m; j++)
-      ret[i][j] = (char *) ret + /* base address */
-                  n * sizeof (void **) + /* skip 1. dim header */
-                  n * m * sizeof (void *) + /* skip 2. dim header */
-                  i * m * o * elementSize + /* skip to 2. dim part */
-                  j * o * elementSize; /* skip to 3. dim row data */
-  }
-  return (void ***) ret;
+    {
+      /* need to cast to (char *) temporarily for byte level acuracy */
+      ret[i] = (char **)((char *)ret + /* base address */
+                         n * sizeof(void **) + /* skip 1. dim header */
+                         i * m * sizeof(void *)); /* skip to 2. dim header */
+      for (size_t j = 0; j < m; j++)
+        ret[i][j] = (char *)ret + /* base address */
+                    n * sizeof(void **) + /* skip 1. dim header */
+                    n * m * sizeof(void *) + /* skip 2. dim header */
+                    i * m * o * elementSize + /* skip to 2. dim part */
+                    j * o * elementSize; /* skip to 3. dim row data */
+    }
+  return (void ***)ret;
 }
 
 
@@ -174,34 +174,34 @@ GNUNET_xnew_array_3d_ (size_t n,
  * @return allocated memory, never NULL
  */
 void *
-GNUNET_xmemdup_ (const void *buf,
-                 size_t size,
-                 const char *filename,
-                 int linenumber)
+GNUNET_xmemdup_(const void *buf,
+                size_t size,
+                const char *filename,
+                int linenumber)
 {
   void *ret;
 
   /* As a security precaution, we generally do not allow very large
    * allocations here */
-  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
+  GNUNET_assert_at(size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
 #ifdef W32_MEM_LIMIT
-  size += sizeof (size_t);
+  size += sizeof(size_t);
   if (mem_used + size > W32_MEM_LIMIT)
     return NULL;
 #endif
-  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
-  ret = malloc (size);
+  GNUNET_assert_at(size < INT_MAX, filename, linenumber);
+  ret = malloc(size);
   if (ret == NULL)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
-    GNUNET_assert (0);
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "malloc");
+      GNUNET_assert(0);
+    }
 #ifdef W32_MEM_LIMIT
-  *((size_t *) ret) = size;
-  ret = &((size_t *) ret)[1];
+  *((size_t *)ret) = size;
+  ret = &((size_t *)ret)[1];
   mem_used += size;
 #endif
-  GNUNET_memcpy (ret, buf, size);
+  GNUNET_memcpy(ret, buf, size);
   return ret;
 }
 
@@ -216,26 +216,26 @@ GNUNET_xmemdup_ (const void *buf,
  * @return pointer to size bytes of memory, NULL if we do not have enough memory
  */
 void *
-GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
+GNUNET_xmalloc_unchecked_(size_t size, const char *filename, int linenumber)
 {
   void *result;
 
-  (void) filename;
-  (void) linenumber;
+  (void)filename;
+  (void)linenumber;
 #ifdef W32_MEM_LIMIT
-  size += sizeof (size_t);
+  size += sizeof(size_t);
   if (mem_used + size > W32_MEM_LIMIT)
     return NULL;
 #endif
 
-  result = malloc (size);
+  result = malloc(size);
   if (NULL == result)
     return NULL;
-  memset (result, 0, size);
+  memset(result, 0, size);
 
 #ifdef W32_MEM_LIMIT
-  *((size_t *) result) = size;
-  result = &((size_t *) result)[1];
+  *((size_t *)result) = size;
+  result = &((size_t *)result)[1];
   mem_used += size;
 #endif
 
@@ -255,24 +255,24 @@ GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
  * @return pointer to size bytes of memory
  */
 void *
-GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
+GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber)
 {
-  (void) filename;
-  (void) linenumber;
+  (void)filename;
+  (void)linenumber;
 
 #ifdef W32_MEM_LIMIT
-  n += sizeof (size_t);
-  ptr = &((size_t *) ptr)[-1];
-  mem_used = mem_used - *((size_t *) ptr) + n;
+  n += sizeof(size_t);
+  ptr = &((size_t *)ptr)[-1];
+  mem_used = mem_used - *((size_t *)ptr) + n;
 #endif
-  ptr = realloc (ptr, n);
+  ptr = realloc(ptr, n);
   if ((NULL == ptr) && (n > 0))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
-    GNUNET_assert (0);
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "realloc");
+      GNUNET_assert(0);
+    }
 #ifdef W32_MEM_LIMIT
-  ptr = &((size_t *) ptr)[1];
+  ptr = &((size_t *)ptr)[1];
 #endif
   return ptr;
 }
@@ -286,15 +286,15 @@ GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
 #endif
 
 #if WINDOWS
-#define M_SIZE(p) _msize (p)
+#define M_SIZE(p) _msize(p)
 #endif
 #if HAVE_MALLOC_NP_H
 #include <malloc_np.h>
 #endif
 #if HAVE_MALLOC_USABLE_SIZE
-#define M_SIZE(p) malloc_usable_size (p)
+#define M_SIZE(p) malloc_usable_size(p)
 #elif HAVE_MALLOC_SIZE
-#define M_SIZE(p) malloc_size (p)
+#define M_SIZE(p) malloc_size(p)
 #endif
 
 /**
@@ -306,28 +306,28 @@ GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
  * @param linenumber where in the code was the call to GNUNET_free
  */
 void
-GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
+GNUNET_xfree_(void *ptr, const char *filename, int linenumber)
 {
-  GNUNET_assert_at (NULL != ptr, filename, linenumber);
+  GNUNET_assert_at(NULL != ptr, filename, linenumber);
 #ifdef W32_MEM_LIMIT
-  ptr = &((size_t *) ptr)[-1];
-  mem_used -= *((size_t *) ptr);
+  ptr = &((size_t *)ptr)[-1];
+  mem_used -= *((size_t *)ptr);
 #endif
 #if defined(M_SIZE)
 #if ENABLE_POISONING
   {
-    const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
+    const uint64_t baadfood = GNUNET_ntohll(0xBAADF00DBAADF00DLL);
     uint64_t *base = ptr;
-    size_t s = M_SIZE (ptr);
+    size_t s = M_SIZE(ptr);
     size_t i;
 
     for (i = 0; i < s / 8; i++)
       base[i] = baadfood;
-    GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
+    GNUNET_memcpy(&base[s / 8], &baadfood, s % 8);
   }
 #endif
 #endif
-  free (ptr);
+  free(ptr);
 }
 
 
@@ -340,26 +340,26 @@ GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
  * @return `strdup(@a str)`
  */
 char *
-GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
+GNUNET_xstrdup_(const char *str, const char *filename, int linenumber)
 {
   char *res;
   size_t slen;
 
-  GNUNET_assert_at (str != NULL, filename, linenumber);
-  slen = strlen (str) + 1;
-  res = GNUNET_xmalloc_ (slen, filename, linenumber);
-  GNUNET_memcpy (res, str, slen);
+  GNUNET_assert_at(str != NULL, filename, linenumber);
+  slen = strlen(str) + 1;
+  res = GNUNET_xmalloc_(slen, filename, linenumber);
+  GNUNET_memcpy(res, str, slen);
   return res;
 }
 
 
-#if ! HAVE_STRNLEN
+#if !HAVE_STRNLEN
 static size_t
-strnlen (const char *s, size_t n)
+strnlen(const char *s, size_t n)
 {
   const char *e;
 
-  e = memchr (s, '\0', n);
+  e = memchr(s, '\0', n);
   if (NULL == e)
     return n;
   return e - s;
@@ -377,19 +377,19 @@ strnlen (const char *s, size_t n)
  * @return `strndup(@a str,@a len)`
  */
 char *
-GNUNET_xstrndup_ (const char *str,
-                  size_t len,
-                  const char *filename,
-                  int linenumber)
+GNUNET_xstrndup_(const char *str,
+                 size_t len,
+                 const char *filename,
+                 int linenumber)
 {
   char *res;
 
   if (0 == len)
-    return GNUNET_strdup ("");
-  GNUNET_assert_at (NULL != str, filename, linenumber);
-  len = strnlen (str, len);
-  res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
-  GNUNET_memcpy (res, str, len);
+    return GNUNET_strdup("");
+  GNUNET_assert_at(NULL != str, filename, linenumber);
+  len = strnlen(str, len);
+  res = GNUNET_xmalloc_(len + 1, filename, linenumber);
+  GNUNET_memcpy(res, str, len);
   /* res[len] = '\0'; 'malloc' zeros out anyway */
   return res;
 }
@@ -408,35 +408,35 @@ GNUNET_xstrndup_ (const char *str,
  * @param linenumber where in the code was the call to GNUNET_array_grow()
  */
 void
-GNUNET_xgrow_ (void **old,
-               size_t elementSize,
-               unsigned int *oldCount,
-               unsigned int newCount,
-               const char *filename,
-               int linenumber)
+GNUNET_xgrow_(void **old,
+              size_t elementSize,
+              unsigned int *oldCount,
+              unsigned int newCount,
+              const char *filename,
+              int linenumber)
 {
   void *tmp;
   size_t size;
 
-  GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
+  GNUNET_assert_at(INT_MAX / elementSize > newCount, filename, linenumber);
   size = newCount * elementSize;
   if (0 == size)
-  {
-    tmp = NULL;
-  }
+    {
+      tmp = NULL;
+    }
   else
-  {
-    tmp = GNUNET_xmalloc_ (size, filename, linenumber);
-    if (NULL != *old)
     {
-      GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
+      tmp = GNUNET_xmalloc_(size, filename, linenumber);
+      if (NULL != *old)
+        {
+          GNUNET_memcpy(tmp, *old, elementSize * GNUNET_MIN(*oldCount, newCount));
+        }
     }
-  }
 
   if (NULL != *old)
-  {
-    GNUNET_xfree_ (*old, filename, linenumber);
-  }
+    {
+      GNUNET_xfree_(*old, filename, linenumber);
+    }
   *old = tmp;
   *oldCount = newCount;
 }
@@ -451,19 +451,19 @@ GNUNET_xgrow_ (void **old,
  * @return number of bytes in `*@a buf`, excluding 0-termination
  */
 int
-GNUNET_asprintf (char **buf, const char *format, ...)
+GNUNET_asprintf(char **buf, const char *format, ...)
 {
   int ret;
   va_list args;
 
-  va_start (args, format);
-  ret = vsnprintf (NULL, 0, format, args);
-  va_end (args);
-  GNUNET_assert (ret >= 0);
-  *buf = GNUNET_malloc (ret + 1);
-  va_start (args, format);
-  ret = vsprintf (*buf, format, args);
-  va_end (args);
+  va_start(args, format);
+  ret = vsnprintf(NULL, 0, format, args);
+  va_end(args);
+  GNUNET_assert(ret >= 0);
+  *buf = GNUNET_malloc(ret + 1);
+  va_start(args, format);
+  ret = vsprintf(*buf, format, args);
+  va_end(args);
   return ret;
 }
 
@@ -478,15 +478,15 @@ GNUNET_asprintf (char **buf, const char *format, ...)
  * @return number of bytes written to buf or negative value on error
  */
 int
-GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
+GNUNET_snprintf(char *buf, size_t size, const char *format, ...)
 {
   int ret;
   va_list args;
 
-  va_start (args, format);
-  ret = vsnprintf (buf, size, format, args);
-  va_end (args);
-  GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
+  va_start(args, format);
+  ret = vsnprintf(buf, size, format, args);
+  va_end(args);
+  GNUNET_assert((ret >= 0) && (((size_t)ret) < size));
   return ret;
 }
 
@@ -498,15 +498,15 @@ GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
  * @return duplicate of the message
  */
 struct GNUNET_MessageHeader *
-GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
+GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_MessageHeader *ret;
   uint16_t msize;
 
-  msize = ntohs (msg->size);
-  GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
-  ret = GNUNET_malloc (msize);
-  GNUNET_memcpy (ret, msg, msize);
+  msize = ntohs(msg->size);
+  GNUNET_assert(msize >= sizeof(struct GNUNET_MessageHeader));
+  ret = GNUNET_malloc(msize);
+  GNUNET_memcpy(ret, msg, msize);
   return ret;
 }
 
diff --git a/src/util/common_endian.c b/src/util/common_endian.c
index d7daa2d79..6ec203dd9 100644
--- a/src/util/common_endian.c
+++ b/src/util/common_endian.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 util/common_endian.c
@@ -28,16 +28,16 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-common-endian",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-common-endian", __VA_ARGS__)
 
 
 uint64_t
-GNUNET_htonll (uint64_t n)
+GNUNET_htonll(uint64_t n)
 {
 #if __BYTE_ORDER == __BIG_ENDIAN
   return n;
 #elif __BYTE_ORDER == __LITTLE_ENDIAN
-  return (((uint64_t) htonl (n)) << 32) + htonl (n >> 32);
+  return (((uint64_t)htonl(n)) << 32) + htonl(n >> 32);
 #else
   #error byteorder undefined
 #endif
@@ -45,12 +45,12 @@ GNUNET_htonll (uint64_t n)
 
 
 uint64_t
-GNUNET_ntohll (uint64_t n)
+GNUNET_ntohll(uint64_t n)
 {
 #if __BYTE_ORDER == __BIG_ENDIAN
   return n;
 #elif __BYTE_ORDER == __LITTLE_ENDIAN
-  return (((uint64_t) ntohl (n)) << 32) + ntohl (n >> 32);
+  return (((uint64_t)ntohl(n)) << 32) + ntohl(n >> 32);
 #else
   #error byteorder undefined
 #endif
@@ -63,11 +63,11 @@ GNUNET_ntohll (uint64_t n)
  * @return the same value in host byte order
  */
 double
-GNUNET_hton_double (double d)
+GNUNET_hton_double(double d)
 {
   double res;
-  uint64_t *in = (uint64_t *) &d;
-  uint64_t *out = (uint64_t *) &res;
+  uint64_t *in = (uint64_t *)&d;
+  uint64_t *out = (uint64_t *)&res;
 
   out[0] = GNUNET_htonll(in[0]);
 
@@ -81,11 +81,11 @@ GNUNET_hton_double (double d)
  * @return the same value in host byte order
  */
 double
-GNUNET_ntoh_double (double d)
+GNUNET_ntoh_double(double d)
 {
   double res;
-  uint64_t *in = (uint64_t *) &d;
-  uint64_t *out = (uint64_t *) &res;
+  uint64_t *in = (uint64_t *)&d;
+  uint64_t *out = (uint64_t *)&res;
 
   out[0] = GNUNET_ntohll(in[0]);
 
diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index d3666ae7d..4c7a5291f 100644
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.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 util/common_logging.c
@@ -77,8 +77,7 @@
 /**
  * Linked list of active loggers.
  */
-struct CustomLogger
-{
+struct CustomLogger {
   /**
    * This is a linked list.
    */
@@ -167,8 +166,7 @@ static FILE *GNUNET_stderr;
 /**
  * Represents a single logging definition
  */
-struct LogDef
-{
+struct LogDef {
   /**
    * Component name regex
    */
@@ -211,7 +209,7 @@ struct LogDef
 };
 
 
-#if ! defined(GNUNET_CULL_LOGGING)
+#if !defined(GNUNET_CULL_LOGGING)
 /**
  * Dynamic array of logging definitions
  */
@@ -259,21 +257,21 @@ static LARGE_INTEGER performance_frequency;
  * @return GNUNET_GE_INVALID if log does not parse
  */
 static enum GNUNET_ErrorType
-get_type (const char *log)
+get_type(const char *log)
 {
   if (NULL == log)
     return GNUNET_ERROR_TYPE_UNSPECIFIED;
-  if (0 == strcasecmp (log, _ ("DEBUG")))
+  if (0 == strcasecmp(log, _("DEBUG")))
     return GNUNET_ERROR_TYPE_DEBUG;
-  if (0 == strcasecmp (log, _ ("INFO")))
+  if (0 == strcasecmp(log, _("INFO")))
     return GNUNET_ERROR_TYPE_INFO;
-  if (0 == strcasecmp (log, _ ("MESSAGE")))
+  if (0 == strcasecmp(log, _("MESSAGE")))
     return GNUNET_ERROR_TYPE_MESSAGE;
-  if (0 == strcasecmp (log, _ ("WARNING")))
+  if (0 == strcasecmp(log, _("WARNING")))
     return GNUNET_ERROR_TYPE_WARNING;
-  if (0 == strcasecmp (log, _ ("ERROR")))
+  if (0 == strcasecmp(log, _("ERROR")))
     return GNUNET_ERROR_TYPE_ERROR;
-  if (0 == strcasecmp (log, _ ("NONE")))
+  if (0 == strcasecmp(log, _("NONE")))
     return GNUNET_ERROR_TYPE_NONE;
   return GNUNET_ERROR_TYPE_INVALID;
 }
@@ -283,35 +281,35 @@ get_type (const char *log)
  * Abort the process, generate a core dump if possible.
  */
 void
-GNUNET_abort_ ()
+GNUNET_abort_()
 {
 #if WINDOWS
-  DebugBreak ();
+  DebugBreak();
 #endif
-  abort ();
+  abort();
 }
 
 
-#if ! defined(GNUNET_CULL_LOGGING)
+#if !defined(GNUNET_CULL_LOGGING)
 /**
  * Utility function - reallocates logdefs array to be twice as large.
  */
 static void
-resize_logdefs ()
+resize_logdefs()
 {
   logdefs_size = (logdefs_size + 1) * 2;
-  logdefs = GNUNET_realloc (logdefs, logdefs_size * sizeof (struct LogDef));
+  logdefs = GNUNET_realloc(logdefs, logdefs_size * sizeof(struct LogDef));
 }
 
 
-#if ! TALER_WALLET_ONLY
+#if !TALER_WALLET_ONLY
 /**
  * Rotate logs, deleting the oldest log.
  *
  * @param new_name new name to add to the rotation
  */
 static void
-log_rotate (const char *new_name)
+log_rotate(const char *new_name)
 {
   static char *rotation[ROTATION_KEEP];
   static unsigned int rotation_off;
@@ -321,13 +319,13 @@ log_rotate (const char *new_name)
     return; /* not a real log file name */
   discard = rotation[rotation_off % ROTATION_KEEP];
   if (NULL != discard)
-  {
-    /* Note: can't log errors during logging (recursion!), so this
-       operation MUST silently fail... */
-    (void) unlink (discard);
-    GNUNET_free (discard);
-  }
-  rotation[rotation_off % ROTATION_KEEP] = GNUNET_strdup (new_name);
+    {
+      /* Note: can't log errors during logging (recursion!), so this
+         operation MUST silently fail... */
+      (void)unlink(discard);
+      GNUNET_free(discard);
+    }
+  rotation[rotation_off % ROTATION_KEEP] = GNUNET_strdup(new_name);
   rotation_off++;
 }
 
@@ -339,7 +337,7 @@ log_rotate (const char *new_name)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-setup_log_file (const struct tm *tm)
+setup_log_file(const struct tm *tm)
 {
   static char last_fn[PATH_MAX + 1];
   char fn[PATH_MAX + 1];
@@ -350,68 +348,68 @@ setup_log_file (const struct tm *tm)
 
   if (NULL == log_file_name)
     return GNUNET_SYSERR;
-  if (0 == strftime (fn, sizeof (fn), log_file_name, tm))
+  if (0 == strftime(fn, sizeof(fn), log_file_name, tm))
     return GNUNET_SYSERR;
-  leftsquare = strrchr (fn, '[');
+  leftsquare = strrchr(fn, '[');
   if ((NULL != leftsquare) && (']' == leftsquare[1]))
-  {
-    char *logfile_copy = GNUNET_strdup (fn);
-
-    logfile_copy[leftsquare - fn] = '\0';
-    logfile_copy[leftsquare - fn + 1] = '\0';
-    snprintf (fn,
-              PATH_MAX,
-              "%s%d%s",
-              logfile_copy,
-              getpid (),
-              &logfile_copy[leftsquare - fn + 2]);
-    GNUNET_free (logfile_copy);
-  }
-  if (0 == strcmp (fn, last_fn))
+    {
+      char *logfile_copy = GNUNET_strdup(fn);
+
+      logfile_copy[leftsquare - fn] = '\0';
+      logfile_copy[leftsquare - fn + 1] = '\0';
+      snprintf(fn,
+               PATH_MAX,
+               "%s%d%s",
+               logfile_copy,
+               getpid(),
+               &logfile_copy[leftsquare - fn + 2]);
+      GNUNET_free(logfile_copy);
+    }
+  if (0 == strcmp(fn, last_fn))
     return GNUNET_OK; /* no change */
-  log_rotate (last_fn);
-  strcpy (last_fn, fn);
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (fn))
-  {
-    fprintf (stderr,
-             "Failed to create directory for `%s': %s\n",
-             fn,
-             strerror (errno));
-    return GNUNET_SYSERR;
-  }
+  log_rotate(last_fn);
+  strcpy(last_fn, fn);
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file(fn))
+    {
+      fprintf(stderr,
+              "Failed to create directory for `%s': %s\n",
+              fn,
+              strerror(errno));
+      return GNUNET_SYSERR;
+    }
 #if WINDOWS
   altlog_fd =
-    open (fn, O_APPEND | O_BINARY | O_WRONLY | O_CREAT, _S_IREAD | _S_IWRITE);
+    open(fn, O_APPEND | O_BINARY | O_WRONLY | O_CREAT, _S_IREAD | _S_IWRITE);
 #else
-  altlog_fd = open (fn,
-                    O_APPEND | O_WRONLY | O_CREAT,
-                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+  altlog_fd = open(fn,
+                   O_APPEND | O_WRONLY | O_CREAT,
+                   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 #endif
   if (-1 != altlog_fd)
-  {
-    if (NULL != GNUNET_stderr)
-      fclose (GNUNET_stderr);
-    dup_return = dup2 (altlog_fd, 2);
-    (void) close (altlog_fd);
-    if (-1 != dup_return)
     {
-      altlog = fdopen (2, "ab");
-      if (NULL == altlog)
-      {
-        (void) close (2);
-        altlog_fd = -1;
-      }
+      if (NULL != GNUNET_stderr)
+        fclose(GNUNET_stderr);
+      dup_return = dup2(altlog_fd, 2);
+      (void)close(altlog_fd);
+      if (-1 != dup_return)
+        {
+          altlog = fdopen(2, "ab");
+          if (NULL == altlog)
+            {
+              (void)close(2);
+              altlog_fd = -1;
+            }
+        }
+      else
+        {
+          altlog_fd = -1;
+        }
     }
-    else
+  if (-1 == altlog_fd)
     {
-      altlog_fd = -1;
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", fn);
+      return GNUNET_SYSERR;
     }
-  }
-  if (-1 == altlog_fd)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
-    return GNUNET_SYSERR;
-  }
   GNUNET_stderr = altlog;
   return GNUNET_OK;
 }
@@ -431,44 +429,44 @@ setup_log_file (const struct tm *tm)
  * @return 0 on success, regex-specific error otherwise
  */
 static int
-add_definition (const char *component,
-                const char *file,
-                const char *function,
-                int from_line,
-                int to_line,
-                int level,
-                int force)
+add_definition(const char *component,
+               const char *file,
+               const char *function,
+               int from_line,
+               int to_line,
+               int level,
+               int force)
 {
   struct LogDef n;
   int r;
 
   if (logdefs_size == logdefs_len)
-    resize_logdefs ();
-  memset (&n, 0, sizeof (n));
-  if (0 == strlen (component))
-    component = (char *) ".*";
-  r = regcomp (&n.component_regex, (const char *) component, REG_NOSUB);
+    resize_logdefs();
+  memset(&n, 0, sizeof(n));
+  if (0 == strlen(component))
+    component = (char *)".*";
+  r = regcomp(&n.component_regex, (const char *)component, REG_NOSUB);
   if (0 != r)
-  {
-    return r;
-  }
-  if (0 == strlen (file))
-    file = (char *) ".*";
-  r = regcomp (&n.file_regex, (const char *) file, REG_NOSUB);
+    {
+      return r;
+    }
+  if (0 == strlen(file))
+    file = (char *)".*";
+  r = regcomp(&n.file_regex, (const char *)file, REG_NOSUB);
   if (0 != r)
-  {
-    regfree (&n.component_regex);
-    return r;
-  }
-  if ((NULL == function) || (0 == strlen (function)))
-    function = (char *) ".*";
-  r = regcomp (&n.function_regex, (const char *) function, REG_NOSUB);
+    {
+      regfree(&n.component_regex);
+      return r;
+    }
+  if ((NULL == function) || (0 == strlen(function)))
+    function = (char *)".*";
+  r = regcomp(&n.function_regex, (const char *)function, REG_NOSUB);
   if (0 != r)
-  {
-    regfree (&n.component_regex);
-    regfree (&n.file_regex);
-    return r;
-  }
+    {
+      regfree(&n.component_regex);
+      regfree(&n.file_regex);
+      return r;
+    }
   n.from_line = from_line;
   n.to_line = to_line;
   n.level = level;
@@ -492,11 +490,11 @@ add_definition (const char *component,
  * @return 0 to disallow the call, 1 to allow it
  */
 int
-GNUNET_get_log_call_status (int caller_level,
-                            const char *comp,
-                            const char *file,
-                            const char *function,
-                            int line)
+GNUNET_get_log_call_status(int caller_level,
+                           const char *comp,
+                           const char *file,
+                           const char *function,
+                           int line)
 {
   struct LogDef *ld;
   int i;
@@ -515,18 +513,18 @@ GNUNET_get_log_call_status (int caller_level,
   /* Only look for forced definitions? */
   force_only = min_level >= 0;
   for (i = 0; i < logdefs_len; i++)
-  {
-    ld = &logdefs[i];
-    if (((! force_only) || ld->force) &&
-        (line >= ld->from_line && line <= ld->to_line) &&
-        (0 == regexec (&ld->component_regex, comp, 0, NULL, 0)) &&
-        (0 == regexec (&ld->file_regex, file, 0, NULL, 0)) &&
-        (0 == regexec (&ld->function_regex, function, 0, NULL, 0)))
     {
-      /* We're finished */
-      return caller_level <= ld->level;
+      ld = &logdefs[i];
+      if (((!force_only) || ld->force) &&
+          (line >= ld->from_line && line <= ld->to_line) &&
+          (0 == regexec(&ld->component_regex, comp, 0, NULL, 0)) &&
+          (0 == regexec(&ld->file_regex, file, 0, NULL, 0)) &&
+          (0 == regexec(&ld->function_regex, function, 0, NULL, 0)))
+        {
+          /* We're finished */
+          return caller_level <= ld->level;
+        }
     }
-  }
   /* No matches - use global level, if defined */
   if (min_level >= 0)
     return caller_level <= min_level;
@@ -562,7 +560,7 @@ GNUNET_get_log_call_status (int caller_level,
  * @return number of added definitions
  */
 static int
-parse_definitions (const char *constname, int force)
+parse_definitions(const char *constname, int force)
 {
   char *def;
   const char *tmp;
@@ -578,108 +576,116 @@ parse_definitions (const char *constname, int force)
   int counter = 0;
   int keep_looking = 1;
 
-  tmp = getenv (constname);
+  tmp = getenv(constname);
   if (NULL == tmp)
     return 0;
-  def = GNUNET_strdup (tmp);
+  def = GNUNET_strdup(tmp);
   from_line = 0;
   to_line = INT_MAX;
   for (p = def, state = 0, start = def; keep_looking; p++)
-  {
-    switch (p[0])
     {
-    case ';': /* found a field separator */
-      p[0] = '\0';
-      switch (state)
-      {
-      case 0: /* within a component name */
-        comp = start;
-        break;
-      case 1: /* within a file name */
-        file = start;
-        break;
-      case 2: /* within a function name */
-        /* after a file name there must be a function name */
-        function = start;
-        break;
-      case 3: /* within a from-to line range */
-        if (strlen (start) > 0)
+      switch (p[0])
         {
-          errno = 0;
-          from_line = strtol (start, &t, 10);
-          if ((0 != errno) || (from_line < 0))
-          {
-            GNUNET_free (def);
-            return counter;
-          }
-          if ((t < p) && ('-' == t[0]))
-          {
-            errno = 0;
-            start = t + 1;
-            to_line = strtol (start, &t, 10);
-            if ((0 != errno) || (to_line < 0) || (t != p))
+        case ';': /* found a field separator */
+          p[0] = '\0';
+          switch (state)
             {
-              GNUNET_free (def);
-              return counter;
+            case 0: /* within a component name */
+              comp = start;
+              break;
+
+            case 1: /* within a file name */
+              file = start;
+              break;
+
+            case 2: /* within a function name */
+              /* after a file name there must be a function name */
+              function = start;
+              break;
+
+            case 3: /* within a from-to line range */
+              if (strlen(start) > 0)
+                {
+                  errno = 0;
+                  from_line = strtol(start, &t, 10);
+                  if ((0 != errno) || (from_line < 0))
+                    {
+                      GNUNET_free(def);
+                      return counter;
+                    }
+                  if ((t < p) && ('-' == t[0]))
+                    {
+                      errno = 0;
+                      start = t + 1;
+                      to_line = strtol(start, &t, 10);
+                      if ((0 != errno) || (to_line < 0) || (t != p))
+                        {
+                          GNUNET_free(def);
+                          return counter;
+                        }
+                    }
+                  else /* one number means "match this line only" */
+                    to_line = from_line;
+                }
+              else /* default to 0-max */
+                {
+                  from_line = 0;
+                  to_line = INT_MAX;
+                }
+              break;
+
+            default:
+              fprintf(
+                stderr,
+                _("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
+                p);
+              break;
             }
-          }
-          else /* one number means "match this line only" */
-            to_line = from_line;
-        }
-        else /* default to 0-max */
-        {
-          from_line = 0;
-          to_line = INT_MAX;
-        }
-        break;
-      default:
-        fprintf (
-          stderr,
-          _ ("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
-          p);
-        break;
-      }
-      start = p + 1;
-      state++;
-      break;
-    case '\0': /* found EOL */
-      keep_looking = 0;
-      /* fall through to '/' */
-    case '/': /* found a definition separator */
-      switch (state)
-      {
-      case 4: /* within a log level */
-        p[0] = '\0';
-        state = 0;
-        level = get_type ((const char *) start);
-        if ((GNUNET_ERROR_TYPE_INVALID == level) ||
-            (GNUNET_ERROR_TYPE_UNSPECIFIED == level) ||
-            (0 != add_definition (comp,
-                                  file,
-                                  function,
-                                  from_line,
-                                  to_line,
-                                  level,
-                                  force)))
-        {
-          GNUNET_free (def);
-          return counter;
+          start = p + 1;
+          state++;
+          break;
+
+        case '\0': /* found EOL */
+          keep_looking = 0;
+
+        /* fall through to '/' */
+        case '/': /* found a definition separator */
+          switch (state)
+            {
+            case 4: /* within a log level */
+              p[0] = '\0';
+              state = 0;
+              level = get_type((const char *)start);
+              if ((GNUNET_ERROR_TYPE_INVALID == level) ||
+                  (GNUNET_ERROR_TYPE_UNSPECIFIED == level) ||
+                  (0 != add_definition(comp,
+                                       file,
+                                       function,
+                                       from_line,
+                                       to_line,
+                                       level,
+                                       force)))
+                {
+                  GNUNET_free(def);
+                  return counter;
+                }
+              counter++;
+              start = p + 1;
+              break;
+
+            default:
+              fprintf(
+                stderr,
+                _("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
+                p);
+              break;
+            }
+
+        default:
+          break;
         }
-        counter++;
-        start = p + 1;
-        break;
-      default:
-        fprintf (
-          stderr,
-          _ ("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
-          p);
-        break;
-      }
-    default:
-      break;
     }
-  }
-  GNUNET_free (def);
+  GNUNET_free(def);
   return counter;
 }
 
@@ -688,15 +694,15 @@ parse_definitions (const char *constname, int force)
  * Utility function - parses GNUNET_LOG and GNUNET_FORCE_LOG.
  */
 static void
-parse_all_definitions ()
+parse_all_definitions()
 {
   if (GNUNET_NO == gnunet_force_log_parsed)
     gnunet_force_log_present =
-      parse_definitions ("GNUNET_FORCE_LOG", 1) > 0 ? GNUNET_YES : GNUNET_NO;
+      parse_definitions("GNUNET_FORCE_LOG", 1) > 0 ? GNUNET_YES : GNUNET_NO;
   gnunet_force_log_parsed = GNUNET_YES;
 
   if (GNUNET_NO == gnunet_log_parsed)
-    parse_definitions ("GNUNET_LOG", 0);
+    parse_definitions("GNUNET_LOG", 0);
   gnunet_log_parsed = GNUNET_YES;
 }
 #endif
@@ -711,43 +717,43 @@ parse_all_definitions ()
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
+GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
 {
   const char *env_logfile;
 
-  min_level = get_type (loglevel);
-#if ! defined(GNUNET_CULL_LOGGING)
-  parse_all_definitions ();
+  min_level = get_type(loglevel);
+#if !defined(GNUNET_CULL_LOGGING)
+  parse_all_definitions();
 #endif
 #ifdef WINDOWS
-  QueryPerformanceFrequency (&performance_frequency);
+  QueryPerformanceFrequency(&performance_frequency);
 #endif
-  GNUNET_free_non_null (component);
-  GNUNET_asprintf (&component, "%s-%d", comp, getpid ());
-  GNUNET_free_non_null (component_nopid);
-  component_nopid = GNUNET_strdup (comp);
+  GNUNET_free_non_null(component);
+  GNUNET_asprintf(&component, "%s-%d", comp, getpid());
+  GNUNET_free_non_null(component_nopid);
+  component_nopid = GNUNET_strdup(comp);
 
-  env_logfile = getenv ("GNUNET_FORCE_LOGFILE");
-  if ((NULL != env_logfile) && (strlen (env_logfile) > 0))
+  env_logfile = getenv("GNUNET_FORCE_LOGFILE");
+  if ((NULL != env_logfile) && (strlen(env_logfile) > 0))
     logfile = env_logfile;
   if (NULL == logfile)
     return GNUNET_OK;
-  GNUNET_free_non_null (log_file_name);
-  log_file_name = GNUNET_STRINGS_filename_expand (logfile);
+  GNUNET_free_non_null(log_file_name);
+  log_file_name = GNUNET_STRINGS_filename_expand(logfile);
   if (NULL == log_file_name)
     return GNUNET_SYSERR;
 #if TALER_WALLET_ONLY || defined(GNUNET_CULL_LOGGING)
   /* log file option not allowed for wallet logic */
-  GNUNET_assert (NULL == logfile);
+  GNUNET_assert(NULL == logfile);
   return GNUNET_OK;
 #else
   {
     time_t t;
     const struct tm *tm;
 
-    t = time (NULL);
-    tm = gmtime (&t);
-    return setup_log_file (tm);
+    t = time(NULL);
+    tm = gmtime(&t);
+    return setup_log_file(tm);
   }
 #endif
 }
@@ -763,11 +769,11 @@ GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
  * @param logger_cls closure for @a logger
  */
 void
-GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
+GNUNET_logger_add(GNUNET_Logger logger, void *logger_cls)
 {
   struct CustomLogger *entry;
 
-  entry = GNUNET_new (struct CustomLogger);
+  entry = GNUNET_new(struct CustomLogger);
   entry->logger = logger;
   entry->logger_cls = logger_cls;
   entry->next = loggers;
@@ -782,7 +788,7 @@ GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
  * @param logger_cls closure for @a logger
  */
 void
-GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
+GNUNET_logger_remove(GNUNET_Logger logger, void *logger_cls)
 {
   struct CustomLogger *pos;
   struct CustomLogger *prev;
@@ -791,16 +797,16 @@ GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
   pos = loggers;
   while ((NULL != pos) &&
          ((pos->logger != logger) || (pos->logger_cls != logger_cls)))
-  {
-    prev = pos;
-    pos = pos->next;
-  }
-  GNUNET_assert (NULL != pos);
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+  GNUNET_assert(NULL != pos);
   if (NULL == prev)
     loggers = pos->next;
   else
     prev->next = pos->next;
-  GNUNET_free (pos);
+  GNUNET_free(pos);
 }
 
 #if WINDOWS
@@ -817,72 +823,72 @@ CRITICAL_SECTION output_message_cs;
  * @param msg the actual message
  */
 static void
-output_message (enum GNUNET_ErrorType kind,
-                const char *comp,
-                const char *datestr,
-                const char *msg)
+output_message(enum GNUNET_ErrorType kind,
+               const char *comp,
+               const char *datestr,
+               const char *msg)
 {
   struct CustomLogger *pos;
 
 #if WINDOWS
-  EnterCriticalSection (&output_message_cs);
+  EnterCriticalSection(&output_message_cs);
 #endif
   /* only use the standard logger if no custom loggers are present */
   if ((NULL != GNUNET_stderr) && (NULL == loggers))
-  {
-    if (kind == GNUNET_ERROR_TYPE_MESSAGE)
     {
-      /* The idea here is to produce "normal" output messages
-       * for end users while still having the power of the
-       * logging engine for developer needs. So ideally this
-       * is what it should look like when CLI tools are used
-       * interactively, yet the same message shouldn't look
-       * this way if the output is going to logfiles or robots
-       * instead.
-       */
-      fprintf (GNUNET_stderr, "* %s", msg);
-    }
-    else if (GNUNET_YES == current_async_scope.have_scope)
-    {
-      static GNUNET_THREAD_LOCAL char id_buf[27];
-      char *end;
-
-      /* We're logging, so skip_log must be currently 0. */
-      skip_log = 100;
-      end = GNUNET_STRINGS_data_to_string (&current_async_scope.scope_id,
-                                           sizeof (struct GNUNET_AsyncScopeId),
-                                           id_buf,
-                                           sizeof (id_buf) - 1);
-      GNUNET_assert (NULL != end);
-      *end = '\0';
-      skip_log = 0;
-      fprintf (GNUNET_stderr,
-               "%s %s(%s) %s %s",
-               datestr,
-               comp,
-               id_buf,
-               GNUNET_error_type_to_string (kind),
-               msg);
-    }
-    else
-    {
-      fprintf (GNUNET_stderr,
-               "%s %s %s %s",
-               datestr,
-               comp,
-               GNUNET_error_type_to_string (kind),
-               msg);
+      if (kind == GNUNET_ERROR_TYPE_MESSAGE)
+        {
+          /* The idea here is to produce "normal" output messages
+           * for end users while still having the power of the
+           * logging engine for developer needs. So ideally this
+           * is what it should look like when CLI tools are used
+           * interactively, yet the same message shouldn't look
+           * this way if the output is going to logfiles or robots
+           * instead.
+           */
+          fprintf(GNUNET_stderr, "* %s", msg);
+        }
+      else if (GNUNET_YES == current_async_scope.have_scope)
+        {
+          static GNUNET_THREAD_LOCAL char id_buf[27];
+          char *end;
+
+          /* We're logging, so skip_log must be currently 0. */
+          skip_log = 100;
+          end = GNUNET_STRINGS_data_to_string(&current_async_scope.scope_id,
+                                              sizeof(struct GNUNET_AsyncScopeId),
+                                              id_buf,
+                                              sizeof(id_buf) - 1);
+          GNUNET_assert(NULL != end);
+          *end = '\0';
+          skip_log = 0;
+          fprintf(GNUNET_stderr,
+                  "%s %s(%s) %s %s",
+                  datestr,
+                  comp,
+                  id_buf,
+                  GNUNET_error_type_to_string(kind),
+                  msg);
+        }
+      else
+        {
+          fprintf(GNUNET_stderr,
+                  "%s %s %s %s",
+                  datestr,
+                  comp,
+                  GNUNET_error_type_to_string(kind),
+                  msg);
+        }
+      fflush(GNUNET_stderr);
     }
-    fflush (GNUNET_stderr);
-  }
   pos = loggers;
   while (NULL != pos)
-  {
-    pos->logger (pos->logger_cls, kind, comp, datestr, msg);
-    pos = pos->next;
-  }
+    {
+      pos->logger(pos->logger_cls, kind, comp, datestr, msg);
+      pos = pos->next;
+    }
 #if WINDOWS
-  LeaveCriticalSection (&output_message_cs);
+  LeaveCriticalSection(&output_message_cs);
 #endif
 }
 
@@ -893,7 +899,7 @@ output_message (enum GNUNET_ErrorType kind,
  * @param datestr our current timestamp
  */
 static void
-flush_bulk (const char *datestr)
+flush_bulk(const char *datestr)
 {
   char msg[DATE_STR_SIZE + BULK_TRACK_SIZE + 256];
   int rev;
@@ -903,31 +909,31 @@ flush_bulk (const char *datestr)
   if ((0 == last_bulk_time.abs_value_us) || (0 == last_bulk_repeat))
     return;
   rev = 0;
-  last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
+  last = memchr(last_bulk, '\0', BULK_TRACK_SIZE);
   if (last == NULL)
     last = &last_bulk[BULK_TRACK_SIZE - 1];
   else if (last != last_bulk)
     last--;
   if (last[0] == '\n')
-  {
-    rev = 1;
-    last[0] = '\0';
-  }
+    {
+      rev = 1;
+      last[0] = '\0';
+    }
   ft =
-    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (
-                                              last_bulk_time),
-                                            GNUNET_YES);
-  snprintf (msg,
-            sizeof (msg),
-            _ ("Message `%.*s' repeated %u times in the last %s\n"),
-            BULK_TRACK_SIZE,
-            last_bulk,
-            last_bulk_repeat,
-            ft);
+    GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(
+                                             last_bulk_time),
+                                           GNUNET_YES);
+  snprintf(msg,
+           sizeof(msg),
+           _("Message `%.*s' repeated %u times in the last %s\n"),
+           BULK_TRACK_SIZE,
+           last_bulk,
+           last_bulk_repeat,
+           ft);
   if (rev == 1)
     last[0] = '\n';
-  output_message (last_bulk_kind, last_bulk_comp, datestr, msg);
-  last_bulk_time = GNUNET_TIME_absolute_get ();
+  output_message(last_bulk_kind, last_bulk_comp, datestr, msg);
+  last_bulk_time = GNUNET_TIME_absolute_get();
   last_bulk_repeat = 0;
 }
 
@@ -939,21 +945,21 @@ flush_bulk (const char *datestr)
  * @param check_reset #GNUNET_YES to assert that the log skip counter is currently zero
  */
 void
-GNUNET_log_skip (int n, int check_reset)
+GNUNET_log_skip(int n, int check_reset)
 {
   int ok;
 
   if (0 == n)
-  {
-    ok = (0 == skip_log);
-    skip_log = 0;
-    if (check_reset)
-      GNUNET_break (ok);
-  }
+    {
+      ok = (0 == skip_log);
+      skip_log = 0;
+      if (check_reset)
+        GNUNET_break(ok);
+    }
   else
-  {
-    skip_log += n;
-  }
+    {
+      skip_log += n;
+    }
 }
 
 
@@ -963,7 +969,7 @@ GNUNET_log_skip (int n, int check_reset)
  * @return number of log calls to be ignored
  */
 int
-GNUNET_get_log_skip ()
+GNUNET_get_log_skip()
 {
   return skip_log;
 }
@@ -978,10 +984,10 @@ GNUNET_get_log_skip ()
  * @param va arguments to the format string "message"
  */
 static void
-mylog (enum GNUNET_ErrorType kind,
-       const char *comp,
-       const char *message,
-       va_list va)
+mylog(enum GNUNET_ErrorType kind,
+      const char *comp,
+      const char *message,
+      va_list va)
 {
   char date[DATE_STR_SIZE];
   char date2[DATE_STR_SIZE];
@@ -989,11 +995,11 @@ mylog (enum GNUNET_ErrorType kind,
   size_t size;
   va_list vacp;
 
-  va_copy (vacp, va);
-  size = vsnprintf (NULL, 0, message, vacp) + 1;
-  GNUNET_assert (0 != size);
-  va_end (vacp);
-  memset (date, 0, DATE_STR_SIZE);
+  va_copy(vacp, va);
+  size = vsnprintf(NULL, 0, message, vacp) + 1;
+  GNUNET_assert(0 != size);
+  va_end(vacp);
+  memset(date, 0, DATE_STR_SIZE);
   {
     char buf[size];
     long long offset;
@@ -1001,92 +1007,92 @@ mylog (enum GNUNET_ErrorType kind,
     LARGE_INTEGER pc;
     time_t timetmp;
 
-    offset = GNUNET_TIME_get_offset ();
-    time (&timetmp);
+    offset = GNUNET_TIME_get_offset();
+    time(&timetmp);
     timetmp += offset / 1000;
-    tmptr = localtime (&timetmp);
+    tmptr = localtime(&timetmp);
     pc.QuadPart = 0;
-    QueryPerformanceCounter (&pc);
+    QueryPerformanceCounter(&pc);
     if (NULL == tmptr)
-    {
-      strcpy (date, "localtime error");
-    }
+      {
+        strcpy(date, "localtime error");
+      }
     else
-    {
-      if (0 ==
-          strftime (date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%020llu", tmptr))
-        abort ();
-      if (0 > snprintf (date,
-                        sizeof (date),
-                        date2,
-                        (long long) (pc.QuadPart /
+      {
+        if (0 ==
+            strftime(date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%020llu", tmptr))
+          abort();
+        if (0 > snprintf(date,
+                         sizeof(date),
+                         date2,
+                         (long long)(pc.QuadPart /
                                      (performance_frequency.QuadPart / 1000))))
-        abort ();
-    }
+          abort();
+      }
 #else
     struct timeval timeofday;
 
-    gettimeofday (&timeofday, NULL);
-    offset = GNUNET_TIME_get_offset ();
+    gettimeofday(&timeofday, NULL);
+    offset = GNUNET_TIME_get_offset();
     if (offset > 0)
-    {
-      timeofday.tv_sec += offset / 1000LL;
-      timeofday.tv_usec += (offset % 1000LL) * 1000LL;
-      if (timeofday.tv_usec > 1000000LL)
       {
-        timeofday.tv_usec -= 1000000LL;
-        timeofday.tv_sec++;
+        timeofday.tv_sec += offset / 1000LL;
+        timeofday.tv_usec += (offset % 1000LL) * 1000LL;
+        if (timeofday.tv_usec > 1000000LL)
+          {
+            timeofday.tv_usec -= 1000000LL;
+            timeofday.tv_sec++;
+          }
       }
-    }
     else
-    {
-      timeofday.tv_sec += offset / 1000LL;
-      if (timeofday.tv_usec > -(offset % 1000LL) * 1000LL)
       {
-        timeofday.tv_usec += (offset % 1000LL) * 1000LL;
+        timeofday.tv_sec += offset / 1000LL;
+        if (timeofday.tv_usec > -(offset % 1000LL) * 1000LL)
+          {
+            timeofday.tv_usec += (offset % 1000LL) * 1000LL;
+          }
+        else
+          {
+            timeofday.tv_usec += 1000000LL + (offset % 1000LL) * 1000LL;
+            timeofday.tv_sec--;
+          }
       }
-      else
+    tmptr = localtime(&timeofday.tv_sec);
+    if (NULL == tmptr)
       {
-        timeofday.tv_usec += 1000000LL + (offset % 1000LL) * 1000LL;
-        timeofday.tv_sec--;
+        strcpy(date, "localtime error");
       }
-    }
-    tmptr = localtime (&timeofday.tv_sec);
-    if (NULL == tmptr)
-    {
-      strcpy (date, "localtime error");
-    }
     else
-    {
-      if (0 == strftime (date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%06u", tmptr))
-        abort ();
-      if (0 > snprintf (date, sizeof (date), date2, timeofday.tv_usec))
-        abort ();
-    }
+      {
+        if (0 == strftime(date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%06u", tmptr))
+          abort();
+        if (0 > snprintf(date, sizeof(date), date2, timeofday.tv_usec))
+          abort();
+      }
 #endif
-    vsnprintf (buf, size, message, va);
-#if ! (defined(GNUNET_CULL_LOGGING) || TALER_WALLET_ONLY)
+    vsnprintf(buf, size, message, va);
+#if !(defined(GNUNET_CULL_LOGGING) || TALER_WALLET_ONLY)
     if (NULL != tmptr)
-      (void) setup_log_file (tmptr);
+      (void)setup_log_file(tmptr);
 #endif
     if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
         (0 != last_bulk_time.abs_value_us) &&
-        (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
-    {
-      last_bulk_repeat++;
-      if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value_us >
-           BULK_DELAY_THRESHOLD) ||
-          (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
-        flush_bulk (date);
-      return;
-    }
-    flush_bulk (date);
-    GNUNET_strlcpy (last_bulk, buf, sizeof (last_bulk));
+        (0 == strncmp(buf, last_bulk, sizeof(last_bulk))))
+      {
+        last_bulk_repeat++;
+        if ((GNUNET_TIME_absolute_get_duration(last_bulk_time).rel_value_us >
+             BULK_DELAY_THRESHOLD) ||
+            (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
+          flush_bulk(date);
+        return;
+      }
+    flush_bulk(date);
+    GNUNET_strlcpy(last_bulk, buf, sizeof(last_bulk));
     last_bulk_repeat = 0;
     last_bulk_kind = kind;
-    last_bulk_time = GNUNET_TIME_absolute_get ();
-    GNUNET_strlcpy (last_bulk_comp, comp, sizeof (last_bulk_comp));
-    output_message (kind, comp, date, buf);
+    last_bulk_time = GNUNET_TIME_absolute_get();
+    GNUNET_strlcpy(last_bulk_comp, comp, sizeof(last_bulk_comp));
+    output_message(kind, comp, date, buf);
   }
 }
 
@@ -1099,13 +1105,13 @@ mylog (enum GNUNET_ErrorType kind,
  * @param ... arguments for format string
  */
 void
-GNUNET_log_nocheck (enum GNUNET_ErrorType kind, const char *message, ...)
+GNUNET_log_nocheck(enum GNUNET_ErrorType kind, const char *message, ...)
 {
   va_list va;
 
-  va_start (va, message);
-  mylog (kind, component, message, va);
-  va_end (va);
+  va_start(va, message);
+  mylog(kind, component, message, va);
+  va_end(va);
 }
 
 
@@ -1119,10 +1125,10 @@ GNUNET_log_nocheck (enum GNUNET_ErrorType kind, const char *message, ...)
  * @param ... arguments for format string
  */
 void
-GNUNET_log_from_nocheck (enum GNUNET_ErrorType kind,
-                         const char *comp,
-                         const char *message,
-                         ...)
+GNUNET_log_from_nocheck(enum GNUNET_ErrorType kind,
+                        const char *comp,
+                        const char *message,
+                        ...)
 {
   va_list va;
   char comp_w_pid[128];
@@ -1130,10 +1136,10 @@ GNUNET_log_from_nocheck (enum GNUNET_ErrorType kind,
   if (comp == NULL)
     comp = component_nopid;
 
-  va_start (va, message);
-  GNUNET_snprintf (comp_w_pid, sizeof (comp_w_pid), "%s-%d", comp, getpid ());
-  mylog (kind, comp_w_pid, message, va);
-  va_end (va);
+  va_start(va, message);
+  GNUNET_snprintf(comp_w_pid, sizeof(comp_w_pid), "%s-%d", comp, getpid());
+  mylog(kind, comp_w_pid, message, va);
+  va_end(va);
 }
 
 
@@ -1144,21 +1150,21 @@ GNUNET_log_from_nocheck (enum GNUNET_ErrorType kind,
  * @return string corresponding to the type
  */
 const char *
-GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
+GNUNET_error_type_to_string(enum GNUNET_ErrorType kind)
 {
   if ((kind & GNUNET_ERROR_TYPE_ERROR) > 0)
-    return _ ("ERROR");
+    return _("ERROR");
   if ((kind & GNUNET_ERROR_TYPE_WARNING) > 0)
-    return _ ("WARNING");
+    return _("WARNING");
   if ((kind & GNUNET_ERROR_TYPE_MESSAGE) > 0)
-    return _ ("MESSAGE");
+    return _("MESSAGE");
   if ((kind & GNUNET_ERROR_TYPE_INFO) > 0)
-    return _ ("INFO");
+    return _("INFO");
   if ((kind & GNUNET_ERROR_TYPE_DEBUG) > 0)
-    return _ ("DEBUG");
+    return _("DEBUG");
   if ((kind & ~GNUNET_ERROR_TYPE_BULK) == 0)
-    return _ ("NONE");
-  return _ ("INVALID");
+    return _("NONE");
+  return _("INVALID");
 }
 
 
@@ -1169,13 +1175,13 @@ GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
  * @return string form; will be overwritten by next call to GNUNET_h2s.
  */
 const char *
-GNUNET_h2s (const struct GNUNET_HashCode *hc)
+GNUNET_h2s(const struct GNUNET_HashCode *hc)
 {
   static GNUNET_THREAD_LOCAL struct GNUNET_CRYPTO_HashAsciiEncoded ret;
 
-  GNUNET_CRYPTO_hash_to_enc (hc, &ret);
+  GNUNET_CRYPTO_hash_to_enc(hc, &ret);
   ret.encoding[8] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1190,13 +1196,13 @@ GNUNET_h2s (const struct GNUNET_HashCode *hc)
  * @return string form; will be overwritten by next call to GNUNET_h2s.
  */
 const char *
-GNUNET_h2s2 (const struct GNUNET_HashCode *hc)
+GNUNET_h2s2(const struct GNUNET_HashCode *hc)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
 
-  GNUNET_CRYPTO_hash_to_enc (hc, &ret);
+  GNUNET_CRYPTO_hash_to_enc(hc, &ret);
   ret.encoding[8] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1210,15 +1216,15 @@ GNUNET_h2s2 (const struct GNUNET_HashCode *hc)
  * @return string
  */
 const char *
-GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
+GNUNET_p2s(const struct GNUNET_CRYPTO_EddsaPublicKey *p)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (p, sizeof (*p), &hc);
-  GNUNET_CRYPTO_hash_to_enc (&hc, &ret);
+  GNUNET_CRYPTO_hash(p, sizeof(*p), &hc);
+  GNUNET_CRYPTO_hash_to_enc(&hc, &ret);
   ret.encoding[6] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1232,15 +1238,15 @@ GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
  * @return string
  */
 const char *
-GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
+GNUNET_p2s2(const struct GNUNET_CRYPTO_EddsaPublicKey *p)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (p, sizeof (*p), &hc);
-  GNUNET_CRYPTO_hash_to_enc (&hc, &ret);
+  GNUNET_CRYPTO_hash(p, sizeof(*p), &hc);
+  GNUNET_CRYPTO_hash_to_enc(&hc, &ret);
   ret.encoding[6] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1254,15 +1260,15 @@ GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
  * @return string
  */
 const char *
-GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
+GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (p, sizeof (*p), &hc);
-  GNUNET_CRYPTO_hash_to_enc (&hc, &ret);
+  GNUNET_CRYPTO_hash(p, sizeof(*p), &hc);
+  GNUNET_CRYPTO_hash_to_enc(&hc, &ret);
   ret.encoding[6] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1276,15 +1282,15 @@ GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
  * @return string
  */
 const char *
-GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
+GNUNET_e2s2(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (p, sizeof (*p), &hc);
-  GNUNET_CRYPTO_hash_to_enc (&hc, &ret);
+  GNUNET_CRYPTO_hash(p, sizeof(*p), &hc);
+  GNUNET_CRYPTO_hash_to_enc(&hc, &ret);
   ret.encoding[6] = '\0';
-  return (const char *) ret.encoding;
+  return (const char *)ret.encoding;
 }
 
 
@@ -1298,13 +1304,13 @@ GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
  * @return string
  */
 const char *
-GNUNET_sh2s (const struct GNUNET_ShortHashCode *shc)
+GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
 {
   static char buf[64];
 
-  GNUNET_STRINGS_data_to_string (shc, sizeof (*shc), buf, sizeof (buf));
+  GNUNET_STRINGS_data_to_string(shc, sizeof(*shc), buf, sizeof(buf));
   buf[6] = '\0';
-  return (const char *) buf;
+  return (const char *)buf;
 }
 
 
@@ -1318,13 +1324,13 @@ GNUNET_sh2s (const struct GNUNET_ShortHashCode *shc)
  * @return string
  */
 const char *
-GNUNET_uuid2s (const struct GNUNET_Uuid *uuid)
+GNUNET_uuid2s(const struct GNUNET_Uuid *uuid)
 {
   static char buf[32];
 
-  GNUNET_STRINGS_data_to_string (uuid, sizeof (*uuid), buf, sizeof (buf));
+  GNUNET_STRINGS_data_to_string(uuid, sizeof(*uuid), buf, sizeof(buf));
   buf[6] = '\0';
-  return (const char *) buf;
+  return (const char *)buf;
 }
 
 
@@ -1337,13 +1343,13 @@ GNUNET_uuid2s (const struct GNUNET_Uuid *uuid)
  * @return string form; will be overwritten by next call to GNUNET_h2s_full.
  */
 const char *
-GNUNET_h2s_full (const struct GNUNET_HashCode *hc)
+GNUNET_h2s_full(const struct GNUNET_HashCode *hc)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
 
-  GNUNET_CRYPTO_hash_to_enc (hc, &ret);
-  ret.encoding[sizeof (ret) - 1] = '\0';
-  return (const char *) ret.encoding;
+  GNUNET_CRYPTO_hash_to_enc(hc, &ret);
+  ret.encoding[sizeof(ret) - 1] = '\0';
+  return (const char *)ret.encoding;
 }
 
 
@@ -1355,16 +1361,16 @@ GNUNET_h2s_full (const struct GNUNET_HashCode *hc)
  *         call to #GNUNET_i2s.
  */
 const char *
-GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
+GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
 {
   static GNUNET_THREAD_LOCAL char buf[5];
   char *ret;
 
   if (NULL == pid)
     return "NULL";
-  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid->public_key);
-  GNUNET_strlcpy (buf, ret, sizeof (buf));
-  GNUNET_free (ret);
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&pid->public_key);
+  GNUNET_strlcpy(buf, ret, sizeof(buf));
+  GNUNET_free(ret);
   return buf;
 }
 
@@ -1380,16 +1386,16 @@ GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
  *         call to #GNUNET_i2s.
  */
 const char *
-GNUNET_i2s2 (const struct GNUNET_PeerIdentity *pid)
+GNUNET_i2s2(const struct GNUNET_PeerIdentity *pid)
 {
   static GNUNET_THREAD_LOCAL char buf[5];
   char *ret;
 
   if (NULL == pid)
     return "NULL";
-  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid->public_key);
-  GNUNET_strlcpy (buf, ret, sizeof (buf));
-  GNUNET_free (ret);
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&pid->public_key);
+  GNUNET_strlcpy(buf, ret, sizeof(buf));
+  GNUNET_free(ret);
   return buf;
 }
 
@@ -1402,14 +1408,14 @@ GNUNET_i2s2 (const struct GNUNET_PeerIdentity *pid)
  *         call to #GNUNET_i2s_full.
  */
 const char *
-GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
+GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
 {
   static GNUNET_THREAD_LOCAL char buf[256];
   char *ret;
 
-  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid->public_key);
-  strcpy (buf, ret);
-  GNUNET_free (ret);
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&pid->public_key);
+  strcpy(buf, ret);
+  GNUNET_free(ret);
   return buf;
 }
 
@@ -1425,12 +1431,12 @@ GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
  *  will be overwritten by next call to #GNUNET_a2s.
  */
 const char *
-GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
+GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
 {
 #ifndef WINDOWS
 #define LEN                           \
-  GNUNET_MAX ((INET6_ADDRSTRLEN + 8), \
-              (1 + sizeof (struct sockaddr_un) - sizeof (sa_family_t)))
+  GNUNET_MAX((INET6_ADDRSTRLEN + 8), \
+             (1 + sizeof(struct sockaddr_un) - sizeof(sa_family_t)))
 #else
 #define LEN (INET6_ADDRSTRLEN + 8)
 #endif
@@ -1443,50 +1449,53 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
   unsigned int off;
 
   if (addr == NULL)
-    return _ ("unknown address");
+    return _("unknown address");
   switch (addr->sa_family)
-  {
-  case AF_INET:
-    if (addrlen != sizeof (struct sockaddr_in))
-      return "<invalid v4 address>";
-    v4 = (const struct sockaddr_in *) addr;
-    inet_ntop (AF_INET, &v4->sin_addr, buf, INET_ADDRSTRLEN);
-    if (0 == ntohs (v4->sin_port))
+    {
+    case AF_INET:
+      if (addrlen != sizeof(struct sockaddr_in))
+        return "<invalid v4 address>";
+      v4 = (const struct sockaddr_in *)addr;
+      inet_ntop(AF_INET, &v4->sin_addr, buf, INET_ADDRSTRLEN);
+      if (0 == ntohs(v4->sin_port))
+        return buf;
+      strcat(buf, ":");
+      GNUNET_snprintf(b2, sizeof(b2), "%u", ntohs(v4->sin_port));
+      strcat(buf, b2);
       return buf;
-    strcat (buf, ":");
-    GNUNET_snprintf (b2, sizeof (b2), "%u", ntohs (v4->sin_port));
-    strcat (buf, b2);
-    return buf;
-  case AF_INET6:
-    if (addrlen != sizeof (struct sockaddr_in6))
-      return "<invalid v4 address>";
-    v6 = (const struct sockaddr_in6 *) addr;
-    buf[0] = '[';
-    inet_ntop (AF_INET6, &v6->sin6_addr, &buf[1], INET6_ADDRSTRLEN);
-    if (0 == ntohs (v6->sin6_port))
-      return &buf[1];
-    strcat (buf, "]:");
-    GNUNET_snprintf (b2, sizeof (b2), "%u", ntohs (v6->sin6_port));
-    strcat (buf, b2);
-    return buf;
-  case AF_UNIX:
-    if (addrlen <= sizeof (sa_family_t))
-      return "<unbound UNIX client>";
-    un = (const struct sockaddr_un *) addr;
-    off = 0;
-    if ('\0' == un->sun_path[0])
-      off++;
-    memset (buf, 0, sizeof (buf));
-    GNUNET_snprintf (buf,
-                     sizeof (buf),
-                     "%s%.*s",
-                     (1 == off) ? "@" : "",
-                     (int) (addrlen - sizeof (sa_family_t) - off),
-                     &un->sun_path[off]);
-    return buf;
-  default:
-    return _ ("invalid address");
-  }
+
+    case AF_INET6:
+      if (addrlen != sizeof(struct sockaddr_in6))
+        return "<invalid v4 address>";
+      v6 = (const struct sockaddr_in6 *)addr;
+      buf[0] = '[';
+      inet_ntop(AF_INET6, &v6->sin6_addr, &buf[1], INET6_ADDRSTRLEN);
+      if (0 == ntohs(v6->sin6_port))
+        return &buf[1];
+      strcat(buf, "]:");
+      GNUNET_snprintf(b2, sizeof(b2), "%u", ntohs(v6->sin6_port));
+      strcat(buf, b2);
+      return buf;
+
+    case AF_UNIX:
+      if (addrlen <= sizeof(sa_family_t))
+        return "<unbound UNIX client>";
+      un = (const struct sockaddr_un *)addr;
+      off = 0;
+      if ('\0' == un->sun_path[0])
+        off++;
+      memset(buf, 0, sizeof(buf));
+      GNUNET_snprintf(buf,
+                      sizeof(buf),
+                      "%s%.*s",
+                      (1 == off) ? "@" : "",
+                      (int)(addrlen - sizeof(sa_family_t) - off),
+                      &un->sun_path[off]);
+      return buf;
+
+    default:
+      return _("invalid address");
+    }
 }
 
 
@@ -1498,15 +1507,15 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
  * @param option name of missing option
  */
 void
-GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
-                           const char *section,
-                           const char *option)
+GNUNET_log_config_missing(enum GNUNET_ErrorType kind,
+                          const char *section,
+                          const char *option)
 {
-  GNUNET_log (kind,
-              _ (
-                "Configuration fails to specify option `%s' in section `%s'!\n"),
-              option,
-              section);
+  GNUNET_log(kind,
+             _(
+               "Configuration fails to specify option `%s' in section `%s'!\n"),
+             option,
+             section);
 }
 
 
@@ -1519,14 +1528,14 @@ GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
  * @param required what is required that is invalid about the option
  */
 void
-GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
-                           const char *section,
-                           const char *option,
-                           const char *required)
+GNUNET_log_config_invalid(enum GNUNET_ErrorType kind,
+                          const char *section,
+                          const char *option,
+                          const char *required)
 {
-  GNUNET_log (
+  GNUNET_log(
     kind,
-    _ (
+    _(
       "Configuration specifies invalid value for option `%s' in section `%s': %s\n"),
     option,
     section,
@@ -1541,8 +1550,8 @@ GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
  * @param old_scope[out] location to save the old scope
  */
 void
-GNUNET_async_scope_enter (const struct GNUNET_AsyncScopeId *aid,
-                          struct GNUNET_AsyncScopeSave *old_scope)
+GNUNET_async_scope_enter(const struct GNUNET_AsyncScopeId *aid,
+                         struct GNUNET_AsyncScopeSave *old_scope)
 {
   *old_scope = current_async_scope;
   current_async_scope.have_scope = GNUNET_YES;
@@ -1556,7 +1565,7 @@ GNUNET_async_scope_enter (const struct GNUNET_AsyncScopeId *aid,
  * @param old_scope scope to restore
  */
 void
-GNUNET_async_scope_restore (struct GNUNET_AsyncScopeSave *old_scope)
+GNUNET_async_scope_restore(struct GNUNET_AsyncScopeSave *old_scope)
 {
   current_async_scope = *old_scope;
 }
@@ -1568,11 +1577,11 @@ GNUNET_async_scope_restore (struct GNUNET_AsyncScopeSave *old_scope)
  * @param[out] aid_ret pointer to where the result is stored
  */
 void
-GNUNET_async_scope_fresh (struct GNUNET_AsyncScopeId *aid_ret)
+GNUNET_async_scope_fresh(struct GNUNET_AsyncScopeId *aid_ret)
 {
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              aid_ret,
-                              sizeof (struct GNUNET_AsyncScopeId));
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             aid_ret,
+                             sizeof(struct GNUNET_AsyncScopeId));
 }
 
 
@@ -1582,7 +1591,7 @@ GNUNET_async_scope_fresh (struct GNUNET_AsyncScopeId *aid_ret)
  * @param[out] scope_ret pointer to where the result is stored
  */
 void
-GNUNET_async_scope_get (struct GNUNET_AsyncScopeSave *scope_ret)
+GNUNET_async_scope_get(struct GNUNET_AsyncScopeSave *scope_ret)
 {
   *scope_ret = current_async_scope;
 }
@@ -1591,15 +1600,15 @@ GNUNET_async_scope_get (struct GNUNET_AsyncScopeSave *scope_ret)
 /**
  * Initializer
  */
-void __attribute__ ((constructor)) GNUNET_util_cl_init ()
+void __attribute__ ((constructor)) GNUNET_util_cl_init()
 {
   GNUNET_stderr = stderr;
 #ifdef MINGW
-  GNInitWinEnv (NULL);
+  GNInitWinEnv(NULL);
 #endif
 #if WINDOWS
-  if (! InitializeCriticalSectionAndSpinCount (&output_message_cs, 0x00000400))
-    GNUNET_abort_ ();
+  if (!InitializeCriticalSectionAndSpinCount(&output_message_cs, 0x00000400))
+    GNUNET_abort_();
 #endif
 }
 
@@ -1607,13 +1616,13 @@ void __attribute__ ((constructor)) GNUNET_util_cl_init ()
 /**
  * Destructor
  */
-void __attribute__ ((destructor)) GNUNET_util_cl_fini ()
+void __attribute__ ((destructor)) GNUNET_util_cl_fini()
 {
 #if WINDOWS
-  DeleteCriticalSection (&output_message_cs);
+  DeleteCriticalSection(&output_message_cs);
 #endif
 #ifdef MINGW
-  GNShutdownWinEnv ();
+  GNShutdownWinEnv();
 #endif
 }
 
diff --git a/src/util/configuration.c b/src/util/configuration.c
index f327071de..4e7659276 100644
--- a/src/util/configuration.c
+++ b/src/util/configuration.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/util/configuration.c
@@ -30,17 +30,15 @@
 #include "gnunet_configuration_lib.h"
 #include "gnunet_disk_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util", __VA_ARGS__)
 
 #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)
 
 /**
  * @brief configuration entry
  */
-struct ConfigEntry
-{
-
+struct ConfigEntry {
   /**
    * This is a linked list.
    */
@@ -61,8 +59,7 @@ struct ConfigEntry
 /**
  * @brief configuration section
  */
-struct ConfigSection
-{
+struct ConfigSection {
   /**
    * This is a linked list.
    */
@@ -83,8 +80,7 @@ struct ConfigSection
 /**
  * @brief configuration data
  */
-struct GNUNET_CONFIGURATION_Handle
-{
+struct GNUNET_CONFIGURATION_Handle {
   /**
    * Configuration sections.
    */
@@ -103,8 +99,7 @@ struct GNUNET_CONFIGURATION_Handle
  * Used for diffing a configuration object against
  * the default one
  */
-struct DiffHandle
-{
+struct DiffHandle {
   const struct GNUNET_CONFIGURATION_Handle *cfg_default;
 
   struct GNUNET_CONFIGURATION_Handle *cfgDiff;
@@ -117,9 +112,9 @@ struct DiffHandle
  * @return fresh configuration object
  */
 struct GNUNET_CONFIGURATION_Handle *
-GNUNET_CONFIGURATION_create ()
+GNUNET_CONFIGURATION_create()
 {
-  return GNUNET_new (struct GNUNET_CONFIGURATION_Handle);
+  return GNUNET_new(struct GNUNET_CONFIGURATION_Handle);
 }
 
 
@@ -129,13 +124,13 @@ GNUNET_CONFIGURATION_create ()
  * @param cfg configuration to destroy
  */
 void
-GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct ConfigSection *sec;
 
   while (NULL != (sec = cfg->sections))
-    GNUNET_CONFIGURATION_remove_section (cfg, sec->name);
-  GNUNET_free (cfg);
+    GNUNET_CONFIGURATION_remove_section(cfg, sec->name);
+  GNUNET_free(cfg);
 }
 
 
@@ -151,22 +146,22 @@ GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
  *   otherwise return value from @a cb.
  */
 int
-GNUNET_CONFIGURATION_parse_and_run (const char *filename,
-                                    GNUNET_CONFIGURATION_Callback cb,
-                                    void *cb_cls)
+GNUNET_CONFIGURATION_parse_and_run(const char *filename,
+                                   GNUNET_CONFIGURATION_Callback cb,
+                                   void *cb_cls)
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   int ret;
 
-  cfg = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, filename))
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return GNUNET_SYSERR;
-  }
-  ret = cb (cb_cls, cfg);
-  GNUNET_CONFIGURATION_destroy (cfg);
+  cfg = GNUNET_CONFIGURATION_create();
+  if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg, filename))
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return GNUNET_SYSERR;
+    }
+  ret = cb(cb_cls, cfg);
+  GNUNET_CONFIGURATION_destroy(cfg);
   return ret;
 }
 
@@ -183,10 +178,10 @@ GNUNET_CONFIGURATION_parse_and_run (const char *filename,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_deserialize (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                  const char *mem,
-                                  size_t size,
-                                  const char *basedir)
+GNUNET_CONFIGURATION_deserialize(struct GNUNET_CONFIGURATION_Handle *cfg,
+                                 const char *mem,
+                                 size_t size,
+                                 const char *basedir)
 {
   char *line;
   char *line_orig;
@@ -204,133 +199,133 @@ GNUNET_CONFIGURATION_deserialize (struct GNUNET_CONFIGURATION_Handle *cfg,
   char *value;
 
   ret = GNUNET_OK;
-  section = GNUNET_strdup ("");
+  section = GNUNET_strdup("");
   nr = 0;
   r_bytes = 0;
   line_orig = NULL;
   while (r_bytes < size)
-  {
-    GNUNET_free_non_null (line_orig);
-    /* fgets-like behaviour on buffer */
-    to_read = size - r_bytes;
-    pos = memchr (&mem[r_bytes], '\n', to_read);
-    if (NULL == pos)
-    {
-      line_orig = GNUNET_strndup (&mem[r_bytes], line_size = to_read);
-      r_bytes += line_size;
-    }
-    else
     {
-      line_orig =
-        GNUNET_strndup (&mem[r_bytes], line_size = (pos - &mem[r_bytes]));
-      r_bytes += line_size + 1;
-    }
-    line = line_orig;
-    /* increment line number */
-    nr++;
-    /* tabs and '\r' are whitespace */
-    emptyline = GNUNET_YES;
-    for (i = 0; i < line_size; i++)
-    {
-      if (line[i] == '\t')
-        line[i] = ' ';
-      if (line[i] == '\r')
-        line[i] = ' ';
-      if (' ' != line[i])
-        emptyline = GNUNET_NO;
-    }
-    /* ignore empty lines */
-    if (GNUNET_YES == emptyline)
-      continue;
-
-    /* remove tailing whitespace */
-    for (i = line_size - 1; (i >= 1) && (isspace ((unsigned char) line[i]));
-         i--)
-      line[i] = '\0';
-
-    /* remove leading whitespace */
-    for (; line[0] != '\0' && (isspace ((unsigned char) line[0])); line++)
-      ;
-
-    /* ignore comments */
-    if (('#' == line[0]) || ('%' == line[0]))
-      continue;
-
-    /* handle special "@INLINE@" directive */
-    if (0 == strncasecmp (line, "@INLINE@ ", strlen ("@INLINE@ ")))
-    {
-      /* @INLINE@ value */
-      value = &line[strlen ("@INLINE@ ")];
-      if (NULL != basedir)
-      {
-        char *fn;
-
-        GNUNET_asprintf (&fn, "%s/%s", basedir, value);
-        if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, fn))
+      GNUNET_free_non_null(line_orig);
+      /* fgets-like behaviour on buffer */
+      to_read = size - r_bytes;
+      pos = memchr(&mem[r_bytes], '\n', to_read);
+      if (NULL == pos)
         {
-          GNUNET_free (fn);
-          ret = GNUNET_SYSERR; /* failed to parse included config */
-          break;
+          line_orig = GNUNET_strndup(&mem[r_bytes], line_size = to_read);
+          r_bytes += line_size;
         }
-        GNUNET_free (fn);
-      }
       else
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Ignoring parsing @INLINE@ configurations, not allowed!\n");
-        ret = GNUNET_SYSERR;
-        break;
-      }
-      continue;
-    }
-    if (('[' == line[0]) && (']' == line[line_size - 1]))
-    {
-      /* [value] */
-      line[line_size - 1] = '\0';
-      value = &line[1];
-      GNUNET_free (section);
-      section = GNUNET_strdup (value);
-      continue;
-    }
-    if (NULL != (eq = strchr (line, '=')))
-    {
-      /* tag = value */
-      tag = GNUNET_strndup (line, eq - line);
+        {
+          line_orig =
+            GNUNET_strndup(&mem[r_bytes], line_size = (pos - &mem[r_bytes]));
+          r_bytes += line_size + 1;
+        }
+      line = line_orig;
+      /* increment line number */
+      nr++;
+      /* tabs and '\r' are whitespace */
+      emptyline = GNUNET_YES;
+      for (i = 0; i < line_size; i++)
+        {
+          if (line[i] == '\t')
+            line[i] = ' ';
+          if (line[i] == '\r')
+            line[i] = ' ';
+          if (' ' != line[i])
+            emptyline = GNUNET_NO;
+        }
+      /* ignore empty lines */
+      if (GNUNET_YES == emptyline)
+        continue;
+
       /* remove tailing whitespace */
-      for (i = strlen (tag) - 1; (i >= 1) && (isspace ((unsigned char) tag[i]));
-           i--)
-        tag[i] = '\0';
-
-      /* Strip whitespace */
-      value = eq + 1;
-      while (isspace ((unsigned char) value[0]))
-        value++;
-      for (i = strlen (value) - 1;
-           (i >= 1) && (isspace ((unsigned char) value[i]));
+      for (i = line_size - 1; (i >= 1) && (isspace((unsigned char)line[i]));
            i--)
-        value[i] = '\0';
+        line[i] = '\0';
 
-      /* remove quotes */
-      i = 0;
-      if (('"' == value[0]) && ('"' == value[strlen (value) - 1]))
-      {
-        value[strlen (value) - 1] = '\0';
-        value++;
-      }
-      GNUNET_CONFIGURATION_set_value_string (cfg, section, tag, &value[i]);
-      GNUNET_free (tag);
-      continue;
+      /* remove leading whitespace */
+      for (; line[0] != '\0' && (isspace((unsigned char)line[0])); line++)
+        ;
+
+      /* ignore comments */
+      if (('#' == line[0]) || ('%' == line[0]))
+        continue;
+
+      /* handle special "@INLINE@" directive */
+      if (0 == strncasecmp(line, "@INLINE@ ", strlen("@INLINE@ ")))
+        {
+          /* @INLINE@ value */
+          value = &line[strlen("@INLINE@ ")];
+          if (NULL != basedir)
+            {
+              char *fn;
+
+              GNUNET_asprintf(&fn, "%s/%s", basedir, value);
+              if (GNUNET_OK != GNUNET_CONFIGURATION_parse(cfg, fn))
+                {
+                  GNUNET_free(fn);
+                  ret = GNUNET_SYSERR; /* failed to parse included config */
+                  break;
+                }
+              GNUNET_free(fn);
+            }
+          else
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Ignoring parsing @INLINE@ configurations, not allowed!\n");
+              ret = GNUNET_SYSERR;
+              break;
+            }
+          continue;
+        }
+      if (('[' == line[0]) && (']' == line[line_size - 1]))
+        {
+          /* [value] */
+          line[line_size - 1] = '\0';
+          value = &line[1];
+          GNUNET_free(section);
+          section = GNUNET_strdup(value);
+          continue;
+        }
+      if (NULL != (eq = strchr(line, '=')))
+        {
+          /* tag = value */
+          tag = GNUNET_strndup(line, eq - line);
+          /* remove tailing whitespace */
+          for (i = strlen(tag) - 1; (i >= 1) && (isspace((unsigned char)tag[i]));
+               i--)
+            tag[i] = '\0';
+
+          /* Strip whitespace */
+          value = eq + 1;
+          while (isspace((unsigned char)value[0]))
+            value++;
+          for (i = strlen(value) - 1;
+               (i >= 1) && (isspace((unsigned char)value[i]));
+               i--)
+            value[i] = '\0';
+
+          /* remove quotes */
+          i = 0;
+          if (('"' == value[0]) && ('"' == value[strlen(value) - 1]))
+            {
+              value[strlen(value) - 1] = '\0';
+              value++;
+            }
+          GNUNET_CONFIGURATION_set_value_string(cfg, section, tag, &value[i]);
+          GNUNET_free(tag);
+          continue;
+        }
+      /* parse error */
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Syntax error while deserializing in line %u\n"),
+          nr);
+      ret = GNUNET_SYSERR;
+      break;
     }
-    /* parse error */
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Syntax error while deserializing in line %u\n"),
-         nr);
-    ret = GNUNET_SYSERR;
-    break;
-  }
-  GNUNET_free_non_null (line_orig);
-  GNUNET_free (section);
-  GNUNET_assert ((GNUNET_OK != ret) || (r_bytes == size));
+  GNUNET_free_non_null(line_orig);
+  GNUNET_free(section);
+  GNUNET_assert((GNUNET_OK != ret) || (r_bytes == size));
   return ret;
 }
 
@@ -344,8 +339,8 @@ GNUNET_CONFIGURATION_deserialize (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg,
-                            const char *filename)
+GNUNET_CONFIGURATION_parse(struct GNUNET_CONFIGURATION_Handle *cfg,
+                           const char *filename)
 {
   uint64_t fs64;
   size_t fs;
@@ -356,43 +351,43 @@ GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg,
   int ret;
   ssize_t sret;
 
-  fn = GNUNET_STRINGS_filename_expand (filename);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to parse config file `%s'\n", fn);
+  fn = GNUNET_STRINGS_filename_expand(filename);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Asked to parse config file `%s'\n", fn);
   if (NULL == fn)
     return GNUNET_SYSERR;
   dirty = cfg->dirty; /* back up value! */
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_file_size (fn, &fs64, GNUNET_YES, GNUNET_YES))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Error while determining the file size of `%s'\n",
-         fn);
-    GNUNET_free (fn);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_DISK_file_size(fn, &fs64, GNUNET_YES, GNUNET_YES))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Error while determining the file size of `%s'\n",
+          fn);
+      GNUNET_free(fn);
+      return GNUNET_SYSERR;
+    }
   if (fs64 > SIZE_MAX)
-  {
-    GNUNET_break (0); /* File size is more than the heap size */
-    GNUNET_free (fn);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0); /* File size is more than the heap size */
+      GNUNET_free(fn);
+      return GNUNET_SYSERR;
+    }
   fs = fs64;
-  mem = GNUNET_malloc (fs);
-  sret = GNUNET_DISK_fn_read (fn, mem, fs);
-  if ((sret < 0) || (fs != (size_t) sret))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING, _ ("Error while reading file `%s'\n"), fn);
-    GNUNET_free (fn);
-    GNUNET_free (mem);
-    return GNUNET_SYSERR;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Deserializing contents of file `%s'\n", fn);
-  endsep = strrchr (fn, (int) '/');
+  mem = GNUNET_malloc(fs);
+  sret = GNUNET_DISK_fn_read(fn, mem, fs);
+  if ((sret < 0) || (fs != (size_t)sret))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING, _("Error while reading file `%s'\n"), fn);
+      GNUNET_free(fn);
+      GNUNET_free(mem);
+      return GNUNET_SYSERR;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Deserializing contents of file `%s'\n", fn);
+  endsep = strrchr(fn, (int)'/');
   if (NULL != endsep)
     *endsep = '\0';
-  ret = GNUNET_CONFIGURATION_deserialize (cfg, mem, fs, fn);
-  GNUNET_free (fn);
-  GNUNET_free (mem);
+  ret = GNUNET_CONFIGURATION_deserialize(cfg, mem, fs, fn);
+  GNUNET_free(fn);
+  GNUNET_free(mem);
   /* restore dirty flag - anything we set in the meantime
    * came from disk */
   cfg->dirty = dirty;
@@ -408,7 +403,7 @@ GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_NO if clean, #GNUNET_YES if dirty, #GNUNET_SYSERR on error (i.e. last save failed)
  */
 int
-GNUNET_CONFIGURATION_is_dirty (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_CONFIGURATION_is_dirty(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   return cfg->dirty;
 }
@@ -423,8 +418,8 @@ GNUNET_CONFIGURATION_is_dirty (const struct GNUNET_CONFIGURATION_Handle *cfg)
  *           present. This memory should be freed by the caller
  */
 char *
-GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                size_t *size)
+GNUNET_CONFIGURATION_serialize(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                               size_t *size)
 {
   struct ConfigSection *sec;
   struct ConfigEntry *ent;
@@ -439,65 +434,65 @@ GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg,
   /* Pass1 : calculate the buffer size required */
   m_size = 0;
   for (sec = cfg->sections; NULL != sec; sec = sec->next)
-  {
-    /* For each section we need to add 3 charaters: {'[',']','\n'} */
-    m_size += strlen (sec->name) + 3;
-    for (ent = sec->entries; NULL != ent; ent = ent->next)
     {
-      if (NULL != ent->val)
-      {
-        /* if val has any '\n' then they occupy +1 character as '\n'->'\\','n' */
-        pos = ent->val;
-        while (NULL != (pos = strstr (pos, "\n")))
+      /* For each section we need to add 3 charaters: {'[',']','\n'} */
+      m_size += strlen(sec->name) + 3;
+      for (ent = sec->entries; NULL != ent; ent = ent->next)
         {
-          m_size++;
-          pos++;
+          if (NULL != ent->val)
+            {
+              /* if val has any '\n' then they occupy +1 character as '\n'->'\\','n' */
+              pos = ent->val;
+              while (NULL != (pos = strstr(pos, "\n")))
+                {
+                  m_size++;
+                  pos++;
+                }
+              /* For each key = value pair we need to add 4 characters (2
+                 spaces and 1 equal-to character and 1 new line) */
+              m_size += strlen(ent->key) + strlen(ent->val) + 4;
+            }
         }
-        /* For each key = value pair we need to add 4 characters (2
-           spaces and 1 equal-to character and 1 new line) */
-        m_size += strlen (ent->key) + strlen (ent->val) + 4;
-      }
+      /* A new line after section end */
+      m_size++;
     }
-    /* A new line after section end */
-    m_size++;
-  }
 
   /* Pass2: Allocate memory and write the configuration to it */
-  mem = GNUNET_malloc (m_size);
+  mem = GNUNET_malloc(m_size);
   sec = cfg->sections;
   c_size = 0;
   *size = c_size;
   while (NULL != sec)
-  {
-    len = GNUNET_asprintf (&cbuf, "[%s]\n", sec->name);
-    GNUNET_assert (0 < len);
-    GNUNET_memcpy (mem + c_size, cbuf, len);
-    c_size += len;
-    GNUNET_free (cbuf);
-    for (ent = sec->entries; NULL != ent; ent = ent->next)
     {
-      if (NULL != ent->val)
-      {
-        val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
-        strcpy (val, ent->val);
-        while (NULL != (pos = strstr (val, "\n")))
+      len = GNUNET_asprintf(&cbuf, "[%s]\n", sec->name);
+      GNUNET_assert(0 < len);
+      GNUNET_memcpy(mem + c_size, cbuf, len);
+      c_size += len;
+      GNUNET_free(cbuf);
+      for (ent = sec->entries; NULL != ent; ent = ent->next)
         {
-          memmove (&pos[2], &pos[1], strlen (&pos[1]));
-          pos[0] = '\\';
-          pos[1] = 'n';
+          if (NULL != ent->val)
+            {
+              val = GNUNET_malloc(strlen(ent->val) * 2 + 1);
+              strcpy(val, ent->val);
+              while (NULL != (pos = strstr(val, "\n")))
+                {
+                  memmove(&pos[2], &pos[1], strlen(&pos[1]));
+                  pos[0] = '\\';
+                  pos[1] = 'n';
+                }
+              len = GNUNET_asprintf(&cbuf, "%s = %s\n", ent->key, val);
+              GNUNET_free(val);
+              GNUNET_memcpy(mem + c_size, cbuf, len);
+              c_size += len;
+              GNUNET_free(cbuf);
+            }
         }
-        len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val);
-        GNUNET_free (val);
-        GNUNET_memcpy (mem + c_size, cbuf, len);
-        c_size += len;
-        GNUNET_free (cbuf);
-      }
+      GNUNET_memcpy(mem + c_size, "\n", 1);
+      c_size++;
+      sec = sec->next;
     }
-    GNUNET_memcpy (mem + c_size, "\n", 1);
-    c_size++;
-    sec = sec->next;
-  }
-  GNUNET_assert (c_size == m_size);
+  GNUNET_assert(c_size == m_size);
   *size = c_size;
   return mem;
 }
@@ -511,42 +506,42 @@ GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle *cfg,
-                            const char *filename)
+GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg,
+                           const char *filename)
 {
   char *fn;
   char *cfg_buf;
   size_t size;
   ssize_t sret;
 
-  fn = GNUNET_STRINGS_filename_expand (filename);
+  fn = GNUNET_STRINGS_filename_expand(filename);
   if (fn == NULL)
     return GNUNET_SYSERR;
-  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn))
-  {
-    GNUNET_free (fn);
-    return GNUNET_SYSERR;
-  }
-  cfg_buf = GNUNET_CONFIGURATION_serialize (cfg, &size);
-  sret = GNUNET_DISK_fn_write (fn,
-                               cfg_buf,
-                               size,
-                               GNUNET_DISK_PERM_USER_READ |
-                                 GNUNET_DISK_PERM_USER_WRITE |
-                                 GNUNET_DISK_PERM_GROUP_READ |
-                                 GNUNET_DISK_PERM_GROUP_WRITE);
-  if ((sret < 0) || (size != (size_t) sret))
-  {
-    GNUNET_free (fn);
-    GNUNET_free (cfg_buf);
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Writing configuration to file `%s' failed\n",
-         filename);
-    cfg->dirty = GNUNET_SYSERR; /* last write failed */
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (fn);
-  GNUNET_free (cfg_buf);
+  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(fn))
+    {
+      GNUNET_free(fn);
+      return GNUNET_SYSERR;
+    }
+  cfg_buf = GNUNET_CONFIGURATION_serialize(cfg, &size);
+  sret = GNUNET_DISK_fn_write(fn,
+                              cfg_buf,
+                              size,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE |
+                              GNUNET_DISK_PERM_GROUP_READ |
+                              GNUNET_DISK_PERM_GROUP_WRITE);
+  if ((sret < 0) || (size != (size_t)sret))
+    {
+      GNUNET_free(fn);
+      GNUNET_free(cfg_buf);
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Writing configuration to file `%s' failed\n",
+          filename);
+      cfg->dirty = GNUNET_SYSERR; /* last write failed */
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(fn);
+  GNUNET_free(cfg_buf);
   cfg->dirty = GNUNET_NO; /* last write succeeded */
   return GNUNET_OK;
 }
@@ -560,9 +555,9 @@ GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param iter_cls closure for @a iter
  */
 void
-GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                              GNUNET_CONFIGURATION_Iterator iter,
-                              void *iter_cls)
+GNUNET_CONFIGURATION_iterate(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                             GNUNET_CONFIGURATION_Iterator iter,
+                             void *iter_cls)
 {
   struct ConfigSection *spos;
   struct ConfigEntry *epos;
@@ -570,7 +565,7 @@ GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
   for (spos = cfg->sections; NULL != spos; spos = spos->next)
     for (epos = spos->entries; NULL != epos; epos = epos->next)
       if (NULL != epos->val)
-        iter (iter_cls, spos->name, epos->key, epos->val);
+        iter(iter_cls, spos->name, epos->key, epos->val);
 }
 
 
@@ -583,7 +578,7 @@ GNUNET_CONFIGURATION_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param iter_cls closure for @a iter
  */
 void
-GNUNET_CONFIGURATION_iterate_section_values (
+GNUNET_CONFIGURATION_iterate_section_values(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   GNUNET_CONFIGURATION_Iterator iter,
@@ -593,13 +588,13 @@ GNUNET_CONFIGURATION_iterate_section_values (
   struct ConfigEntry *epos;
 
   spos = cfg->sections;
-  while ((spos != NULL) && (0 != strcasecmp (spos->name, section)))
+  while ((spos != NULL) && (0 != strcasecmp(spos->name, section)))
     spos = spos->next;
   if (NULL == spos)
     return;
   for (epos = spos->entries; NULL != epos; epos = epos->next)
     if (NULL != epos->val)
-      iter (iter_cls, spos->name, epos->key, epos->val);
+      iter(iter_cls, spos->name, epos->key, epos->val);
 }
 
 
@@ -611,7 +606,7 @@ GNUNET_CONFIGURATION_iterate_section_values (
  * @param iter_cls closure for @a iter
  */
 void
-GNUNET_CONFIGURATION_iterate_sections (
+GNUNET_CONFIGURATION_iterate_sections(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_CONFIGURATION_Section_Iterator iter,
   void *iter_cls)
@@ -621,11 +616,11 @@ GNUNET_CONFIGURATION_iterate_sections (
 
   next = cfg->sections;
   while (next != NULL)
-  {
-    spos = next;
-    next = spos->next;
-    iter (iter_cls, spos->name);
-  }
+    {
+      spos = next;
+      next = spos->next;
+      iter(iter_cls, spos->name);
+    }
 }
 
 
@@ -636,8 +631,8 @@ GNUNET_CONFIGURATION_iterate_sections (
  * @param section name of the section to remove
  */
 void
-GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                     const char *section)
+GNUNET_CONFIGURATION_remove_section(struct GNUNET_CONFIGURATION_Handle *cfg,
+                                    const char *section)
 {
   struct ConfigSection *spos;
   struct ConfigSection *prev;
@@ -646,28 +641,28 @@ GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle *cfg,
   prev = NULL;
   spos = cfg->sections;
   while (NULL != spos)
-  {
-    if (0 == strcasecmp (section, spos->name))
     {
-      if (NULL == prev)
-        cfg->sections = spos->next;
-      else
-        prev->next = spos->next;
-      while (NULL != (ent = spos->entries))
-      {
-        spos->entries = ent->next;
-        GNUNET_free (ent->key);
-        GNUNET_free_non_null (ent->val);
-        GNUNET_free (ent);
-        cfg->dirty = GNUNET_YES;
-      }
-      GNUNET_free (spos->name);
-      GNUNET_free (spos);
-      return;
+      if (0 == strcasecmp(section, spos->name))
+        {
+          if (NULL == prev)
+            cfg->sections = spos->next;
+          else
+            prev->next = spos->next;
+          while (NULL != (ent = spos->entries))
+            {
+              spos->entries = ent->next;
+              GNUNET_free(ent->key);
+              GNUNET_free_non_null(ent->val);
+              GNUNET_free(ent);
+              cfg->dirty = GNUNET_YES;
+            }
+          GNUNET_free(spos->name);
+          GNUNET_free(spos);
+          return;
+        }
+      prev = spos;
+      spos = spos->next;
     }
-    prev = spos;
-    spos = spos->next;
-  }
 }
 
 
@@ -681,14 +676,14 @@ GNUNET_CONFIGURATION_remove_section (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param value value to copy
  */
 static void
-copy_entry (void *cls,
-            const char *section,
-            const char *option,
-            const char *value)
+copy_entry(void *cls,
+           const char *section,
+           const char *option,
+           const char *value)
 {
   struct GNUNET_CONFIGURATION_Handle *dst = cls;
 
-  GNUNET_CONFIGURATION_set_value_string (dst, section, option, value);
+  GNUNET_CONFIGURATION_set_value_string(dst, section, option, value);
 }
 
 
@@ -699,12 +694,12 @@ copy_entry (void *cls,
  * @return duplicate configuration
  */
 struct GNUNET_CONFIGURATION_Handle *
-GNUNET_CONFIGURATION_dup (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_CONFIGURATION_Handle *ret;
 
-  ret = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_iterate (cfg, &copy_entry, ret);
+  ret = GNUNET_CONFIGURATION_create();
+  GNUNET_CONFIGURATION_iterate(cfg, &copy_entry, ret);
   return ret;
 }
 
@@ -717,13 +712,13 @@ GNUNET_CONFIGURATION_dup (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @return matching entry, NULL if not found
  */
 static struct ConfigSection *
-find_section (const struct GNUNET_CONFIGURATION_Handle *cfg,
-              const char *section)
+find_section(const struct GNUNET_CONFIGURATION_Handle *cfg,
+             const char *section)
 {
   struct ConfigSection *pos;
 
   pos = cfg->sections;
-  while ((pos != NULL) && (0 != strcasecmp (section, pos->name)))
+  while ((pos != NULL) && (0 != strcasecmp(section, pos->name)))
     pos = pos->next;
   return pos;
 }
@@ -738,17 +733,17 @@ find_section (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return matching entry, NULL if not found
  */
 static struct ConfigEntry *
-find_entry (const struct GNUNET_CONFIGURATION_Handle *cfg,
-            const char *section,
-            const char *key)
+find_entry(const struct GNUNET_CONFIGURATION_Handle *cfg,
+           const char *section,
+           const char *key)
 {
   struct ConfigSection *sec;
   struct ConfigEntry *pos;
 
-  if (NULL == (sec = find_section (cfg, section)))
+  if (NULL == (sec = find_section(cfg, section)))
     return NULL;
   pos = sec->entries;
-  while ((pos != NULL) && (0 != strcasecmp (key, pos->key)))
+  while ((pos != NULL) && (0 != strcasecmp(key, pos->key)))
     pos = pos->next;
   return pos;
 }
@@ -765,19 +760,19 @@ find_entry (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param value value to copy (of the default conf.)
  */
 static void
-compare_entries (void *cls,
-                 const char *section,
-                 const char *option,
-                 const char *value)
+compare_entries(void *cls,
+                const char *section,
+                const char *option,
+                const char *value)
 {
   struct DiffHandle *dh = cls;
   struct ConfigEntry *entNew;
 
-  entNew = find_entry (dh->cfg_default, section, option);
+  entNew = find_entry(dh->cfg_default, section, option);
   if ((NULL != entNew) && (NULL != entNew->val) &&
-      (0 == strcmp (entNew->val, value)))
+      (0 == strcmp(entNew->val, value)))
     return;
-  GNUNET_CONFIGURATION_set_value_string (dh->cfgDiff, section, option, value);
+  GNUNET_CONFIGURATION_set_value_string(dh->cfgDiff, section, option, value);
 }
 
 
@@ -789,15 +784,15 @@ compare_entries (void *cls,
  * @return configuration with only the differences, never NULL
  */
 struct GNUNET_CONFIGURATION_Handle *
-GNUNET_CONFIGURATION_get_diff (
+GNUNET_CONFIGURATION_get_diff(
   const struct GNUNET_CONFIGURATION_Handle *cfg_default,
   const struct GNUNET_CONFIGURATION_Handle *cfg_new)
 {
   struct DiffHandle diffHandle;
 
-  diffHandle.cfgDiff = GNUNET_CONFIGURATION_create ();
+  diffHandle.cfgDiff = GNUNET_CONFIGURATION_create();
   diffHandle.cfg_default = cfg_default;
-  GNUNET_CONFIGURATION_iterate (cfg_new, &compare_entries, &diffHandle);
+  GNUNET_CONFIGURATION_iterate(cfg_new, &compare_entries, &diffHandle);
   return diffHandle.cfgDiff;
 }
 
@@ -811,7 +806,7 @@ GNUNET_CONFIGURATION_get_diff (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_write_diffs (
+GNUNET_CONFIGURATION_write_diffs(
   const struct GNUNET_CONFIGURATION_Handle *cfg_default,
   const struct GNUNET_CONFIGURATION_Handle *cfg_new,
   const char *filename)
@@ -819,9 +814,9 @@ GNUNET_CONFIGURATION_write_diffs (
   int ret;
   struct GNUNET_CONFIGURATION_Handle *diff;
 
-  diff = GNUNET_CONFIGURATION_get_diff (cfg_default, cfg_new);
-  ret = GNUNET_CONFIGURATION_write (diff, filename);
-  GNUNET_CONFIGURATION_destroy (diff);
+  diff = GNUNET_CONFIGURATION_get_diff(cfg_default, cfg_new);
+  ret = GNUNET_CONFIGURATION_write(diff, filename);
+  GNUNET_CONFIGURATION_destroy(diff);
   return ret;
 }
 
@@ -835,42 +830,42 @@ GNUNET_CONFIGURATION_write_diffs (
  * @param value value to set
  */
 void
-GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *section,
-                                       const char *option,
-                                       const char *value)
+GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg,
+                                      const char *section,
+                                      const char *option,
+                                      const char *value)
 {
   struct ConfigSection *sec;
   struct ConfigEntry *e;
   char *nv;
 
-  e = find_entry (cfg, section, option);
+  e = find_entry(cfg, section, option);
   if (NULL != e)
-  {
-    if (NULL == value)
     {
-      GNUNET_free_non_null (e->val);
-      e->val = NULL;
+      if (NULL == value)
+        {
+          GNUNET_free_non_null(e->val);
+          e->val = NULL;
+        }
+      else
+        {
+          nv = GNUNET_strdup(value);
+          GNUNET_free_non_null(e->val);
+          e->val = nv;
+        }
+      return;
     }
-    else
+  sec = find_section(cfg, section);
+  if (sec == NULL)
     {
-      nv = GNUNET_strdup (value);
-      GNUNET_free_non_null (e->val);
-      e->val = nv;
+      sec = GNUNET_new(struct ConfigSection);
+      sec->name = GNUNET_strdup(section);
+      sec->next = cfg->sections;
+      cfg->sections = sec;
     }
-    return;
-  }
-  sec = find_section (cfg, section);
-  if (sec == NULL)
-  {
-    sec = GNUNET_new (struct ConfigSection);
-    sec->name = GNUNET_strdup (section);
-    sec->next = cfg->sections;
-    cfg->sections = sec;
-  }
-  e = GNUNET_new (struct ConfigEntry);
-  e->key = GNUNET_strdup (option);
-  e->val = GNUNET_strdup (value);
+  e = GNUNET_new(struct ConfigEntry);
+  e->key = GNUNET_strdup(option);
+  e->val = GNUNET_strdup(value);
   e->next = sec->entries;
   sec->entries = e;
 }
@@ -885,15 +880,15 @@ GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param number value to set
  */
 void
-GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                       const char *section,
-                                       const char *option,
-                                       unsigned long long number)
+GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg,
+                                      const char *section,
+                                      const char *option,
+                                      unsigned long long number)
 {
   char s[64];
 
-  GNUNET_snprintf (s, 64, "%llu", number);
-  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, s);
+  GNUNET_snprintf(s, 64, "%llu", number);
+  GNUNET_CONFIGURATION_set_value_string(cfg, section, option, s);
 }
 
 
@@ -907,7 +902,7 @@ GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_number (
+GNUNET_CONFIGURATION_get_value_number(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -916,11 +911,11 @@ GNUNET_CONFIGURATION_get_value_number (
   struct ConfigEntry *e;
   char dummy[2];
 
-  if (NULL == (e = find_entry (cfg, section, option)))
+  if (NULL == (e = find_entry(cfg, section, option)))
     return GNUNET_SYSERR;
   if (NULL == e->val)
     return GNUNET_SYSERR;
-  if (1 != sscanf (e->val, "%llu%1s", number, dummy))
+  if (1 != sscanf(e->val, "%llu%1s", number, dummy))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -936,7 +931,7 @@ GNUNET_CONFIGURATION_get_value_number (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_float (
+GNUNET_CONFIGURATION_get_value_float(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -945,11 +940,11 @@ GNUNET_CONFIGURATION_get_value_float (
   struct ConfigEntry *e;
   char dummy[2];
 
-  if (NULL == (e = find_entry (cfg, section, option)))
+  if (NULL == (e = find_entry(cfg, section, option)))
     return GNUNET_SYSERR;
   if (NULL == e->val)
     return GNUNET_SYSERR;
-  if (1 != sscanf (e->val, "%f%1s", number, dummy))
+  if (1 != sscanf(e->val, "%f%1s", number, dummy))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -965,7 +960,7 @@ GNUNET_CONFIGURATION_get_value_float (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_time (
+GNUNET_CONFIGURATION_get_value_time(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -974,16 +969,16 @@ GNUNET_CONFIGURATION_get_value_time (
   struct ConfigEntry *e;
   int ret;
 
-  if (NULL == (e = find_entry (cfg, section, option)))
+  if (NULL == (e = find_entry(cfg, section, option)))
     return GNUNET_SYSERR;
   if (NULL == e->val)
     return GNUNET_SYSERR;
-  ret = GNUNET_STRINGS_fancy_time_to_relative (e->val, time);
+  ret = GNUNET_STRINGS_fancy_time_to_relative(e->val, time);
   if (GNUNET_OK != ret)
-    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                               section,
-                               option,
-                               _ ("Not a valid relative time specification"));
+    GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
+                              section,
+                              option,
+                              _("Not a valid relative time specification"));
   return ret;
 }
 
@@ -998,7 +993,7 @@ GNUNET_CONFIGURATION_get_value_time (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_size (
+GNUNET_CONFIGURATION_get_value_size(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1006,11 +1001,11 @@ GNUNET_CONFIGURATION_get_value_size (
 {
   struct ConfigEntry *e;
 
-  if (NULL == (e = find_entry (cfg, section, option)))
+  if (NULL == (e = find_entry(cfg, section, option)))
     return GNUNET_SYSERR;
   if (NULL == e->val)
     return GNUNET_SYSERR;
-  return GNUNET_STRINGS_fancy_size_to_bytes (e->val, size);
+  return GNUNET_STRINGS_fancy_size_to_bytes(e->val, size);
 }
 
 
@@ -1025,7 +1020,7 @@ GNUNET_CONFIGURATION_get_value_size (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_string (
+GNUNET_CONFIGURATION_get_value_string(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1033,12 +1028,12 @@ GNUNET_CONFIGURATION_get_value_string (
 {
   struct ConfigEntry *e;
 
-  if ((NULL == (e = find_entry (cfg, section, option))) || (NULL == e->val))
-  {
-    *value = NULL;
-    return GNUNET_SYSERR;
-  }
-  *value = GNUNET_strdup (e->val);
+  if ((NULL == (e = find_entry(cfg, section, option))) || (NULL == e->val))
+    {
+      *value = NULL;
+      return GNUNET_SYSERR;
+    }
+  *value = GNUNET_strdup(e->val);
   return GNUNET_OK;
 }
 
@@ -1056,7 +1051,7 @@ GNUNET_CONFIGURATION_get_value_string (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_choice (
+GNUNET_CONFIGURATION_get_value_choice(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1066,21 +1061,21 @@ GNUNET_CONFIGURATION_get_value_choice (
   struct ConfigEntry *e;
   unsigned int i;
 
-  if (NULL == (e = find_entry (cfg, section, option)))
+  if (NULL == (e = find_entry(cfg, section, option)))
     return GNUNET_SYSERR;
   for (i = 0; NULL != choices[i]; i++)
-    if (0 == strcasecmp (choices[i], e->val))
+    if (0 == strcasecmp(choices[i], e->val))
       break;
   if (NULL == choices[i])
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Configuration value '%s' for '%s'"
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Configuration value '%s' for '%s'"
             " in section '%s' is not in set of legal choices\n"),
-         e->val,
-         option,
-         section);
-    return GNUNET_SYSERR;
-  }
+          e->val,
+          option,
+          section);
+      return GNUNET_SYSERR;
+    }
   *value = choices[i];
   return GNUNET_OK;
 }
@@ -1099,11 +1094,11 @@ GNUNET_CONFIGURATION_get_value_choice (
  *         #GNUNET_SYSERR on decoding error
  */
 int
-GNUNET_CONFIGURATION_get_data (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                               const char *section,
-                               const char *option,
-                               void *buf,
-                               size_t buf_size)
+GNUNET_CONFIGURATION_get_data(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                              const char *section,
+                              const char *option,
+                              void *buf,
+                              size_t buf_size)
 {
   char *enc;
   int res;
@@ -1111,21 +1106,21 @@ GNUNET_CONFIGURATION_get_data (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   if (GNUNET_OK !=
       (res =
-         GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &enc)))
+         GNUNET_CONFIGURATION_get_value_string(cfg, section, option, &enc)))
     return res;
-  data_size = (strlen (enc) * 5) / 8;
+  data_size = (strlen(enc) * 5) / 8;
   if (data_size != buf_size)
-  {
-    GNUNET_free (enc);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_free(enc);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (enc, strlen (enc), buf, buf_size))
-  {
-    GNUNET_free (enc);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (enc);
+      GNUNET_STRINGS_string_to_data(enc, strlen(enc), buf, buf_size))
+    {
+      GNUNET_free(enc);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(enc);
   return GNUNET_OK;
 }
 
@@ -1139,13 +1134,13 @@ GNUNET_CONFIGURATION_get_data (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_YES if so, #GNUNET_NO if not.
  */
 int
-GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                 const char *section,
-                                 const char *option)
+GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                const char *section,
+                                const char *option)
 {
   struct ConfigEntry *e;
 
-  if ((NULL == (e = find_entry (cfg, section, option))) || (NULL == e->val))
+  if ((NULL == (e = find_entry(cfg, section, option))) || (NULL == e->val))
     return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -1167,9 +1162,9 @@ GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return $-expanded string
  */
 static char *
-expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cfg,
-               char *orig,
-               unsigned int depth)
+expand_dollar(const struct GNUNET_CONFIGURATION_Handle *cfg,
+              char *orig,
+              unsigned int depth)
 {
   int i;
   char *prefix;
@@ -1187,124 +1182,127 @@ expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cfg,
   if (NULL == orig)
     return NULL;
   if (depth > 128)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ (
-           "Recursive expansion suspected, aborting $-expansion for term `%s'\n"),
-         orig);
-    return orig;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to $-expand %s\n", orig);
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _(
+            "Recursive expansion suspected, aborting $-expansion for term `%s'\n"),
+          orig);
+      return orig;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Asked to $-expand %s\n", orig);
   if ('$' != orig[0])
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Doesn't start with $ - not expanding\n");
-    return orig;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Doesn't start with $ - not expanding\n");
+      return orig;
+    }
   erased_char = 0;
   erased_pos = NULL;
   if ('{' == orig[1])
-  {
-    start = &orig[2];
-    lopen = 1;
-    end = &orig[1];
-    while (lopen > 0)
-    {
-      end++;
-      switch (*end)
-      {
-      case '}':
-        lopen--;
-        break;
-      case '{':
-        lopen++;
-        break;
-      case '\0':
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             _ ("Missing closing `%s' in option `%s'\n"),
-             "}",
-             orig);
-        return orig;
-      default:
-        break;
-      }
-    }
-    erased_char = *end;
-    erased_pos = end;
-    *end = '\0';
-    post = end + 1;
-    def = strchr (orig, ':');
-    if (NULL != def)
     {
-      *def = '\0';
-      def++;
-      if (('-' == *def) || ('=' == *def))
-        def++;
-      def = GNUNET_strdup (def);
+      start = &orig[2];
+      lopen = 1;
+      end = &orig[1];
+      while (lopen > 0)
+        {
+          end++;
+          switch (*end)
+            {
+            case '}':
+              lopen--;
+              break;
+
+            case '{':
+              lopen++;
+              break;
+
+            case '\0':
+              LOG(GNUNET_ERROR_TYPE_WARNING,
+                  _("Missing closing `%s' in option `%s'\n"),
+                  "}",
+                  orig);
+              return orig;
+
+            default:
+              break;
+            }
+        }
+      erased_char = *end;
+      erased_pos = end;
+      *end = '\0';
+      post = end + 1;
+      def = strchr(orig, ':');
+      if (NULL != def)
+        {
+          *def = '\0';
+          def++;
+          if (('-' == *def) || ('=' == *def))
+            def++;
+          def = GNUNET_strdup(def);
+        }
     }
-  }
   else
-  {
-    start = &orig[1];
-    def = NULL;
-    i = 0;
-    while ((orig[i] != '/') && (orig[i] != '\\') && (orig[i] != '\0') &&
-           (orig[i] != ' '))
-      i++;
-    if (orig[i] == '\0')
-    {
-      post = "";
-    }
-    else
     {
-      erased_char = orig[i];
-      erased_pos = &orig[i];
-      orig[i] = '\0';
-      post = &orig[i + 1];
+      start = &orig[1];
+      def = NULL;
+      i = 0;
+      while ((orig[i] != '/') && (orig[i] != '\\') && (orig[i] != '\0') &&
+             (orig[i] != ' '))
+        i++;
+      if (orig[i] == '\0')
+        {
+          post = "";
+        }
+      else
+        {
+          erased_char = orig[i];
+          erased_pos = &orig[i];
+          orig[i] = '\0';
+          post = &orig[i + 1];
+        }
     }
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Split into `%s' and `%s' with default %s\n",
-       start,
-       post,
-       def);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Split into `%s' and `%s' with default %s\n",
+      start,
+      post,
+      def);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", start, &prefix))
-  {
-    if (NULL == (env = getenv (start)))
+      GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", start, &prefix))
     {
-      /* try default */
-      def = expand_dollar (cfg, def, depth + 1);
-      env = def;
+      if (NULL == (env = getenv(start)))
+        {
+          /* try default */
+          def = expand_dollar(cfg, def, depth + 1);
+          env = def;
+        }
+      if (NULL == env)
+        {
+          start = GNUNET_strdup(start);
+          if (erased_pos)
+            *erased_pos = erased_char;
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _(
+                "Failed to expand `%s' in `%s' as it is neither found in [PATHS] nor defined as an environmental variable\n"),
+              start,
+              orig);
+          GNUNET_free(start);
+          return orig;
+        }
+      prefix = GNUNET_strdup(env);
     }
-    if (NULL == env)
+  prefix = GNUNET_CONFIGURATION_expand_dollar(cfg, prefix);
+  if ((erased_pos) && ('}' != erased_char))
     {
-      start = GNUNET_strdup (start);
-      if (erased_pos)
-        *erased_pos = erased_char;
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _ (
-             "Failed to expand `%s' in `%s' as it is neither found in [PATHS] nor defined as an environmental variable\n"),
-           start,
-           orig);
-      GNUNET_free (start);
-      return orig;
+      len = strlen(prefix) + 1;
+      prefix = GNUNET_realloc(prefix, len + 1);
+      prefix[len - 1] = erased_char;
+      prefix[len] = '\0';
     }
-    prefix = GNUNET_strdup (env);
-  }
-  prefix = GNUNET_CONFIGURATION_expand_dollar (cfg, prefix);
-  if ((erased_pos) && ('}' != erased_char))
-  {
-    len = strlen (prefix) + 1;
-    prefix = GNUNET_realloc (prefix, len + 1);
-    prefix[len - 1] = erased_char;
-    prefix[len] = '\0';
-  }
-  result = GNUNET_malloc (strlen (prefix) + strlen (post) + 1);
-  strcpy (result, prefix);
-  strcat (result, post);
-  GNUNET_free_non_null (def);
-  GNUNET_free (prefix);
-  GNUNET_free (orig);
+  result = GNUNET_malloc(strlen(prefix) + strlen(post) + 1);
+  strcpy(result, prefix);
+  strcat(result, post);
+  GNUNET_free_non_null(def);
+  GNUNET_free(prefix);
+  GNUNET_free(orig);
   return result;
 }
 
@@ -1326,7 +1324,7 @@ expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return $-expanded string
  */
 char *
-GNUNET_CONFIGURATION_expand_dollar (
+GNUNET_CONFIGURATION_expand_dollar(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   char *orig)
 {
@@ -1335,16 +1333,16 @@ GNUNET_CONFIGURATION_expand_dollar (
   size_t len;
 
   for (i = 0; '\0' != orig[i]; i++)
-  {
-    if ('$' != orig[i])
-      continue;
-    dup = GNUNET_strdup (orig + i);
-    dup = expand_dollar (cfg, dup, 0);
-    len = strlen (dup) + 1;
-    orig = GNUNET_realloc (orig, i + len);
-    GNUNET_memcpy (orig + i, dup, len);
-    GNUNET_free (dup);
-  }
+    {
+      if ('$' != orig[i])
+        continue;
+      dup = GNUNET_strdup(orig + i);
+      dup = expand_dollar(cfg, dup, 0);
+      len = strlen(dup) + 1;
+      orig = GNUNET_realloc(orig, i + len);
+      GNUNET_memcpy(orig + i, dup, len);
+      GNUNET_free(dup);
+    }
   return orig;
 }
 
@@ -1360,7 +1358,7 @@ GNUNET_CONFIGURATION_expand_dollar (
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_filename (
+GNUNET_CONFIGURATION_get_value_filename(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1369,15 +1367,15 @@ GNUNET_CONFIGURATION_get_value_filename (
   char *tmp;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &tmp))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to retrieve filename\n");
-    *value = NULL;
-    return GNUNET_SYSERR;
-  }
-  tmp = GNUNET_CONFIGURATION_expand_dollar (cfg, tmp);
-  *value = GNUNET_STRINGS_filename_expand (tmp);
-  GNUNET_free (tmp);
+      GNUNET_CONFIGURATION_get_value_string(cfg, section, option, &tmp))
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Failed to retrieve filename\n");
+      *value = NULL;
+      return GNUNET_SYSERR;
+    }
+  tmp = GNUNET_CONFIGURATION_expand_dollar(cfg, tmp);
+  *value = GNUNET_STRINGS_filename_expand(tmp);
+  GNUNET_free(tmp);
   if (*value == NULL)
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -1394,17 +1392,17 @@ GNUNET_CONFIGURATION_get_value_filename (
  * @return #GNUNET_YES, #GNUNET_NO or #GNUNET_SYSERR
  */
 int
-GNUNET_CONFIGURATION_get_value_yesno (
+GNUNET_CONFIGURATION_get_value_yesno(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option)
 {
-  static const char *yesno[] = {"YES", "NO", NULL};
+  static const char *yesno[] = { "YES", "NO", NULL };
   const char *val;
   int ret;
 
   ret =
-    GNUNET_CONFIGURATION_get_value_choice (cfg, section, option, yesno, &val);
+    GNUNET_CONFIGURATION_get_value_choice(cfg, section, option, yesno, &val);
   if (ret == GNUNET_SYSERR)
     return ret;
   if (val == yesno[0])
@@ -1424,7 +1422,7 @@ GNUNET_CONFIGURATION_get_value_yesno (
  * @return number of filenames iterated over, -1 on error
  */
 int
-GNUNET_CONFIGURATION_iterate_value_filenames (
+GNUNET_CONFIGURATION_iterate_value_filenames(
   const struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1438,53 +1436,55 @@ GNUNET_CONFIGURATION_iterate_value_filenames (
   int ret;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
+      GNUNET_CONFIGURATION_get_value_string(cfg, section, option, &list))
     return 0;
-  GNUNET_assert (list != NULL);
+  GNUNET_assert(list != NULL);
   ret = 0;
   pos = list;
   while (1)
-  {
-    while (pos[0] == ' ')
-      pos++;
-    if (strlen (pos) == 0)
-      break;
-    end = pos + 1;
-    while ((end[0] != ' ') && (end[0] != '\0'))
     {
-      if (end[0] == '\\')
-      {
-        switch (end[1])
+      while (pos[0] == ' ')
+        pos++;
+      if (strlen(pos) == 0)
+        break;
+      end = pos + 1;
+      while ((end[0] != ' ') && (end[0] != '\0'))
         {
-        case '\\':
-        case ' ':
-          memmove (end, &end[1], strlen (&end[1]) + 1);
-        case '\0':
-          /* illegal, but just keep it */
-          break;
-        default:
-          /* illegal, but just ignore that there was a '/' */
-          break;
+          if (end[0] == '\\')
+            {
+              switch (end[1])
+                {
+                case '\\':
+                case ' ':
+                  memmove(end, &end[1], strlen(&end[1]) + 1);
+
+                case '\0':
+                  /* illegal, but just keep it */
+                  break;
+
+                default:
+                  /* illegal, but just ignore that there was a '/' */
+                  break;
+                }
+            }
+          end++;
         }
-      }
-      end++;
-    }
-    old = end[0];
-    end[0] = '\0';
-    if (strlen (pos) > 0)
-    {
-      ret++;
-      if ((cb != NULL) && (GNUNET_OK != cb (cb_cls, pos)))
-      {
-        ret = GNUNET_SYSERR;
+      old = end[0];
+      end[0] = '\0';
+      if (strlen(pos) > 0)
+        {
+          ret++;
+          if ((cb != NULL) && (GNUNET_OK != cb(cb_cls, pos)))
+            {
+              ret = GNUNET_SYSERR;
+              break;
+            }
+        }
+      if (old == '\0')
         break;
-      }
+      pos = end + 1;
     }
-    if (old == '\0')
-      break;
-    pos = end + 1;
-  }
-  GNUNET_free (list);
+  GNUNET_free(list);
   return ret;
 }
 
@@ -1496,32 +1496,33 @@ GNUNET_CONFIGURATION_iterate_value_filenames (
  * @return FIXME
  */
 static char *
-escape_name (const char *value)
+escape_name(const char *value)
 {
   char *escaped;
   const char *rpos;
   char *wpos;
 
-  escaped = GNUNET_malloc (strlen (value) * 2 + 1);
-  memset (escaped, 0, strlen (value) * 2 + 1);
+  escaped = GNUNET_malloc(strlen(value) * 2 + 1);
+  memset(escaped, 0, strlen(value) * 2 + 1);
   rpos = value;
   wpos = escaped;
   while (rpos[0] != '\0')
-  {
-    switch (rpos[0])
     {
-    case '\\':
-    case ' ':
-      wpos[0] = '\\';
-      wpos[1] = rpos[0];
-      wpos += 2;
-      break;
-    default:
-      wpos[0] = rpos[0];
-      wpos++;
+      switch (rpos[0])
+        {
+        case '\\':
+        case ' ':
+          wpos[0] = '\\';
+          wpos[1] = rpos[0];
+          wpos += 2;
+          break;
+
+        default:
+          wpos[0] = rpos[0];
+          wpos++;
+        }
+      rpos++;
     }
-    rpos++;
-  }
   return escaped;
 }
 
@@ -1534,11 +1535,11 @@ escape_name (const char *value)
  * @return #GNUNET_OK if the names do not match, #GNUNET_SYSERR if they do
  */
 static int
-test_match (void *cls, const char *fn)
+test_match(void *cls, const char *fn)
 {
   const char *of = cls;
 
-  return (0 == strcmp (of, fn)) ? GNUNET_SYSERR : GNUNET_OK;
+  return (0 == strcmp(of, fn)) ? GNUNET_SYSERR : GNUNET_OK;
 }
 
 
@@ -1555,7 +1556,7 @@ test_match (void *cls, const char *fn)
  *         #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_append_value_filename (
+GNUNET_CONFIGURATION_append_value_filename(
   struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1566,25 +1567,25 @@ GNUNET_CONFIGURATION_append_value_filename (
   char *nw;
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
-                                                    section,
-                                                    option,
-                                                    &test_match,
-                                                    (void *) value))
+      GNUNET_CONFIGURATION_iterate_value_filenames(cfg,
+                                                   section,
+                                                   option,
+                                                   &test_match,
+                                                   (void *)value))
     return GNUNET_NO; /* already exists */
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
-    old = GNUNET_strdup ("");
-  escaped = escape_name (value);
-  nw = GNUNET_malloc (strlen (old) + strlen (escaped) + 2);
-  strcpy (nw, old);
-  if (strlen (old) > 0)
-    strcat (nw, " ");
-  strcat (nw, escaped);
-  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, nw);
-  GNUNET_free (old);
-  GNUNET_free (nw);
-  GNUNET_free (escaped);
+      GNUNET_CONFIGURATION_get_value_string(cfg, section, option, &old))
+    old = GNUNET_strdup("");
+  escaped = escape_name(value);
+  nw = GNUNET_malloc(strlen(old) + strlen(escaped) + 2);
+  strcpy(nw, old);
+  if (strlen(old) > 0)
+    strcat(nw, " ");
+  strcat(nw, escaped);
+  GNUNET_CONFIGURATION_set_value_string(cfg, section, option, nw);
+  GNUNET_free(old);
+  GNUNET_free(nw);
+  GNUNET_free(escaped);
   return GNUNET_OK;
 }
 
@@ -1602,7 +1603,7 @@ GNUNET_CONFIGURATION_append_value_filename (
  *         #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_remove_value_filename (
+GNUNET_CONFIGURATION_remove_value_filename(
   struct GNUNET_CONFIGURATION_Handle *cfg,
   const char *section,
   const char *option,
@@ -1615,62 +1616,64 @@ GNUNET_CONFIGURATION_remove_value_filename (
   char old;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
+      GNUNET_CONFIGURATION_get_value_string(cfg, section, option, &list))
     return GNUNET_NO;
-  match = escape_name (value);
+  match = escape_name(value);
   pos = list;
   while (1)
-  {
-    while (pos[0] == ' ')
-      pos++;
-    if (strlen (pos) == 0)
-      break;
-    end = pos + 1;
-    while ((end[0] != ' ') && (end[0] != '\0'))
     {
-      if (end[0] == '\\')
-      {
-        switch (end[1])
+      while (pos[0] == ' ')
+        pos++;
+      if (strlen(pos) == 0)
+        break;
+      end = pos + 1;
+      while ((end[0] != ' ') && (end[0] != '\0'))
         {
-        case '\\':
-        case ' ':
+          if (end[0] == '\\')
+            {
+              switch (end[1])
+                {
+                case '\\':
+                case ' ':
+                  end++;
+                  break;
+
+                case '\0':
+                  /* illegal, but just keep it */
+                  break;
+
+                default:
+                  /* illegal, but just ignore that there was a '/' */
+                  break;
+                }
+            }
           end++;
-          break;
-        case '\0':
-          /* illegal, but just keep it */
-          break;
-        default:
-          /* illegal, but just ignore that there was a '/' */
-          break;
         }
-      }
-      end++;
-    }
-    old = end[0];
-    end[0] = '\0';
-    if (0 == strcmp (pos, match))
-    {
-      if (old != '\0')
-        memmove (pos, &end[1], strlen (&end[1]) + 1);
-      else
-      {
-        if (pos != list)
-          pos[-1] = '\0';
-        else
-          pos[0] = '\0';
-      }
-      GNUNET_CONFIGURATION_set_value_string (cfg, section, option, list);
-      GNUNET_free (list);
-      GNUNET_free (match);
-      return GNUNET_OK;
+      old = end[0];
+      end[0] = '\0';
+      if (0 == strcmp(pos, match))
+        {
+          if (old != '\0')
+            memmove(pos, &end[1], strlen(&end[1]) + 1);
+          else
+            {
+              if (pos != list)
+                pos[-1] = '\0';
+              else
+                pos[0] = '\0';
+            }
+          GNUNET_CONFIGURATION_set_value_string(cfg, section, option, list);
+          GNUNET_free(list);
+          GNUNET_free(match);
+          return GNUNET_OK;
+        }
+      if (old == '\0')
+        break;
+      end[0] = old;
+      pos = end + 1;
     }
-    if (old == '\0')
-      break;
-    end[0] = old;
-    pos = end + 1;
-  }
-  GNUNET_free (list);
-  GNUNET_free (match);
+  GNUNET_free(list);
+  GNUNET_free(match);
   return GNUNET_NO;
 }
 
@@ -1685,21 +1688,21 @@ GNUNET_CONFIGURATION_remove_value_filename (
  * @return #GNUNET_OK on success
  */
 static int
-parse_configuration_file (void *cls, const char *filename)
+parse_configuration_file(void *cls, const char *filename)
 {
   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   char *ext;
   int ret;
 
   /* Examine file extension */
-  ext = strrchr (filename, '.');
-  if ((NULL == ext) || (0 != strcmp (ext, ".conf")))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Skipping file `%s'\n", filename);
-    return GNUNET_OK;
-  }
-
-  ret = GNUNET_CONFIGURATION_parse (cfg, filename);
+  ext = strrchr(filename, '.');
+  if ((NULL == ext) || (0 != strcmp(ext, ".conf")))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Skipping file `%s'\n", filename);
+      return GNUNET_OK;
+    }
+
+  ret = GNUNET_CONFIGURATION_parse(cfg, filename);
   return ret;
 }
 
@@ -1713,11 +1716,11 @@ parse_configuration_file (void *cls, const char *filename)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                const char *defaults_d)
+GNUNET_CONFIGURATION_load_from(struct GNUNET_CONFIGURATION_Handle *cfg,
+                               const char *defaults_d)
 {
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_directory_scan (defaults_d, &parse_configuration_file, cfg))
+      GNUNET_DISK_directory_scan(defaults_d, &parse_configuration_file, cfg))
     return GNUNET_SYSERR; /* no configuration at all found */
   return GNUNET_OK;
 }
diff --git a/src/util/configuration_loader.c b/src/util/configuration_loader.c
index 095e69474..ccf9a25b2 100644
--- a/src/util/configuration_loader.c
+++ b/src/util/configuration_loader.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file src/util/configuration_loader.c
@@ -27,7 +27,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-configuration", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-configuration", __VA_ARGS__)
 
 
 /**
@@ -39,48 +39,48 @@
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
-                           const char *filename)
+GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg,
+                          const char *filename)
 {
   char *baseconfig;
   const char *base_config_varname;
 
-  base_config_varname = GNUNET_OS_project_data_get ()->base_config_varname;
+  base_config_varname = GNUNET_OS_project_data_get()->base_config_varname;
 
-  if (NULL != (baseconfig = getenv (base_config_varname)))
-  {
-    baseconfig = GNUNET_strdup (baseconfig);
-  }
+  if (NULL != (baseconfig = getenv(base_config_varname)))
+    {
+      baseconfig = GNUNET_strdup(baseconfig);
+    }
   else
-  {
-    char *ipath;
+    {
+      char *ipath;
 
-    ipath = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
-    if (NULL == ipath)
-      return GNUNET_SYSERR;
-    GNUNET_asprintf (&baseconfig, "%s%s", ipath, "config.d");
-    GNUNET_free (ipath);
-  }
+      ipath = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
+      if (NULL == ipath)
+        return GNUNET_SYSERR;
+      GNUNET_asprintf(&baseconfig, "%s%s", ipath, "config.d");
+      GNUNET_free(ipath);
+    }
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_load_from (cfg,
-                                      baseconfig))
-  {
-    GNUNET_free (baseconfig);
-    return GNUNET_SYSERR;       /* no configuration at all found */
-  }
-  GNUNET_free (baseconfig);
+      GNUNET_CONFIGURATION_load_from(cfg,
+                                     baseconfig))
+    {
+      GNUNET_free(baseconfig);
+      return GNUNET_SYSERR;     /* no configuration at all found */
+    }
+  GNUNET_free(baseconfig);
   if ((NULL != filename) &&
-      (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, filename)))
-  {
-    /* specified configuration not found */
-    return GNUNET_SYSERR;
-  }
+      (GNUNET_OK != GNUNET_CONFIGURATION_parse(cfg, filename)))
+    {
+      /* specified configuration not found */
+      return GNUNET_SYSERR;
+    }
   if (((GNUNET_YES !=
-        GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) &&
+        GNUNET_CONFIGURATION_have_value(cfg, "PATHS", "DEFAULTCONFIG"))) &&
       (filename != NULL))
-    GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
-                                           filename);
+    GNUNET_CONFIGURATION_set_value_string(cfg, "PATHS", "DEFAULTCONFIG",
+                                          filename);
   return GNUNET_OK;
 }
 
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c
index a4033defe..1bc559ba3 100644
--- a/src/util/container_bloomfilter.c
+++ b/src/util/container_bloomfilter.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 util/container_bloomfilter.c
  * @brief data structure used to reduce disk accesses.
@@ -43,20 +43,18 @@
 #include "gnunet_util_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-bloomfilter", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-bloomfilter", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-container-bloomfilter", syscall)
+  GNUNET_log_from_strerror(kind, "util-container-bloomfilter", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename)             \
-  GNUNET_log_from_strerror_file (kind,                         \
-                                 "util-container-bloomfilter", \
-                                 syscall,                      \
-                                 filename)
-
-struct GNUNET_CONTAINER_BloomFilter
-{
+  GNUNET_log_from_strerror_file(kind,                         \
+                                "util-container-bloomfilter", \
+                                syscall,                      \
+                                filename)
 
+struct GNUNET_CONTAINER_BloomFilter {
   /**
    * The actual bloomfilter bit array
    */
@@ -91,7 +89,7 @@ struct GNUNET_CONTAINER_BloomFilter
  * @return addresses set per element in the bf
  */
 size_t
-GNUNET_CONTAINER_bloomfilter_get_element_addresses (
+GNUNET_CONTAINER_bloomfilter_get_element_addresses(
   const struct GNUNET_CONTAINER_BloomFilter *bf)
 {
   if (bf == NULL)
@@ -107,7 +105,7 @@ GNUNET_CONTAINER_bloomfilter_get_element_addresses (
  * @return number of bytes used for the data of the bloom filter
  */
 size_t
-GNUNET_CONTAINER_bloomfilter_get_size (
+GNUNET_CONTAINER_bloomfilter_get_size(
   const struct GNUNET_CONTAINER_BloomFilter *bf)
 {
   if (bf == NULL)
@@ -123,12 +121,12 @@ GNUNET_CONTAINER_bloomfilter_get_size (
  * @return copy of the bf
  */
 struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_copy (
+GNUNET_CONTAINER_bloomfilter_copy(
   const struct GNUNET_CONTAINER_BloomFilter *bf)
 {
-  return GNUNET_CONTAINER_bloomfilter_init (bf->bitArray,
-                                            bf->bitArraySize,
-                                            bf->addressesPerElement);
+  return GNUNET_CONTAINER_bloomfilter_init(bf->bitArray,
+                                           bf->bitArraySize,
+                                           bf->addressesPerElement);
 }
 
 
@@ -140,7 +138,7 @@ GNUNET_CONTAINER_bloomfilter_copy (
  * @param bitIdx which bit to set
  */
 static void
-setBit (char *bitArray, unsigned int bitIdx)
+setBit(char *bitArray, unsigned int bitIdx)
 {
   size_t arraySlot;
   unsigned int targetBit;
@@ -158,7 +156,7 @@ setBit (char *bitArray, unsigned int bitIdx)
  * @param bitIdx which bit to unset
  */
 static void
-clearBit (char *bitArray, unsigned int bitIdx)
+clearBit(char *bitArray, unsigned int bitIdx)
 {
   size_t slot;
   unsigned int targetBit;
@@ -176,7 +174,7 @@ clearBit (char *bitArray, unsigned int bitIdx)
  * @return GNUNET_YES if the bit is set, GNUNET_NO if not.
  */
 static int
-testBit (char *bitArray, unsigned int bitIdx)
+testBit(char *bitArray, unsigned int bitIdx)
 {
   size_t slot;
   unsigned int targetBit;
@@ -199,9 +197,9 @@ testBit (char *bitArray, unsigned int bitIdx)
  * @param fh A file to keep the 4 bit address usage counters in
  */
 static void
-incrementBit (char *bitArray,
-              unsigned int bitIdx,
-              const struct GNUNET_DISK_FileHandle *fh)
+incrementBit(char *bitArray,
+             unsigned int bitIdx,
+             const struct GNUNET_DISK_FileHandle *fh)
 {
   off_t fileSlot;
   unsigned char value;
@@ -209,34 +207,34 @@ incrementBit (char *bitArray,
   unsigned int low;
   unsigned int targetLoc;
 
-  setBit (bitArray, bitIdx);
-  if (GNUNET_DISK_handle_invalid (fh))
+  setBit(bitArray, bitIdx);
+  if (GNUNET_DISK_handle_invalid(fh))
     return;
   /* Update the counter file on disk */
   fileSlot = bitIdx / 2;
   targetLoc = bitIdx % 2;
 
-  GNUNET_assert (fileSlot ==
-                 GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_DISK_SEEK_SET));
-  if (1 != GNUNET_DISK_file_read (fh, &value, 1))
+  GNUNET_assert(fileSlot ==
+                GNUNET_DISK_file_seek(fh, fileSlot, GNUNET_DISK_SEEK_SET));
+  if (1 != GNUNET_DISK_file_read(fh, &value, 1))
     value = 0;
   low = value & 0xF;
   high = (value & (~0xF)) >> 4;
 
   if (targetLoc == 0)
-  {
-    if (low < 0xF)
-      low++;
-  }
+    {
+      if (low < 0xF)
+        low++;
+    }
   else
-  {
-    if (high < 0xF)
-      high++;
-  }
+    {
+      if (high < 0xF)
+        high++;
+    }
   value = ((high << 4) | low);
-  GNUNET_assert (fileSlot ==
-                 GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_DISK_SEEK_SET));
-  GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
+  GNUNET_assert(fileSlot ==
+                GNUNET_DISK_file_seek(fh, fileSlot, GNUNET_DISK_SEEK_SET));
+  GNUNET_assert(1 == GNUNET_DISK_file_write(fh, &value, 1));
 }
 
 /**
@@ -248,9 +246,9 @@ incrementBit (char *bitArray,
  * @param fh A file to keep the 4bit address usage counters in
  */
 static void
-decrementBit (char *bitArray,
-              unsigned int bitIdx,
-              const struct GNUNET_DISK_FileHandle *fh)
+decrementBit(char *bitArray,
+             unsigned int bitIdx,
+             const struct GNUNET_DISK_FileHandle *fh)
 {
   off_t fileslot;
   unsigned char value;
@@ -258,49 +256,49 @@ decrementBit (char *bitArray,
   unsigned int low;
   unsigned int targetLoc;
 
-  if (GNUNET_DISK_handle_invalid (fh))
+  if (GNUNET_DISK_handle_invalid(fh))
     return; /* cannot decrement! */
   /* Each char slot in the counter file holds two 4 bit counters */
   fileslot = bitIdx / 2;
   targetLoc = bitIdx % 2;
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_file_seek (fh, fileslot, GNUNET_DISK_SEEK_SET))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "seek");
-    return;
-  }
-  if (1 != GNUNET_DISK_file_read (fh, &value, 1))
+      GNUNET_DISK_file_seek(fh, fileslot, GNUNET_DISK_SEEK_SET))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "seek");
+      return;
+    }
+  if (1 != GNUNET_DISK_file_read(fh, &value, 1))
     value = 0;
   low = value & 0xF;
   high = (value & 0xF0) >> 4;
 
   /* decrement, but once we have reached the max, never go back! */
   if (targetLoc == 0)
-  {
-    if ((low > 0) && (low < 0xF))
-      low--;
-    if (low == 0)
     {
-      clearBit (bitArray, bitIdx);
+      if ((low > 0) && (low < 0xF))
+        low--;
+      if (low == 0)
+        {
+          clearBit(bitArray, bitIdx);
+        }
     }
-  }
   else
-  {
-    if ((high > 0) && (high < 0xF))
-      high--;
-    if (high == 0)
     {
-      clearBit (bitArray, bitIdx);
+      if ((high > 0) && (high < 0xF))
+        high--;
+      if (high == 0)
+        {
+          clearBit(bitArray, bitIdx);
+        }
     }
-  }
   value = ((high << 4) | low);
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_file_seek (fh, fileslot, GNUNET_DISK_SEEK_SET))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "seek");
-    return;
-  }
-  GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
+      GNUNET_DISK_file_seek(fh, fileslot, GNUNET_DISK_SEEK_SET))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "seek");
+      return;
+    }
+  GNUNET_assert(1 == GNUNET_DISK_file_write(fh, &value, 1));
 }
 
 #define BUFFSIZE 65536
@@ -313,33 +311,33 @@ decrementBit (char *bitArray,
  * @return GNUNET_OK if created ok, GNUNET_SYSERR otherwise
  */
 static int
-make_empty_file (const struct GNUNET_DISK_FileHandle *fh, size_t size)
+make_empty_file(const struct GNUNET_DISK_FileHandle *fh, size_t size)
 {
   char buffer[BUFFSIZE];
   size_t bytesleft = size;
   int res = 0;
 
-  if (GNUNET_DISK_handle_invalid (fh))
+  if (GNUNET_DISK_handle_invalid(fh))
     return GNUNET_SYSERR;
-  memset (buffer, 0, sizeof (buffer));
-  GNUNET_DISK_file_seek (fh, 0, GNUNET_DISK_SEEK_SET);
+  memset(buffer, 0, sizeof(buffer));
+  GNUNET_DISK_file_seek(fh, 0, GNUNET_DISK_SEEK_SET);
   while (bytesleft > 0)
-  {
-    if (bytesleft > sizeof (buffer))
-    {
-      res = GNUNET_DISK_file_write (fh, buffer, sizeof (buffer));
-      if (res >= 0)
-        bytesleft -= res;
-    }
-    else
     {
-      res = GNUNET_DISK_file_write (fh, buffer, bytesleft);
-      if (res >= 0)
-        bytesleft -= res;
+      if (bytesleft > sizeof(buffer))
+        {
+          res = GNUNET_DISK_file_write(fh, buffer, sizeof(buffer));
+          if (res >= 0)
+            bytesleft -= res;
+        }
+      else
+        {
+          res = GNUNET_DISK_file_write(fh, buffer, bytesleft);
+          if (res >= 0)
+            bytesleft -= res;
+        }
+      if (GNUNET_SYSERR == res)
+        return GNUNET_SYSERR;
     }
-    if (GNUNET_SYSERR == res)
-      return GNUNET_SYSERR;
-  }
   return GNUNET_OK;
 }
 
@@ -370,10 +368,10 @@ typedef int (*BitIterator) (void *cls,
  * @param key the key for which we iterate over the BF bits
  */
 static void
-iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
-             BitIterator callback,
-             void *arg,
-             const struct GNUNET_HashCode *key)
+iterateBits(const struct GNUNET_CONTAINER_BloomFilter *bf,
+            BitIterator callback,
+            void *arg,
+            const struct GNUNET_HashCode *key)
 {
   struct GNUNET_HashCode tmp[2];
   int bitCount;
@@ -383,32 +381,32 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
   bitCount = bf->addressesPerElement;
   tmp[0] = *key;
   round = 0;
-  GNUNET_assert (bf->bitArraySize > 0);
-  GNUNET_assert (bf->bitArraySize * 8LL > bf->bitArraySize);
+  GNUNET_assert(bf->bitArraySize > 0);
+  GNUNET_assert(bf->bitArraySize * 8LL > bf->bitArraySize);
   while (bitCount > 0)
-  {
-    while (slot < (sizeof (struct GNUNET_HashCode) / sizeof (uint32_t)))
-    {
-      if (GNUNET_YES !=
-          callback (arg,
-                    bf,
-                    ntohl ((((uint32_t *) &tmp[round & 1])[slot])) %
-                      ((bf->bitArraySize * 8LL))))
-        return;
-      slot++;
-      bitCount--;
-      if (bitCount == 0)
-        break;
-    }
-    if (bitCount > 0)
     {
-      GNUNET_CRYPTO_hash (&tmp[round & 1],
-                          sizeof (struct GNUNET_HashCode),
-                          &tmp[(round + 1) & 1]);
-      round++;
-      slot = 0;
+      while (slot < (sizeof(struct GNUNET_HashCode) / sizeof(uint32_t)))
+        {
+          if (GNUNET_YES !=
+              callback(arg,
+                       bf,
+                       ntohl((((uint32_t *)&tmp[round & 1])[slot])) %
+                       ((bf->bitArraySize * 8LL))))
+            return;
+          slot++;
+          bitCount--;
+          if (bitCount == 0)
+            break;
+        }
+      if (bitCount > 0)
+        {
+          GNUNET_CRYPTO_hash(&tmp[round & 1],
+                             sizeof(struct GNUNET_HashCode),
+                             &tmp[(round + 1) & 1]);
+          round++;
+          slot = 0;
+        }
     }
-  }
 }
 
 
@@ -421,13 +419,13 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
  * @return GNUNET_YES
  */
 static int
-incrementBitCallback (void *cls,
-                      const struct GNUNET_CONTAINER_BloomFilter *bf,
-                      unsigned int bit)
+incrementBitCallback(void *cls,
+                     const struct GNUNET_CONTAINER_BloomFilter *bf,
+                     unsigned int bit)
 {
   struct GNUNET_CONTAINER_BloomFilter *b = cls;
 
-  incrementBit (b->bitArray, bit, bf->fh);
+  incrementBit(b->bitArray, bit, bf->fh);
   return GNUNET_YES;
 }
 
@@ -441,13 +439,13 @@ incrementBitCallback (void *cls,
  * @return GNUNET_YES
  */
 static int
-decrementBitCallback (void *cls,
-                      const struct GNUNET_CONTAINER_BloomFilter *bf,
-                      unsigned int bit)
+decrementBitCallback(void *cls,
+                     const struct GNUNET_CONTAINER_BloomFilter *bf,
+                     unsigned int bit)
 {
   struct GNUNET_CONTAINER_BloomFilter *b = cls;
 
-  decrementBit (b->bitArray, bit, bf->fh);
+  decrementBit(b->bitArray, bit, bf->fh);
   return GNUNET_YES;
 }
 
@@ -461,17 +459,17 @@ decrementBitCallback (void *cls,
  * @return YES if the bit is set, NO if not
  */
 static int
-testBitCallback (void *cls,
-                 const struct GNUNET_CONTAINER_BloomFilter *bf,
-                 unsigned int bit)
+testBitCallback(void *cls,
+                const struct GNUNET_CONTAINER_BloomFilter *bf,
+                unsigned int bit)
 {
   int *arg = cls;
 
-  if (GNUNET_NO == testBit (bf->bitArray, bit))
-  {
-    *arg = GNUNET_NO;
-    return GNUNET_NO;
-  }
+  if (GNUNET_NO == testBit(bf->bitArray, bit))
+    {
+      *arg = GNUNET_NO;
+      return GNUNET_NO;
+    }
   return GNUNET_YES;
 }
 
@@ -489,9 +487,9 @@ testBitCallback (void *cls,
  * @return the bloomfilter
  */
 struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_load (const char *filename,
-                                   size_t size,
-                                   unsigned int k)
+GNUNET_CONTAINER_bloomfilter_load(const char *filename,
+                                  size_t size,
+                                  unsigned int k)
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
   char *rbuff;
@@ -501,7 +499,7 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
   off_t fsize;
   int must_read;
 
-  GNUNET_assert (NULL != filename);
+  GNUNET_assert(NULL != filename);
   if ((k == 0) || (size == 0))
     return NULL;
   if (size < BUFFSIZE)
@@ -511,115 +509,115 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
     ui *= 2;
   size = ui; /* make sure it's a power of 2 */
 
-  bf = GNUNET_new (struct GNUNET_CONTAINER_BloomFilter);
+  bf = GNUNET_new(struct GNUNET_CONTAINER_BloomFilter);
   /* Try to open a bloomfilter file */
-  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
-    bf->fh = GNUNET_DISK_file_open (filename,
-                                    GNUNET_DISK_OPEN_READWRITE,
-                                    GNUNET_DISK_PERM_USER_READ |
-                                      GNUNET_DISK_PERM_USER_WRITE);
+  if (GNUNET_YES == GNUNET_DISK_file_test(filename))
+    bf->fh = GNUNET_DISK_file_open(filename,
+                                   GNUNET_DISK_OPEN_READWRITE,
+                                   GNUNET_DISK_PERM_USER_READ |
+                                   GNUNET_DISK_PERM_USER_WRITE);
   if (NULL != bf->fh)
-  {
-    /* file existed, try to read it! */
-    must_read = GNUNET_YES;
-    if (GNUNET_OK != GNUNET_DISK_file_handle_size (bf->fh, &fsize))
-    {
-      GNUNET_DISK_file_close (bf->fh);
-      GNUNET_free (bf);
-      return NULL;
-    }
-    if (0 == fsize)
-    {
-      /* found existing empty file, just overwrite */
-      if (GNUNET_OK != make_empty_file (bf->fh, size * 4LL))
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
-        GNUNET_DISK_file_close (bf->fh);
-        GNUNET_free (bf);
-        return NULL;
-      }
-    }
-    else if (fsize != ((off_t) size) * 4LL)
     {
-      GNUNET_log (
-        GNUNET_ERROR_TYPE_ERROR,
-        _ (
-          "Size of file on disk is incorrect for this Bloom filter (want %llu, have %llu)\n"),
-        (unsigned long long) (size * 4LL),
-        (unsigned long long) fsize);
-      GNUNET_DISK_file_close (bf->fh);
-      GNUNET_free (bf);
-      return NULL;
+      /* file existed, try to read it! */
+      must_read = GNUNET_YES;
+      if (GNUNET_OK != GNUNET_DISK_file_handle_size(bf->fh, &fsize))
+        {
+          GNUNET_DISK_file_close(bf->fh);
+          GNUNET_free(bf);
+          return NULL;
+        }
+      if (0 == fsize)
+        {
+          /* found existing empty file, just overwrite */
+          if (GNUNET_OK != make_empty_file(bf->fh, size * 4LL))
+            {
+              GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "write");
+              GNUNET_DISK_file_close(bf->fh);
+              GNUNET_free(bf);
+              return NULL;
+            }
+        }
+      else if (fsize != ((off_t)size) * 4LL)
+        {
+          GNUNET_log(
+            GNUNET_ERROR_TYPE_ERROR,
+            _(
+              "Size of file on disk is incorrect for this Bloom filter (want %llu, have %llu)\n"),
+            (unsigned long long)(size * 4LL),
+            (unsigned long long)fsize);
+          GNUNET_DISK_file_close(bf->fh);
+          GNUNET_free(bf);
+          return NULL;
+        }
     }
-  }
   else
-  {
-    /* file did not exist, don't read, just create */
-    must_read = GNUNET_NO;
-    bf->fh = GNUNET_DISK_file_open (filename,
-                                    GNUNET_DISK_OPEN_CREATE |
-                                      GNUNET_DISK_OPEN_READWRITE,
-                                    GNUNET_DISK_PERM_USER_READ |
-                                      GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == bf->fh)
     {
-      GNUNET_free (bf);
-      return NULL;
+      /* file did not exist, don't read, just create */
+      must_read = GNUNET_NO;
+      bf->fh = GNUNET_DISK_file_open(filename,
+                                     GNUNET_DISK_OPEN_CREATE |
+                                     GNUNET_DISK_OPEN_READWRITE,
+                                     GNUNET_DISK_PERM_USER_READ |
+                                     GNUNET_DISK_PERM_USER_WRITE);
+      if (NULL == bf->fh)
+        {
+          GNUNET_free(bf);
+          return NULL;
+        }
+      if (GNUNET_OK != make_empty_file(bf->fh, size * 4LL))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "write");
+          GNUNET_DISK_file_close(bf->fh);
+          GNUNET_free(bf);
+          return NULL;
+        }
     }
-    if (GNUNET_OK != make_empty_file (bf->fh, size * 4LL))
+  bf->filename = GNUNET_strdup(filename);
+  /* Alloc block */
+  bf->bitArray = GNUNET_malloc_large(size);
+  if (NULL == bf->bitArray)
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
-      GNUNET_DISK_file_close (bf->fh);
-      GNUNET_free (bf);
+      if (NULL != bf->fh)
+        GNUNET_DISK_file_close(bf->fh);
+      GNUNET_free(bf->filename);
+      GNUNET_free(bf);
       return NULL;
     }
-  }
-  bf->filename = GNUNET_strdup (filename);
-  /* Alloc block */
-  bf->bitArray = GNUNET_malloc_large (size);
-  if (NULL == bf->bitArray)
-  {
-    if (NULL != bf->fh)
-      GNUNET_DISK_file_close (bf->fh);
-    GNUNET_free (bf->filename);
-    GNUNET_free (bf);
-    return NULL;
-  }
   bf->bitArraySize = size;
   bf->addressesPerElement = k;
   if (GNUNET_YES != must_read)
     return bf; /* already done! */
   /* Read from the file what bits we can */
-  rbuff = GNUNET_malloc (BUFFSIZE);
+  rbuff = GNUNET_malloc(BUFFSIZE);
   pos = 0;
-  while (pos < ((off_t) size) * 8LL)
-  {
-    int res;
-
-    res = GNUNET_DISK_file_read (bf->fh, rbuff, BUFFSIZE);
-    if (res == -1)
+  while (pos < ((off_t)size) * 8LL)
     {
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "read", bf->filename);
-      GNUNET_free (rbuff);
-      GNUNET_free (bf->filename);
-      GNUNET_DISK_file_close (bf->fh);
-      GNUNET_free (bf);
-      return NULL;
-    }
-    if (res == 0)
-      break; /* is ok! we just did not use that many bits yet */
-    for (i = 0; i < res; i++)
-    {
-      if ((rbuff[i] & 0x0F) != 0)
-        setBit (bf->bitArray, pos + i * 2);
-      if ((rbuff[i] & 0xF0) != 0)
-        setBit (bf->bitArray, pos + i * 2 + 1);
+      int res;
+
+      res = GNUNET_DISK_file_read(bf->fh, rbuff, BUFFSIZE);
+      if (res == -1)
+        {
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "read", bf->filename);
+          GNUNET_free(rbuff);
+          GNUNET_free(bf->filename);
+          GNUNET_DISK_file_close(bf->fh);
+          GNUNET_free(bf);
+          return NULL;
+        }
+      if (res == 0)
+        break; /* is ok! we just did not use that many bits yet */
+      for (i = 0; i < res; i++)
+        {
+          if ((rbuff[i] & 0x0F) != 0)
+            setBit(bf->bitArray, pos + i * 2);
+          if ((rbuff[i] & 0xF0) != 0)
+            setBit(bf->bitArray, pos + i * 2 + 1);
+        }
+      if (res < BUFFSIZE)
+        break;
+      pos += BUFFSIZE * 2; /* 2 bits per byte in the buffer */
     }
-    if (res < BUFFSIZE)
-      break;
-    pos += BUFFSIZE * 2; /* 2 bits per byte in the buffer */
-  }
-  GNUNET_free (rbuff);
+  GNUNET_free(rbuff);
   return bf;
 }
 
@@ -638,27 +636,27 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename,
  * @return the bloomfilter
  */
 struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_init (const char *data,
-                                   size_t size,
-                                   unsigned int k)
+GNUNET_CONTAINER_bloomfilter_init(const char *data,
+                                  size_t size,
+                                  unsigned int k)
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
 
   if ((0 == k) || (0 == size))
     return NULL;
-  bf = GNUNET_new (struct GNUNET_CONTAINER_BloomFilter);
+  bf = GNUNET_new(struct GNUNET_CONTAINER_BloomFilter);
   bf->filename = NULL;
   bf->fh = NULL;
-  bf->bitArray = GNUNET_malloc_large (size);
+  bf->bitArray = GNUNET_malloc_large(size);
   if (NULL == bf->bitArray)
-  {
-    GNUNET_free (bf);
-    return NULL;
-  }
+    {
+      GNUNET_free(bf);
+      return NULL;
+    }
   bf->bitArraySize = size;
   bf->addressesPerElement = k;
   if (NULL != data)
-    GNUNET_memcpy (bf->bitArray, data, size);
+    GNUNET_memcpy(bf->bitArray, data, size);
   return bf;
 }
 
@@ -673,7 +671,7 @@ GNUNET_CONTAINER_bloomfilter_init (const char *data,
  * @return #GNUNET_SYSERR if the data array is not big enough
  */
 int
-GNUNET_CONTAINER_bloomfilter_get_raw_data (
+GNUNET_CONTAINER_bloomfilter_get_raw_data(
   const struct GNUNET_CONTAINER_BloomFilter *bf,
   char *data,
   size_t size)
@@ -682,7 +680,7 @@ GNUNET_CONTAINER_bloomfilter_get_raw_data (
     return GNUNET_SYSERR;
   if (bf->bitArraySize != size)
     return GNUNET_SYSERR;
-  GNUNET_memcpy (data, bf->bitArray, size);
+  GNUNET_memcpy(data, bf->bitArray, size);
   return GNUNET_OK;
 }
 
@@ -695,15 +693,15 @@ GNUNET_CONTAINER_bloomfilter_get_raw_data (
  * @param bf the filter
  */
 void
-GNUNET_CONTAINER_bloomfilter_free (struct GNUNET_CONTAINER_BloomFilter *bf)
+GNUNET_CONTAINER_bloomfilter_free(struct GNUNET_CONTAINER_BloomFilter *bf)
 {
   if (NULL == bf)
     return;
   if (bf->fh != NULL)
-    GNUNET_DISK_file_close (bf->fh);
-  GNUNET_free_non_null (bf->filename);
-  GNUNET_free (bf->bitArray);
-  GNUNET_free (bf);
+    GNUNET_DISK_file_close(bf->fh);
+  GNUNET_free_non_null(bf->filename);
+  GNUNET_free(bf->bitArray);
+  GNUNET_free(bf);
 }
 
 
@@ -713,14 +711,14 @@ GNUNET_CONTAINER_bloomfilter_free (struct GNUNET_CONTAINER_BloomFilter *bf)
  * @param bf the filter
  */
 void
-GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf)
+GNUNET_CONTAINER_bloomfilter_clear(struct GNUNET_CONTAINER_BloomFilter *bf)
 {
   if (NULL == bf)
     return;
 
-  memset (bf->bitArray, 0, bf->bitArraySize);
+  memset(bf->bitArray, 0, bf->bitArraySize);
   if (bf->filename != NULL)
-    make_empty_file (bf->fh, bf->bitArraySize * 4LL);
+    make_empty_file(bf->fh, bf->bitArraySize * 4LL);
 }
 
 
@@ -732,7 +730,7 @@ GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf)
  * @return #GNUNET_YES if the element is in the filter, #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_bloomfilter_test (
+GNUNET_CONTAINER_bloomfilter_test(
   const struct GNUNET_CONTAINER_BloomFilter *bf,
   const struct GNUNET_HashCode *e)
 {
@@ -741,7 +739,7 @@ GNUNET_CONTAINER_bloomfilter_test (
   if (NULL == bf)
     return GNUNET_YES;
   res = GNUNET_YES;
-  iterateBits (bf, &testBitCallback, &res, e);
+  iterateBits(bf, &testBitCallback, &res, e);
   return res;
 }
 
@@ -753,12 +751,12 @@ GNUNET_CONTAINER_bloomfilter_test (
  * @param e the element
  */
 void
-GNUNET_CONTAINER_bloomfilter_add (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                  const struct GNUNET_HashCode *e)
+GNUNET_CONTAINER_bloomfilter_add(struct GNUNET_CONTAINER_BloomFilter *bf,
+                                 const struct GNUNET_HashCode *e)
 {
   if (NULL == bf)
     return;
-  iterateBits (bf, &incrementBitCallback, bf, e);
+  iterateBits(bf, &incrementBitCallback, bf, e);
 }
 
 
@@ -773,9 +771,9 @@ GNUNET_CONTAINER_bloomfilter_add (struct GNUNET_CONTAINER_BloomFilter *bf,
  * @param size number of bytes in data
  */
 int
-GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                 const char *data,
-                                 size_t size)
+GNUNET_CONTAINER_bloomfilter_or(struct GNUNET_CONTAINER_BloomFilter *bf,
+                                const char *data,
+                                size_t size)
 {
   unsigned int i;
   unsigned int n;
@@ -786,13 +784,13 @@ GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
     return GNUNET_YES;
   if (bf->bitArraySize != size)
     return GNUNET_SYSERR;
-  fc = (unsigned long long *) bf->bitArray;
-  dc = (const unsigned long long *) data;
-  n = size / sizeof (unsigned long long);
+  fc = (unsigned long long *)bf->bitArray;
+  dc = (const unsigned long long *)data;
+  n = size / sizeof(unsigned long long);
 
   for (i = 0; i < n; i++)
     fc[i] |= dc[i];
-  for (i = n * sizeof (unsigned long long); i < size; i++)
+  for (i = n * sizeof(unsigned long long); i < size; i++)
     bf->bitArray[i] |= data[i];
   return GNUNET_OK;
 }
@@ -808,7 +806,7 @@ GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_CONTAINER_bloomfilter_or2 (
+GNUNET_CONTAINER_bloomfilter_or2(
   struct GNUNET_CONTAINER_BloomFilter *bf,
   const struct GNUNET_CONTAINER_BloomFilter *to_or)
 {
@@ -821,18 +819,18 @@ GNUNET_CONTAINER_bloomfilter_or2 (
   if (NULL == bf)
     return GNUNET_OK;
   if (bf->bitArraySize != to_or->bitArraySize)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   size = bf->bitArraySize;
-  fc = (unsigned long long *) bf->bitArray;
-  dc = (const unsigned long long *) to_or->bitArray;
-  n = size / sizeof (unsigned long long);
+  fc = (unsigned long long *)bf->bitArray;
+  dc = (const unsigned long long *)to_or->bitArray;
+  n = size / sizeof(unsigned long long);
 
   for (i = 0; i < n; i++)
     fc[i] |= dc[i];
-  for (i = n * sizeof (unsigned long long); i < size; i++)
+  for (i = n * sizeof(unsigned long long); i < size; i++)
     bf->bitArray[i] |= to_or->bitArray[i];
   return GNUNET_OK;
 }
@@ -845,14 +843,14 @@ GNUNET_CONTAINER_bloomfilter_or2 (
  * @param e the element to remove
  */
 void
-GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                     const struct GNUNET_HashCode *e)
+GNUNET_CONTAINER_bloomfilter_remove(struct GNUNET_CONTAINER_BloomFilter *bf,
+                                    const struct GNUNET_HashCode *e)
 {
   if (NULL == bf)
     return;
   if (NULL == bf->filename)
     return;
-  iterateBits (bf, &decrementBitCallback, bf, e);
+  iterateBits(bf, &decrementBitCallback, bf, e);
 }
 
 /**
@@ -867,27 +865,27 @@ GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
  * @param k the new number of GNUNET_CRYPTO_hash-function to apply per element
  */
 void
-GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                     GNUNET_CONTAINER_HashCodeIterator iterator,
-                                     void *iterator_cls,
-                                     size_t size,
-                                     unsigned int k)
+GNUNET_CONTAINER_bloomfilter_resize(struct GNUNET_CONTAINER_BloomFilter *bf,
+                                    GNUNET_CONTAINER_HashCodeIterator iterator,
+                                    void *iterator_cls,
+                                    size_t size,
+                                    unsigned int k)
 {
   struct GNUNET_HashCode hc;
   unsigned int i;
 
-  GNUNET_free (bf->bitArray);
+  GNUNET_free(bf->bitArray);
   i = 1;
   while (i < size)
     i *= 2;
   size = i; /* make sure it's a power of 2 */
   bf->addressesPerElement = k;
   bf->bitArraySize = size;
-  bf->bitArray = GNUNET_malloc (size);
+  bf->bitArray = GNUNET_malloc(size);
   if (NULL != bf->filename)
-    make_empty_file (bf->fh, bf->bitArraySize * 4LL);
-  while (GNUNET_YES == iterator (iterator_cls, &hc))
-    GNUNET_CONTAINER_bloomfilter_add (bf, &hc);
+    make_empty_file(bf->fh, bf->bitArraySize * 4LL);
+  while (GNUNET_YES == iterator(iterator_cls, &hc))
+    GNUNET_CONTAINER_bloomfilter_add(bf, &hc);
 }
 
 /* end of container_bloomfilter.c */
diff --git a/src/util/container_heap.c b/src/util/container_heap.c
index d5dca20ef..3c8e6ce58 100644
--- a/src/util/container_heap.c
+++ b/src/util/container_heap.c
@@ -1,22 +1,22 @@
 /*
-  This file is part of GNUnet.
-  Copyright (C) 2008, 2009 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/>.
+   This file is part of GNUnet.
+   Copyright (C) 2008, 2009 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 util/container_heap.c
@@ -28,15 +28,14 @@
 #include "platform.h"
 #include "gnunet_container_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-container-heap", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-container-heap", __VA_ARGS__)
 
 #define EXTRA_CHECKS 0
 
 /**
  * Node in the heap.
  */
-struct GNUNET_CONTAINER_HeapNode
-{
+struct GNUNET_CONTAINER_HeapNode {
   /**
    * Heap this node belongs to.
    */
@@ -72,15 +71,12 @@ struct GNUNET_CONTAINER_HeapNode
    * (excluding this node itself).
    */
   unsigned int tree_size;
-
 };
 
 /**
  * Handle to a node in a heap.
  */
-struct GNUNET_CONTAINER_Heap
-{
-
+struct GNUNET_CONTAINER_Heap {
   /**
    * Root of the heap.
    */
@@ -100,7 +96,6 @@ struct GNUNET_CONTAINER_Heap
    * How is the heap sorted?
    */
   enum GNUNET_CONTAINER_HeapOrder order;
-
 };
 
 
@@ -111,17 +106,17 @@ struct GNUNET_CONTAINER_Heap
  * @param node subtree to check
  */
 static void
-check (const struct GNUNET_CONTAINER_HeapNode *node)
+check(const struct GNUNET_CONTAINER_HeapNode *node)
 {
   if (NULL == node)
     return;
-  GNUNET_assert (node->tree_size ==
-                 ((node->left_child ==
-                   NULL) ? 0 : 1 + node->left_child->tree_size) +
-                 ((node->right_child ==
-                   NULL) ? 0 : 1 + node->right_child->tree_size));
-  check (node->left_child);
-  check (node->right_child);
+  GNUNET_assert(node->tree_size ==
+                ((node->left_child ==
+                  NULL) ? 0 : 1 + node->left_child->tree_size) +
+                ((node->right_child ==
+                  NULL) ? 0 : 1 + node->right_child->tree_size));
+  check(node->left_child);
+  check(node->right_child);
 }
 
 
@@ -138,11 +133,11 @@ check (const struct GNUNET_CONTAINER_HeapNode *node)
  * @return handle to the heap
  */
 struct GNUNET_CONTAINER_Heap *
-GNUNET_CONTAINER_heap_create (enum GNUNET_CONTAINER_HeapOrder order)
+GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
 {
   struct GNUNET_CONTAINER_Heap *heap;
 
-  heap = GNUNET_new (struct GNUNET_CONTAINER_Heap);
+  heap = GNUNET_new(struct GNUNET_CONTAINER_Heap);
   heap->order = order;
   return heap;
 }
@@ -155,10 +150,10 @@ GNUNET_CONTAINER_heap_create (enum GNUNET_CONTAINER_HeapOrder order)
  * @param heap heap to destroy
  */
 void
-GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
+GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
 {
-  GNUNET_break (heap->size == 0);
-  GNUNET_free (heap);
+  GNUNET_break(heap->size == 0);
+  GNUNET_free(heap);
 }
 
 
@@ -169,7 +164,7 @@ GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
  * @return Element at the root, or NULL if heap is empty.
  */
 void *
-GNUNET_CONTAINER_heap_peek (const struct GNUNET_CONTAINER_Heap *heap)
+GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
 {
   if (heap->root == NULL)
     return NULL;
@@ -187,9 +182,9 @@ GNUNET_CONTAINER_heap_peek (const struct GNUNET_CONTAINER_Heap *heap)
  *         #GNUNET_NO  if the heap is empty.
  */
 int
-GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap *heap,
-                             void **element,
-                             GNUNET_CONTAINER_HeapCostType *cost)
+GNUNET_CONTAINER_heap_peek2(const struct GNUNET_CONTAINER_Heap *heap,
+                            void **element,
+                            GNUNET_CONTAINER_HeapCostType *cost)
 {
   if (NULL == heap->root)
     return GNUNET_NO;
@@ -208,7 +203,7 @@ GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap *heap,
  * @return number of elements stored
  */
 unsigned int
-GNUNET_CONTAINER_heap_get_size (const struct GNUNET_CONTAINER_Heap *heap)
+GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap)
 {
   return heap->size;
 }
@@ -221,8 +216,8 @@ GNUNET_CONTAINER_heap_get_size (const struct GNUNET_CONTAINER_Heap *heap)
  * @return cost of the node
  */
 GNUNET_CONTAINER_HeapCostType
-GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode
-                                     *node)
+GNUNET_CONTAINER_heap_node_get_cost(const struct GNUNET_CONTAINER_HeapNode
+                                    *node)
 {
   return node->cost;
 }
@@ -238,19 +233,19 @@ GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode
  * @return GNUNET_YES to continue to iterate
  */
 static int
-node_iterator (const struct GNUNET_CONTAINER_Heap *heap,
-               struct GNUNET_CONTAINER_HeapNode *node,
-               GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
+node_iterator(const struct GNUNET_CONTAINER_Heap *heap,
+              struct GNUNET_CONTAINER_HeapNode *node,
+              GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
 {
   if (node == NULL)
     return GNUNET_YES;
   if (GNUNET_YES !=
-      node_iterator (heap, node->left_child, iterator, iterator_cls))
+      node_iterator(heap, node->left_child, iterator, iterator_cls))
     return GNUNET_NO;
   if (GNUNET_YES !=
-      node_iterator (heap, node->right_child, iterator, iterator_cls))
+      node_iterator(heap, node->right_child, iterator, iterator_cls))
     return GNUNET_NO;
-  return iterator (iterator_cls, node, node->element, node->cost);
+  return iterator(iterator_cls, node, node->element, node->cost);
 }
 
 
@@ -262,11 +257,11 @@ node_iterator (const struct GNUNET_CONTAINER_Heap *heap,
  * @param iterator_cls closure for iterator
  */
 void
-GNUNET_CONTAINER_heap_iterate (const struct GNUNET_CONTAINER_Heap *heap,
-                               GNUNET_CONTAINER_HeapIterator iterator,
-                               void *iterator_cls)
+GNUNET_CONTAINER_heap_iterate(const struct GNUNET_CONTAINER_Heap *heap,
+                              GNUNET_CONTAINER_HeapIterator iterator,
+                              void *iterator_cls)
 {
-  (void) node_iterator (heap, heap->root, iterator, iterator_cls);
+  (void)node_iterator(heap, heap->root, iterator, iterator_cls);
 }
 
 
@@ -282,7 +277,7 @@ GNUNET_CONTAINER_heap_iterate (const struct GNUNET_CONTAINER_Heap *heap,
  *         NULL if the tree is empty.
  */
 void *
-GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
+GNUNET_CONTAINER_heap_walk_get_next(struct GNUNET_CONTAINER_Heap *heap)
 {
   struct GNUNET_CONTAINER_HeapNode *pos;
   void *element;
@@ -294,9 +289,9 @@ GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
     pos = heap->root;
   element = pos->element;
   heap->walk_pos =
-      (0 ==
-       GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                 2)) ? pos->right_child : pos->left_child;
+    (0 ==
+     GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                              2)) ? pos->right_child : pos->left_child;
   return element;
 }
 
@@ -310,55 +305,55 @@ GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
  * @param node node to insert (which may be a subtree itself)
  */
 static void
-insert_node (struct GNUNET_CONTAINER_Heap *heap,
-             struct GNUNET_CONTAINER_HeapNode *pos,
-             struct GNUNET_CONTAINER_HeapNode *node)
+insert_node(struct GNUNET_CONTAINER_Heap *heap,
+            struct GNUNET_CONTAINER_HeapNode *pos,
+            struct GNUNET_CONTAINER_HeapNode *node)
 {
   struct GNUNET_CONTAINER_HeapNode *parent;
 
-  GNUNET_assert (node->parent == NULL);
+  GNUNET_assert(node->parent == NULL);
   while ((heap->order == GNUNET_CONTAINER_HEAP_ORDER_MAX) ? (pos->cost >=
                                                              node->cost)
          : (pos->cost <= node->cost))
-  {
-    /* node is descendent of pos */
-    pos->tree_size += (1 + node->tree_size);
-    if (pos->left_child == NULL)
-    {
-      pos->left_child = node;
-      node->parent = pos;
-      return;
-    }
-    if (pos->right_child == NULL)
     {
-      pos->right_child = node;
-      node->parent = pos;
-      return;
+      /* node is descendent of pos */
+      pos->tree_size += (1 + node->tree_size);
+      if (pos->left_child == NULL)
+        {
+          pos->left_child = node;
+          node->parent = pos;
+          return;
+        }
+      if (pos->right_child == NULL)
+        {
+          pos->right_child = node;
+          node->parent = pos;
+          return;
+        }
+      /* keep it balanced by descending into smaller subtree */
+      if (pos->left_child->tree_size < pos->right_child->tree_size)
+        pos = pos->left_child;
+      else
+        pos = pos->right_child;
     }
-    /* keep it balanced by descending into smaller subtree */
-    if (pos->left_child->tree_size < pos->right_child->tree_size)
-      pos = pos->left_child;
-    else
-      pos = pos->right_child;
-  }
   /* make 'node' parent of 'pos' */
   parent = pos->parent;
   pos->parent = NULL;
   node->parent = parent;
   if (NULL == parent)
-  {
-    heap->root = node;
-  }
+    {
+      heap->root = node;
+    }
   else
-  {
-    if (parent->left_child == pos)
-      parent->left_child = node;
-    else
-      parent->right_child = node;
-  }
+    {
+      if (parent->left_child == pos)
+        parent->left_child = node;
+      else
+        parent->right_child = node;
+    }
   /* insert 'pos' below 'node' */
-  insert_node (heap, node, pos);
-  CHECK (pos);
+  insert_node(heap, node, pos);
+  CHECK(pos);
 }
 
 
@@ -371,12 +366,12 @@ insert_node (struct GNUNET_CONTAINER_Heap *heap,
  * @return node for the new element
  */
 struct GNUNET_CONTAINER_HeapNode *
-GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap, void *element,
-                              GNUNET_CONTAINER_HeapCostType cost)
+GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element,
+                             GNUNET_CONTAINER_HeapCostType cost)
 {
   struct GNUNET_CONTAINER_HeapNode *node;
 
-  node = GNUNET_new (struct GNUNET_CONTAINER_HeapNode);
+  node = GNUNET_new(struct GNUNET_CONTAINER_HeapNode);
   node->heap = heap;
   node->element = element;
   node->cost = cost;
@@ -384,9 +379,9 @@ GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap, void *element,
   if (NULL == heap->root)
     heap->root = node;
   else
-    insert_node (heap, heap->root, node);
-  GNUNET_assert (heap->size == heap->root->tree_size + 1);
-  CHECK (heap->root);
+    insert_node(heap, heap->root, node);
+  GNUNET_assert(heap->size == heap->root->tree_size + 1);
+  CHECK(heap->root);
   return node;
 }
 
@@ -398,7 +393,7 @@ GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap, void *element,
  * @return element data stored at the root node, NULL if heap is empty
  */
 void *
-GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
+GNUNET_CONTAINER_heap_remove_root(struct GNUNET_CONTAINER_Heap *heap)
 {
   void *ret;
   struct GNUNET_CONTAINER_HeapNode *root;
@@ -408,30 +403,30 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
   heap->size--;
   ret = root->element;
   if (root->left_child == NULL)
-  {
-    heap->root = root->right_child;
-    if (root->right_child != NULL)
-      root->right_child->parent = NULL;
-  }
+    {
+      heap->root = root->right_child;
+      if (root->right_child != NULL)
+        root->right_child->parent = NULL;
+    }
   else if (root->right_child == NULL)
-  {
-    heap->root = root->left_child;
-    root->left_child->parent = NULL;
-  }
+    {
+      heap->root = root->left_child;
+      root->left_child->parent = NULL;
+    }
   else
-  {
-    root->left_child->parent = NULL;
-    root->right_child->parent = NULL;
-    heap->root = root->left_child;
-    insert_node (heap, heap->root, root->right_child);
-  }
+    {
+      root->left_child->parent = NULL;
+      root->right_child->parent = NULL;
+      heap->root = root->left_child;
+      insert_node(heap, heap->root, root->right_child);
+    }
   if (heap->walk_pos == root)
     heap->walk_pos = heap->root;
-  GNUNET_free (root);
+  GNUNET_free(root);
 #if EXTRA_CHECKS
-  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
-                 (heap->size == heap->root->tree_size + 1));
-  CHECK (heap->root);
+  GNUNET_assert(((heap->size == 0) && (heap->root == NULL)) ||
+                (heap->size == heap->root->tree_size + 1));
+  CHECK(heap->root);
 #endif
   return ret;
 }
@@ -444,7 +439,7 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
  * 'size' field of the tree.
  */
 static void
-remove_node (struct GNUNET_CONTAINER_HeapNode *node)
+remove_node(struct GNUNET_CONTAINER_HeapNode *node)
 {
   struct GNUNET_CONTAINER_HeapNode *ancestor;
   struct GNUNET_CONTAINER_Heap *heap = node->heap;
@@ -462,48 +457,48 @@ remove_node (struct GNUNET_CONTAINER_HeapNode *node)
 
   /* unlink 'node' itself and insert children in its place */
   if (node->parent == NULL)
-  {
-    if (node->left_child != NULL)
     {
-      heap->root = node->left_child;
-      node->left_child->parent = NULL;
-      if (node->right_child != NULL)
-      {
-        node->right_child->parent = NULL;
-        insert_node (heap, heap->root, node->right_child);
-      }
-    }
-    else
-    {
-      heap->root = node->right_child;
-      if (node->right_child != NULL)
-        node->right_child->parent = NULL;
+      if (node->left_child != NULL)
+        {
+          heap->root = node->left_child;
+          node->left_child->parent = NULL;
+          if (node->right_child != NULL)
+            {
+              node->right_child->parent = NULL;
+              insert_node(heap, heap->root, node->right_child);
+            }
+        }
+      else
+        {
+          heap->root = node->right_child;
+          if (node->right_child != NULL)
+            node->right_child->parent = NULL;
+        }
     }
-  }
   else
-  {
-    if (node->parent->left_child == node)
-      node->parent->left_child = NULL;
-    else
-      node->parent->right_child = NULL;
-    if (node->left_child != NULL)
     {
-      node->left_child->parent = NULL;
-      node->parent->tree_size -= (1 + node->left_child->tree_size);
-      insert_node (heap, node->parent, node->left_child);
-    }
-    if (node->right_child != NULL)
-    {
-      node->right_child->parent = NULL;
-      node->parent->tree_size -= (1 + node->right_child->tree_size);
-      insert_node (heap, node->parent, node->right_child);
+      if (node->parent->left_child == node)
+        node->parent->left_child = NULL;
+      else
+        node->parent->right_child = NULL;
+      if (node->left_child != NULL)
+        {
+          node->left_child->parent = NULL;
+          node->parent->tree_size -= (1 + node->left_child->tree_size);
+          insert_node(heap, node->parent, node->left_child);
+        }
+      if (node->right_child != NULL)
+        {
+          node->right_child->parent = NULL;
+          node->parent->tree_size -= (1 + node->right_child->tree_size);
+          insert_node(heap, node->parent, node->right_child);
+        }
     }
-  }
   node->parent = NULL;
   node->left_child = NULL;
   node->right_child = NULL;
-  GNUNET_assert (node->tree_size == 0);
-  CHECK (heap->root);
+  GNUNET_assert(node->tree_size == 0);
+  CHECK(heap->root);
 }
 
 
@@ -514,25 +509,25 @@ remove_node (struct GNUNET_CONTAINER_HeapNode *node)
  * @return element data stored at the node
  */
 void *
-GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node)
+GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
 {
   void *ret;
   struct GNUNET_CONTAINER_Heap *heap;
 
   heap = node->heap;
-  CHECK (heap->root);
+  CHECK(heap->root);
   if (heap->walk_pos == node)
-    (void) GNUNET_CONTAINER_heap_walk_get_next (heap);
-  remove_node (node);
+    (void)GNUNET_CONTAINER_heap_walk_get_next(heap);
+  remove_node(node);
   heap->size--;
   ret = node->element;
   if (heap->walk_pos == node)
     heap->walk_pos = NULL;
-  GNUNET_free (node);
+  GNUNET_free(node);
 #if EXTRA_CHECKS
-  CHECK (heap->root);
-  GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
-                 (heap->size == heap->root->tree_size + 1));
+  CHECK(heap->root);
+  GNUNET_assert(((heap->size == 0) && (heap->root == NULL)) ||
+                (heap->size == heap->root->tree_size + 1));
 #endif
   return ret;
 }
@@ -545,19 +540,19 @@ GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node)
  * @param new_cost new cost for the node
  */
 void
-GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node,
-                                   GNUNET_CONTAINER_HeapCostType new_cost)
+GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node,
+                                  GNUNET_CONTAINER_HeapCostType new_cost)
 {
   struct GNUNET_CONTAINER_Heap *heap = node->heap;
 
-  remove_node (node);
+  remove_node(node);
   node->cost = new_cost;
   if (NULL == heap->root)
     heap->root = node;
   else
-    insert_node (heap,
-                 heap->root,
-                 node);
+    insert_node(heap,
+                heap->root,
+                node);
 }
 
 
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
index 4989b876a..e134ef869 100644
--- a/src/util/container_meta_data.c
+++ b/src/util/container_meta_data.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 util/container_meta_data.c
@@ -31,7 +31,7 @@
 #endif
 #include <zlib.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-container-meta-data", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-container-meta-data", __VA_ARGS__)
 
 
 
@@ -51,10 +51,10 @@
  *         #GNUNET_NO if compression did not help
  */
 int
-GNUNET_try_compression (const char *data,
-                        size_t old_size,
-                        char **result,
-                        size_t *new_size)
+GNUNET_try_compression(const char *data,
+                       size_t old_size,
+                       char **result,
+                       size_t *new_size)
 {
   char *tmp;
   uLongf dlen;
@@ -62,27 +62,27 @@ GNUNET_try_compression (const char *data,
   *result = NULL;
   *new_size = 0;
 #ifdef compressBound
-  dlen = compressBound (old_size);
+  dlen = compressBound(old_size);
 #else
   dlen = old_size + (old_size / 100) + 20;
   /* documentation says 100.1% oldSize + 12 bytes, but we
    * should be able to overshoot by more to be safe */
 #endif
-  tmp = GNUNET_malloc (dlen);
+  tmp = GNUNET_malloc(dlen);
   if (Z_OK ==
-      compress2 ((Bytef *) tmp,
-                 &dlen,
-                 (const Bytef *) data,
-                 old_size, 9))
-  {
-    if (dlen < old_size)
+      compress2((Bytef *)tmp,
+                &dlen,
+                (const Bytef *)data,
+                old_size, 9))
     {
-      *result = tmp;
-      *new_size = dlen;
-      return GNUNET_YES;
+      if (dlen < old_size)
+        {
+          *result = tmp;
+          *new_size = dlen;
+          return GNUNET_YES;
+        }
     }
-  }
-  GNUNET_free (tmp);
+  GNUNET_free(tmp);
   return GNUNET_NO;
 }
 
@@ -98,22 +98,22 @@ GNUNET_try_compression (const char *data,
  * @return NULL on error, buffer of @a output_size decompressed bytes otherwise
  */
 char *
-GNUNET_decompress (const char *input,
-                   size_t input_size,
-                   size_t output_size)
+GNUNET_decompress(const char *input,
+                  size_t input_size,
+                  size_t output_size)
 {
   char *output;
   uLongf olen;
 
   olen = output_size;
-  output = GNUNET_malloc (olen);
+  output = GNUNET_malloc(olen);
   if (Z_OK ==
-      uncompress ((Bytef *) output,
-                  &olen,
-                  (const Bytef *) input,
-                  input_size))
+      uncompress((Bytef *)output,
+                 &olen,
+                 (const Bytef *)input,
+                 input_size))
     return output;
-  GNUNET_free (output);
+  GNUNET_free(output);
   return NULL;
 }
 
@@ -121,8 +121,7 @@ GNUNET_decompress (const char *input,
 /**
  * Meta data item.
  */
-struct MetaItem
-{
+struct MetaItem {
   /**
    * This is a doubly linked list.
    */
@@ -162,14 +161,12 @@ struct MetaItem
    * Format of the meta data.
    */
   enum EXTRACTOR_MetaFormat format;
-
 };
 
 /**
  * Meta data to associate with a file, directory or namespace.
  */
-struct GNUNET_CONTAINER_MetaData
-{
+struct GNUNET_CONTAINER_MetaData {
   /**
    * Head of linked list of the meta data items.
    */
@@ -195,7 +192,6 @@ struct GNUNET_CONTAINER_MetaData
    * Number of items in the linked list.
    */
   unsigned int item_count;
-
 };
 
 
@@ -205,9 +201,9 @@ struct GNUNET_CONTAINER_MetaData
  * @return empty meta-data container
  */
 struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_create ()
+GNUNET_CONTAINER_meta_data_create()
 {
-  return GNUNET_new (struct GNUNET_CONTAINER_MetaData);
+  return GNUNET_new(struct GNUNET_CONTAINER_MetaData);
 }
 
 
@@ -217,12 +213,12 @@ GNUNET_CONTAINER_meta_data_create ()
  * @param mi item to free
  */
 static void
-meta_item_free (struct MetaItem *mi)
+meta_item_free(struct MetaItem *mi)
 {
-  GNUNET_free_non_null (mi->plugin_name);
-  GNUNET_free_non_null (mi->mime_type);
-  GNUNET_free_non_null (mi->data);
-  GNUNET_free (mi);
+  GNUNET_free_non_null(mi->plugin_name);
+  GNUNET_free_non_null(mi->mime_type);
+  GNUNET_free_non_null(mi->data);
+  GNUNET_free(mi);
 }
 
 
@@ -233,11 +229,11 @@ meta_item_free (struct MetaItem *mi)
  * @param md meta data that changed
  */
 static void
-invalidate_sbuf (struct GNUNET_CONTAINER_MetaData *md)
+invalidate_sbuf(struct GNUNET_CONTAINER_MetaData *md)
 {
   if (NULL == md->sbuf)
     return;
-  GNUNET_free (md->sbuf);
+  GNUNET_free(md->sbuf);
   md->sbuf = NULL;
   md->sbuf_size = 0;
 }
@@ -249,19 +245,19 @@ invalidate_sbuf (struct GNUNET_CONTAINER_MetaData *md)
  * @param md what to free
  */
 void
-GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
 {
   struct MetaItem *pos;
 
   if (NULL == md)
     return;
   while (NULL != (pos = md->items_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
-    meta_item_free (pos);
-  }
-  GNUNET_free_non_null (md->sbuf);
-  GNUNET_free (md);
+    {
+      GNUNET_CONTAINER_DLL_remove(md->items_head, md->items_tail, pos);
+      meta_item_free(pos);
+    }
+  GNUNET_free_non_null(md->sbuf);
+  GNUNET_free(md);
 }
 
 
@@ -271,19 +267,19 @@ GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
  * @param md metadata to manipulate
  */
 void
-GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_CONTAINER_meta_data_clear(struct GNUNET_CONTAINER_MetaData *md)
 {
   struct MetaItem *mi;
 
   if (NULL == md)
     return;
   while (NULL != (mi = md->items_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, mi);
-    meta_item_free (mi);
-  }
-  GNUNET_free_non_null (md->sbuf);
-  memset (md, 0, sizeof (struct GNUNET_CONTAINER_MetaData));
+    {
+      GNUNET_CONTAINER_DLL_remove(md->items_head, md->items_tail, mi);
+      meta_item_free(mi);
+    }
+  GNUNET_free_non_null(md->sbuf);
+  memset(md, 0, sizeof(struct GNUNET_CONTAINER_MetaData));
 }
 
 
@@ -298,10 +294,10 @@ GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
  * @return #GNUNET_YES if they are equal
  */
 int
-GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
-                                       *md1,
-                                       const struct GNUNET_CONTAINER_MetaData
-                                       *md2)
+GNUNET_CONTAINER_meta_data_test_equal(const struct GNUNET_CONTAINER_MetaData
+                                      *md1,
+                                      const struct GNUNET_CONTAINER_MetaData
+                                      *md2)
 {
   struct MetaItem *i;
   struct MetaItem *j;
@@ -312,23 +308,23 @@ GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
   if (md1->item_count != md2->item_count)
     return GNUNET_NO;
   for (i = md1->items_head; NULL != i; i = i->next)
-  {
-    found = GNUNET_NO;
-    for (j = md2->items_head; NULL != j; j = j->next)
     {
-      if ((i->type == j->type) && (i->format == j->format) &&
-          (i->data_size == j->data_size) &&
-          (0 == memcmp (i->data, j->data, i->data_size)))
-      {
-        found = GNUNET_YES;
-        break;
-      }
-      if (j->data_size < i->data_size)
-        break; /* elements are sorted by (decreasing) size... */
+      found = GNUNET_NO;
+      for (j = md2->items_head; NULL != j; j = j->next)
+        {
+          if ((i->type == j->type) && (i->format == j->format) &&
+              (i->data_size == j->data_size) &&
+              (0 == memcmp(i->data, j->data, i->data_size)))
+            {
+              found = GNUNET_YES;
+              break;
+            }
+          if (j->data_size < i->data_size)
+            break; /* elements are sorted by (decreasing) size... */
+        }
+      if (GNUNET_NO == found)
+        return GNUNET_NO;
     }
-    if (GNUNET_NO == found)
-      return GNUNET_NO;
-  }
   return GNUNET_YES;
 }
 
@@ -352,12 +348,12 @@ GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
  *         data_mime_type and plugin_name are not considered for "exists" checks
  */
 int
-GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
-                                   const char *plugin_name,
-                                   enum EXTRACTOR_MetaType type,
-                                   enum EXTRACTOR_MetaFormat format,
-                                   const char *data_mime_type, const char *data,
-                                   size_t data_size)
+GNUNET_CONTAINER_meta_data_insert(struct GNUNET_CONTAINER_MetaData *md,
+                                  const char *plugin_name,
+                                  enum EXTRACTOR_MetaType type,
+                                  enum EXTRACTOR_MetaFormat format,
+                                  const char *data_mime_type, const char *data,
+                                  size_t data_size)
 {
   struct MetaItem *pos;
   struct MetaItem *mi;
@@ -365,61 +361,61 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
 
   if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
       (EXTRACTOR_METAFORMAT_C_STRING == format))
-    GNUNET_break ('\0' == data[data_size - 1]);
+    GNUNET_break('\0' == data[data_size - 1]);
 
   for (pos = md->items_head; NULL != pos; pos = pos->next)
-  {
-    if (pos->data_size < data_size)
-      break; /* elements are sorted by size in the list */
-    if ((pos->type == type) && (pos->data_size == data_size) &&
-        (0 == memcmp (pos->data, data, data_size)))
     {
-      if ((NULL == pos->mime_type) && (NULL != data_mime_type))
-      {
-        pos->mime_type = GNUNET_strdup (data_mime_type);
-        invalidate_sbuf (md);
-      }
-      if ((EXTRACTOR_METAFORMAT_C_STRING == pos->format) &&
-          (EXTRACTOR_METAFORMAT_UTF8 == format))
-      {
-        pos->format = EXTRACTOR_METAFORMAT_UTF8;
-        invalidate_sbuf (md);
-      }
-      return GNUNET_SYSERR;
+      if (pos->data_size < data_size)
+        break; /* elements are sorted by size in the list */
+      if ((pos->type == type) && (pos->data_size == data_size) &&
+          (0 == memcmp(pos->data, data, data_size)))
+        {
+          if ((NULL == pos->mime_type) && (NULL != data_mime_type))
+            {
+              pos->mime_type = GNUNET_strdup(data_mime_type);
+              invalidate_sbuf(md);
+            }
+          if ((EXTRACTOR_METAFORMAT_C_STRING == pos->format) &&
+              (EXTRACTOR_METAFORMAT_UTF8 == format))
+            {
+              pos->format = EXTRACTOR_METAFORMAT_UTF8;
+              invalidate_sbuf(md);
+            }
+          return GNUNET_SYSERR;
+        }
     }
-  }
   md->item_count++;
-  mi = GNUNET_new (struct MetaItem);
+  mi = GNUNET_new(struct MetaItem);
   mi->type = type;
   mi->format = format;
   mi->data_size = data_size;
   if (NULL == pos)
-    GNUNET_CONTAINER_DLL_insert_tail (md->items_head,
-                                      md->items_tail,
-                                      mi);
+    GNUNET_CONTAINER_DLL_insert_tail(md->items_head,
+                                     md->items_tail,
+                                     mi);
   else
-    GNUNET_CONTAINER_DLL_insert_after (md->items_head,
-                                       md->items_tail,
-                                       pos->prev,
-                                       mi);
+    GNUNET_CONTAINER_DLL_insert_after(md->items_head,
+                                      md->items_tail,
+                                      pos->prev,
+                                      mi);
   mi->mime_type =
-      (NULL == data_mime_type) ? NULL : GNUNET_strdup (data_mime_type);
-  mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup (plugin_name);
-  mi->data = GNUNET_malloc (data_size);
-  GNUNET_memcpy (mi->data, data, data_size);
+    (NULL == data_mime_type) ? NULL : GNUNET_strdup(data_mime_type);
+  mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup(plugin_name);
+  mi->data = GNUNET_malloc(data_size);
+  GNUNET_memcpy(mi->data, data, data_size);
   /* change all dir separators to POSIX style ('/') */
-  if ( (EXTRACTOR_METATYPE_FILENAME == type) ||
-       (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type) )
-  {
-    p = mi->data;
-    while (('\0' != *p) && (p < mi->data + data_size))
+  if ((EXTRACTOR_METATYPE_FILENAME == type) ||
+      (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type))
     {
-      if ('\\' == *p)
-        *p = '/';
-      p++;
+      p = mi->data;
+      while (('\0' != *p) && (p < mi->data + data_size))
+        {
+          if ('\\' == *p)
+            *p = '/';
+          p++;
+        }
     }
-  }
-  invalidate_sbuf (md);
+  invalidate_sbuf(md);
   return GNUNET_OK;
 }
 
@@ -441,14 +437,14 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
  * @return 0 (to continue)
  */
 static int
-merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
-              enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
-              const char *data, size_t data_size)
+merge_helper(void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
+             enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
+             const char *data, size_t data_size)
 {
   struct GNUNET_CONTAINER_MetaData *md = cls;
 
-  (void) GNUNET_CONTAINER_meta_data_insert (md, plugin_name, type, format,
-                                            data_mime_type, data, data_size);
+  (void)GNUNET_CONTAINER_meta_data_insert(md, plugin_name, type, format,
+                                          data_mime_type, data, data_size);
   return 0;
 }
 
@@ -461,10 +457,10 @@ merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
  * @param in metadata to merge
  */
 void
-GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md,
-                                  const struct GNUNET_CONTAINER_MetaData *in)
+GNUNET_CONTAINER_meta_data_merge(struct GNUNET_CONTAINER_MetaData *md,
+                                 const struct GNUNET_CONTAINER_MetaData *in)
 {
-  GNUNET_CONTAINER_meta_data_iterate (in, &merge_helper, md);
+  GNUNET_CONTAINER_meta_data_iterate(in, &merge_helper, md);
 }
 
 
@@ -479,28 +475,28 @@ GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the item does not exist in md
  */
 int
-GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
-                                   enum EXTRACTOR_MetaType type,
-                                   const char *data, size_t data_size)
+GNUNET_CONTAINER_meta_data_delete(struct GNUNET_CONTAINER_MetaData *md,
+                                  enum EXTRACTOR_MetaType type,
+                                  const char *data, size_t data_size)
 {
   struct MetaItem *pos;
 
   for (pos = md->items_head; NULL != pos; pos = pos->next)
-  {
-    if (pos->data_size < data_size)
-      break; /* items are sorted by (decreasing) size */
-    if ((pos->type == type) &&
-        ((NULL == data) ||
-         ((pos->data_size == data_size) &&
-          (0 == memcmp (pos->data, data, data_size)))))
     {
-      GNUNET_CONTAINER_DLL_remove (md->items_head, md->items_tail, pos);
-      meta_item_free (pos);
-      md->item_count--;
-      invalidate_sbuf (md);
-      return GNUNET_OK;
+      if (pos->data_size < data_size)
+        break; /* items are sorted by (decreasing) size */
+      if ((pos->type == type) &&
+          ((NULL == data) ||
+           ((pos->data_size == data_size) &&
+            (0 == memcmp(pos->data, data, data_size)))))
+        {
+          GNUNET_CONTAINER_DLL_remove(md->items_head, md->items_tail, pos);
+          meta_item_free(pos);
+          md->item_count--;
+          invalidate_sbuf(md);
+          return GNUNET_OK;
+        }
     }
-  }
   return GNUNET_SYSERR;
 }
 
@@ -512,21 +508,21 @@ GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
  * @param md metadata to modify
  */
 void
-GNUNET_CONTAINER_meta_data_add_publication_date (struct
-                                                 GNUNET_CONTAINER_MetaData *md)
+GNUNET_CONTAINER_meta_data_add_publication_date(struct
+                                                GNUNET_CONTAINER_MetaData *md)
 {
   const char *dat;
   struct GNUNET_TIME_Absolute t;
 
-  t = GNUNET_TIME_absolute_get ();
-  GNUNET_CONTAINER_meta_data_delete (md,
-                                     EXTRACTOR_METATYPE_PUBLICATION_DATE,
-                                     NULL, 0);
-  dat = GNUNET_STRINGS_absolute_time_to_string (t);
-  GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
-                                     EXTRACTOR_METATYPE_PUBLICATION_DATE,
-                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                     dat, strlen (dat) + 1);
+  t = GNUNET_TIME_absolute_get();
+  GNUNET_CONTAINER_meta_data_delete(md,
+                                    EXTRACTOR_METATYPE_PUBLICATION_DATE,
+                                    NULL, 0);
+  dat = GNUNET_STRINGS_absolute_time_to_string(t);
+  GNUNET_CONTAINER_meta_data_insert(md, "<gnunet>",
+                                    EXTRACTOR_METATYPE_PUBLICATION_DATE,
+                                    EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                    dat, strlen(dat) + 1);
 }
 
 
@@ -539,9 +535,9 @@ GNUNET_CONTAINER_meta_data_add_publication_date (struct
  * @return number of entries
  */
 int
-GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
-                                    EXTRACTOR_MetaDataProcessor iter,
-                                    void *iter_cls)
+GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md,
+                                   EXTRACTOR_MetaDataProcessor iter,
+                                   void *iter_cls)
 {
   struct MetaItem *pos;
 
@@ -551,8 +547,8 @@ GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
     return md->item_count;
   for (pos = md->items_head; NULL != pos; pos = pos->next)
     if (0 !=
-        iter (iter_cls, pos->plugin_name, pos->type, pos->format,
-              pos->mime_type, pos->data, pos->data_size))
+        iter(iter_cls, pos->plugin_name, pos->type, pos->format,
+             pos->mime_type, pos->data, pos->data_size))
       return md->item_count;
   return md->item_count;
 }
@@ -569,8 +565,8 @@ GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
  * @return NULL if no entry was found
  */
 char *
-GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData *md,
-                                        enum EXTRACTOR_MetaType type)
+GNUNET_CONTAINER_meta_data_get_by_type(const struct GNUNET_CONTAINER_MetaData *md,
+                                       enum EXTRACTOR_MetaType type)
 {
   struct MetaItem *pos;
 
@@ -580,7 +576,7 @@ GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData *
     if ((type == pos->type) &&
         ((pos->format == EXTRACTOR_METAFORMAT_UTF8) ||
          (pos->format == EXTRACTOR_METAFORMAT_C_STRING)))
-      return GNUNET_strdup (pos->data);
+      return GNUNET_strdup(pos->data);
   return NULL;
 }
 
@@ -597,9 +593,9 @@ GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData *
  *  otherwise client is responsible for freeing the value!
  */
 char *
-GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
-                                               GNUNET_CONTAINER_MetaData *md,
-                                               ...)
+GNUNET_CONTAINER_meta_data_get_first_by_types(const struct
+                                              GNUNET_CONTAINER_MetaData *md,
+                                              ...)
 {
   char *ret;
   va_list args;
@@ -608,16 +604,16 @@ GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
   if (NULL == md)
     return NULL;
   ret = NULL;
-  va_start (args, md);
+  va_start(args, md);
   while (1)
-  {
-    type = va_arg (args, int);
-    if (-1 == type)
-      break;
-    if (NULL != (ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type)))
-      break;
-  }
-  va_end (args);
+    {
+      type = va_arg(args, int);
+      if (-1 == type)
+        break;
+      if (NULL != (ret = GNUNET_CONTAINER_meta_data_get_by_type(md, type)))
+        break;
+    }
+  va_end(args);
   return ret;
 }
 
@@ -631,8 +627,8 @@ GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
  * @return number of bytes in thumbnail, 0 if not available
  */
 size_t
-GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData
-                                          * md, unsigned char **thumb)
+GNUNET_CONTAINER_meta_data_get_thumbnail(const struct GNUNET_CONTAINER_MetaData
+                                         * md, unsigned char **thumb)
 {
   struct MetaItem *pos;
   struct MetaItem *match;
@@ -641,22 +637,22 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData
     return 0;
   match = NULL;
   for (pos = md->items_head; NULL != pos; pos = pos->next)
-  {
-    if ((NULL != pos->mime_type) &&
-        (0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
-        (EXTRACTOR_METAFORMAT_BINARY == pos->format))
     {
-      if (NULL == match)
-        match = pos;
-      else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
-               (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
-        match = pos;
+      if ((NULL != pos->mime_type) &&
+          (0 == strncasecmp("image/", pos->mime_type, strlen("image/"))) &&
+          (EXTRACTOR_METAFORMAT_BINARY == pos->format))
+        {
+          if (NULL == match)
+            match = pos;
+          else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
+                   (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
+            match = pos;
+        }
     }
-  }
   if ((NULL == match) || (0 == match->data_size))
     return 0;
-  *thumb = GNUNET_malloc (match->data_size);
-  GNUNET_memcpy (*thumb, match->data, match->data_size);
+  *thumb = GNUNET_malloc(match->data_size);
+  GNUNET_memcpy(*thumb, match->data, match->data_size);
   return match->data_size;
 }
 
@@ -668,19 +664,19 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData
  * @return duplicate meta-data container
  */
 struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
-                                      *md)
+GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData
+                                     *md)
 {
   struct GNUNET_CONTAINER_MetaData *ret;
   struct MetaItem *pos;
 
   if (NULL == md)
     return NULL;
-  ret = GNUNET_CONTAINER_meta_data_create ();
+  ret = GNUNET_CONTAINER_meta_data_create();
   for (pos = md->items_tail; NULL != pos; pos = pos->prev)
-    GNUNET_CONTAINER_meta_data_insert (ret, pos->plugin_name, pos->type,
-                                       pos->format, pos->mime_type, pos->data,
-                                       pos->data_size);
+    GNUNET_CONTAINER_meta_data_insert(ret, pos->plugin_name, pos->type,
+                                      pos->format, pos->mime_type, pos->data,
+                                      pos->data_size);
   return ret;
 }
 
@@ -700,8 +696,7 @@ GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
 /**
  * Header for serialized meta data.
  */
-struct MetaDataHeader
-{
+struct MetaDataHeader {
   /**
    * The version of the MD serialization.  The highest bit is used to
    * indicate compression.
@@ -734,8 +729,7 @@ struct MetaDataHeader
 /**
  * Entry of serialized meta data.
  */
-struct MetaDataEntry
-{
+struct MetaDataEntry {
   /**
    * Meta data type.  Corresponds to an 'enum EXTRACTOR_MetaType'
    */
@@ -760,7 +754,6 @@ struct MetaDataEntry
    * Number of bytes in the mime type including 0-terminator.  0 for NULL.
    */
   uint32_t mime_type_len;
-
 };
 
 
@@ -779,11 +772,11 @@ struct MetaDataEntry
  *         space)
  */
 ssize_t
-GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
-                                      *md, char **target, size_t max,
-                                      enum
-                                      GNUNET_CONTAINER_MetaDataSerializationOptions
-                                      opt)
+GNUNET_CONTAINER_meta_data_serialize(const struct GNUNET_CONTAINER_MetaData
+                                     *md, char **target, size_t max,
+                                     enum
+                                     GNUNET_CONTAINER_MetaDataSerializationOptions
+                                     opt)
 {
   struct GNUNET_CONTAINER_MetaData *vmd;
   struct MetaItem *pos;
@@ -804,195 +797,195 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
   size_t rlen;
   int comp;
 
-  if (max < sizeof (struct MetaDataHeader))
+  if (max < sizeof(struct MetaDataHeader))
     return GNUNET_SYSERR;       /* far too small */
   if (NULL == md)
     return 0;
 
   if (NULL != md->sbuf)
-  {
-    /* try to use serialization cache */
-    if (md->sbuf_size <= max)
     {
-      if (NULL == *target)
-        *target = GNUNET_malloc (md->sbuf_size);
-      GNUNET_memcpy (*target, md->sbuf, md->sbuf_size);
-      return md->sbuf_size;
+      /* try to use serialization cache */
+      if (md->sbuf_size <= max)
+        {
+          if (NULL == *target)
+            *target = GNUNET_malloc(md->sbuf_size);
+          GNUNET_memcpy(*target, md->sbuf, md->sbuf_size);
+          return md->sbuf_size;
+        }
+      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
+        return GNUNET_SYSERR;   /* can say that this will fail */
+      /* need to compute a partial serialization, sbuf useless ... */
     }
-    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
-      return GNUNET_SYSERR;     /* can say that this will fail */
-    /* need to compute a partial serialization, sbuf useless ... */
-  }
   dst = NULL;
   msize = 0;
   for (pos = md->items_tail; NULL != pos; pos = pos->prev)
-  {
-    msize += sizeof (struct MetaDataEntry);
-    msize += pos->data_size;
-    if (NULL != pos->plugin_name)
-      msize += strlen (pos->plugin_name) + 1;
-    if (NULL != pos->mime_type)
-      msize += strlen (pos->mime_type) + 1;
-  }
-  size = (size_t) msize;
+    {
+      msize += sizeof(struct MetaDataEntry);
+      msize += pos->data_size;
+      if (NULL != pos->plugin_name)
+        msize += strlen(pos->plugin_name) + 1;
+      if (NULL != pos->mime_type)
+        msize += strlen(pos->mime_type) + 1;
+    }
+  size = (size_t)msize;
   if (size != msize)
-  {
-    GNUNET_break (0);           /* integer overflow */
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);          /* integer overflow */
+      return GNUNET_SYSERR;
+    }
   if (size >= GNUNET_MAX_MALLOC_CHECKED)
-  {
-    /* too large to be processed */
-    return GNUNET_SYSERR;
-  }
-  ent = GNUNET_malloc (size);
-  mdata = (char *) &ent[md->item_count];
-  off = size - (md->item_count * sizeof (struct MetaDataEntry));
+    {
+      /* too large to be processed */
+      return GNUNET_SYSERR;
+    }
+  ent = GNUNET_malloc(size);
+  mdata = (char *)&ent[md->item_count];
+  off = size - (md->item_count * sizeof(struct MetaDataEntry));
   i = 0;
   for (pos = md->items_head; NULL != pos; pos = pos->next)
-  {
-    ent[i].type = htonl ((uint32_t) pos->type);
-    ent[i].format = htonl ((uint32_t) pos->format);
-    ent[i].data_size = htonl ((uint32_t) pos->data_size);
-    if (NULL == pos->plugin_name)
-      plen = 0;
-    else
-      plen = strlen (pos->plugin_name) + 1;
-    ent[i].plugin_name_len = htonl ((uint32_t) plen);
-    if (NULL == pos->mime_type)
-      mlen = 0;
-    else
-      mlen = strlen (pos->mime_type) + 1;
-    ent[i].mime_type_len = htonl ((uint32_t) mlen);
-    off -= pos->data_size;
-    if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) ||
-        (EXTRACTOR_METAFORMAT_C_STRING == pos->format))
-      GNUNET_break ('\0' == pos->data[pos->data_size - 1]);
-    GNUNET_memcpy (&mdata[off], pos->data, pos->data_size);
-    off -= plen;
-    if (NULL != pos->plugin_name)
-      GNUNET_memcpy (&mdata[off], pos->plugin_name, plen);
-    off -= mlen;
-    if (NULL != pos->mime_type)
-      GNUNET_memcpy (&mdata[off], pos->mime_type, mlen);
-    i++;
-  }
-  GNUNET_assert (0 == off);
+    {
+      ent[i].type = htonl((uint32_t)pos->type);
+      ent[i].format = htonl((uint32_t)pos->format);
+      ent[i].data_size = htonl((uint32_t)pos->data_size);
+      if (NULL == pos->plugin_name)
+        plen = 0;
+      else
+        plen = strlen(pos->plugin_name) + 1;
+      ent[i].plugin_name_len = htonl((uint32_t)plen);
+      if (NULL == pos->mime_type)
+        mlen = 0;
+      else
+        mlen = strlen(pos->mime_type) + 1;
+      ent[i].mime_type_len = htonl((uint32_t)mlen);
+      off -= pos->data_size;
+      if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) ||
+          (EXTRACTOR_METAFORMAT_C_STRING == pos->format))
+        GNUNET_break('\0' == pos->data[pos->data_size - 1]);
+      GNUNET_memcpy(&mdata[off], pos->data, pos->data_size);
+      off -= plen;
+      if (NULL != pos->plugin_name)
+        GNUNET_memcpy(&mdata[off], pos->plugin_name, plen);
+      off -= mlen;
+      if (NULL != pos->mime_type)
+        GNUNET_memcpy(&mdata[off], pos->mime_type, mlen);
+      i++;
+    }
+  GNUNET_assert(0 == off);
 
   clen = 0;
   cdata = NULL;
   left = size;
   i = 0;
   for (pos = md->items_head; NULL != pos; pos = pos->next)
-  {
-    comp = GNUNET_NO;
-    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
-      comp = GNUNET_try_compression ((const char *) &ent[i],
-                                     left,
-                                     &cdata,
-                                     &clen);
-
-    if ((NULL == md->sbuf) && (0 == i))
     {
-      /* fill 'sbuf'; this "modifies" md, but since this is only
-       * an internal cache we will cast away the 'const' instead
-       * of making the API look strange. */
-      vmd = (struct GNUNET_CONTAINER_MetaData *) md;
-      hdr = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
-      hdr->size = htonl (left);
-      hdr->entries = htonl (md->item_count);
-      if (GNUNET_YES == comp)
-      {
-        GNUNET_assert (clen < left);
-        hdr->version = htonl (2 | HEADER_COMPRESSED);
-        GNUNET_memcpy (&hdr[1], cdata, clen);
-        vmd->sbuf_size = clen + sizeof (struct MetaDataHeader);
-      }
-      else
-      {
-        hdr->version = htonl (2);
-        GNUNET_memcpy (&hdr[1], &ent[0], left);
-        vmd->sbuf_size = left + sizeof (struct MetaDataHeader);
-      }
-      vmd->sbuf = (char *) hdr;
+      comp = GNUNET_NO;
+      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
+        comp = GNUNET_try_compression((const char *)&ent[i],
+                                      left,
+                                      &cdata,
+                                      &clen);
+
+      if ((NULL == md->sbuf) && (0 == i))
+        {
+          /* fill 'sbuf'; this "modifies" md, but since this is only
+           * an internal cache we will cast away the 'const' instead
+           * of making the API look strange. */
+          vmd = (struct GNUNET_CONTAINER_MetaData *)md;
+          hdr = GNUNET_malloc(left + sizeof(struct MetaDataHeader));
+          hdr->size = htonl(left);
+          hdr->entries = htonl(md->item_count);
+          if (GNUNET_YES == comp)
+            {
+              GNUNET_assert(clen < left);
+              hdr->version = htonl(2 | HEADER_COMPRESSED);
+              GNUNET_memcpy(&hdr[1], cdata, clen);
+              vmd->sbuf_size = clen + sizeof(struct MetaDataHeader);
+            }
+          else
+            {
+              hdr->version = htonl(2);
+              GNUNET_memcpy(&hdr[1], &ent[0], left);
+              vmd->sbuf_size = left + sizeof(struct MetaDataHeader);
+            }
+          vmd->sbuf = (char *)hdr;
+        }
+
+      if (((left + sizeof(struct MetaDataHeader)) <= max) ||
+          ((GNUNET_YES == comp) && (clen <= max)))
+        {
+          /* success, this now fits! */
+          if (GNUNET_YES == comp)
+            {
+              if (NULL == dst)
+                dst = GNUNET_malloc(clen + sizeof(struct MetaDataHeader));
+              hdr = (struct MetaDataHeader *)dst;
+              hdr->version = htonl(2 | HEADER_COMPRESSED);
+              hdr->size = htonl(left);
+              hdr->entries = htonl(md->item_count - i);
+              GNUNET_memcpy(&dst[sizeof(struct MetaDataHeader)], cdata, clen);
+              GNUNET_free(cdata);
+              cdata = NULL;
+              GNUNET_free(ent);
+              rlen = clen + sizeof(struct MetaDataHeader);
+            }
+          else
+            {
+              if (NULL == dst)
+                dst = GNUNET_malloc(left + sizeof(struct MetaDataHeader));
+              hdr = (struct MetaDataHeader *)dst;
+              hdr->version = htonl(2);
+              hdr->entries = htonl(md->item_count - i);
+              hdr->size = htonl(left);
+              GNUNET_memcpy(&dst[sizeof(struct MetaDataHeader)], &ent[i], left);
+              GNUNET_free(ent);
+              rlen = left + sizeof(struct MetaDataHeader);
+            }
+          if (NULL != *target)
+            {
+              if (GNUNET_YES == comp)
+                GNUNET_memcpy(*target, dst, clen + sizeof(struct MetaDataHeader));
+              else
+                GNUNET_memcpy(*target, dst, left + sizeof(struct MetaDataHeader));
+              GNUNET_free(dst);
+            }
+          else
+            {
+              *target = dst;
+            }
+          return rlen;
+        }
+
+      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
+        {
+          /* does not fit! */
+          GNUNET_free(ent);
+          return GNUNET_SYSERR;
+        }
+
+      /* next iteration: ignore the corresponding meta data at the
+       * end and try again without it */
+      left -= sizeof(struct MetaDataEntry);
+      left -= pos->data_size;
+      if (NULL != pos->plugin_name)
+        left -= strlen(pos->plugin_name) + 1;
+      if (NULL != pos->mime_type)
+        left -= strlen(pos->mime_type) + 1;
+
+      GNUNET_free_non_null(cdata);
+      cdata = NULL;
+
+      i++;
     }
-
-    if (((left + sizeof (struct MetaDataHeader)) <= max) ||
-        ((GNUNET_YES == comp) && (clen <= max)))
-    {
-      /* success, this now fits! */
-      if (GNUNET_YES == comp)
-      {
-        if (NULL == dst)
-          dst = GNUNET_malloc (clen + sizeof (struct MetaDataHeader));
-        hdr = (struct MetaDataHeader *) dst;
-        hdr->version = htonl (2 | HEADER_COMPRESSED);
-        hdr->size = htonl (left);
-        hdr->entries = htonl (md->item_count - i);
-        GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen);
-        GNUNET_free (cdata);
-        cdata = NULL;
-        GNUNET_free (ent);
-        rlen = clen + sizeof (struct MetaDataHeader);
-      }
-      else
-      {
-        if (NULL == dst)
-          dst = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
-        hdr = (struct MetaDataHeader *) dst;
-        hdr->version = htonl (2);
-        hdr->entries = htonl (md->item_count - i);
-        hdr->size = htonl (left);
-        GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left);
-        GNUNET_free (ent);
-        rlen = left + sizeof (struct MetaDataHeader);
-      }
-      if (NULL != *target)
-      {
-        if (GNUNET_YES == comp)
-          GNUNET_memcpy (*target, dst, clen + sizeof (struct MetaDataHeader));
-        else
-          GNUNET_memcpy (*target, dst, left + sizeof (struct MetaDataHeader));
-        GNUNET_free (dst);
-      }
-      else
-      {
-        *target = dst;
-      }
-      return rlen;
-    }
-
-    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
-    {
-      /* does not fit! */
-      GNUNET_free (ent);
-      return GNUNET_SYSERR;
-    }
-
-    /* next iteration: ignore the corresponding meta data at the
-     * end and try again without it */
-    left -= sizeof (struct MetaDataEntry);
-    left -= pos->data_size;
-    if (NULL != pos->plugin_name)
-      left -= strlen (pos->plugin_name) + 1;
-    if (NULL != pos->mime_type)
-      left -= strlen (pos->mime_type) + 1;
-
-    GNUNET_free_non_null (cdata);
-    cdata = NULL;
-
-    i++;
-  }
-  GNUNET_free (ent);
+  GNUNET_free(ent);
 
   /* nothing fit, only write header! */
-  ihdr.version = htonl (2);
-  ihdr.entries = htonl (0);
-  ihdr.size = htonl (0);
+  ihdr.version = htonl(2);
+  ihdr.entries = htonl(0);
+  ihdr.size = htonl(0);
   if (NULL == *target)
-    *target = (char *) GNUNET_new (struct MetaDataHeader);
-  GNUNET_memcpy (*target, &ihdr, sizeof (struct MetaDataHeader));
-  return sizeof (struct MetaDataHeader);
+    *target = (char *)GNUNET_new(struct MetaDataHeader);
+  GNUNET_memcpy(*target, &ihdr, sizeof(struct MetaDataHeader));
+  return sizeof(struct MetaDataHeader);
 }
 
 
@@ -1003,8 +996,8 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
  * @return number of bytes needed for serialization, -1 on error
  */
 ssize_t
-GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
-                                                GNUNET_CONTAINER_MetaData *md)
+GNUNET_CONTAINER_meta_data_get_serialized_size(const struct
+                                               GNUNET_CONTAINER_MetaData *md)
 {
   ssize_t ret;
   char *ptr;
@@ -1013,10 +1006,10 @@ GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
     return md->sbuf_size;
   ptr = NULL;
   ret =
-      GNUNET_CONTAINER_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
-                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+    GNUNET_CONTAINER_meta_data_serialize(md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
+                                         GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   if (-1 != ret)
-    GNUNET_free (ptr);
+    GNUNET_free(ptr);
   return ret;
 }
 
@@ -1030,7 +1023,7 @@ GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
  *         bad format)
  */
 struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
+GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
 {
   struct GNUNET_CONTAINER_MetaData *md;
   struct MetaDataHeader hdr;
@@ -1052,137 +1045,137 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
   const char *mime_type;
   enum EXTRACTOR_MetaFormat format;
 
-  if (size < sizeof (struct MetaDataHeader))
+  if (size < sizeof(struct MetaDataHeader))
     return NULL;
-  GNUNET_memcpy (&hdr, input, sizeof (struct MetaDataHeader));
-  version = ntohl (hdr.version) & HEADER_VERSION_MASK;
-  compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0;
+  GNUNET_memcpy(&hdr, input, sizeof(struct MetaDataHeader));
+  version = ntohl(hdr.version) & HEADER_VERSION_MASK;
+  compressed = (ntohl(hdr.version) & HEADER_COMPRESSED) != 0;
 
   if (1 == version)
     return NULL;                /* null pointer */
   if (2 != version)
-  {
-    GNUNET_break_op (0);        /* unsupported version */
-    return NULL;
-  }
-
-  ic = ntohl (hdr.entries);
-  dataSize = ntohl (hdr.size);
-  if ( ((sizeof (struct MetaDataEntry) * ic) > dataSize) ||
-       ( (0 != ic) &&
-         (dataSize / ic < sizeof (struct MetaDataEntry)) ) )
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-
-  if (compressed)
-  {
-    if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
     {
-      /* make sure we don't blow our memory limit because of a mal-formed
-       * message... */
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);       /* unsupported version */
       return NULL;
     }
-    data =
-      GNUNET_decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
-                         size - sizeof (struct MetaDataHeader),
-                         dataSize);
-    if (NULL == data)
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
-    cdata = data;
-  }
-  else
-  {
-    data = NULL;
-    cdata = (const char *) &input[sizeof (struct MetaDataHeader)];
-    if (dataSize != size - sizeof (struct MetaDataHeader))
+
+  ic = ntohl(hdr.entries);
+  dataSize = ntohl(hdr.size);
+  if (((sizeof(struct MetaDataEntry) * ic) > dataSize) ||
+      ((0 != ic) &&
+       (dataSize / ic < sizeof(struct MetaDataEntry))))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return NULL;
     }
-  }
 
-  md = GNUNET_CONTAINER_meta_data_create ();
-  left = dataSize - ic * sizeof (struct MetaDataEntry);
-  mdata = &cdata[ic * sizeof (struct MetaDataEntry)];
-  for (i = 0; i < ic; i++)
-  {
-    GNUNET_memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
-            sizeof (struct MetaDataEntry));
-    format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
-    if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
-        (EXTRACTOR_METAFORMAT_C_STRING != format) &&
-        (EXTRACTOR_METAFORMAT_BINARY != format))
-    {
-      GNUNET_break_op (0);
-      break;
-    }
-    dlen = ntohl (ent.data_size);
-    plen = ntohl (ent.plugin_name_len);
-    mlen = ntohl (ent.mime_type_len);
-    if (dlen > left)
-    {
-      GNUNET_break_op (0);
-      break;
-    }
-    left -= dlen;
-    meta_data = &mdata[left];
-    if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
-        (EXTRACTOR_METAFORMAT_C_STRING == format))
-    {
-      if (0 == dlen)
-      {
-        GNUNET_break_op (0);
-        break;
-      }
-      if ('\0' != meta_data[dlen - 1])
-      {
-        GNUNET_break_op (0);
-        break;
-      }
-    }
-    if (plen > left)
+  if (compressed)
     {
-      GNUNET_break_op (0);
-      break;
+      if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
+        {
+          /* make sure we don't blow our memory limit because of a mal-formed
+           * message... */
+          GNUNET_break_op(0);
+          return NULL;
+        }
+      data =
+        GNUNET_decompress((const char *)&input[sizeof(struct MetaDataHeader)],
+                          size - sizeof(struct MetaDataHeader),
+                          dataSize);
+      if (NULL == data)
+        {
+          GNUNET_break_op(0);
+          return NULL;
+        }
+      cdata = data;
     }
-    left -= plen;
-    if ((plen > 0) && ('\0' != mdata[left + plen - 1]))
+  else
     {
-      GNUNET_break_op (0);
-      break;
+      data = NULL;
+      cdata = (const char *)&input[sizeof(struct MetaDataHeader)];
+      if (dataSize != size - sizeof(struct MetaDataHeader))
+        {
+          GNUNET_break_op(0);
+          return NULL;
+        }
     }
-    if (0 == plen)
-      plugin_name = NULL;
-    else
-      plugin_name = &mdata[left];
 
-    if (mlen > left)
-    {
-      GNUNET_break_op (0);
-      break;
-    }
-    left -= mlen;
-    if ((mlen > 0) && ('\0' != mdata[left + mlen - 1]))
+  md = GNUNET_CONTAINER_meta_data_create();
+  left = dataSize - ic * sizeof(struct MetaDataEntry);
+  mdata = &cdata[ic * sizeof(struct MetaDataEntry)];
+  for (i = 0; i < ic; i++)
     {
-      GNUNET_break_op (0);
-      break;
+      GNUNET_memcpy(&ent, &cdata[i * sizeof(struct MetaDataEntry)],
+                    sizeof(struct MetaDataEntry));
+      format = (enum EXTRACTOR_MetaFormat)ntohl(ent.format);
+      if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
+          (EXTRACTOR_METAFORMAT_C_STRING != format) &&
+          (EXTRACTOR_METAFORMAT_BINARY != format))
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      dlen = ntohl(ent.data_size);
+      plen = ntohl(ent.plugin_name_len);
+      mlen = ntohl(ent.mime_type_len);
+      if (dlen > left)
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      left -= dlen;
+      meta_data = &mdata[left];
+      if ((EXTRACTOR_METAFORMAT_UTF8 == format) ||
+          (EXTRACTOR_METAFORMAT_C_STRING == format))
+        {
+          if (0 == dlen)
+            {
+              GNUNET_break_op(0);
+              break;
+            }
+          if ('\0' != meta_data[dlen - 1])
+            {
+              GNUNET_break_op(0);
+              break;
+            }
+        }
+      if (plen > left)
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      left -= plen;
+      if ((plen > 0) && ('\0' != mdata[left + plen - 1]))
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      if (0 == plen)
+        plugin_name = NULL;
+      else
+        plugin_name = &mdata[left];
+
+      if (mlen > left)
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      left -= mlen;
+      if ((mlen > 0) && ('\0' != mdata[left + mlen - 1]))
+        {
+          GNUNET_break_op(0);
+          break;
+        }
+      if (0 == mlen)
+        mime_type = NULL;
+      else
+        mime_type = &mdata[left];
+      GNUNET_CONTAINER_meta_data_insert(md, plugin_name,
+                                        (enum EXTRACTOR_MetaType)
+                                        ntohl(ent.type), format, mime_type,
+                                        meta_data, dlen);
     }
-    if (0 == mlen)
-      mime_type = NULL;
-    else
-      mime_type = &mdata[left];
-    GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
-                                       (enum EXTRACTOR_MetaType)
-                                       ntohl (ent.type), format, mime_type,
-                                       meta_data, dlen);
-  }
-  GNUNET_free_non_null (data);
+  GNUNET_free_non_null(data);
   return md;
 }
 
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c
index bcf6dccf0..62e5311d8 100644
--- a/src/util/container_multihashmap.c
+++ b/src/util/container_multihashmap.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 util/container_multihashmap.c
  * @brief hash map where the same key may be present multiple times
@@ -27,7 +27,7 @@
 #include "gnunet_container_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-multihashmap", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-multihashmap", __VA_ARGS__)
 
 /**
  * Maximum recursion depth for callbacks of
@@ -41,9 +41,7 @@
 /**
  * An entry in the hash map with the full key.
  */
-struct BigMapEntry
-{
-
+struct BigMapEntry {
   /**
    * Value of the entry.
    */
@@ -64,9 +62,7 @@ struct BigMapEntry
 /**
  * An entry in the hash map with just a pointer to the key.
  */
-struct SmallMapEntry
-{
-
+struct SmallMapEntry {
   /**
    * Value of the entry.
    */
@@ -87,8 +83,7 @@ struct SmallMapEntry
 /**
  * Entry in the map.
  */
-union MapEntry
-{
+union MapEntry {
   /**
    * Variant used if map entries only contain a pointer to the key.
    */
@@ -104,8 +99,7 @@ union MapEntry
 /**
  * Internal representation of the hash map.
  */
-struct GNUNET_CONTAINER_MultiHashMap
-{
+struct GNUNET_CONTAINER_MultiHashMap {
   /**
    * All of our buckets.
    */
@@ -152,8 +146,7 @@ struct GNUNET_CONTAINER_MultiHashMap
  * Cursor into a multihashmap.
  * Allows to enumerate elements asynchronously.
  */
-struct GNUNET_CONTAINER_MultiHashMapIterator
-{
+struct GNUNET_CONTAINER_MultiHashMapIterator {
   /**
    * Position in the bucket @e idx
    */
@@ -193,34 +186,34 @@ struct GNUNET_CONTAINER_MultiHashMapIterator
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiHashMap *
-GNUNET_CONTAINER_multihashmap_create (unsigned int len, int do_not_copy_keys)
+GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
 {
   struct GNUNET_CONTAINER_MultiHashMap *hm;
 
-  GNUNET_assert (len > 0);
-  hm = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap);
-  if (len * sizeof (union MapEntry) > GNUNET_MAX_MALLOC_CHECKED)
-  {
-    size_t s;
-    /* application *explicitly* requested very large map, hopefully
-       it checks the return value... */
-    s = len * sizeof (union MapEntry);
-    if ((s / sizeof (union MapEntry)) != len)
-      return NULL; /* integer overflow on multiplication */
-    if (NULL == (hm->map = GNUNET_malloc_large (s)))
+  GNUNET_assert(len > 0);
+  hm = GNUNET_new(struct GNUNET_CONTAINER_MultiHashMap);
+  if (len * sizeof(union MapEntry) > GNUNET_MAX_MALLOC_CHECKED)
     {
-      /* out of memory */
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Out of memory allocating large hash map (%u entries)\n",
-                  len);
-      GNUNET_free (hm);
-      return NULL;
+      size_t s;
+      /* application *explicitly* requested very large map, hopefully
+         it checks the return value... */
+      s = len * sizeof(union MapEntry);
+      if ((s / sizeof(union MapEntry)) != len)
+        return NULL; /* integer overflow on multiplication */
+      if (NULL == (hm->map = GNUNET_malloc_large(s)))
+        {
+          /* out of memory */
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Out of memory allocating large hash map (%u entries)\n",
+                     len);
+          GNUNET_free(hm);
+          return NULL;
+        }
     }
-  }
   else
-  {
-    hm->map = GNUNET_new_array (len, union MapEntry);
-  }
+    {
+      hm->map = GNUNET_new_array(len, union MapEntry);
+    }
   hm->map_length = len;
   hm->use_small_entries = do_not_copy_keys;
   return hm;
@@ -234,44 +227,44 @@ GNUNET_CONTAINER_multihashmap_create (unsigned int len, int do_not_copy_keys)
  * @param map the map
  */
 void
-GNUNET_CONTAINER_multihashmap_destroy (
+GNUNET_CONTAINER_multihashmap_destroy(
   struct GNUNET_CONTAINER_MultiHashMap *map)
 {
-  GNUNET_assert (0 == map->next_cache_off);
+  GNUNET_assert(0 == map->next_cache_off);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    union MapEntry me;
-
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        GNUNET_free (sme);
-      }
-      me.sme = NULL;
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        GNUNET_free (bme);
-      }
-      me.bme = NULL;
+      union MapEntry me;
+
+      me = map->map[i];
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              GNUNET_free(sme);
+            }
+          me.sme = NULL;
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              GNUNET_free(bme);
+            }
+          me.bme = NULL;
+        }
     }
-  }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  GNUNET_free(map->map);
+  GNUNET_free(map);
 }
 
 
@@ -283,11 +276,11 @@ GNUNET_CONTAINER_multihashmap_destroy (
  * @return offset into the "map" array of "map"
  */
 static unsigned int
-idx_of (const struct GNUNET_CONTAINER_MultiHashMap *map,
-        const struct GNUNET_HashCode *key)
+idx_of(const struct GNUNET_CONTAINER_MultiHashMap *map,
+       const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert (map != NULL);
-  return (*(unsigned int *) key) % map->map_length;
+  GNUNET_assert(map != NULL);
+  return (*(unsigned int *)key) % map->map_length;
 }
 
 
@@ -298,7 +291,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiHashMap *map,
  * @return the number of key value pairs
  */
 unsigned int
-GNUNET_CONTAINER_multihashmap_size (
+GNUNET_CONTAINER_multihashmap_size(
   const struct GNUNET_CONTAINER_MultiHashMap *map)
 {
   return map->size;
@@ -316,29 +309,29 @@ GNUNET_CONTAINER_multihashmap_size (
  *   key-value pairs with value NULL
  */
 void *
-GNUNET_CONTAINER_multihashmap_get (
+GNUNET_CONTAINER_multihashmap_get(
   const struct GNUNET_CONTAINER_MultiHashMap *map,
   const struct GNUNET_HashCode *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
+    {
+      struct SmallMapEntry *sme;
 
-    for (sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return sme->value;
-  }
+      for (sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return sme->value;
+    }
   else
-  {
-    struct BigMapEntry *bme;
+    {
+      struct BigMapEntry *bme;
 
-    for (bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return bme->value;
-  }
+      for (bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return bme->value;
+    }
   return NULL;
 }
 
@@ -353,7 +346,7 @@ GNUNET_CONTAINER_multihashmap_get (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multihashmap_iterate (
+GNUNET_CONTAINER_multihashmap_iterate(
   struct GNUNET_CONTAINER_MultiHashMap *map,
   GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
   void *it_cls)
@@ -363,54 +356,54 @@ GNUNET_CONTAINER_multihashmap_iterate (
   union MapEntry *ce;
   struct GNUNET_HashCode kc;
 
-  GNUNET_assert (NULL != map);
+  GNUNET_assert(NULL != map);
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   count = 0;
   for (unsigned i = 0; i < map->map_length; i++)
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      ce->sme = me.sme;
-      while (NULL != (sme = ce->sme))
-      {
-        ce->sme = sme->next;
-        if (NULL != it)
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct SmallMapEntry *sme;
+
+          ce->sme = me.sme;
+          while (NULL != (sme = ce->sme))
+            {
+              ce->sme = sme->next;
+              if (NULL != it)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      ce->bme = me.bme;
-      while (NULL != (bme = ce->bme))
-      {
-        ce->bme = bme->next;
-        if (NULL != it)
+      else
         {
-          kc = bme->key;
-          if (GNUNET_OK != it (it_cls, &kc, bme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct BigMapEntry *bme;
+
+          ce->bme = me.bme;
+          while (NULL != (bme = ce->bme))
+            {
+              ce->bme = bme->next;
+              if (NULL != it)
+                {
+                  kc = bme->key;
+                  if (GNUNET_OK != it(it_cls, &kc, bme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -423,8 +416,8 @@ GNUNET_CONTAINER_multihashmap_iterate (
  * @param bme the entry that is about to be free'd
  */
 static void
-update_next_cache_bme (struct GNUNET_CONTAINER_MultiHashMap *map,
-                       const struct BigMapEntry *bme)
+update_next_cache_bme(struct GNUNET_CONTAINER_MultiHashMap *map,
+                      const struct BigMapEntry *bme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].bme == bme)
@@ -440,8 +433,8 @@ update_next_cache_bme (struct GNUNET_CONTAINER_MultiHashMap *map,
  * @param sme the entry that is about to be free'd
  */
 static void
-update_next_cache_sme (struct GNUNET_CONTAINER_MultiHashMap *map,
-                       const struct SmallMapEntry *sme)
+update_next_cache_sme(struct GNUNET_CONTAINER_MultiHashMap *map,
+                      const struct SmallMapEntry *sme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].sme == sme)
@@ -461,59 +454,59 @@ update_next_cache_sme (struct GNUNET_CONTAINER_MultiHashMap *map,
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
-                                      const struct GNUNET_HashCode *key,
-                                      const void *value)
+GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map,
+                                     const struct GNUNET_HashCode *key,
+                                     const void *value)
 {
   union MapEntry me;
   unsigned int i;
 
   map->modification_counter++;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *p;
-
-    p = NULL;
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
     {
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (value == sme->value))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = sme;
+      struct SmallMapEntry *p;
+
+      p = NULL;
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, sme->key)) && (value == sme->value))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = sme;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *p;
-
-    p = NULL;
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
     {
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (value == bme->value))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = bme;
+      struct BigMapEntry *p;
+
+      p = NULL;
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, &bme->key)) && (value == bme->value))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = bme;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -527,7 +520,7 @@ GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
  * @return number of values removed
  */
 int
-GNUNET_CONTAINER_multihashmap_remove_all (
+GNUNET_CONTAINER_multihashmap_remove_all(
   struct GNUNET_CONTAINER_MultiHashMap *map,
   const struct GNUNET_HashCode *key)
 {
@@ -538,70 +531,70 @@ GNUNET_CONTAINER_multihashmap_remove_all (
   map->modification_counter++;
 
   ret = 0;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-    struct SmallMapEntry *p;
-
-    p = NULL;
-    sme = me.sme;
-    while (NULL != sme)
     {
-      if (0 == GNUNET_memcmp (key, sme->key))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        if (NULL == p)
-          sme = map->map[i].sme;
-        else
-          sme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = sme;
-        sme = sme->next;
-      }
+      struct SmallMapEntry *sme;
+      struct SmallMapEntry *p;
+
+      p = NULL;
+      sme = me.sme;
+      while (NULL != sme)
+        {
+          if (0 == GNUNET_memcmp(key, sme->key))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              if (NULL == p)
+                sme = map->map[i].sme;
+              else
+                sme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = sme;
+              sme = sme->next;
+            }
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-    struct BigMapEntry *p;
-
-    p = NULL;
-    bme = me.bme;
-    while (NULL != bme)
     {
-      if (0 == GNUNET_memcmp (key, &bme->key))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        if (NULL == p)
-          bme = map->map[i].bme;
-        else
-          bme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = bme;
-        bme = bme->next;
-      }
+      struct BigMapEntry *bme;
+      struct BigMapEntry *p;
+
+      p = NULL;
+      bme = me.bme;
+      while (NULL != bme)
+        {
+          if (0 == GNUNET_memcmp(key, &bme->key))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              if (NULL == p)
+                bme = map->map[i].bme;
+              else
+                bme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = bme;
+              bme = bme->next;
+            }
+        }
     }
-  }
   return ret;
 }
 
@@ -615,12 +608,12 @@ GNUNET_CONTAINER_multihashmap_remove_all (
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-remove_all (void *cls, const struct GNUNET_HashCode *key, void *value)
+remove_all(void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_CONTAINER_MultiHashMap *map = cls;
 
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (map, key, value));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_remove(map, key, value));
   return GNUNET_OK;
 }
 
@@ -634,12 +627,12 @@ remove_all (void *cls, const struct GNUNET_HashCode *key, void *value)
  * @return number of values removed
  */
 unsigned int
-GNUNET_CONTAINER_multihashmap_clear (struct GNUNET_CONTAINER_MultiHashMap *map)
+GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map)
 {
   unsigned int ret;
 
   ret = map->size;
-  GNUNET_CONTAINER_multihashmap_iterate (map, &remove_all, map);
+  GNUNET_CONTAINER_multihashmap_iterate(map, &remove_all, map);
   return ret;
 }
 
@@ -654,29 +647,29 @@ GNUNET_CONTAINER_multihashmap_clear (struct GNUNET_CONTAINER_MultiHashMap *map)
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multihashmap_contains (
+GNUNET_CONTAINER_multihashmap_contains(
   const struct GNUNET_CONTAINER_MultiHashMap *map,
   const struct GNUNET_HashCode *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
+    {
+      struct SmallMapEntry *sme;
 
-    for (sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return GNUNET_YES;
-  }
+      for (sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return GNUNET_YES;
+    }
   else
-  {
-    struct BigMapEntry *bme;
+    {
+      struct BigMapEntry *bme;
 
-    for (bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return GNUNET_YES;
-  }
+      for (bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -692,30 +685,30 @@ GNUNET_CONTAINER_multihashmap_contains (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multihashmap_contains_value (
+GNUNET_CONTAINER_multihashmap_contains_value(
   const struct GNUNET_CONTAINER_MultiHashMap *map,
   const struct GNUNET_HashCode *key,
   const void *value)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
+    {
+      struct SmallMapEntry *sme;
 
-    for (sme = me.sme; NULL != sme; sme = sme->next)
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (sme->value == value))
-        return GNUNET_YES;
-  }
+      for (sme = me.sme; NULL != sme; sme = sme->next)
+        if ((0 == GNUNET_memcmp(key, sme->key)) && (sme->value == value))
+          return GNUNET_YES;
+    }
   else
-  {
-    struct BigMapEntry *bme;
+    {
+      struct BigMapEntry *bme;
 
-    for (bme = me.bme; NULL != bme; bme = bme->next)
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (bme->value == value))
-        return GNUNET_YES;
-  }
+      for (bme = me.bme; NULL != bme; bme = bme->next)
+        if ((0 == GNUNET_memcmp(key, &bme->key)) && (bme->value == value))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -726,7 +719,7 @@ GNUNET_CONTAINER_multihashmap_contains_value (
  * @param map the hash map to grow
  */
 static void
-grow (struct GNUNET_CONTAINER_MultiHashMap *map)
+grow(struct GNUNET_CONTAINER_MultiHashMap *map)
 {
   union MapEntry *old_map;
   union MapEntry *new_map;
@@ -736,46 +729,46 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map)
 
   old_map = map->map;
   old_len = map->map_length;
-  GNUNET_assert (0 != old_len);
+  GNUNET_assert(0 != old_len);
   new_len = old_len * 2;
   if (0 == new_len) /* 2^31 * 2 == 0 */
     new_len = old_len; /* never use 0 */
   if (new_len == old_len)
     return; /* nothing changed */
-  new_map = GNUNET_malloc_large (new_len * sizeof (union MapEntry));
+  new_map = GNUNET_malloc_large(new_len * sizeof(union MapEntry));
   if (NULL == new_map)
     return; /* grow not possible */
   map->modification_counter++;
   map->map_length = new_len;
   map->map = new_map;
   for (unsigned int i = 0; i < old_len; i++)
-  {
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-
-      while (NULL != (sme = old_map[i].sme))
-      {
-        old_map[i].sme = sme->next;
-        idx = idx_of (map, sme->key);
-        sme->next = new_map[idx].sme;
-        new_map[idx].sme = sme;
-      }
-    }
-    else
     {
-      struct BigMapEntry *bme;
-
-      while (NULL != (bme = old_map[i].bme))
-      {
-        old_map[i].bme = bme->next;
-        idx = idx_of (map, &bme->key);
-        bme->next = new_map[idx].bme;
-        new_map[idx].bme = bme;
-      }
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+
+          while (NULL != (sme = old_map[i].sme))
+            {
+              old_map[i].sme = sme->next;
+              idx = idx_of(map, sme->key);
+              sme->next = new_map[idx].sme;
+              new_map[idx].sme = sme;
+            }
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+
+          while (NULL != (bme = old_map[i].bme))
+            {
+              old_map[i].bme = bme->next;
+              idx = idx_of(map, &bme->key);
+              bme->next = new_map[idx].bme;
+              new_map[idx].bme = bme;
+            }
+        }
     }
-  }
-  GNUNET_free (old_map);
+  GNUNET_free(old_map);
 }
 
 
@@ -792,71 +785,71 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map)
  *                       value already exists
  */
 int
-GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
-                                   const struct GNUNET_HashCode *key,
-                                   void *value,
-                                   enum GNUNET_CONTAINER_MultiHashMapOption opt)
+GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map,
+                                  const struct GNUNET_HashCode *key,
+                                  void *value,
+                                  enum GNUNET_CONTAINER_MultiHashMapOption opt)
 {
   union MapEntry me;
   unsigned int i;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
       (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      for (sme = me.sme; NULL != sme; sme = sme->next)
-        if (0 == GNUNET_memcmp (key, sme->key))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          sme->value = value;
-          return GNUNET_NO;
+          struct SmallMapEntry *sme;
+
+          for (sme = me.sme; NULL != sme; sme = sme->next)
+            if (0 == GNUNET_memcmp(key, sme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                sme->value = value;
+                return GNUNET_NO;
+              }
         }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      for (bme = me.bme; NULL != bme; bme = bme->next)
-        if (0 == GNUNET_memcmp (key, &bme->key))
+      else
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          bme->value = value;
-          return GNUNET_NO;
+          struct BigMapEntry *bme;
+
+          for (bme = me.bme; NULL != bme; bme = bme->next)
+            if (0 == GNUNET_memcmp(key, &bme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                bme->value = value;
+                return GNUNET_NO;
+              }
         }
     }
-  }
   if (map->size / 3 >= map->map_length / 4)
-  {
-    grow (map);
-    i = idx_of (map, key);
-  }
+    {
+      grow(map);
+      i = idx_of(map, key);
+    }
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    sme = GNUNET_new (struct SmallMapEntry);
-    sme->key = key;
-    sme->value = value;
-    sme->next = map->map[i].sme;
-    map->map[i].sme = sme;
-  }
+    {
+      struct SmallMapEntry *sme;
+
+      sme = GNUNET_new(struct SmallMapEntry);
+      sme->key = key;
+      sme->value = value;
+      sme->next = map->map[i].sme;
+      map->map[i].sme = sme;
+    }
   else
-  {
-    struct BigMapEntry *bme;
-
-    bme = GNUNET_new (struct BigMapEntry);
-    bme->key = *key;
-    bme->value = value;
-    bme->next = map->map[i].bme;
-    map->map[i].bme = bme;
-  }
+    {
+      struct BigMapEntry *bme;
+
+      bme = GNUNET_new(struct BigMapEntry);
+      bme->key = *key;
+      bme->value = value;
+      bme->next = map->map[i].bme;
+      map->map[i].bme = bme;
+    }
   map->size++;
   return GNUNET_OK;
 }
@@ -873,7 +866,7 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multihashmap_get_multiple (
+GNUNET_CONTAINER_multihashmap_get_multiple(
   struct GNUNET_CONTAINER_MultiHashMap *map,
   const struct GNUNET_HashCode *key,
   GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
@@ -884,46 +877,46 @@ GNUNET_CONTAINER_multihashmap_get_multiple (
   union MapEntry *ce;
 
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   count = 0;
-  me = &map->map[idx_of (map, key)];
+  me = &map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    ce->sme = me->sme;
-    while (NULL != (sme = ce->sme))
     {
-      ce->sme = sme->next;
-      if (0 != GNUNET_memcmp (key, sme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, sme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct SmallMapEntry *sme;
+
+      ce->sme = me->sme;
+      while (NULL != (sme = ce->sme))
+        {
+          ce->sme = sme->next;
+          if (0 != GNUNET_memcmp(key, sme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, sme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-
-    ce->bme = me->bme;
-    while (NULL != (bme = ce->bme))
     {
-      ce->bme = bme->next;
-      if (0 != GNUNET_memcmp (key, &bme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, bme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct BigMapEntry *bme;
+
+      ce->bme = me->bme;
+      while (NULL != (bme = ce->bme))
+        {
+          ce->bme = bme->next;
+          if (0 != GNUNET_memcmp(key, &bme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, bme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -940,7 +933,7 @@ GNUNET_CONTAINER_multihashmap_get_multiple (
  * @return the number of key value pairs processed, zero or one.
  */
 unsigned int
-GNUNET_CONTAINER_multihashmap_get_random (
+GNUNET_CONTAINER_multihashmap_get_random(
   const struct GNUNET_CONTAINER_MultiHashMap *map,
   GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
   void *it_cls)
@@ -953,48 +946,48 @@ GNUNET_CONTAINER_multihashmap_get_random (
     return 0;
   if (NULL == it)
     return 1;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, map->size);
+  off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, map->size);
   for (idx = 0; idx < map->map_length; idx++)
-  {
-    me = map->map[idx];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        if (0 == off)
+      me = map->map[idx];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        if (0 == off)
+      else
         {
-          if (GNUNET_OK != it (it_cls, &bme->key, bme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, &bme->key, bme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
     }
-  }
-  GNUNET_break (0);
+  GNUNET_break(0);
   return GNUNET_SYSERR;
 }
 
@@ -1012,12 +1005,12 @@ GNUNET_CONTAINER_multihashmap_get_random (
  * @return an iterator over the given multihashmap 'map'
  */
 struct GNUNET_CONTAINER_MultiHashMapIterator *
-GNUNET_CONTAINER_multihashmap_iterator_create (
+GNUNET_CONTAINER_multihashmap_iterator_create(
   const struct GNUNET_CONTAINER_MultiHashMap *map)
 {
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
 
-  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMapIterator);
+  iter = GNUNET_new(struct GNUNET_CONTAINER_MultiHashMapIterator);
   iter->map = map;
   iter->modification_counter = map->modification_counter;
   iter->me = map->map[0];
@@ -1040,47 +1033,47 @@ GNUNET_CONTAINER_multihashmap_iterator_create (
  *         #GNUNET_NO if we are out of elements
  */
 int
-GNUNET_CONTAINER_multihashmap_iterator_next (
+GNUNET_CONTAINER_multihashmap_iterator_next(
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter,
   struct GNUNET_HashCode *key,
   const void **value)
 {
   /* make sure the map has not been modified */
-  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
+  GNUNET_assert(iter->modification_counter == iter->map->modification_counter);
 
   /* look for the next entry, skipping empty buckets */
   while (1)
-  {
-    if (iter->idx >= iter->map->map_length)
-      return GNUNET_NO;
-    if (GNUNET_YES == iter->map->use_small_entries)
-    {
-      if (NULL != iter->me.sme)
-      {
-        if (NULL != key)
-          *key = *iter->me.sme->key;
-        if (NULL != value)
-          *value = iter->me.sme->value;
-        iter->me.sme = iter->me.sme->next;
-        return GNUNET_YES;
-      }
-    }
-    else
     {
-      if (NULL != iter->me.bme)
-      {
-        if (NULL != key)
-          *key = iter->me.bme->key;
-        if (NULL != value)
-          *value = iter->me.bme->value;
-        iter->me.bme = iter->me.bme->next;
-        return GNUNET_YES;
-      }
+      if (iter->idx >= iter->map->map_length)
+        return GNUNET_NO;
+      if (GNUNET_YES == iter->map->use_small_entries)
+        {
+          if (NULL != iter->me.sme)
+            {
+              if (NULL != key)
+                *key = *iter->me.sme->key;
+              if (NULL != value)
+                *value = iter->me.sme->value;
+              iter->me.sme = iter->me.sme->next;
+              return GNUNET_YES;
+            }
+        }
+      else
+        {
+          if (NULL != iter->me.bme)
+            {
+              if (NULL != key)
+                *key = iter->me.bme->key;
+              if (NULL != value)
+                *value = iter->me.bme->value;
+              iter->me.bme = iter->me.bme->next;
+              return GNUNET_YES;
+            }
+        }
+      iter->idx += 1;
+      if (iter->idx < iter->map->map_length)
+        iter->me = iter->map->map[iter->idx];
     }
-    iter->idx += 1;
-    if (iter->idx < iter->map->map_length)
-      iter->me = iter->map->map[iter->idx];
-  }
 }
 
 
@@ -1090,10 +1083,10 @@ GNUNET_CONTAINER_multihashmap_iterator_next (
  * @param iter the iterator to destroy
  */
 void
-GNUNET_CONTAINER_multihashmap_iterator_destroy (
+GNUNET_CONTAINER_multihashmap_iterator_destroy(
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter)
 {
-  GNUNET_free (iter);
+  GNUNET_free(iter);
 }
 
 
diff --git a/src/util/container_multihashmap32.c b/src/util/container_multihashmap32.c
index 0956ada67..82d908555 100644
--- a/src/util/container_multihashmap32.c
+++ b/src/util/container_multihashmap32.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 util/container_multihashmap32.c
  * @brief a version of hash map implemented in container_multihashmap.c but with
@@ -29,7 +29,7 @@
 #include "gnunet_container_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-multihashmap32", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-multihashmap32", __VA_ARGS__)
 
 
 /**
@@ -43,9 +43,7 @@
 /**
  * An entry in the hash map.
  */
-struct MapEntry
-{
-
+struct MapEntry {
   /**
    * Key for the entry.
    */
@@ -65,9 +63,7 @@ struct MapEntry
 /**
  * Internal representation of the hash map.
  */
-struct GNUNET_CONTAINER_MultiHashMap32
-{
-
+struct GNUNET_CONTAINER_MultiHashMap32 {
   /**
    * All of our buckets.
    */
@@ -108,8 +104,7 @@ struct GNUNET_CONTAINER_MultiHashMap32
  * Cursor into a multihashmap.
  * Allows to enumerate elements asynchronously.
  */
-struct GNUNET_CONTAINER_MultiHashMap32Iterator
-{
+struct GNUNET_CONTAINER_MultiHashMap32Iterator {
   /**
    * Position in the bucket @e idx
    */
@@ -140,18 +135,18 @@ struct GNUNET_CONTAINER_MultiHashMap32Iterator
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiHashMap32 *
-GNUNET_CONTAINER_multihashmap32_create (unsigned int len)
+GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
 {
   struct GNUNET_CONTAINER_MultiHashMap32 *ret;
 
-  GNUNET_assert (len > 0);
-  ret = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap32);
-  ret->map = GNUNET_malloc_large (len * sizeof (struct MapEntry *));
+  GNUNET_assert(len > 0);
+  ret = GNUNET_new(struct GNUNET_CONTAINER_MultiHashMap32);
+  ret->map = GNUNET_malloc_large(len * sizeof(struct MapEntry *));
   if (NULL == ret->map)
-  {
-    GNUNET_free (ret);
-    return NULL;
-  }
+    {
+      GNUNET_free(ret);
+      return NULL;
+    }
   ret->map_length = len;
   return ret;
 }
@@ -164,21 +159,21 @@ GNUNET_CONTAINER_multihashmap32_create (unsigned int len)
  * @param map the map
  */
 void
-GNUNET_CONTAINER_multihashmap32_destroy (
+GNUNET_CONTAINER_multihashmap32_destroy(
   struct GNUNET_CONTAINER_MultiHashMap32 *map)
 {
   struct MapEntry *e;
 
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    while (NULL != (e = map->map[i]))
     {
-      map->map[i] = e->next;
-      GNUNET_free (e);
+      while (NULL != (e = map->map[i]))
+        {
+          map->map[i] = e->next;
+          GNUNET_free(e);
+        }
     }
-  }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  GNUNET_free(map->map);
+  GNUNET_free(map);
 }
 
 
@@ -190,10 +185,10 @@ GNUNET_CONTAINER_multihashmap32_destroy (
  * @return offset into the "map" array of "m"
  */
 static unsigned int
-idx_of (const struct GNUNET_CONTAINER_MultiHashMap32 *m, const uint32_t key)
+idx_of(const struct GNUNET_CONTAINER_MultiHashMap32 *m, const uint32_t key)
 {
-  GNUNET_assert (NULL != m);
-  return ((unsigned int) key) % m->map_length;
+  GNUNET_assert(NULL != m);
+  return ((unsigned int)key) % m->map_length;
 }
 
 
@@ -204,7 +199,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiHashMap32 *m, const uint32_t key)
  * @return the number of key value pairs
  */
 unsigned int
-GNUNET_CONTAINER_multihashmap32_size (
+GNUNET_CONTAINER_multihashmap32_size(
   const struct GNUNET_CONTAINER_MultiHashMap32 *map)
 {
   return map->size;
@@ -222,19 +217,19 @@ GNUNET_CONTAINER_multihashmap32_size (
  *   key-value pairs with value NULL
  */
 void *
-GNUNET_CONTAINER_multihashmap32_get (
+GNUNET_CONTAINER_multihashmap32_get(
   const struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key)
 {
   struct MapEntry *e;
 
-  e = map->map[idx_of (map, key)];
+  e = map->map[idx_of(map, key)];
   while (NULL != e)
-  {
-    if (key == e->key)
-      return e->value;
-    e = e->next;
-  }
+    {
+      if (key == e->key)
+        return e->value;
+      e = e->next;
+    }
   return NULL;
 }
 
@@ -249,7 +244,7 @@ GNUNET_CONTAINER_multihashmap32_get (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multihashmap32_iterate (
+GNUNET_CONTAINER_multihashmap32_iterate(
   struct GNUNET_CONTAINER_MultiHashMap32 *map,
   GNUNET_CONTAINER_MulitHashMapIterator32Callback it,
   void *it_cls)
@@ -258,29 +253,29 @@ GNUNET_CONTAINER_multihashmap32_iterate (
   struct MapEntry **ce;
 
   count = 0;
-  GNUNET_assert (NULL != map);
+  GNUNET_assert(NULL != map);
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    struct MapEntry *e;
-
-    *ce = map->map[i];
-    while (NULL != (e = *ce))
     {
-      *ce = e->next;
-      if (NULL != it)
-      {
-        if (GNUNET_OK != it (it_cls, e->key, e->value))
+      struct MapEntry *e;
+
+      *ce = map->map[i];
+      while (NULL != (e = *ce))
         {
-          GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-          return GNUNET_SYSERR;
+          *ce = e->next;
+          if (NULL != it)
+            {
+              if (GNUNET_OK != it(it_cls, e->key, e->value))
+                {
+                  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                  return GNUNET_SYSERR;
+                }
+            }
+          count++;
         }
-      }
-      count++;
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -293,8 +288,8 @@ GNUNET_CONTAINER_multihashmap32_iterate (
  * @param bme the entry that is about to be free'd
  */
 static void
-update_next_cache (struct GNUNET_CONTAINER_MultiHashMap32 *map,
-                   const struct MapEntry *me)
+update_next_cache(struct GNUNET_CONTAINER_MultiHashMap32 *map,
+                  const struct MapEntry *me)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i] == me)
@@ -314,7 +309,7 @@ update_next_cache (struct GNUNET_CONTAINER_MultiHashMap32 *map,
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multihashmap32_remove (
+GNUNET_CONTAINER_multihashmap32_remove(
   struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key,
   const void *value)
@@ -325,25 +320,25 @@ GNUNET_CONTAINER_multihashmap32_remove (
 
   map->modification_counter++;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   p = NULL;
   e = map->map[i];
   while (e != NULL)
-  {
-    if ((key == e->key) && (value == e->value))
     {
-      if (p == NULL)
-        map->map[i] = e->next;
-      else
-        p->next = e->next;
-      update_next_cache (map, e);
-      GNUNET_free (e);
-      map->size--;
-      return GNUNET_YES;
+      if ((key == e->key) && (value == e->value))
+        {
+          if (p == NULL)
+            map->map[i] = e->next;
+          else
+            p->next = e->next;
+          update_next_cache(map, e);
+          GNUNET_free(e);
+          map->size--;
+          return GNUNET_YES;
+        }
+      p = e;
+      e = e->next;
     }
-    p = e;
-    e = e->next;
-  }
   return GNUNET_NO;
 }
 
@@ -357,7 +352,7 @@ GNUNET_CONTAINER_multihashmap32_remove (
  * @return number of values removed
  */
 int
-GNUNET_CONTAINER_multihashmap32_remove_all (
+GNUNET_CONTAINER_multihashmap32_remove_all(
   struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key)
 {
@@ -369,32 +364,32 @@ GNUNET_CONTAINER_multihashmap32_remove_all (
   map->modification_counter++;
 
   ret = 0;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   p = NULL;
   e = map->map[i];
   while (e != NULL)
-  {
-    if (key == e->key)
     {
-      if (p == NULL)
-        map->map[i] = e->next;
-      else
-        p->next = e->next;
-      update_next_cache (map, e);
-      GNUNET_free (e);
-      map->size--;
-      if (p == NULL)
-        e = map->map[i];
+      if (key == e->key)
+        {
+          if (p == NULL)
+            map->map[i] = e->next;
+          else
+            p->next = e->next;
+          update_next_cache(map, e);
+          GNUNET_free(e);
+          map->size--;
+          if (p == NULL)
+            e = map->map[i];
+          else
+            e = p->next;
+          ret++;
+        }
       else
-        e = p->next;
-      ret++;
-    }
-    else
-    {
-      p = e;
-      e = e->next;
+        {
+          p = e;
+          e = e->next;
+        }
     }
-  }
   return ret;
 }
 
@@ -409,19 +404,19 @@ GNUNET_CONTAINER_multihashmap32_remove_all (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multihashmap32_contains (
+GNUNET_CONTAINER_multihashmap32_contains(
   const struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key)
 {
   struct MapEntry *e;
 
-  e = map->map[idx_of (map, key)];
+  e = map->map[idx_of(map, key)];
   while (e != NULL)
-  {
-    if (key == e->key)
-      return GNUNET_YES;
-    e = e->next;
-  }
+    {
+      if (key == e->key)
+        return GNUNET_YES;
+      e = e->next;
+    }
   return GNUNET_NO;
 }
 
@@ -437,20 +432,20 @@ GNUNET_CONTAINER_multihashmap32_contains (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multihashmap32_contains_value (
+GNUNET_CONTAINER_multihashmap32_contains_value(
   const struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key,
   const void *value)
 {
   struct MapEntry *e;
 
-  e = map->map[idx_of (map, key)];
+  e = map->map[idx_of(map, key)];
   while (e != NULL)
-  {
-    if ((key == e->key) && (e->value == value))
-      return GNUNET_YES;
-    e = e->next;
-  }
+    {
+      if ((key == e->key) && (e->value == value))
+        return GNUNET_YES;
+      e = e->next;
+    }
   return GNUNET_NO;
 }
 
@@ -461,7 +456,7 @@ GNUNET_CONTAINER_multihashmap32_contains_value (
  * @param map the hash map to grow
  */
 static void
-grow (struct GNUNET_CONTAINER_MultiHashMap32 *map)
+grow(struct GNUNET_CONTAINER_MultiHashMap32 *map)
 {
   struct MapEntry **old_map;
   struct MapEntry **new_map;
@@ -477,23 +472,23 @@ grow (struct GNUNET_CONTAINER_MultiHashMap32 *map)
     new_len = old_len; /* never use 0 */
   if (new_len == old_len)
     return; /* nothing changed */
-  new_map = GNUNET_malloc_large (new_len * sizeof (struct MapEntry *));
+  new_map = GNUNET_malloc_large(new_len * sizeof(struct MapEntry *));
   if (NULL == new_map)
     return; /* grow not possible */
   map->modification_counter++;
   map->map_length = new_len;
   map->map = new_map;
   for (unsigned int i = 0; i < old_len; i++)
-  {
-    while (NULL != (e = old_map[i]))
     {
-      old_map[i] = e->next;
-      idx = idx_of (map, e->key);
-      e->next = new_map[idx];
-      new_map[idx] = e;
+      while (NULL != (e = old_map[i]))
+        {
+          old_map[i] = e->next;
+          idx = idx_of(map, e->key);
+          e->next = new_map[idx];
+          new_map[idx] = e;
+        }
     }
-  }
-  GNUNET_free (old_map);
+  GNUNET_free(old_map);
 }
 
 
@@ -510,7 +505,7 @@ grow (struct GNUNET_CONTAINER_MultiHashMap32 *map)
  *                       value already exists
  */
 int
-GNUNET_CONTAINER_multihashmap32_put (
+GNUNET_CONTAINER_multihashmap32_put(
   struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key,
   void *value,
@@ -519,29 +514,29 @@ GNUNET_CONTAINER_multihashmap32_put (
   struct MapEntry *e;
   unsigned int i;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
       (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-  {
-    e = map->map[i];
-    while (e != NULL)
     {
-      if (key == e->key)
-      {
-        if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-          return GNUNET_SYSERR;
-        e->value = value;
-        return GNUNET_NO;
-      }
-      e = e->next;
+      e = map->map[i];
+      while (e != NULL)
+        {
+          if (key == e->key)
+            {
+              if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                return GNUNET_SYSERR;
+              e->value = value;
+              return GNUNET_NO;
+            }
+          e = e->next;
+        }
     }
-  }
   if (map->size / 3 >= map->map_length / 4)
-  {
-    grow (map);
-    i = idx_of (map, key);
-  }
-  e = GNUNET_new (struct MapEntry);
+    {
+      grow(map);
+      i = idx_of(map, key);
+    }
+  e = GNUNET_new(struct MapEntry);
   e->key = key;
   e->value = value;
   e->next = map->map[i];
@@ -562,7 +557,7 @@ GNUNET_CONTAINER_multihashmap32_put (
  *         GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multihashmap32_get_multiple (
+GNUNET_CONTAINER_multihashmap32_get_multiple(
   struct GNUNET_CONTAINER_MultiHashMap32 *map,
   uint32_t key,
   GNUNET_CONTAINER_MulitHashMapIterator32Callback it,
@@ -574,22 +569,22 @@ GNUNET_CONTAINER_multihashmap32_get_multiple (
 
   count = 0;
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
 
-  *ce = map->map[idx_of (map, key)];
+  *ce = map->map[idx_of(map, key)];
   while (NULL != (e = *ce))
-  {
-    *ce = e->next;
-    if (key != e->key)
-      continue;
-    if ((NULL != it) && (GNUNET_OK != it (it_cls, key, e->value)))
     {
-      GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-      return GNUNET_SYSERR;
+      *ce = e->next;
+      if (key != e->key)
+        continue;
+      if ((NULL != it) && (GNUNET_OK != it(it_cls, key, e->value)))
+        {
+          GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+          return GNUNET_SYSERR;
+        }
+      count++;
     }
-    count++;
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -607,12 +602,12 @@ GNUNET_CONTAINER_multihashmap32_get_multiple (
  * @return an iterator over the given multihashmap @a map
  */
 struct GNUNET_CONTAINER_MultiHashMap32Iterator *
-GNUNET_CONTAINER_multihashmap32_iterator_create (
+GNUNET_CONTAINER_multihashmap32_iterator_create(
   const struct GNUNET_CONTAINER_MultiHashMap32 *map)
 {
   struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter;
 
-  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap32Iterator);
+  iter = GNUNET_new(struct GNUNET_CONTAINER_MultiHashMap32Iterator);
   iter->map = map;
   iter->modification_counter = map->modification_counter;
   iter->me = map->map[0];
@@ -635,32 +630,32 @@ GNUNET_CONTAINER_multihashmap32_iterator_create (
  *         #GNUNET_NO if we are out of elements
  */
 int
-GNUNET_CONTAINER_multihashmap32_iterator_next (
+GNUNET_CONTAINER_multihashmap32_iterator_next(
   struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter,
   uint32_t *key,
   const void **value)
 {
   /* make sure the map has not been modified */
-  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
+  GNUNET_assert(iter->modification_counter == iter->map->modification_counter);
 
   /* look for the next entry, skipping empty buckets */
   while (1)
-  {
-    if (iter->idx >= iter->map->map_length)
-      return GNUNET_NO;
-    if (NULL != iter->me)
     {
-      if (NULL != key)
-        *key = iter->me->key;
-      if (NULL != value)
-        *value = iter->me->value;
-      iter->me = iter->me->next;
-      return GNUNET_YES;
+      if (iter->idx >= iter->map->map_length)
+        return GNUNET_NO;
+      if (NULL != iter->me)
+        {
+          if (NULL != key)
+            *key = iter->me->key;
+          if (NULL != value)
+            *value = iter->me->value;
+          iter->me = iter->me->next;
+          return GNUNET_YES;
+        }
+      iter->idx += 1;
+      if (iter->idx < iter->map->map_length)
+        iter->me = iter->map->map[iter->idx];
     }
-    iter->idx += 1;
-    if (iter->idx < iter->map->map_length)
-      iter->me = iter->map->map[iter->idx];
-  }
 }
 
 
@@ -670,10 +665,10 @@ GNUNET_CONTAINER_multihashmap32_iterator_next (
  * @param iter the iterator to destroy
  */
 void
-GNUNET_CONTAINER_multihashmap32_iterator_destroy (
+GNUNET_CONTAINER_multihashmap32_iterator_destroy(
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter)
 {
-  GNUNET_free (iter);
+  GNUNET_free(iter);
 }
 
 
diff --git a/src/util/container_multipeermap.c b/src/util/container_multipeermap.c
index d03221cb5..0cd56b9fc 100644
--- a/src/util/container_multipeermap.c
+++ b/src/util/container_multipeermap.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 util/container_multipeermap.c
  * @brief hash map where the same key may be present multiple times
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-multipeermap", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-multipeermap", __VA_ARGS__)
 
 /**
  * Maximum recursion depth for callbacks of
@@ -40,9 +40,7 @@
 /**
  * An entry in the hash map with the full key.
  */
-struct BigMapEntry
-{
-
+struct BigMapEntry {
   /**
    * Value of the entry.
    */
@@ -63,9 +61,7 @@ struct BigMapEntry
 /**
  * An entry in the hash map with just a pointer to the key.
  */
-struct SmallMapEntry
-{
-
+struct SmallMapEntry {
   /**
    * Value of the entry.
    */
@@ -86,8 +82,7 @@ struct SmallMapEntry
 /**
  * Entry in the map.
  */
-union MapEntry
-{
+union MapEntry {
   /**
    * Variant used if map entries only contain a pointer to the key.
    */
@@ -103,8 +98,7 @@ union MapEntry
 /**
  * Internal representation of the hash map.
  */
-struct GNUNET_CONTAINER_MultiPeerMap
-{
+struct GNUNET_CONTAINER_MultiPeerMap {
   /**
    * All of our buckets.
    */
@@ -151,8 +145,7 @@ struct GNUNET_CONTAINER_MultiPeerMap
  * Cursor into a multipeermap.
  * Allows to enumerate elements asynchronously.
  */
-struct GNUNET_CONTAINER_MultiPeerMapIterator
-{
+struct GNUNET_CONTAINER_MultiPeerMapIterator {
   /**
    * Position in the bucket 'idx'
    */
@@ -192,18 +185,18 @@ struct GNUNET_CONTAINER_MultiPeerMapIterator
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiPeerMap *
-GNUNET_CONTAINER_multipeermap_create (unsigned int len, int do_not_copy_keys)
+GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
 {
   struct GNUNET_CONTAINER_MultiPeerMap *map;
 
-  GNUNET_assert (len > 0);
-  map = GNUNET_new (struct GNUNET_CONTAINER_MultiPeerMap);
-  map->map = GNUNET_malloc_large (len * sizeof (union MapEntry));
+  GNUNET_assert(len > 0);
+  map = GNUNET_new(struct GNUNET_CONTAINER_MultiPeerMap);
+  map->map = GNUNET_malloc_large(len * sizeof(union MapEntry));
   if (NULL == map->map)
-  {
-    GNUNET_free (map);
-    return NULL;
-  }
+    {
+      GNUNET_free(map);
+      return NULL;
+    }
   map->map_length = len;
   map->use_small_entries = do_not_copy_keys;
   return map;
@@ -217,44 +210,44 @@ GNUNET_CONTAINER_multipeermap_create (unsigned int len, int do_not_copy_keys)
  * @param map the map
  */
 void
-GNUNET_CONTAINER_multipeermap_destroy (
+GNUNET_CONTAINER_multipeermap_destroy(
   struct GNUNET_CONTAINER_MultiPeerMap *map)
 {
-  GNUNET_assert (0 == map->next_cache_off);
+  GNUNET_assert(0 == map->next_cache_off);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    union MapEntry me;
-
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        GNUNET_free (sme);
-      }
-      me.sme = NULL;
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        GNUNET_free (bme);
-      }
-      me.bme = NULL;
+      union MapEntry me;
+
+      me = map->map[i];
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              GNUNET_free(sme);
+            }
+          me.sme = NULL;
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              GNUNET_free(bme);
+            }
+          me.bme = NULL;
+        }
     }
-  }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  GNUNET_free(map->map);
+  GNUNET_free(map);
 }
 
 
@@ -266,13 +259,13 @@ GNUNET_CONTAINER_multipeermap_destroy (
  * @return offset into the "map" array of "map"
  */
 static unsigned int
-idx_of (const struct GNUNET_CONTAINER_MultiPeerMap *map,
-        const struct GNUNET_PeerIdentity *key)
+idx_of(const struct GNUNET_CONTAINER_MultiPeerMap *map,
+       const struct GNUNET_PeerIdentity *key)
 {
   unsigned int kx;
 
-  GNUNET_assert (NULL != map);
-  GNUNET_memcpy (&kx, key, sizeof (kx));
+  GNUNET_assert(NULL != map);
+  GNUNET_memcpy(&kx, key, sizeof(kx));
   return kx % map->map_length;
 }
 
@@ -284,7 +277,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiPeerMap *map,
  * @return the number of key value pairs
  */
 unsigned int
-GNUNET_CONTAINER_multipeermap_size (
+GNUNET_CONTAINER_multipeermap_size(
   const struct GNUNET_CONTAINER_MultiPeerMap *map)
 {
   return map->size;
@@ -302,25 +295,25 @@ GNUNET_CONTAINER_multipeermap_size (
  *   key-value pairs with value NULL
  */
 void *
-GNUNET_CONTAINER_multipeermap_get (
+GNUNET_CONTAINER_multipeermap_get(
   const struct GNUNET_CONTAINER_MultiPeerMap *map,
   const struct GNUNET_PeerIdentity *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return sme->value;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return sme->value;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return bme->value;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return bme->value;
+    }
   return NULL;
 }
 
@@ -335,7 +328,7 @@ GNUNET_CONTAINER_multipeermap_get (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multipeermap_iterate (
+GNUNET_CONTAINER_multipeermap_iterate(
   struct GNUNET_CONTAINER_MultiPeerMap *map,
   GNUNET_CONTAINER_PeerMapIterator it,
   void *it_cls)
@@ -346,53 +339,53 @@ GNUNET_CONTAINER_multipeermap_iterate (
   struct GNUNET_PeerIdentity kc;
 
   count = 0;
-  GNUNET_assert (NULL != map);
+  GNUNET_assert(NULL != map);
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      ce->sme = me.sme;
-      while (NULL != (sme = ce->sme))
-      {
-        ce->sme = sme->next;
-        if (NULL != it)
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct SmallMapEntry *sme;
+
+          ce->sme = me.sme;
+          while (NULL != (sme = ce->sme))
+            {
+              ce->sme = sme->next;
+              if (NULL != it)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      ce->bme = me.bme;
-      while (NULL != (bme = ce->bme))
-      {
-        ce->bme = bme->next;
-        if (NULL != it)
+      else
         {
-          kc = bme->key;
-          if (GNUNET_OK != it (it_cls, &kc, bme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct BigMapEntry *bme;
+
+          ce->bme = me.bme;
+          while (NULL != (bme = ce->bme))
+            {
+              ce->bme = bme->next;
+              if (NULL != it)
+                {
+                  kc = bme->key;
+                  if (GNUNET_OK != it(it_cls, &kc, bme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -405,8 +398,8 @@ GNUNET_CONTAINER_multipeermap_iterate (
  * @param bme the entry that is about to be free'd
  */
 static void
-update_next_cache_bme (struct GNUNET_CONTAINER_MultiPeerMap *map,
-                       const struct BigMapEntry *bme)
+update_next_cache_bme(struct GNUNET_CONTAINER_MultiPeerMap *map,
+                      const struct BigMapEntry *bme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].bme == bme)
@@ -422,8 +415,8 @@ update_next_cache_bme (struct GNUNET_CONTAINER_MultiPeerMap *map,
  * @param sme the entry that is about to be free'd
  */
 static void
-update_next_cache_sme (struct GNUNET_CONTAINER_MultiPeerMap *map,
-                       const struct SmallMapEntry *sme)
+update_next_cache_sme(struct GNUNET_CONTAINER_MultiPeerMap *map,
+                      const struct SmallMapEntry *sme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].sme == sme)
@@ -443,56 +436,56 @@ update_next_cache_sme (struct GNUNET_CONTAINER_MultiPeerMap *map,
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multipeermap_remove (struct GNUNET_CONTAINER_MultiPeerMap *map,
-                                      const struct GNUNET_PeerIdentity *key,
-                                      const void *value)
+GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map,
+                                     const struct GNUNET_PeerIdentity *key,
+                                     const void *value)
 {
   union MapEntry me;
   unsigned int i;
 
   map->modification_counter++;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *p = NULL;
-
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
     {
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (value == sme->value))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = sme;
+      struct SmallMapEntry *p = NULL;
+
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, sme->key)) && (value == sme->value))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = sme;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *p = NULL;
-
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
     {
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (value == bme->value))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = bme;
+      struct BigMapEntry *p = NULL;
+
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, &bme->key)) && (value == bme->value))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = bme;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -506,7 +499,7 @@ GNUNET_CONTAINER_multipeermap_remove (struct GNUNET_CONTAINER_MultiPeerMap *map,
  * @return number of values removed
  */
 int
-GNUNET_CONTAINER_multipeermap_remove_all (
+GNUNET_CONTAINER_multipeermap_remove_all(
   struct GNUNET_CONTAINER_MultiPeerMap *map,
   const struct GNUNET_PeerIdentity *key)
 {
@@ -517,70 +510,70 @@ GNUNET_CONTAINER_multipeermap_remove_all (
   map->modification_counter++;
 
   ret = 0;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-    struct SmallMapEntry *p;
-
-    p = NULL;
-    sme = me.sme;
-    while (NULL != sme)
     {
-      if (0 == GNUNET_memcmp (key, sme->key))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        if (NULL == p)
-          sme = map->map[i].sme;
-        else
-          sme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = sme;
-        sme = sme->next;
-      }
+      struct SmallMapEntry *sme;
+      struct SmallMapEntry *p;
+
+      p = NULL;
+      sme = me.sme;
+      while (NULL != sme)
+        {
+          if (0 == GNUNET_memcmp(key, sme->key))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              if (NULL == p)
+                sme = map->map[i].sme;
+              else
+                sme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = sme;
+              sme = sme->next;
+            }
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-    struct BigMapEntry *p;
-
-    p = NULL;
-    bme = me.bme;
-    while (NULL != bme)
     {
-      if (0 == GNUNET_memcmp (key, &bme->key))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        if (NULL == p)
-          bme = map->map[i].bme;
-        else
-          bme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = bme;
-        bme = bme->next;
-      }
+      struct BigMapEntry *bme;
+      struct BigMapEntry *p;
+
+      p = NULL;
+      bme = me.bme;
+      while (NULL != bme)
+        {
+          if (0 == GNUNET_memcmp(key, &bme->key))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              if (NULL == p)
+                bme = map->map[i].bme;
+              else
+                bme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = bme;
+              bme = bme->next;
+            }
+        }
     }
-  }
   return ret;
 }
 
@@ -595,25 +588,25 @@ GNUNET_CONTAINER_multipeermap_remove_all (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multipeermap_contains (
+GNUNET_CONTAINER_multipeermap_contains(
   const struct GNUNET_CONTAINER_MultiPeerMap *map,
   const struct GNUNET_PeerIdentity *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -629,26 +622,26 @@ GNUNET_CONTAINER_multipeermap_contains (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multipeermap_contains_value (
+GNUNET_CONTAINER_multipeermap_contains_value(
   const struct GNUNET_CONTAINER_MultiPeerMap *map,
   const struct GNUNET_PeerIdentity *key,
   const void *value)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (sme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if ((0 == GNUNET_memcmp(key, sme->key)) && (sme->value == value))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (bme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if ((0 == GNUNET_memcmp(key, &bme->key)) && (bme->value == value))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -659,7 +652,7 @@ GNUNET_CONTAINER_multipeermap_contains_value (
  * @param map the hash map to grow
  */
 static void
-grow (struct GNUNET_CONTAINER_MultiPeerMap *map)
+grow(struct GNUNET_CONTAINER_MultiPeerMap *map)
 {
   union MapEntry *old_map;
   union MapEntry *new_map;
@@ -669,46 +662,46 @@ grow (struct GNUNET_CONTAINER_MultiPeerMap *map)
 
   old_map = map->map;
   old_len = map->map_length;
-  GNUNET_assert (0 != old_len);
+  GNUNET_assert(0 != old_len);
   new_len = old_len * 2;
   if (0 == new_len) /* 2^31 * 2 == 0 */
     new_len = old_len; /* never use 0 */
   if (new_len == old_len)
     return; /* nothing changed */
-  new_map = GNUNET_malloc_large (new_len * sizeof (union MapEntry));
+  new_map = GNUNET_malloc_large(new_len * sizeof(union MapEntry));
   if (NULL == new_map)
     return; /* grow not possible */
   map->modification_counter++;
   map->map_length = new_len;
   map->map = new_map;
   for (unsigned int i = 0; i < old_len; i++)
-  {
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-
-      while (NULL != (sme = old_map[i].sme))
-      {
-        old_map[i].sme = sme->next;
-        idx = idx_of (map, sme->key);
-        sme->next = new_map[idx].sme;
-        new_map[idx].sme = sme;
-      }
-    }
-    else
     {
-      struct BigMapEntry *bme;
-
-      while (NULL != (bme = old_map[i].bme))
-      {
-        old_map[i].bme = bme->next;
-        idx = idx_of (map, &bme->key);
-        bme->next = new_map[idx].bme;
-        new_map[idx].bme = bme;
-      }
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+
+          while (NULL != (sme = old_map[i].sme))
+            {
+              old_map[i].sme = sme->next;
+              idx = idx_of(map, sme->key);
+              sme->next = new_map[idx].sme;
+              new_map[idx].sme = sme;
+            }
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+
+          while (NULL != (bme = old_map[i].bme))
+            {
+              old_map[i].bme = bme->next;
+              idx = idx_of(map, &bme->key);
+              bme->next = new_map[idx].bme;
+              new_map[idx].bme = bme;
+            }
+        }
     }
-  }
-  GNUNET_free (old_map);
+  GNUNET_free(old_map);
 }
 
 
@@ -725,71 +718,71 @@ grow (struct GNUNET_CONTAINER_MultiPeerMap *map)
  *                       value already exists
  */
 int
-GNUNET_CONTAINER_multipeermap_put (struct GNUNET_CONTAINER_MultiPeerMap *map,
-                                   const struct GNUNET_PeerIdentity *key,
-                                   void *value,
-                                   enum GNUNET_CONTAINER_MultiHashMapOption opt)
+GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map,
+                                  const struct GNUNET_PeerIdentity *key,
+                                  void *value,
+                                  enum GNUNET_CONTAINER_MultiHashMapOption opt)
 {
   union MapEntry me;
   unsigned int i;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
       (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      for (sme = me.sme; NULL != sme; sme = sme->next)
-        if (0 == GNUNET_memcmp (key, sme->key))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          sme->value = value;
-          return GNUNET_NO;
+          struct SmallMapEntry *sme;
+
+          for (sme = me.sme; NULL != sme; sme = sme->next)
+            if (0 == GNUNET_memcmp(key, sme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                sme->value = value;
+                return GNUNET_NO;
+              }
         }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      for (bme = me.bme; NULL != bme; bme = bme->next)
-        if (0 == GNUNET_memcmp (key, &bme->key))
+      else
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          bme->value = value;
-          return GNUNET_NO;
+          struct BigMapEntry *bme;
+
+          for (bme = me.bme; NULL != bme; bme = bme->next)
+            if (0 == GNUNET_memcmp(key, &bme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                bme->value = value;
+                return GNUNET_NO;
+              }
         }
     }
-  }
   if (map->size / 3 >= map->map_length / 4)
-  {
-    grow (map);
-    i = idx_of (map, key);
-  }
+    {
+      grow(map);
+      i = idx_of(map, key);
+    }
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    sme = GNUNET_new (struct SmallMapEntry);
-    sme->key = key;
-    sme->value = value;
-    sme->next = map->map[i].sme;
-    map->map[i].sme = sme;
-  }
+    {
+      struct SmallMapEntry *sme;
+
+      sme = GNUNET_new(struct SmallMapEntry);
+      sme->key = key;
+      sme->value = value;
+      sme->next = map->map[i].sme;
+      map->map[i].sme = sme;
+    }
   else
-  {
-    struct BigMapEntry *bme;
-
-    bme = GNUNET_new (struct BigMapEntry);
-    bme->key = *key;
-    bme->value = value;
-    bme->next = map->map[i].bme;
-    map->map[i].bme = bme;
-  }
+    {
+      struct BigMapEntry *bme;
+
+      bme = GNUNET_new(struct BigMapEntry);
+      bme->key = *key;
+      bme->value = value;
+      bme->next = map->map[i].bme;
+      map->map[i].bme = bme;
+    }
   map->size++;
   return GNUNET_OK;
 }
@@ -806,7 +799,7 @@ GNUNET_CONTAINER_multipeermap_put (struct GNUNET_CONTAINER_MultiPeerMap *map,
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multipeermap_get_multiple (
+GNUNET_CONTAINER_multipeermap_get_multiple(
   struct GNUNET_CONTAINER_MultiPeerMap *map,
   const struct GNUNET_PeerIdentity *key,
   GNUNET_CONTAINER_PeerMapIterator it,
@@ -817,46 +810,46 @@ GNUNET_CONTAINER_multipeermap_get_multiple (
   union MapEntry *ce;
 
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   count = 0;
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    ce->sme = me.sme;
-    while (NULL != (sme = ce->sme))
     {
-      ce->sme = sme->next;
-      if (0 != GNUNET_memcmp (key, sme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, sme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct SmallMapEntry *sme;
+
+      ce->sme = me.sme;
+      while (NULL != (sme = ce->sme))
+        {
+          ce->sme = sme->next;
+          if (0 != GNUNET_memcmp(key, sme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, sme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-
-    ce->bme = me.bme;
-    while (NULL != (bme = ce->bme))
     {
-      ce->bme = bme->next;
-      if (0 != GNUNET_memcmp (key, &bme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, bme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct BigMapEntry *bme;
+
+      ce->bme = me.bme;
+      while (NULL != (bme = ce->bme))
+        {
+          ce->bme = bme->next;
+          if (0 != GNUNET_memcmp(key, &bme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, bme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -873,7 +866,7 @@ GNUNET_CONTAINER_multipeermap_get_multiple (
  * @return the number of key value pairs processed, zero or one.
  */
 unsigned int
-GNUNET_CONTAINER_multipeermap_get_random (
+GNUNET_CONTAINER_multipeermap_get_random(
   const struct GNUNET_CONTAINER_MultiPeerMap *map,
   GNUNET_CONTAINER_PeerMapIterator it,
   void *it_cls)
@@ -885,48 +878,48 @@ GNUNET_CONTAINER_multipeermap_get_random (
     return 0;
   if (NULL == it)
     return 1;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, map->size);
+  off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, map->size);
   for (unsigned int idx = 0; idx < map->map_length; idx++)
-  {
-    me = map->map[idx];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        if (0 == off)
+      me = map->map[idx];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        if (0 == off)
+      else
         {
-          if (GNUNET_OK != it (it_cls, &bme->key, bme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, &bme->key, bme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
     }
-  }
-  GNUNET_break (0);
+  GNUNET_break(0);
   return GNUNET_SYSERR;
 }
 
@@ -944,12 +937,12 @@ GNUNET_CONTAINER_multipeermap_get_random (
  * @return an iterator over the given multipeermap 'map'
  */
 struct GNUNET_CONTAINER_MultiPeerMapIterator *
-GNUNET_CONTAINER_multipeermap_iterator_create (
+GNUNET_CONTAINER_multipeermap_iterator_create(
   const struct GNUNET_CONTAINER_MultiPeerMap *map)
 {
   struct GNUNET_CONTAINER_MultiPeerMapIterator *iter;
 
-  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiPeerMapIterator);
+  iter = GNUNET_new(struct GNUNET_CONTAINER_MultiPeerMapIterator);
   iter->map = map;
   iter->modification_counter = map->modification_counter;
   iter->me = map->map[0];
@@ -972,47 +965,47 @@ GNUNET_CONTAINER_multipeermap_iterator_create (
  *         #GNUNET_NO if we are out of elements
  */
 int
-GNUNET_CONTAINER_multipeermap_iterator_next (
+GNUNET_CONTAINER_multipeermap_iterator_next(
   struct GNUNET_CONTAINER_MultiPeerMapIterator *iter,
   struct GNUNET_PeerIdentity *key,
   const void **value)
 {
   /* make sure the map has not been modified */
-  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
+  GNUNET_assert(iter->modification_counter == iter->map->modification_counter);
 
   /* look for the next entry, skipping empty buckets */
   while (1)
-  {
-    if (iter->idx >= iter->map->map_length)
-      return GNUNET_NO;
-    if (GNUNET_YES == iter->map->use_small_entries)
     {
-      if (NULL != iter->me.sme)
-      {
-        if (NULL != key)
-          *key = *iter->me.sme->key;
-        if (NULL != value)
-          *value = iter->me.sme->value;
-        iter->me.sme = iter->me.sme->next;
-        return GNUNET_YES;
-      }
-    }
-    else
-    {
-      if (NULL != iter->me.bme)
-      {
-        if (NULL != key)
-          *key = iter->me.bme->key;
-        if (NULL != value)
-          *value = iter->me.bme->value;
-        iter->me.bme = iter->me.bme->next;
-        return GNUNET_YES;
-      }
+      if (iter->idx >= iter->map->map_length)
+        return GNUNET_NO;
+      if (GNUNET_YES == iter->map->use_small_entries)
+        {
+          if (NULL != iter->me.sme)
+            {
+              if (NULL != key)
+                *key = *iter->me.sme->key;
+              if (NULL != value)
+                *value = iter->me.sme->value;
+              iter->me.sme = iter->me.sme->next;
+              return GNUNET_YES;
+            }
+        }
+      else
+        {
+          if (NULL != iter->me.bme)
+            {
+              if (NULL != key)
+                *key = iter->me.bme->key;
+              if (NULL != value)
+                *value = iter->me.bme->value;
+              iter->me.bme = iter->me.bme->next;
+              return GNUNET_YES;
+            }
+        }
+      iter->idx += 1;
+      if (iter->idx < iter->map->map_length)
+        iter->me = iter->map->map[iter->idx];
     }
-    iter->idx += 1;
-    if (iter->idx < iter->map->map_length)
-      iter->me = iter->map->map[iter->idx];
-  }
 }
 
 
@@ -1022,10 +1015,10 @@ GNUNET_CONTAINER_multipeermap_iterator_next (
  * @param iter the iterator to destroy
  */
 void
-GNUNET_CONTAINER_multipeermap_iterator_destroy (
+GNUNET_CONTAINER_multipeermap_iterator_destroy(
   struct GNUNET_CONTAINER_MultiPeerMapIterator *iter)
 {
-  GNUNET_free (iter);
+  GNUNET_free(iter);
 }
 
 
diff --git a/src/util/container_multishortmap.c b/src/util/container_multishortmap.c
index 0371b0a48..4f2bc149d 100644
--- a/src/util/container_multishortmap.c
+++ b/src/util/container_multishortmap.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 util/container_multishortmap.c
  * @brief hash map where the same key may be present multiple times
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-multishortmap", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-multishortmap", __VA_ARGS__)
 
 /**
  * Maximum recursion depth for callbacks of
@@ -41,9 +41,7 @@
 /**
  * An entry in the hash map with the full key.
  */
-struct BigMapEntry
-{
-
+struct BigMapEntry {
   /**
    * Value of the entry.
    */
@@ -64,9 +62,7 @@ struct BigMapEntry
 /**
  * An entry in the hash map with just a pointer to the key.
  */
-struct SmallMapEntry
-{
-
+struct SmallMapEntry {
   /**
    * Value of the entry.
    */
@@ -87,8 +83,7 @@ struct SmallMapEntry
 /**
  * Entry in the map.
  */
-union MapEntry
-{
+union MapEntry {
   /**
    * Variant used if map entries only contain a pointer to the key.
    */
@@ -104,8 +99,7 @@ union MapEntry
 /**
  * Internal representation of the hash map.
  */
-struct GNUNET_CONTAINER_MultiShortmap
-{
+struct GNUNET_CONTAINER_MultiShortmap {
   /**
    * All of our buckets.
    */
@@ -152,8 +146,7 @@ struct GNUNET_CONTAINER_MultiShortmap
  * Cursor into a multishortmap.
  * Allows to enumerate elements asynchronously.
  */
-struct GNUNET_CONTAINER_MultiShortmapIterator
-{
+struct GNUNET_CONTAINER_MultiShortmapIterator {
   /**
    * Position in the bucket 'idx'
    */
@@ -193,18 +186,18 @@ struct GNUNET_CONTAINER_MultiShortmapIterator
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiShortmap *
-GNUNET_CONTAINER_multishortmap_create (unsigned int len, int do_not_copy_keys)
+GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
 {
   struct GNUNET_CONTAINER_MultiShortmap *map;
 
-  GNUNET_assert (len > 0);
-  map = GNUNET_new (struct GNUNET_CONTAINER_MultiShortmap);
-  map->map = GNUNET_malloc_large (len * sizeof (union MapEntry));
+  GNUNET_assert(len > 0);
+  map = GNUNET_new(struct GNUNET_CONTAINER_MultiShortmap);
+  map->map = GNUNET_malloc_large(len * sizeof(union MapEntry));
   if (NULL == map->map)
-  {
-    GNUNET_free (map);
-    return NULL;
-  }
+    {
+      GNUNET_free(map);
+      return NULL;
+    }
   map->map_length = len;
   map->use_small_entries = do_not_copy_keys;
   return map;
@@ -218,44 +211,44 @@ GNUNET_CONTAINER_multishortmap_create (unsigned int len, int do_not_copy_keys)
  * @param map the map
  */
 void
-GNUNET_CONTAINER_multishortmap_destroy (
+GNUNET_CONTAINER_multishortmap_destroy(
   struct GNUNET_CONTAINER_MultiShortmap *map)
 {
-  GNUNET_assert (0 == map->next_cache_off);
+  GNUNET_assert(0 == map->next_cache_off);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    union MapEntry me;
-
-    me = map->map[i];
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        GNUNET_free (sme);
-      }
-      me.sme = NULL;
-    }
-    else
     {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        GNUNET_free (bme);
-      }
-      me.bme = NULL;
+      union MapEntry me;
+
+      me = map->map[i];
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              GNUNET_free(sme);
+            }
+          me.sme = NULL;
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              GNUNET_free(bme);
+            }
+          me.bme = NULL;
+        }
     }
-  }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  GNUNET_free(map->map);
+  GNUNET_free(map);
 }
 
 
@@ -267,13 +260,13 @@ GNUNET_CONTAINER_multishortmap_destroy (
  * @return offset into the "map" array of "map"
  */
 static unsigned int
-idx_of (const struct GNUNET_CONTAINER_MultiShortmap *map,
-        const struct GNUNET_ShortHashCode *key)
+idx_of(const struct GNUNET_CONTAINER_MultiShortmap *map,
+       const struct GNUNET_ShortHashCode *key)
 {
   unsigned int kx;
 
-  GNUNET_assert (NULL != map);
-  GNUNET_memcpy (&kx, key, sizeof (kx));
+  GNUNET_assert(NULL != map);
+  GNUNET_memcpy(&kx, key, sizeof(kx));
   return kx % map->map_length;
 }
 
@@ -285,7 +278,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiShortmap *map,
  * @return the number of key value pairs
  */
 unsigned int
-GNUNET_CONTAINER_multishortmap_size (
+GNUNET_CONTAINER_multishortmap_size(
   const struct GNUNET_CONTAINER_MultiShortmap *map)
 {
   return map->size;
@@ -303,25 +296,25 @@ GNUNET_CONTAINER_multishortmap_size (
  *   key-value pairs with value NULL
  */
 void *
-GNUNET_CONTAINER_multishortmap_get (
+GNUNET_CONTAINER_multishortmap_get(
   const struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return sme->value;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return sme->value;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return bme->value;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return bme->value;
+    }
   return NULL;
 }
 
@@ -336,7 +329,7 @@ GNUNET_CONTAINER_multishortmap_get (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multishortmap_iterate (
+GNUNET_CONTAINER_multishortmap_iterate(
   struct GNUNET_CONTAINER_MultiShortmap *map,
   GNUNET_CONTAINER_ShortmapIterator it,
   void *it_cls)
@@ -347,50 +340,50 @@ GNUNET_CONTAINER_multishortmap_iterate (
   struct GNUNET_ShortHashCode kc;
 
   count = 0;
-  GNUNET_assert (NULL != map);
+  GNUNET_assert(NULL != map);
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      ce->sme = me.sme;
-      while (NULL != (sme = ce->sme))
-      {
-        ce->sme = sme->next;
-        if ((NULL != it) && (GNUNET_OK != it (it_cls, sme->key, sme->value)))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-          return GNUNET_SYSERR;
+          struct SmallMapEntry *sme;
+
+          ce->sme = me.sme;
+          while (NULL != (sme = ce->sme))
+            {
+              ce->sme = sme->next;
+              if ((NULL != it) && (GNUNET_OK != it(it_cls, sme->key, sme->value)))
+                {
+                  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                  return GNUNET_SYSERR;
+                }
+              count++;
+            }
         }
-        count++;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      ce->bme = me.bme;
-      while (NULL != (bme = ce->bme))
-      {
-        ce->bme = bme->next;
-        if (NULL != it)
+      else
         {
-          kc = bme->key;
-          if (GNUNET_OK != it (it_cls, &kc, bme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct BigMapEntry *bme;
+
+          ce->bme = me.bme;
+          while (NULL != (bme = ce->bme))
+            {
+              ce->bme = bme->next;
+              if (NULL != it)
+                {
+                  kc = bme->key;
+                  if (GNUNET_OK != it(it_cls, &kc, bme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -403,8 +396,8 @@ GNUNET_CONTAINER_multishortmap_iterate (
  * @param bme the entry that is about to be free'd
  */
 static void
-update_next_cache_bme (struct GNUNET_CONTAINER_MultiShortmap *map,
-                       const struct BigMapEntry *bme)
+update_next_cache_bme(struct GNUNET_CONTAINER_MultiShortmap *map,
+                      const struct BigMapEntry *bme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].bme == bme)
@@ -420,8 +413,8 @@ update_next_cache_bme (struct GNUNET_CONTAINER_MultiShortmap *map,
  * @param sme the entry that is about to be free'd
  */
 static void
-update_next_cache_sme (struct GNUNET_CONTAINER_MultiShortmap *map,
-                       const struct SmallMapEntry *sme)
+update_next_cache_sme(struct GNUNET_CONTAINER_MultiShortmap *map,
+                      const struct SmallMapEntry *sme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].sme == sme)
@@ -441,7 +434,7 @@ update_next_cache_sme (struct GNUNET_CONTAINER_MultiShortmap *map,
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multishortmap_remove (
+GNUNET_CONTAINER_multishortmap_remove(
   struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key,
   const void *value)
@@ -450,48 +443,48 @@ GNUNET_CONTAINER_multishortmap_remove (
   unsigned int i;
 
   map->modification_counter++;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *p = NULL;
-
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
     {
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (value == sme->value))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = sme;
+      struct SmallMapEntry *p = NULL;
+
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, sme->key)) && (value == sme->value))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = sme;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *p = NULL;
-
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
     {
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (value == bme->value))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = bme;
+      struct BigMapEntry *p = NULL;
+
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, &bme->key)) && (value == bme->value))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = bme;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -505,7 +498,7 @@ GNUNET_CONTAINER_multishortmap_remove (
  * @return number of values removed
  */
 int
-GNUNET_CONTAINER_multishortmap_remove_all (
+GNUNET_CONTAINER_multishortmap_remove_all(
   struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key)
 {
@@ -516,70 +509,70 @@ GNUNET_CONTAINER_multishortmap_remove_all (
   map->modification_counter++;
 
   ret = 0;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-    struct SmallMapEntry *p;
-
-    p = NULL;
-    sme = me.sme;
-    while (NULL != sme)
     {
-      if (0 == GNUNET_memcmp (key, sme->key))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        if (NULL == p)
-          sme = map->map[i].sme;
-        else
-          sme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = sme;
-        sme = sme->next;
-      }
+      struct SmallMapEntry *sme;
+      struct SmallMapEntry *p;
+
+      p = NULL;
+      sme = me.sme;
+      while (NULL != sme)
+        {
+          if (0 == GNUNET_memcmp(key, sme->key))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              if (NULL == p)
+                sme = map->map[i].sme;
+              else
+                sme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = sme;
+              sme = sme->next;
+            }
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-    struct BigMapEntry *p;
-
-    p = NULL;
-    bme = me.bme;
-    while (NULL != bme)
     {
-      if (0 == GNUNET_memcmp (key, &bme->key))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        if (NULL == p)
-          bme = map->map[i].bme;
-        else
-          bme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = bme;
-        bme = bme->next;
-      }
+      struct BigMapEntry *bme;
+      struct BigMapEntry *p;
+
+      p = NULL;
+      bme = me.bme;
+      while (NULL != bme)
+        {
+          if (0 == GNUNET_memcmp(key, &bme->key))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              if (NULL == p)
+                bme = map->map[i].bme;
+              else
+                bme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = bme;
+              bme = bme->next;
+            }
+        }
     }
-  }
   return ret;
 }
 
@@ -594,25 +587,25 @@ GNUNET_CONTAINER_multishortmap_remove_all (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multishortmap_contains (
+GNUNET_CONTAINER_multishortmap_contains(
   const struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -628,26 +621,26 @@ GNUNET_CONTAINER_multishortmap_contains (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multishortmap_contains_value (
+GNUNET_CONTAINER_multishortmap_contains_value(
   const struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key,
   const void *value)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (sme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if ((0 == GNUNET_memcmp(key, sme->key)) && (sme->value == value))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (bme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if ((0 == GNUNET_memcmp(key, &bme->key)) && (bme->value == value))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -658,7 +651,7 @@ GNUNET_CONTAINER_multishortmap_contains_value (
  * @param map the hash map to grow
  */
 static void
-grow (struct GNUNET_CONTAINER_MultiShortmap *map)
+grow(struct GNUNET_CONTAINER_MultiShortmap *map)
 {
   union MapEntry *old_map;
   union MapEntry *new_map;
@@ -673,40 +666,40 @@ grow (struct GNUNET_CONTAINER_MultiShortmap *map)
     new_len = old_len; /* never use 0 */
   if (new_len == old_len)
     return; /* nothing changed */
-  new_map = GNUNET_malloc_large (new_len * sizeof (union MapEntry));
+  new_map = GNUNET_malloc_large(new_len * sizeof(union MapEntry));
   if (NULL == new_map)
     return; /* grow not possible */
   map->modification_counter++;
   map->map_length = new_len;
   map->map = new_map;
   for (unsigned int i = 0; i < old_len; i++)
-  {
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-
-      while (NULL != (sme = old_map[i].sme))
-      {
-        old_map[i].sme = sme->next;
-        idx = idx_of (map, sme->key);
-        sme->next = new_map[idx].sme;
-        new_map[idx].sme = sme;
-      }
-    }
-    else
     {
-      struct BigMapEntry *bme;
-
-      while (NULL != (bme = old_map[i].bme))
-      {
-        old_map[i].bme = bme->next;
-        idx = idx_of (map, &bme->key);
-        bme->next = new_map[idx].bme;
-        new_map[idx].bme = bme;
-      }
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+
+          while (NULL != (sme = old_map[i].sme))
+            {
+              old_map[i].sme = sme->next;
+              idx = idx_of(map, sme->key);
+              sme->next = new_map[idx].sme;
+              new_map[idx].sme = sme;
+            }
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+
+          while (NULL != (bme = old_map[i].bme))
+            {
+              old_map[i].bme = bme->next;
+              idx = idx_of(map, &bme->key);
+              bme->next = new_map[idx].bme;
+              new_map[idx].bme = bme;
+            }
+        }
     }
-  }
-  GNUNET_free (old_map);
+  GNUNET_free(old_map);
 }
 
 
@@ -723,7 +716,7 @@ grow (struct GNUNET_CONTAINER_MultiShortmap *map)
  *                       value already exists
  */
 int
-GNUNET_CONTAINER_multishortmap_put (
+GNUNET_CONTAINER_multishortmap_put(
   struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key,
   void *value,
@@ -732,59 +725,59 @@ GNUNET_CONTAINER_multishortmap_put (
   union MapEntry me;
   unsigned int i;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
       (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-        if (0 == GNUNET_memcmp (key, sme->key))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          sme->value = value;
-          return GNUNET_NO;
+          for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+            if (0 == GNUNET_memcmp(key, sme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                sme->value = value;
+                return GNUNET_NO;
+              }
         }
-    }
-    else
-    {
-      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-        if (0 == GNUNET_memcmp (key, &bme->key))
+      else
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          bme->value = value;
-          return GNUNET_NO;
+          for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+            if (0 == GNUNET_memcmp(key, &bme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                bme->value = value;
+                return GNUNET_NO;
+              }
         }
     }
-  }
   if (map->size / 3 >= map->map_length / 4)
-  {
-    grow (map);
-    i = idx_of (map, key);
-  }
+    {
+      grow(map);
+      i = idx_of(map, key);
+    }
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    sme = GNUNET_new (struct SmallMapEntry);
-    sme->key = key;
-    sme->value = value;
-    sme->next = map->map[i].sme;
-    map->map[i].sme = sme;
-  }
+    {
+      struct SmallMapEntry *sme;
+
+      sme = GNUNET_new(struct SmallMapEntry);
+      sme->key = key;
+      sme->value = value;
+      sme->next = map->map[i].sme;
+      map->map[i].sme = sme;
+    }
   else
-  {
-    struct BigMapEntry *bme;
-
-    bme = GNUNET_new (struct BigMapEntry);
-    bme->key = *key;
-    bme->value = value;
-    bme->next = map->map[i].bme;
-    map->map[i].bme = bme;
-  }
+    {
+      struct BigMapEntry *bme;
+
+      bme = GNUNET_new(struct BigMapEntry);
+      bme->key = *key;
+      bme->value = value;
+      bme->next = map->map[i].bme;
+      map->map[i].bme = bme;
+    }
   map->size++;
   return GNUNET_OK;
 }
@@ -801,7 +794,7 @@ GNUNET_CONTAINER_multishortmap_put (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multishortmap_get_multiple (
+GNUNET_CONTAINER_multishortmap_get_multiple(
   struct GNUNET_CONTAINER_MultiShortmap *map,
   const struct GNUNET_ShortHashCode *key,
   GNUNET_CONTAINER_ShortmapIterator it,
@@ -812,46 +805,46 @@ GNUNET_CONTAINER_multishortmap_get_multiple (
   union MapEntry *ce;
 
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   count = 0;
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    ce->sme = me.sme;
-    while (NULL != (sme = ce->sme))
     {
-      ce->sme = sme->next;
-      if (0 != GNUNET_memcmp (key, sme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, sme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct SmallMapEntry *sme;
+
+      ce->sme = me.sme;
+      while (NULL != (sme = ce->sme))
+        {
+          ce->sme = sme->next;
+          if (0 != GNUNET_memcmp(key, sme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, sme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-
-    ce->bme = me.bme;
-    while (NULL != (bme = ce->bme))
     {
-      ce->bme = bme->next;
-      if (0 != GNUNET_memcmp (key, &bme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, bme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct BigMapEntry *bme;
+
+      ce->bme = me.bme;
+      while (NULL != (bme = ce->bme))
+        {
+          ce->bme = bme->next;
+          if (0 != GNUNET_memcmp(key, &bme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, bme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -868,7 +861,7 @@ GNUNET_CONTAINER_multishortmap_get_multiple (
  * @return the number of key value pairs processed, zero or one.
  */
 unsigned int
-GNUNET_CONTAINER_multishortmap_get_random (
+GNUNET_CONTAINER_multishortmap_get_random(
   const struct GNUNET_CONTAINER_MultiShortmap *map,
   GNUNET_CONTAINER_ShortmapIterator it,
   void *it_cls)
@@ -880,38 +873,38 @@ GNUNET_CONTAINER_multishortmap_get_random (
     return 0;
   if (NULL == it)
     return 1;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, map->size);
+  off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, map->size);
   for (unsigned int idx = 0; idx < map->map_length; idx++)
-  {
-    me = map->map[idx];
-    if (map->use_small_entries)
     {
-      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      {
-        if (0 == off)
+      me = map->map[idx];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+            {
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
-    }
-    else
-    {
-      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      {
-        if (0 == off)
+      else
         {
-          if (GNUNET_OK != it (it_cls, &bme->key, bme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+            {
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, &bme->key, bme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
     }
-  }
-  GNUNET_break (0);
+  GNUNET_break(0);
   return GNUNET_SYSERR;
 }
 
@@ -929,12 +922,12 @@ GNUNET_CONTAINER_multishortmap_get_random (
  * @return an iterator over the given multishortmap 'map'
  */
 struct GNUNET_CONTAINER_MultiShortmapIterator *
-GNUNET_CONTAINER_multishortmap_iterator_create (
+GNUNET_CONTAINER_multishortmap_iterator_create(
   const struct GNUNET_CONTAINER_MultiShortmap *map)
 {
   struct GNUNET_CONTAINER_MultiShortmapIterator *iter;
 
-  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiShortmapIterator);
+  iter = GNUNET_new(struct GNUNET_CONTAINER_MultiShortmapIterator);
   iter->map = map;
   iter->modification_counter = map->modification_counter;
   iter->me = map->map[0];
@@ -957,47 +950,47 @@ GNUNET_CONTAINER_multishortmap_iterator_create (
  *         #GNUNET_NO if we are out of elements
  */
 int
-GNUNET_CONTAINER_multishortmap_iterator_next (
+GNUNET_CONTAINER_multishortmap_iterator_next(
   struct GNUNET_CONTAINER_MultiShortmapIterator *iter,
   struct GNUNET_ShortHashCode *key,
   const void **value)
 {
   /* make sure the map has not been modified */
-  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
+  GNUNET_assert(iter->modification_counter == iter->map->modification_counter);
 
   /* look for the next entry, skipping empty buckets */
   while (1)
-  {
-    if (iter->idx >= iter->map->map_length)
-      return GNUNET_NO;
-    if (GNUNET_YES == iter->map->use_small_entries)
     {
-      if (NULL != iter->me.sme)
-      {
-        if (NULL != key)
-          *key = *iter->me.sme->key;
-        if (NULL != value)
-          *value = iter->me.sme->value;
-        iter->me.sme = iter->me.sme->next;
-        return GNUNET_YES;
-      }
-    }
-    else
-    {
-      if (NULL != iter->me.bme)
-      {
-        if (NULL != key)
-          *key = iter->me.bme->key;
-        if (NULL != value)
-          *value = iter->me.bme->value;
-        iter->me.bme = iter->me.bme->next;
-        return GNUNET_YES;
-      }
+      if (iter->idx >= iter->map->map_length)
+        return GNUNET_NO;
+      if (GNUNET_YES == iter->map->use_small_entries)
+        {
+          if (NULL != iter->me.sme)
+            {
+              if (NULL != key)
+                *key = *iter->me.sme->key;
+              if (NULL != value)
+                *value = iter->me.sme->value;
+              iter->me.sme = iter->me.sme->next;
+              return GNUNET_YES;
+            }
+        }
+      else
+        {
+          if (NULL != iter->me.bme)
+            {
+              if (NULL != key)
+                *key = iter->me.bme->key;
+              if (NULL != value)
+                *value = iter->me.bme->value;
+              iter->me.bme = iter->me.bme->next;
+              return GNUNET_YES;
+            }
+        }
+      iter->idx += 1;
+      if (iter->idx < iter->map->map_length)
+        iter->me = iter->map->map[iter->idx];
     }
-    iter->idx += 1;
-    if (iter->idx < iter->map->map_length)
-      iter->me = iter->map->map[iter->idx];
-  }
 }
 
 
@@ -1007,10 +1000,10 @@ GNUNET_CONTAINER_multishortmap_iterator_next (
  * @param iter the iterator to destroy
  */
 void
-GNUNET_CONTAINER_multishortmap_iterator_destroy (
+GNUNET_CONTAINER_multishortmap_iterator_destroy(
   struct GNUNET_CONTAINER_MultiShortmapIterator *iter)
 {
-  GNUNET_free (iter);
+  GNUNET_free(iter);
 }
 
 
diff --git a/src/util/container_multiuuidmap.c b/src/util/container_multiuuidmap.c
index dd21fd128..78ed7f2b7 100644
--- a/src/util/container_multiuuidmap.c
+++ b/src/util/container_multiuuidmap.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 util/container_multiuuidmap.c
  * @brief hash map for UUIDs where the same key may be present multiple times
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-container-multiuuidmap", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-container-multiuuidmap", __VA_ARGS__)
 
 /**
  * Maximum recursion depth for callbacks of
@@ -41,9 +41,7 @@
 /**
  * An entry in the hash map with the full key.
  */
-struct BigMapEntry
-{
-
+struct BigMapEntry {
   /**
    * Value of the entry.
    */
@@ -64,9 +62,7 @@ struct BigMapEntry
 /**
  * An entry in the hash map with just a pointer to the key.
  */
-struct SmallMapEntry
-{
-
+struct SmallMapEntry {
   /**
    * Value of the entry.
    */
@@ -87,8 +83,7 @@ struct SmallMapEntry
 /**
  * Entry in the map.
  */
-union MapEntry
-{
+union MapEntry {
   /**
    * Variant used if map entries only contain a pointer to the key.
    */
@@ -104,8 +99,7 @@ union MapEntry
 /**
  * Internal representation of the hash map.
  */
-struct GNUNET_CONTAINER_MultiUuidmap
-{
+struct GNUNET_CONTAINER_MultiUuidmap {
   /**
    * All of our buckets.
    */
@@ -152,8 +146,7 @@ struct GNUNET_CONTAINER_MultiUuidmap
  * Cursor into a multiuuidmap.
  * Allows to enumerate elements asynchronously.
  */
-struct GNUNET_CONTAINER_MultiUuidmapIterator
-{
+struct GNUNET_CONTAINER_MultiUuidmapIterator {
   /**
    * Position in the bucket 'idx'
    */
@@ -193,18 +186,18 @@ struct GNUNET_CONTAINER_MultiUuidmapIterator
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiUuidmap *
-GNUNET_CONTAINER_multiuuidmap_create (unsigned int len, int do_not_copy_keys)
+GNUNET_CONTAINER_multiuuidmap_create(unsigned int len, int do_not_copy_keys)
 {
   struct GNUNET_CONTAINER_MultiUuidmap *map;
 
-  GNUNET_assert (len > 0);
-  map = GNUNET_new (struct GNUNET_CONTAINER_MultiUuidmap);
-  map->map = GNUNET_malloc_large (len * sizeof (union MapEntry));
+  GNUNET_assert(len > 0);
+  map = GNUNET_new(struct GNUNET_CONTAINER_MultiUuidmap);
+  map->map = GNUNET_malloc_large(len * sizeof(union MapEntry));
   if (NULL == map->map)
-  {
-    GNUNET_free (map);
-    return NULL;
-  }
+    {
+      GNUNET_free(map);
+      return NULL;
+    }
   map->map_length = len;
   map->use_small_entries = do_not_copy_keys;
   return map;
@@ -218,44 +211,44 @@ GNUNET_CONTAINER_multiuuidmap_create (unsigned int len, int do_not_copy_keys)
  * @param map the map
  */
 void
-GNUNET_CONTAINER_multiuuidmap_destroy (
+GNUNET_CONTAINER_multiuuidmap_destroy(
   struct GNUNET_CONTAINER_MultiUuidmap *map)
 {
-  GNUNET_assert (0 == map->next_cache_off);
+  GNUNET_assert(0 == map->next_cache_off);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    union MapEntry me;
-
-    me = map->map[i];
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-      struct SmallMapEntry *nxt;
-
-      nxt = me.sme;
-      while (NULL != (sme = nxt))
-      {
-        nxt = sme->next;
-        GNUNET_free (sme);
-      }
-      me.sme = NULL;
-    }
-    else
     {
-      struct BigMapEntry *bme;
-      struct BigMapEntry *nxt;
-
-      nxt = me.bme;
-      while (NULL != (bme = nxt))
-      {
-        nxt = bme->next;
-        GNUNET_free (bme);
-      }
-      me.bme = NULL;
+      union MapEntry me;
+
+      me = map->map[i];
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+          struct SmallMapEntry *nxt;
+
+          nxt = me.sme;
+          while (NULL != (sme = nxt))
+            {
+              nxt = sme->next;
+              GNUNET_free(sme);
+            }
+          me.sme = NULL;
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+          struct BigMapEntry *nxt;
+
+          nxt = me.bme;
+          while (NULL != (bme = nxt))
+            {
+              nxt = bme->next;
+              GNUNET_free(bme);
+            }
+          me.bme = NULL;
+        }
     }
-  }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  GNUNET_free(map->map);
+  GNUNET_free(map);
 }
 
 
@@ -267,13 +260,13 @@ GNUNET_CONTAINER_multiuuidmap_destroy (
  * @return offset into the "map" array of "map"
  */
 static unsigned int
-idx_of (const struct GNUNET_CONTAINER_MultiUuidmap *map,
-        const struct GNUNET_Uuid *key)
+idx_of(const struct GNUNET_CONTAINER_MultiUuidmap *map,
+       const struct GNUNET_Uuid *key)
 {
   unsigned int kx;
 
-  GNUNET_assert (NULL != map);
-  GNUNET_memcpy (&kx, key, sizeof (kx));
+  GNUNET_assert(NULL != map);
+  GNUNET_memcpy(&kx, key, sizeof(kx));
   return kx % map->map_length;
 }
 
@@ -285,7 +278,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiUuidmap *map,
  * @return the number of key value pairs
  */
 unsigned int
-GNUNET_CONTAINER_multiuuidmap_size (
+GNUNET_CONTAINER_multiuuidmap_size(
   const struct GNUNET_CONTAINER_MultiUuidmap *map)
 {
   return map->size;
@@ -303,25 +296,25 @@ GNUNET_CONTAINER_multiuuidmap_size (
  *   key-value pairs with value NULL
  */
 void *
-GNUNET_CONTAINER_multiuuidmap_get (
+GNUNET_CONTAINER_multiuuidmap_get(
   const struct GNUNET_CONTAINER_MultiUuidmap *map,
   const struct GNUNET_Uuid *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return sme->value;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return sme->value;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return bme->value;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return bme->value;
+    }
   return NULL;
 }
 
@@ -336,7 +329,7 @@ GNUNET_CONTAINER_multiuuidmap_get (
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multiuuidmap_iterate (
+GNUNET_CONTAINER_multiuuidmap_iterate(
   struct GNUNET_CONTAINER_MultiUuidmap *map,
   GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
   void *it_cls)
@@ -347,50 +340,50 @@ GNUNET_CONTAINER_multiuuidmap_iterate (
   struct GNUNET_Uuid kc;
 
   count = 0;
-  GNUNET_assert (NULL != map);
+  GNUNET_assert(NULL != map);
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   for (unsigned int i = 0; i < map->map_length; i++)
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      struct SmallMapEntry *sme;
-
-      ce->sme = me.sme;
-      while (NULL != (sme = ce->sme))
-      {
-        ce->sme = sme->next;
-        if ((NULL != it) && (GNUNET_OK != it (it_cls, sme->key, sme->value)))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-          return GNUNET_SYSERR;
+          struct SmallMapEntry *sme;
+
+          ce->sme = me.sme;
+          while (NULL != (sme = ce->sme))
+            {
+              ce->sme = sme->next;
+              if ((NULL != it) && (GNUNET_OK != it(it_cls, sme->key, sme->value)))
+                {
+                  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                  return GNUNET_SYSERR;
+                }
+              count++;
+            }
         }
-        count++;
-      }
-    }
-    else
-    {
-      struct BigMapEntry *bme;
-
-      ce->bme = me.bme;
-      while (NULL != (bme = ce->bme))
-      {
-        ce->bme = bme->next;
-        if (NULL != it)
+      else
         {
-          kc = bme->key;
-          if (GNUNET_OK != it (it_cls, &kc, bme->value))
-          {
-            GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-            return GNUNET_SYSERR;
-          }
+          struct BigMapEntry *bme;
+
+          ce->bme = me.bme;
+          while (NULL != (bme = ce->bme))
+            {
+              ce->bme = bme->next;
+              if (NULL != it)
+                {
+                  kc = bme->key;
+                  if (GNUNET_OK != it(it_cls, &kc, bme->value))
+                    {
+                      GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+                      return GNUNET_SYSERR;
+                    }
+                }
+              count++;
+            }
         }
-        count++;
-      }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -403,8 +396,8 @@ GNUNET_CONTAINER_multiuuidmap_iterate (
  * @param bme the entry that is about to be free'd
  */
 static void
-update_next_cache_bme (struct GNUNET_CONTAINER_MultiUuidmap *map,
-                       const struct BigMapEntry *bme)
+update_next_cache_bme(struct GNUNET_CONTAINER_MultiUuidmap *map,
+                      const struct BigMapEntry *bme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].bme == bme)
@@ -420,8 +413,8 @@ update_next_cache_bme (struct GNUNET_CONTAINER_MultiUuidmap *map,
  * @param sme the entry that is about to be free'd
  */
 static void
-update_next_cache_sme (struct GNUNET_CONTAINER_MultiUuidmap *map,
-                       const struct SmallMapEntry *sme)
+update_next_cache_sme(struct GNUNET_CONTAINER_MultiUuidmap *map,
+                      const struct SmallMapEntry *sme)
 {
   for (unsigned int i = 0; i < map->next_cache_off; i++)
     if (map->next_cache[i].sme == sme)
@@ -441,56 +434,56 @@ update_next_cache_sme (struct GNUNET_CONTAINER_MultiUuidmap *map,
  *  is not in the map
  */
 int
-GNUNET_CONTAINER_multiuuidmap_remove (struct GNUNET_CONTAINER_MultiUuidmap *map,
-                                      const struct GNUNET_Uuid *key,
-                                      const void *value)
+GNUNET_CONTAINER_multiuuidmap_remove(struct GNUNET_CONTAINER_MultiUuidmap *map,
+                                     const struct GNUNET_Uuid *key,
+                                     const void *value)
 {
   union MapEntry me;
   unsigned int i;
 
   map->modification_counter++;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *p = NULL;
-
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
     {
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (value == sme->value))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = sme;
+      struct SmallMapEntry *p = NULL;
+
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, sme->key)) && (value == sme->value))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = sme;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *p = NULL;
-
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
     {
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (value == bme->value))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        return GNUNET_YES;
-      }
-      p = bme;
+      struct BigMapEntry *p = NULL;
+
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        {
+          if ((0 == GNUNET_memcmp(key, &bme->key)) && (value == bme->value))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              return GNUNET_YES;
+            }
+          p = bme;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -504,7 +497,7 @@ GNUNET_CONTAINER_multiuuidmap_remove (struct GNUNET_CONTAINER_MultiUuidmap *map,
  * @return number of values removed
  */
 int
-GNUNET_CONTAINER_multiuuidmap_remove_all (
+GNUNET_CONTAINER_multiuuidmap_remove_all(
   struct GNUNET_CONTAINER_MultiUuidmap *map,
   const struct GNUNET_Uuid *key)
 {
@@ -515,70 +508,70 @@ GNUNET_CONTAINER_multiuuidmap_remove_all (
   map->modification_counter++;
 
   ret = 0;
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   me = map->map[i];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-    struct SmallMapEntry *p;
-
-    p = NULL;
-    sme = me.sme;
-    while (NULL != sme)
     {
-      if (0 == GNUNET_memcmp (key, sme->key))
-      {
-        if (NULL == p)
-          map->map[i].sme = sme->next;
-        else
-          p->next = sme->next;
-        update_next_cache_sme (map, sme);
-        GNUNET_free (sme);
-        map->size--;
-        if (NULL == p)
-          sme = map->map[i].sme;
-        else
-          sme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = sme;
-        sme = sme->next;
-      }
+      struct SmallMapEntry *sme;
+      struct SmallMapEntry *p;
+
+      p = NULL;
+      sme = me.sme;
+      while (NULL != sme)
+        {
+          if (0 == GNUNET_memcmp(key, sme->key))
+            {
+              if (NULL == p)
+                map->map[i].sme = sme->next;
+              else
+                p->next = sme->next;
+              update_next_cache_sme(map, sme);
+              GNUNET_free(sme);
+              map->size--;
+              if (NULL == p)
+                sme = map->map[i].sme;
+              else
+                sme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = sme;
+              sme = sme->next;
+            }
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-    struct BigMapEntry *p;
-
-    p = NULL;
-    bme = me.bme;
-    while (NULL != bme)
     {
-      if (0 == GNUNET_memcmp (key, &bme->key))
-      {
-        if (NULL == p)
-          map->map[i].bme = bme->next;
-        else
-          p->next = bme->next;
-        update_next_cache_bme (map, bme);
-        GNUNET_free (bme);
-        map->size--;
-        if (NULL == p)
-          bme = map->map[i].bme;
-        else
-          bme = p->next;
-        ret++;
-      }
-      else
-      {
-        p = bme;
-        bme = bme->next;
-      }
+      struct BigMapEntry *bme;
+      struct BigMapEntry *p;
+
+      p = NULL;
+      bme = me.bme;
+      while (NULL != bme)
+        {
+          if (0 == GNUNET_memcmp(key, &bme->key))
+            {
+              if (NULL == p)
+                map->map[i].bme = bme->next;
+              else
+                p->next = bme->next;
+              update_next_cache_bme(map, bme);
+              GNUNET_free(bme);
+              map->size--;
+              if (NULL == p)
+                bme = map->map[i].bme;
+              else
+                bme = p->next;
+              ret++;
+            }
+          else
+            {
+              p = bme;
+              bme = bme->next;
+            }
+        }
     }
-  }
   return ret;
 }
 
@@ -593,25 +586,25 @@ GNUNET_CONTAINER_multiuuidmap_remove_all (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multiuuidmap_contains (
+GNUNET_CONTAINER_multiuuidmap_contains(
   const struct GNUNET_CONTAINER_MultiUuidmap *map,
   const struct GNUNET_Uuid *key)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if (0 == GNUNET_memcmp (key, sme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if (0 == GNUNET_memcmp(key, sme->key))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if (0 == GNUNET_memcmp (key, &bme->key))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if (0 == GNUNET_memcmp(key, &bme->key))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -627,26 +620,26 @@ GNUNET_CONTAINER_multiuuidmap_contains (
  *         #GNUNET_NO if not
  */
 int
-GNUNET_CONTAINER_multiuuidmap_contains_value (
+GNUNET_CONTAINER_multiuuidmap_contains_value(
   const struct GNUNET_CONTAINER_MultiUuidmap *map,
   const struct GNUNET_Uuid *key,
   const void *value)
 {
   union MapEntry me;
 
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      if ((0 == GNUNET_memcmp (key, sme->key)) && (sme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+        if ((0 == GNUNET_memcmp(key, sme->key)) && (sme->value == value))
+          return GNUNET_YES;
+    }
   else
-  {
-    for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      if ((0 == GNUNET_memcmp (key, &bme->key)) && (bme->value == value))
-        return GNUNET_YES;
-  }
+    {
+      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+        if ((0 == GNUNET_memcmp(key, &bme->key)) && (bme->value == value))
+          return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -657,7 +650,7 @@ GNUNET_CONTAINER_multiuuidmap_contains_value (
  * @param map the hash map to grow
  */
 static void
-grow (struct GNUNET_CONTAINER_MultiUuidmap *map)
+grow(struct GNUNET_CONTAINER_MultiUuidmap *map)
 {
   union MapEntry *old_map;
   union MapEntry *new_map;
@@ -672,40 +665,40 @@ grow (struct GNUNET_CONTAINER_MultiUuidmap *map)
     new_len = old_len; /* never use 0 */
   if (new_len == old_len)
     return; /* nothing changed */
-  new_map = GNUNET_malloc_large (new_len * sizeof (union MapEntry));
+  new_map = GNUNET_malloc_large(new_len * sizeof(union MapEntry));
   if (NULL == new_map)
     return; /* grow not possible */
   map->modification_counter++;
   map->map_length = new_len;
   map->map = new_map;
   for (unsigned int i = 0; i < old_len; i++)
-  {
-    if (map->use_small_entries)
-    {
-      struct SmallMapEntry *sme;
-
-      while (NULL != (sme = old_map[i].sme))
-      {
-        old_map[i].sme = sme->next;
-        idx = idx_of (map, sme->key);
-        sme->next = new_map[idx].sme;
-        new_map[idx].sme = sme;
-      }
-    }
-    else
     {
-      struct BigMapEntry *bme;
-
-      while (NULL != (bme = old_map[i].bme))
-      {
-        old_map[i].bme = bme->next;
-        idx = idx_of (map, &bme->key);
-        bme->next = new_map[idx].bme;
-        new_map[idx].bme = bme;
-      }
+      if (map->use_small_entries)
+        {
+          struct SmallMapEntry *sme;
+
+          while (NULL != (sme = old_map[i].sme))
+            {
+              old_map[i].sme = sme->next;
+              idx = idx_of(map, sme->key);
+              sme->next = new_map[idx].sme;
+              new_map[idx].sme = sme;
+            }
+        }
+      else
+        {
+          struct BigMapEntry *bme;
+
+          while (NULL != (bme = old_map[i].bme))
+            {
+              old_map[i].bme = bme->next;
+              idx = idx_of(map, &bme->key);
+              bme->next = new_map[idx].bme;
+              new_map[idx].bme = bme;
+            }
+        }
     }
-  }
-  GNUNET_free (old_map);
+  GNUNET_free(old_map);
 }
 
 
@@ -722,67 +715,67 @@ grow (struct GNUNET_CONTAINER_MultiUuidmap *map)
  *                       value already exists
  */
 int
-GNUNET_CONTAINER_multiuuidmap_put (struct GNUNET_CONTAINER_MultiUuidmap *map,
-                                   const struct GNUNET_Uuid *key,
-                                   void *value,
-                                   enum GNUNET_CONTAINER_MultiHashMapOption opt)
+GNUNET_CONTAINER_multiuuidmap_put(struct GNUNET_CONTAINER_MultiUuidmap *map,
+                                  const struct GNUNET_Uuid *key,
+                                  void *value,
+                                  enum GNUNET_CONTAINER_MultiHashMapOption opt)
 {
   union MapEntry me;
   unsigned int i;
 
-  i = idx_of (map, key);
+  i = idx_of(map, key);
   if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
       (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-  {
-    me = map->map[i];
-    if (map->use_small_entries)
     {
-      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-        if (0 == GNUNET_memcmp (key, sme->key))
+      me = map->map[i];
+      if (map->use_small_entries)
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          sme->value = value;
-          return GNUNET_NO;
+          for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+            if (0 == GNUNET_memcmp(key, sme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                sme->value = value;
+                return GNUNET_NO;
+              }
         }
-    }
-    else
-    {
-      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-        if (0 == GNUNET_memcmp (key, &bme->key))
+      else
         {
-          if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
-            return GNUNET_SYSERR;
-          bme->value = value;
-          return GNUNET_NO;
+          for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+            if (0 == GNUNET_memcmp(key, &bme->key))
+              {
+                if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                  return GNUNET_SYSERR;
+                bme->value = value;
+                return GNUNET_NO;
+              }
         }
     }
-  }
   if (map->size / 3 >= map->map_length / 4)
-  {
-    grow (map);
-    i = idx_of (map, key);
-  }
+    {
+      grow(map);
+      i = idx_of(map, key);
+    }
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    sme = GNUNET_new (struct SmallMapEntry);
-    sme->key = key;
-    sme->value = value;
-    sme->next = map->map[i].sme;
-    map->map[i].sme = sme;
-  }
+    {
+      struct SmallMapEntry *sme;
+
+      sme = GNUNET_new(struct SmallMapEntry);
+      sme->key = key;
+      sme->value = value;
+      sme->next = map->map[i].sme;
+      map->map[i].sme = sme;
+    }
   else
-  {
-    struct BigMapEntry *bme;
-
-    bme = GNUNET_new (struct BigMapEntry);
-    bme->key = *key;
-    bme->value = value;
-    bme->next = map->map[i].bme;
-    map->map[i].bme = bme;
-  }
+    {
+      struct BigMapEntry *bme;
+
+      bme = GNUNET_new(struct BigMapEntry);
+      bme->key = *key;
+      bme->value = value;
+      bme->next = map->map[i].bme;
+      map->map[i].bme = bme;
+    }
   map->size++;
   return GNUNET_OK;
 }
@@ -799,7 +792,7 @@ GNUNET_CONTAINER_multiuuidmap_put (struct GNUNET_CONTAINER_MultiUuidmap *map,
  *         #GNUNET_SYSERR if it aborted iteration
  */
 int
-GNUNET_CONTAINER_multiuuidmap_get_multiple (
+GNUNET_CONTAINER_multiuuidmap_get_multiple(
   struct GNUNET_CONTAINER_MultiUuidmap *map,
   const struct GNUNET_Uuid *key,
   GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
@@ -810,46 +803,46 @@ GNUNET_CONTAINER_multiuuidmap_get_multiple (
   union MapEntry *ce;
 
   ce = &map->next_cache[map->next_cache_off];
-  GNUNET_assert (++map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(++map->next_cache_off < NEXT_CACHE_SIZE);
   count = 0;
-  me = map->map[idx_of (map, key)];
+  me = map->map[idx_of(map, key)];
   if (map->use_small_entries)
-  {
-    struct SmallMapEntry *sme;
-
-    ce->sme = me.sme;
-    while (NULL != (sme = ce->sme))
     {
-      ce->sme = sme->next;
-      if (0 != GNUNET_memcmp (key, sme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, sme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct SmallMapEntry *sme;
+
+      ce->sme = me.sme;
+      while (NULL != (sme = ce->sme))
+        {
+          ce->sme = sme->next;
+          if (0 != GNUNET_memcmp(key, sme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, sme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
   else
-  {
-    struct BigMapEntry *bme;
-
-    ce->bme = me.bme;
-    while (NULL != (bme = ce->bme))
     {
-      ce->bme = bme->next;
-      if (0 != GNUNET_memcmp (key, &bme->key))
-        continue;
-      if ((NULL != it) && (GNUNET_OK != it (it_cls, key, bme->value)))
-      {
-        GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
-        return GNUNET_SYSERR;
-      }
-      count++;
+      struct BigMapEntry *bme;
+
+      ce->bme = me.bme;
+      while (NULL != (bme = ce->bme))
+        {
+          ce->bme = bme->next;
+          if (0 != GNUNET_memcmp(key, &bme->key))
+            continue;
+          if ((NULL != it) && (GNUNET_OK != it(it_cls, key, bme->value)))
+            {
+              GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
+              return GNUNET_SYSERR;
+            }
+          count++;
+        }
     }
-  }
-  GNUNET_assert (--map->next_cache_off < NEXT_CACHE_SIZE);
+  GNUNET_assert(--map->next_cache_off < NEXT_CACHE_SIZE);
   return count;
 }
 
@@ -866,7 +859,7 @@ GNUNET_CONTAINER_multiuuidmap_get_multiple (
  * @return the number of key value pairs processed, zero or one.
  */
 unsigned int
-GNUNET_CONTAINER_multiuuidmap_get_random (
+GNUNET_CONTAINER_multiuuidmap_get_random(
   const struct GNUNET_CONTAINER_MultiUuidmap *map,
   GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
   void *it_cls)
@@ -878,38 +871,38 @@ GNUNET_CONTAINER_multiuuidmap_get_random (
     return 0;
   if (NULL == it)
     return 1;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, map->size);
+  off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, map->size);
   for (unsigned int idx = 0; idx < map->map_length; idx++)
-  {
-    me = map->map[idx];
-    if (map->use_small_entries)
     {
-      for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
-      {
-        if (0 == off)
+      me = map->map[idx];
+      if (map->use_small_entries)
         {
-          if (GNUNET_OK != it (it_cls, sme->key, sme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          for (struct SmallMapEntry *sme = me.sme; NULL != sme; sme = sme->next)
+            {
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, sme->key, sme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
-    }
-    else
-    {
-      for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
-      {
-        if (0 == off)
+      else
         {
-          if (GNUNET_OK != it (it_cls, &bme->key, bme->value))
-            return GNUNET_SYSERR;
-          return 1;
+          for (struct BigMapEntry *bme = me.bme; NULL != bme; bme = bme->next)
+            {
+              if (0 == off)
+                {
+                  if (GNUNET_OK != it(it_cls, &bme->key, bme->value))
+                    return GNUNET_SYSERR;
+                  return 1;
+                }
+              off--;
+            }
         }
-        off--;
-      }
     }
-  }
-  GNUNET_break (0);
+  GNUNET_break(0);
   return GNUNET_SYSERR;
 }
 
@@ -927,12 +920,12 @@ GNUNET_CONTAINER_multiuuidmap_get_random (
  * @return an iterator over the given multiuuidmap 'map'
  */
 struct GNUNET_CONTAINER_MultiUuidmapIterator *
-GNUNET_CONTAINER_multiuuidmap_iterator_create (
+GNUNET_CONTAINER_multiuuidmap_iterator_create(
   const struct GNUNET_CONTAINER_MultiUuidmap *map)
 {
   struct GNUNET_CONTAINER_MultiUuidmapIterator *iter;
 
-  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiUuidmapIterator);
+  iter = GNUNET_new(struct GNUNET_CONTAINER_MultiUuidmapIterator);
   iter->map = map;
   iter->modification_counter = map->modification_counter;
   iter->me = map->map[0];
@@ -955,47 +948,47 @@ GNUNET_CONTAINER_multiuuidmap_iterator_create (
  *         #GNUNET_NO if we are out of elements
  */
 int
-GNUNET_CONTAINER_multiuuidmap_iterator_next (
+GNUNET_CONTAINER_multiuuidmap_iterator_next(
   struct GNUNET_CONTAINER_MultiUuidmapIterator *iter,
   struct GNUNET_Uuid *key,
   const void **value)
 {
   /* make sure the map has not been modified */
-  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
+  GNUNET_assert(iter->modification_counter == iter->map->modification_counter);
 
   /* look for the next entry, skipping empty buckets */
   while (1)
-  {
-    if (iter->idx >= iter->map->map_length)
-      return GNUNET_NO;
-    if (GNUNET_YES == iter->map->use_small_entries)
     {
-      if (NULL != iter->me.sme)
-      {
-        if (NULL != key)
-          *key = *iter->me.sme->key;
-        if (NULL != value)
-          *value = iter->me.sme->value;
-        iter->me.sme = iter->me.sme->next;
-        return GNUNET_YES;
-      }
-    }
-    else
-    {
-      if (NULL != iter->me.bme)
-      {
-        if (NULL != key)
-          *key = iter->me.bme->key;
-        if (NULL != value)
-          *value = iter->me.bme->value;
-        iter->me.bme = iter->me.bme->next;
-        return GNUNET_YES;
-      }
+      if (iter->idx >= iter->map->map_length)
+        return GNUNET_NO;
+      if (GNUNET_YES == iter->map->use_small_entries)
+        {
+          if (NULL != iter->me.sme)
+            {
+              if (NULL != key)
+                *key = *iter->me.sme->key;
+              if (NULL != value)
+                *value = iter->me.sme->value;
+              iter->me.sme = iter->me.sme->next;
+              return GNUNET_YES;
+            }
+        }
+      else
+        {
+          if (NULL != iter->me.bme)
+            {
+              if (NULL != key)
+                *key = iter->me.bme->key;
+              if (NULL != value)
+                *value = iter->me.bme->value;
+              iter->me.bme = iter->me.bme->next;
+              return GNUNET_YES;
+            }
+        }
+      iter->idx += 1;
+      if (iter->idx < iter->map->map_length)
+        iter->me = iter->map->map[iter->idx];
     }
-    iter->idx += 1;
-    if (iter->idx < iter->map->map_length)
-      iter->me = iter->map->map[iter->idx];
-  }
 }
 
 
@@ -1005,10 +998,10 @@ GNUNET_CONTAINER_multiuuidmap_iterator_next (
  * @param iter the iterator to destroy
  */
 void
-GNUNET_CONTAINER_multiuuidmap_iterator_destroy (
+GNUNET_CONTAINER_multiuuidmap_iterator_destroy(
   struct GNUNET_CONTAINER_MultiUuidmapIterator *iter)
 {
-  GNUNET_free (iter);
+  GNUNET_free(iter);
 }
 
 
diff --git a/src/util/crypto_abe.c b/src/util/crypto_abe.c
index 1d69a01ae..d702738de 100644
--- a/src/util/crypto_abe.c
+++ b/src/util/crypto_abe.c
@@ -11,13 +11,13 @@
      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 util/crypto_random.c
@@ -32,57 +32,55 @@
 
 #include "gnunet_crypto_lib.h"
 
-struct GNUNET_CRYPTO_AbeMasterKey
-{
+struct GNUNET_CRYPTO_AbeMasterKey {
   gabe_pub_t* pub;
   gabe_msk_t* msk;
 };
 
-struct GNUNET_CRYPTO_AbeKey
-{
+struct GNUNET_CRYPTO_AbeKey {
   gabe_pub_t* pub;
   gabe_prv_t* prv;
 };
 
 static int
-init_aes( element_t k, int enc,
-          gcry_cipher_hd_t* handle,
-          struct GNUNET_CRYPTO_SymmetricSessionKey *key,
-          unsigned char* iv)
+init_aes(element_t k, int enc,
+         gcry_cipher_hd_t* handle,
+         struct GNUNET_CRYPTO_SymmetricSessionKey *key,
+         unsigned char* iv)
 {
   int rc;
   int key_len;
   unsigned char* key_buf;
 
   key_len = element_length_in_bytes(k) < 33 ? 3 : element_length_in_bytes(k);
-  key_buf = (unsigned char*) malloc(key_len);
+  key_buf = (unsigned char*)malloc(key_len);
   element_to_bytes(key_buf, k);
 
-  GNUNET_memcpy (key->aes_key,
-                 key_buf,
-                 GNUNET_CRYPTO_AES_KEY_LENGTH);
-  GNUNET_assert (0 ==
-                 gcry_cipher_open (handle, GCRY_CIPHER_AES256,
-                                   GCRY_CIPHER_MODE_CFB, 0));
-  rc = gcry_cipher_setkey (*handle,
-                           key->aes_key,
-                           sizeof (key->aes_key));
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
-  memset (iv, 0, 16); //TODO make reasonable
-  rc = gcry_cipher_setiv (*handle,
-                          iv,
-                          16);
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  GNUNET_memcpy(key->aes_key,
+                key_buf,
+                GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_assert(0 ==
+                gcry_cipher_open(handle, GCRY_CIPHER_AES256,
+                                 GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey(*handle,
+                          key->aes_key,
+                          sizeof(key->aes_key));
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
+  memset(iv, 0, 16);  //TODO make reasonable
+  rc = gcry_cipher_setiv(*handle,
+                         iv,
+                         16);
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
 
   free(key_buf);
   return rc;
 }
 
 static int
-aes_128_cbc_encrypt( char* pt,
-                     int size,
-                     element_t k,
-                     char **ct )
+aes_128_cbc_encrypt(char* pt,
+                    int size,
+                    element_t k,
+                    char **ct)
 {
   gcry_cipher_hd_t handle;
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
@@ -91,34 +89,35 @@ aes_128_cbc_encrypt( char* pt,
   int padding;
   int buf_size;
   uint8_t len[4];
+
   init_aes(k, 1, &handle, &skey, iv);
 
   /* TODO make less crufty */
 
   /* stuff in real length (big endian) before padding */
-  len[0] = (size & 0xff000000)>>24;
-  len[1] = (size & 0xff0000)>>16;
-  len[2] = (size & 0xff00)>>8;
-  len[3] = (size & 0xff)>>0;
-  padding = 16 - ((4+size) % 16);
+  len[0] = (size & 0xff000000) >> 24;
+  len[1] = (size & 0xff0000) >> 16;
+  len[2] = (size & 0xff00) >> 8;
+  len[3] = (size & 0xff) >> 0;
+  padding = 16 - ((4 + size) % 16);
   buf_size = 4 + size + padding;
-  buf = GNUNET_malloc (buf_size);
-  GNUNET_memcpy (buf, len, 4);
-  GNUNET_memcpy (buf+4, pt, size);
-  *ct = GNUNET_malloc (buf_size);
+  buf = GNUNET_malloc(buf_size);
+  GNUNET_memcpy(buf, len, 4);
+  GNUNET_memcpy(buf + 4, pt, size);
+  *ct = GNUNET_malloc(buf_size);
 
-  GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, buf_size));
-  gcry_cipher_close (handle);
+  GNUNET_assert(0 == gcry_cipher_encrypt(handle, *ct, buf_size, buf, buf_size));
+  gcry_cipher_close(handle);
   //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
-  GNUNET_free (buf);
+  GNUNET_free(buf);
   return buf_size;
 }
 
 static int
-aes_128_cbc_decrypt( char* ct,
-                     int size,
-                     element_t k,
-                     char **pt )
+aes_128_cbc_decrypt(char* ct,
+                    int size,
+                    element_t k,
+                    char **pt)
 {
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
   gcry_cipher_hd_t handle;
@@ -128,108 +127,109 @@ aes_128_cbc_decrypt( char* ct,
 
   init_aes(k, 1, &handle, &skey, iv);
 
-  tmp = GNUNET_malloc (size);
+  tmp = GNUNET_malloc(size);
 
   //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
-  GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size));
-  gcry_cipher_close (handle);
+  GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, ct, size));
+  gcry_cipher_close(handle);
   /* TODO make less crufty */
 
   /* get real length */
   len = 0;
   len = len
-    | ((tmp[0])<<24) | ((tmp[1])<<16)
-    | ((tmp[2])<<8)  | ((tmp[3])<<0);
+        | ((tmp[0]) << 24) | ((tmp[1]) << 16)
+        | ((tmp[2]) << 8) | ((tmp[3]) << 0);
   /* truncate any garbage from the padding */
-  *pt = GNUNET_malloc (len);
-  GNUNET_memcpy (*pt, tmp+4, len);
-  GNUNET_free (tmp);
+  *pt = GNUNET_malloc(len);
+  GNUNET_memcpy(*pt, tmp + 4, len);
+  GNUNET_free(tmp);
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeMasterKey*
-GNUNET_CRYPTO_cpabe_create_master_key (void)
+GNUNET_CRYPTO_cpabe_create_master_key(void)
 {
   struct GNUNET_CRYPTO_AbeMasterKey* key;
-  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
+
+  key = GNUNET_new(struct GNUNET_CRYPTO_AbeMasterKey);
   gabe_setup(&key->pub, &key->msk);
-  GNUNET_assert (NULL != key->pub);
-  GNUNET_assert (NULL != key->msk);
+  GNUNET_assert(NULL != key->pub);
+  GNUNET_assert(NULL != key->msk);
   return key;
 }
 
 void
-GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key)
+GNUNET_CRYPTO_cpabe_delete_master_key(struct GNUNET_CRYPTO_AbeMasterKey *key)
 {
-  gabe_msk_free (key->msk);
-  gabe_pub_free (key->pub);
+  gabe_msk_free(key->msk);
+  gabe_pub_free(key->pub);
   //GNUNET_free (key->msk);
   //gabe_msk_free (key->msk); //For some reason free of pub implicit?
-  GNUNET_free (key);
+  GNUNET_free(key);
 }
 
 struct GNUNET_CRYPTO_AbeKey*
-GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key,
-                             char **attrs)
+GNUNET_CRYPTO_cpabe_create_key(struct GNUNET_CRYPTO_AbeMasterKey *key,
+                               char **attrs)
 {
   struct GNUNET_CRYPTO_AbeKey *prv_key;
   int size;
   char *tmp;
 
-  prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
+  prv_key = GNUNET_new(struct GNUNET_CRYPTO_AbeKey);
   prv_key->prv = gabe_keygen(key->pub, key->msk, attrs);
   size = gabe_pub_serialize(key->pub, &tmp);
   prv_key->pub = gabe_pub_unserialize(tmp, size);
-  GNUNET_free (tmp);
-  GNUNET_assert (NULL != prv_key->prv);
+  GNUNET_free(tmp);
+  GNUNET_assert(NULL != prv_key->prv);
   return prv_key;
 }
 
 void
-GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key,
-                                int delete_pub)
+GNUNET_CRYPTO_cpabe_delete_key(struct GNUNET_CRYPTO_AbeKey *key,
+                               int delete_pub)
 {
   //Memory management in gabe is buggy
-  gabe_prv_free (key->prv);
+  gabe_prv_free(key->prv);
   if (GNUNET_YES == delete_pub)
-    gabe_pub_free (key->pub);
-  GNUNET_free (key);
+    gabe_pub_free(key->pub);
+  GNUNET_free(key);
 }
 
 ssize_t
-write_cpabe (void **result,
-             uint32_t file_len,
-             char* cph_buf,
-             int cph_buf_len,
-             char* aes_buf,
-             int aes_buf_len)
+write_cpabe(void **result,
+            uint32_t file_len,
+            char* cph_buf,
+            int cph_buf_len,
+            char* aes_buf,
+            int aes_buf_len)
 {
   char *ptr;
   uint32_t *len;
 
-  *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len);
+  *result = GNUNET_malloc(12 + cph_buf_len + aes_buf_len);
   ptr = *result;
-  len = (uint32_t*) ptr;
-  *len = htonl (file_len);
+  len = (uint32_t*)ptr;
+  *len = htonl(file_len);
   ptr += 4;
-  len = (uint32_t*) ptr;
-  *len = htonl (aes_buf_len);
+  len = (uint32_t*)ptr;
+  *len = htonl(aes_buf_len);
   ptr += 4;
-  GNUNET_memcpy (ptr, aes_buf, aes_buf_len);
+  GNUNET_memcpy(ptr, aes_buf, aes_buf_len);
   ptr += aes_buf_len;
-  len = (uint32_t*) ptr;
-  *len = htonl (cph_buf_len);
+  len = (uint32_t*)ptr;
+  *len = htonl(cph_buf_len);
   ptr += 4;
-  GNUNET_memcpy (ptr, cph_buf, cph_buf_len);
+  GNUNET_memcpy(ptr, cph_buf, cph_buf_len);
   return 12 + cph_buf_len + aes_buf_len;
 }
 
 ssize_t
-read_cpabe (const void *data,
-            char** cph_buf,
-            int *cph_buf_len,
-            char** aes_buf,
-            int *aes_buf_len)
+read_cpabe(const void *data,
+           char** cph_buf,
+           int *cph_buf_len,
+           char** aes_buf,
+           int *aes_buf_len)
 {
   int buf_len;
   char *ptr;
@@ -237,29 +237,29 @@ read_cpabe (const void *data,
 
   ptr = (char*)data;
   len = (uint32_t*)ptr;
-  buf_len = ntohl (*len);
+  buf_len = ntohl(*len);
   ptr += 4;
   len = (uint32_t*)ptr;
-  *aes_buf_len = ntohl (*len);
+  *aes_buf_len = ntohl(*len);
   ptr += 4;
-  *aes_buf = GNUNET_malloc (*aes_buf_len);
-  GNUNET_memcpy (*aes_buf, ptr, *aes_buf_len);
+  *aes_buf = GNUNET_malloc(*aes_buf_len);
+  GNUNET_memcpy(*aes_buf, ptr, *aes_buf_len);
   ptr += *aes_buf_len;
   len = (uint32_t*)ptr;
-  *cph_buf_len = ntohl (*len);
+  *cph_buf_len = ntohl(*len);
   ptr += 4;
-  *cph_buf = GNUNET_malloc (*cph_buf_len);
-  GNUNET_memcpy (*cph_buf, ptr, *cph_buf_len);
+  *cph_buf = GNUNET_malloc(*cph_buf_len);
+  GNUNET_memcpy(*cph_buf, ptr, *cph_buf_len);
 
   return buf_len;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_encrypt (const void *block,
-                             size_t size,
-                             const char *policy,
-                             const struct GNUNET_CRYPTO_AbeMasterKey *key,
-                             void **result)
+GNUNET_CRYPTO_cpabe_encrypt(const void *block,
+                            size_t size,
+                            const char *policy,
+                            const struct GNUNET_CRYPTO_AbeMasterKey *key,
+                            void **result)
 {
   gabe_cph_t* cph;
   char* plt;
@@ -270,15 +270,15 @@ GNUNET_CRYPTO_cpabe_encrypt (const void *block,
   int aes_buf_len;
   ssize_t result_len;
 
-  if( !(cph = gabe_enc(key->pub, m, (char*)policy)) )
+  if (!(cph = gabe_enc(key->pub, m, (char*)policy)))
     return GNUNET_SYSERR;
   cph_buf_len = gabe_cph_serialize(cph,
-                                &cph_buf);
+                                   &cph_buf);
   gabe_cph_free(cph);
-  GNUNET_free (cph);
-  plt = GNUNET_memdup (block, size);
+  GNUNET_free(cph);
+  plt = GNUNET_memdup(block, size);
   aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf);
-  GNUNET_free (plt);
+  GNUNET_free(plt);
   element_clear(m);
   result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len);
   GNUNET_free(cph_buf);
@@ -287,10 +287,10 @@ GNUNET_CRYPTO_cpabe_encrypt (const void *block,
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_decrypt (const void *block,
-                             size_t size,
-                             const struct GNUNET_CRYPTO_AbeKey *key,
-                             void **result)
+GNUNET_CRYPTO_cpabe_decrypt(const void *block,
+                            size_t size,
+                            const struct GNUNET_CRYPTO_AbeKey *key,
+                            void **result)
 {
   char* aes_buf;
   char* cph_buf;
@@ -302,22 +302,23 @@ GNUNET_CRYPTO_cpabe_decrypt (const void *block,
 
   read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
   cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size);
-  if( !gabe_dec(key->pub, key->prv, cph, m) ) {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s\n", gabe_error());
-    GNUNET_free (aes_buf);
-    GNUNET_free (cph_buf);
-    gabe_cph_free(cph);
-    GNUNET_free (cph);
-    element_clear (m);
-    return GNUNET_SYSERR;
-  }
+  if (!gabe_dec(key->pub, key->prv, cph, m))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "%s\n", gabe_error());
+      GNUNET_free(aes_buf);
+      GNUNET_free(cph_buf);
+      gabe_cph_free(cph);
+      GNUNET_free(cph);
+      element_clear(m);
+      return GNUNET_SYSERR;
+    }
   gabe_cph_free(cph);
-  GNUNET_free (cph);
+  GNUNET_free(cph);
   plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result);
-  GNUNET_free (cph_buf);
-  GNUNET_free (aes_buf);
-  element_clear (m);
+  GNUNET_free(cph_buf);
+  GNUNET_free(aes_buf);
+  element_clear(m);
   //freeing is buggy in gabe
   //gabe_prv_free (prv);
   //gabe_pub_free (pub);
@@ -325,8 +326,8 @@ GNUNET_CRYPTO_cpabe_decrypt (const void *block,
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
-                                   void **result)
+GNUNET_CRYPTO_cpabe_serialize_key(const struct GNUNET_CRYPTO_AbeKey *key,
+                                  void **result)
 {
   ssize_t len;
   char *pub;
@@ -334,21 +335,21 @@ GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
   int pub_len;
   int prv_len;
 
-  pub_len = gabe_pub_serialize (key->pub, &pub);
-  prv_len = gabe_prv_serialize (key->prv, &prv);
+  pub_len = gabe_pub_serialize(key->pub, &pub);
+  prv_len = gabe_prv_serialize(key->prv, &prv);
 
   len = pub_len + prv_len + 12;
-  write_cpabe (result, len, pub, pub_len, prv, prv_len);
+  write_cpabe(result, len, pub, pub_len, prv, prv_len);
 
-  GNUNET_free (pub);
-  GNUNET_free (prv);
+  GNUNET_free(pub);
+  GNUNET_free(prv);
 
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeKey*
-GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
-                                     size_t len)
+GNUNET_CRYPTO_cpabe_deserialize_key(const void *data,
+                                    size_t len)
 {
   struct GNUNET_CRYPTO_AbeKey *key;
   char *pub;
@@ -356,23 +357,23 @@ GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
   int prv_len;
   int pub_len;
 
-  key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
-  read_cpabe (data,
-              &pub,
-              &pub_len,
-              &prv,
-              &prv_len);
-  key->pub = gabe_pub_unserialize (pub, pub_len);
-  key->prv = gabe_prv_unserialize (key->pub, prv, prv_len);
-
-  GNUNET_free (pub);
-  GNUNET_free (prv);
+  key = GNUNET_new(struct GNUNET_CRYPTO_AbeKey);
+  read_cpabe(data,
+             &pub,
+             &pub_len,
+             &prv,
+             &prv_len);
+  key->pub = gabe_pub_unserialize(pub, pub_len);
+  key->prv = gabe_prv_unserialize(key->pub, prv, prv_len);
+
+  GNUNET_free(pub);
+  GNUNET_free(prv);
   return key;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKey *key,
-                                          void **result)
+GNUNET_CRYPTO_cpabe_serialize_master_key(const struct GNUNET_CRYPTO_AbeMasterKey *key,
+                                         void **result)
 {
   ssize_t len;
   char *pub;
@@ -380,21 +381,21 @@ GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKe
   int pub_len;
   int msk_len;
 
-  pub_len = gabe_pub_serialize (key->pub, &pub);
-  msk_len = gabe_msk_serialize (key->msk, &msk);
+  pub_len = gabe_pub_serialize(key->pub, &pub);
+  msk_len = gabe_msk_serialize(key->msk, &msk);
 
   len = pub_len + msk_len + 12;
-  write_cpabe (result, len, pub, pub_len, msk, msk_len);
+  write_cpabe(result, len, pub, pub_len, msk, msk_len);
 
-  GNUNET_free (pub);
-  GNUNET_free (msk);
+  GNUNET_free(pub);
+  GNUNET_free(msk);
 
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeMasterKey*
-GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
-                                            size_t len)
+GNUNET_CRYPTO_cpabe_deserialize_master_key(const void *data,
+                                           size_t len)
 {
   struct GNUNET_CRYPTO_AbeMasterKey *key;
   char *msk;
@@ -402,17 +403,17 @@ GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
   int msk_len;
   int pub_len;
 
-  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
-  read_cpabe (data,
-              &pub,
-              &pub_len,
-              &msk,
-              &msk_len);
-  key->pub = gabe_pub_unserialize (pub, pub_len);
-  key->msk = gabe_msk_unserialize (key->pub, msk, msk_len);
-
-  GNUNET_free (pub);
-  GNUNET_free (msk);
+  key = GNUNET_new(struct GNUNET_CRYPTO_AbeMasterKey);
+  read_cpabe(data,
+             &pub,
+             &pub_len,
+             &msk,
+             &msk_len);
+  key->pub = gabe_pub_unserialize(pub, pub_len);
+  key->msk = gabe_msk_unserialize(key->pub, msk, msk_len);
+
+  GNUNET_free(pub);
+  GNUNET_free(msk);
 
   return key;
 }
diff --git a/src/util/crypto_crc.c b/src/util/crypto_crc.c
index 3d8e23e24..e547ef329 100644
--- a/src/util/crypto_crc.c
+++ b/src/util/crypto_crc.c
@@ -11,7 +11,7 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -20,7 +20,7 @@
      For the actual CRC-32 code:
      Copyright abandoned; this code is in the public domain.
      Provided to GNUnet by peter@horizon.com
-*/
+ */
 
 /**
  * @file util/crypto_crc.c
@@ -30,7 +30,7 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-crc", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-crc", __VA_ARGS__)
 
 /* Avoid wasting space on 8-byte longs. */
 #if UINT_MAX >= 0xffffffff
@@ -53,7 +53,7 @@ static GNUNET_uLong crc_table[256];
  * even on a table that someone else is using concurrently.
  */
 static void
-crc_init ()
+crc_init()
 {
   static int once;
   unsigned int i, j;
@@ -64,12 +64,12 @@ crc_init ()
   once = 1;
   crc_table[0] = 0;
   for (i = 128; i; i >>= 1)
-  {
-    h = (h >> 1) ^ ((h & 1) ? POLYNOMIAL : 0);
-    /* h is now crc_table[i] */
-    for (j = 0; j < 256; j += 2 * i)
-      crc_table[i + j] = crc_table[j] ^ h;
-  }
+    {
+      h = (h >> 1) ^ ((h & 1) ? POLYNOMIAL : 0);
+      /* h is now crc_table[i] */
+      for (j = 0; j < 256; j += 2 * i)
+        crc_table[i + j] = crc_table[j] ^ h;
+    }
 }
 
 /*
@@ -83,10 +83,10 @@ crc_init ()
  * property of detecting all burst errors of length 32 bits or less.
  */
 static GNUNET_uLong
-crc32 (GNUNET_uLong crc, const char *buf, size_t len)
+crc32(GNUNET_uLong crc, const char *buf, size_t len)
 {
-  crc_init ();
-  GNUNET_assert (crc_table[255] != 0);
+  crc_init();
+  GNUNET_assert(crc_table[255] != 0);
   crc ^= 0xffffffff;
   while (len--)
     crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
@@ -102,12 +102,12 @@ crc32 (GNUNET_uLong crc, const char *buf, size_t len)
  * @return the resulting CRC32 checksum
  */
 int32_t
-GNUNET_CRYPTO_crc32_n (const void *buf, size_t len)
+GNUNET_CRYPTO_crc32_n(const void *buf, size_t len)
 {
   GNUNET_uLong crc;
 
-  crc = crc32 (0L, Z_NULL, 0);
-  crc = crc32 (crc, (char *) buf, len);
+  crc = crc32(0L, Z_NULL, 0);
+  crc = crc32(crc, (char *)buf, len);
   return crc;
 }
 
@@ -121,9 +121,10 @@ GNUNET_CRYPTO_crc32_n (const void *buf, size_t len)
  * @return updated crc sum (must be subjected to #GNUNET_CRYPTO_crc16_finish() to get actual crc16)
  */
 uint32_t
-GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len)
+GNUNET_CRYPTO_crc16_step(uint32_t sum, const void *buf, size_t len)
 {
   const uint16_t *hdr = buf;
+
   for (; len >= 2; len -= 2)
     sum += *(hdr++);
   if (len == 1)
@@ -139,7 +140,7 @@ GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len)
  * @return crc16 value
  */
 uint16_t
-GNUNET_CRYPTO_crc16_finish (uint32_t sum)
+GNUNET_CRYPTO_crc16_finish(uint32_t sum)
 {
   sum = (sum >> 16) + (sum & 0xFFFF);
   sum += (sum >> 16);
@@ -156,12 +157,12 @@ GNUNET_CRYPTO_crc16_finish (uint32_t sum)
  * @return crc16 value
  */
 uint16_t
-GNUNET_CRYPTO_crc16_n (const void *buf, size_t len)
+GNUNET_CRYPTO_crc16_n(const void *buf, size_t len)
 {
   const uint16_t *hdr = buf;
-  uint32_t sum = GNUNET_CRYPTO_crc16_step (0, hdr, len);
+  uint32_t sum = GNUNET_CRYPTO_crc16_step(0, hdr, len);
 
-  return GNUNET_CRYPTO_crc16_finish (sum);
+  return GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -174,8 +175,8 @@ GNUNET_CRYPTO_crc16_n (const void *buf, size_t len)
  * @return crc8 value
  */
 uint8_t
-GNUNET_CRYPTO_crc8_n (const void *buf,
-                      size_t len)
+GNUNET_CRYPTO_crc8_n(const void *buf,
+                     size_t len)
 {
   const uint8_t *data = buf;
   unsigned int crc = 0;
@@ -183,16 +184,16 @@ GNUNET_CRYPTO_crc8_n (const void *buf,
   int j;
 
   for (j = len; 0 != j; j--)
-  {
-    crc ^= (*data++ << 8);
-    for (i = 8; 0 != i; i--)
     {
-      if (0 != (crc & 0x8000))
-        crc ^= (0x1070 << 3);
-      crc <<= 1;
+      crc ^= (*data++ << 8);
+      for (i = 8; 0 != i; i--)
+        {
+          if (0 != (crc & 0x8000))
+            crc ^= (0x1070 << 3);
+          crc <<= 1;
+        }
     }
-  }
-  return (uint8_t) (crc >> 8);
+  return (uint8_t)(crc >> 8);
 }
 
 
diff --git a/src/util/crypto_ecc.c b/src/util/crypto_ecc.c
index 9e6f533f3..d954dfd98 100644
--- a/src/util/crypto_ecc.c
+++ b/src/util/crypto_ecc.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 util/crypto_ecc.c
@@ -39,13 +39,13 @@
  */
 #define CURVE "Ed25519"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-crypto-ecc", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-ecc", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-crypto-ecc", syscall)
+  GNUNET_log_from_strerror(kind, "util-crypto-ecc", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-crypto-ecc", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-crypto-ecc", syscall, filename)
 
 /**
  * Log an error message at log-level 'level' that indicates
@@ -54,14 +54,14 @@
  */
 #define LOG_GCRY(level, cmd, rc)                      \
   do                                                  \
-  {                                                   \
-    LOG (level,                                       \
-         _ ("`%s' failed at %s:%d with error: %s\n"), \
-         cmd,                                         \
-         __FILE__,                                    \
-         __LINE__,                                    \
-         gcry_strerror (rc));                         \
-  } while (0)
+    {                                                   \
+      LOG(level,                                       \
+          _("`%s' failed at %s:%d with error: %s\n"), \
+          cmd,                                         \
+          __FILE__,                                    \
+          __LINE__,                                    \
+          gcry_strerror(rc));                         \
+    } while (0)
 
 
 /**
@@ -74,10 +74,10 @@
  * @return 0 on success
  */
 static int
-key_from_sexp (gcry_mpi_t *array,
-               gcry_sexp_t sexp,
-               const char *topname,
-               const char *elems)
+key_from_sexp(gcry_mpi_t *array,
+              gcry_sexp_t sexp,
+              const char *topname,
+              const char *elems)
 {
   gcry_sexp_t list;
   gcry_sexp_t l2;
@@ -85,43 +85,43 @@ key_from_sexp (gcry_mpi_t *array,
   unsigned int i;
   unsigned int idx;
 
-  list = gcry_sexp_find_token (sexp, topname, 0);
-  if (! list)
+  list = gcry_sexp_find_token(sexp, topname, 0);
+  if (!list)
     return 1;
-  l2 = gcry_sexp_cadr (list);
-  gcry_sexp_release (list);
+  l2 = gcry_sexp_cadr(list);
+  gcry_sexp_release(list);
   list = l2;
-  if (! list)
+  if (!list)
     return 2;
 
   idx = 0;
   for (s = elems; *s; s++, idx++)
-  {
-    l2 = gcry_sexp_find_token (list, s, 1);
-    if (! l2)
-    {
-      for (i = 0; i < idx; i++)
-      {
-        gcry_free (array[i]);
-        array[i] = NULL;
-      }
-      gcry_sexp_release (list);
-      return 3; /* required parameter not found */
-    }
-    array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
-    gcry_sexp_release (l2);
-    if (! array[idx])
     {
-      for (i = 0; i < idx; i++)
-      {
-        gcry_free (array[i]);
-        array[i] = NULL;
-      }
-      gcry_sexp_release (list);
-      return 4; /* required parameter is invalid */
+      l2 = gcry_sexp_find_token(list, s, 1);
+      if (!l2)
+        {
+          for (i = 0; i < idx; i++)
+            {
+              gcry_free(array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release(list);
+          return 3; /* required parameter not found */
+        }
+      array[idx] = gcry_sexp_nth_mpi(l2, 1, GCRYMPI_FMT_USG);
+      gcry_sexp_release(l2);
+      if (!array[idx])
+        {
+          for (i = 0; i < idx; i++)
+            {
+              gcry_free(array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release(list);
+          return 4; /* required parameter is invalid */
+        }
     }
-  }
-  gcry_sexp_release (list);
+  gcry_sexp_release(list);
   return 0;
 }
 
@@ -134,28 +134,28 @@ key_from_sexp (gcry_mpi_t *array,
  * @return NULL on error
  */
 static gcry_sexp_t
-decode_private_ecdsa_key (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
+decode_private_ecdsa_key(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
 {
   gcry_sexp_t result;
   int rc;
 
-  rc = gcry_sexp_build (&result,
-                        NULL,
-                        "(private-key(ecc(curve \"" CURVE "\")"
-                        "(d %b)))",
-                        (int) sizeof (priv->d),
-                        priv->d);
+  rc = gcry_sexp_build(&result,
+                       NULL,
+                       "(private-key(ecc(curve \"" CURVE "\")"
+                       "(d %b)))",
+                       (int)sizeof(priv->d),
+                       priv->d);
   if (0 != rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    GNUNET_assert (0);
-  }
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      GNUNET_assert(0);
+    }
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (result)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    GNUNET_assert (0);
-  }
+  if (0 != (rc = gcry_pk_testkey(result)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      GNUNET_assert(0);
+    }
 #endif
   return result;
 }
@@ -169,28 +169,28 @@ decode_private_ecdsa_key (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
  * @return NULL on error
  */
 static gcry_sexp_t
-decode_private_eddsa_key (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
+decode_private_eddsa_key(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
 {
   gcry_sexp_t result;
   int rc;
 
-  rc = gcry_sexp_build (&result,
-                        NULL,
-                        "(private-key(ecc(curve \"" CURVE "\")"
-                        "(flags eddsa)(d %b)))",
-                        (int) sizeof (priv->d),
-                        priv->d);
+  rc = gcry_sexp_build(&result,
+                       NULL,
+                       "(private-key(ecc(curve \"" CURVE "\")"
+                       "(flags eddsa)(d %b)))",
+                       (int)sizeof(priv->d),
+                       priv->d);
   if (0 != rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    GNUNET_assert (0);
-  }
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      GNUNET_assert(0);
+    }
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (result)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    GNUNET_assert (0);
-  }
+  if (0 != (rc = gcry_pk_testkey(result)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      GNUNET_assert(0);
+    }
 #endif
   return result;
 }
@@ -204,28 +204,28 @@ decode_private_eddsa_key (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
  * @return NULL on error
  */
 static gcry_sexp_t
-decode_private_ecdhe_key (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv)
+decode_private_ecdhe_key(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv)
 {
   gcry_sexp_t result;
   int rc;
 
-  rc = gcry_sexp_build (&result,
-                        NULL,
-                        "(private-key(ecc(curve \"" CURVE "\")"
-                        "(d %b)))",
-                        (int) sizeof (priv->d),
-                        priv->d);
+  rc = gcry_sexp_build(&result,
+                       NULL,
+                       "(private-key(ecc(curve \"" CURVE "\")"
+                       "(d %b)))",
+                       (int)sizeof(priv->d),
+                       priv->d);
   if (0 != rc)
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    GNUNET_assert (0);
-  }
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      GNUNET_assert(0);
+    }
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (result)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    GNUNET_assert (0);
-  }
+  if (0 != (rc = gcry_pk_testkey(result)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      GNUNET_assert(0);
+    }
 #endif
   return result;
 }
@@ -238,7 +238,7 @@ decode_private_ecdhe_key (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv)
  * @param pub where to write the public key
  */
 void
-GNUNET_CRYPTO_ecdsa_key_get_public (
+GNUNET_CRYPTO_ecdsa_key_get_public(
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
   struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
 {
@@ -246,19 +246,19 @@ GNUNET_CRYPTO_ecdsa_key_get_public (
   gcry_ctx_t ctx;
   gcry_mpi_t q;
 
-  BENCHMARK_START (ecdsa_key_get_public);
+  BENCHMARK_START(ecdsa_key_get_public);
 
-  sexp = decode_private_ecdsa_key (priv);
-  GNUNET_assert (NULL != sexp);
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, sexp, NULL));
-  gcry_sexp_release (sexp);
-  q = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-  GNUNET_assert (NULL != q);
-  GNUNET_CRYPTO_mpi_print_unsigned (pub->q_y, sizeof (pub->q_y), q);
-  gcry_mpi_release (q);
-  gcry_ctx_release (ctx);
+  sexp = decode_private_ecdsa_key(priv);
+  GNUNET_assert(NULL != sexp);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, sexp, NULL));
+  gcry_sexp_release(sexp);
+  q = gcry_mpi_ec_get_mpi("q@eddsa", ctx, 0);
+  GNUNET_assert(NULL != q);
+  GNUNET_CRYPTO_mpi_print_unsigned(pub->q_y, sizeof(pub->q_y), q);
+  gcry_mpi_release(q);
+  gcry_ctx_release(ctx);
 
-  BENCHMARK_END (ecdsa_key_get_public);
+  BENCHMARK_END(ecdsa_key_get_public);
 }
 
 
@@ -269,7 +269,7 @@ GNUNET_CRYPTO_ecdsa_key_get_public (
  * @param pub where to write the public key
  */
 void
-GNUNET_CRYPTO_eddsa_key_get_public (
+GNUNET_CRYPTO_eddsa_key_get_public(
   const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
   struct GNUNET_CRYPTO_EddsaPublicKey *pub)
 {
@@ -277,19 +277,19 @@ GNUNET_CRYPTO_eddsa_key_get_public (
   gcry_ctx_t ctx;
   gcry_mpi_t q;
 
-  BENCHMARK_START (eddsa_key_get_public);
+  BENCHMARK_START(eddsa_key_get_public);
 
-  sexp = decode_private_eddsa_key (priv);
-  GNUNET_assert (NULL != sexp);
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, sexp, NULL));
-  gcry_sexp_release (sexp);
-  q = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-  GNUNET_assert (q);
-  GNUNET_CRYPTO_mpi_print_unsigned (pub->q_y, sizeof (pub->q_y), q);
-  gcry_mpi_release (q);
-  gcry_ctx_release (ctx);
+  sexp = decode_private_eddsa_key(priv);
+  GNUNET_assert(NULL != sexp);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, sexp, NULL));
+  gcry_sexp_release(sexp);
+  q = gcry_mpi_ec_get_mpi("q@eddsa", ctx, 0);
+  GNUNET_assert(q);
+  GNUNET_CRYPTO_mpi_print_unsigned(pub->q_y, sizeof(pub->q_y), q);
+  gcry_mpi_release(q);
+  gcry_ctx_release(ctx);
 
-  BENCHMARK_END (eddsa_key_get_public);
+  BENCHMARK_END(eddsa_key_get_public);
 }
 
 
@@ -300,7 +300,7 @@ GNUNET_CRYPTO_eddsa_key_get_public (
  * @param pub where to write the public key
  */
 void
-GNUNET_CRYPTO_ecdhe_key_get_public (
+GNUNET_CRYPTO_ecdhe_key_get_public(
   const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
   struct GNUNET_CRYPTO_EcdhePublicKey *pub)
 {
@@ -308,19 +308,19 @@ GNUNET_CRYPTO_ecdhe_key_get_public (
   gcry_ctx_t ctx;
   gcry_mpi_t q;
 
-  BENCHMARK_START (ecdhe_key_get_public);
+  BENCHMARK_START(ecdhe_key_get_public);
 
-  sexp = decode_private_ecdhe_key (priv);
-  GNUNET_assert (NULL != sexp);
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, sexp, NULL));
-  gcry_sexp_release (sexp);
-  q = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-  GNUNET_assert (q);
-  GNUNET_CRYPTO_mpi_print_unsigned (pub->q_y, sizeof (pub->q_y), q);
-  gcry_mpi_release (q);
-  gcry_ctx_release (ctx);
+  sexp = decode_private_ecdhe_key(priv);
+  GNUNET_assert(NULL != sexp);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, sexp, NULL));
+  gcry_sexp_release(sexp);
+  q = gcry_mpi_ec_get_mpi("q@eddsa", ctx, 0);
+  GNUNET_assert(q);
+  GNUNET_CRYPTO_mpi_print_unsigned(pub->q_y, sizeof(pub->q_y), q);
+  gcry_mpi_release(q);
+  gcry_ctx_release(ctx);
 
-  BENCHMARK_END (ecdhe_key_get_public);
+  BENCHMARK_END(ecdhe_key_get_public);
 }
 
 
@@ -331,27 +331,27 @@ GNUNET_CRYPTO_ecdhe_key_get_public (
  * @return string representing @a pub
  */
 char *
-GNUNET_CRYPTO_ecdsa_public_key_to_string (
+GNUNET_CRYPTO_ecdsa_public_key_to_string(
   const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
 {
   char *pubkeybuf;
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
   char *end;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
   keylen /= 5;
-  pubkeybuf = GNUNET_malloc (keylen + 1);
+  pubkeybuf = GNUNET_malloc(keylen + 1);
   end =
-    GNUNET_STRINGS_data_to_string ((unsigned char *) pub,
-                                   sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
-                                   pubkeybuf,
-                                   keylen);
+    GNUNET_STRINGS_data_to_string((unsigned char *)pub,
+                                  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
+                                  pubkeybuf,
+                                  keylen);
   if (NULL == end)
-  {
-    GNUNET_free (pubkeybuf);
-    return NULL;
-  }
+    {
+      GNUNET_free(pubkeybuf);
+      return NULL;
+    }
   *end = '\0';
   return pubkeybuf;
 }
@@ -364,27 +364,27 @@ GNUNET_CRYPTO_ecdsa_public_key_to_string (
  * @return string representing @a pub
  */
 char *
-GNUNET_CRYPTO_eddsa_public_key_to_string (
+GNUNET_CRYPTO_eddsa_public_key_to_string(
   const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
 {
   char *pubkeybuf;
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
   char *end;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
   keylen /= 5;
-  pubkeybuf = GNUNET_malloc (keylen + 1);
+  pubkeybuf = GNUNET_malloc(keylen + 1);
   end =
-    GNUNET_STRINGS_data_to_string ((unsigned char *) pub,
-                                   sizeof (struct GNUNET_CRYPTO_EddsaPublicKey),
-                                   pubkeybuf,
-                                   keylen);
+    GNUNET_STRINGS_data_to_string((unsigned char *)pub,
+                                  sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
+                                  pubkeybuf,
+                                  keylen);
   if (NULL == end)
-  {
-    GNUNET_free (pubkeybuf);
-    return NULL;
-  }
+    {
+      GNUNET_free(pubkeybuf);
+      return NULL;
+    }
   *end = '\0';
   return pubkeybuf;
 }
@@ -397,27 +397,27 @@ GNUNET_CRYPTO_eddsa_public_key_to_string (
  * @return string representing @a pub
  */
 char *
-GNUNET_CRYPTO_eddsa_private_key_to_string (
+GNUNET_CRYPTO_eddsa_private_key_to_string(
   const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
 {
   char *privkeybuf;
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
   char *end;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
   keylen /= 5;
-  privkeybuf = GNUNET_malloc (keylen + 1);
-  end = GNUNET_STRINGS_data_to_string ((unsigned char *) priv,
-                                       sizeof (
-                                         struct GNUNET_CRYPTO_EddsaPrivateKey),
-                                       privkeybuf,
-                                       keylen);
+  privkeybuf = GNUNET_malloc(keylen + 1);
+  end = GNUNET_STRINGS_data_to_string((unsigned char *)priv,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EddsaPrivateKey),
+                                      privkeybuf,
+                                      keylen);
   if (NULL == end)
-  {
-    GNUNET_free (privkeybuf);
-    return NULL;
-  }
+    {
+      GNUNET_free(privkeybuf);
+      return NULL;
+    }
   *end = '\0';
   return privkeybuf;
 }
@@ -430,27 +430,27 @@ GNUNET_CRYPTO_eddsa_private_key_to_string (
  * @return string representing @a priv
  */
 char *
-GNUNET_CRYPTO_ecdsa_private_key_to_string (
+GNUNET_CRYPTO_ecdsa_private_key_to_string(
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
 {
   char *privkeybuf;
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)) * 8;
   char *end;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
   keylen /= 5;
-  privkeybuf = GNUNET_malloc (keylen + 1);
-  end = GNUNET_STRINGS_data_to_string ((unsigned char *) priv,
-                                       sizeof (
-                                         struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                                       privkeybuf,
-                                       keylen);
+  privkeybuf = GNUNET_malloc(keylen + 1);
+  end = GNUNET_STRINGS_data_to_string((unsigned char *)priv,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                                      privkeybuf,
+                                      keylen);
   if (NULL == end)
-  {
-    GNUNET_free (privkeybuf);
-    return NULL;
-  }
+    {
+      GNUNET_free(privkeybuf);
+      return NULL;
+    }
   *end = '\0';
   return privkeybuf;
 }
@@ -465,12 +465,12 @@ GNUNET_CRYPTO_ecdsa_private_key_to_string (
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecdsa_public_key_from_string (
+GNUNET_CRYPTO_ecdsa_public_key_from_string(
   const char *enc,
   size_t enclen,
   struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
 {
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
@@ -479,11 +479,11 @@ GNUNET_CRYPTO_ecdsa_public_key_from_string (
     return GNUNET_SYSERR;
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (enc,
-                                     enclen,
-                                     pub,
-                                     sizeof (
-                                       struct GNUNET_CRYPTO_EcdsaPublicKey)))
+      GNUNET_STRINGS_string_to_data(enc,
+                                    enclen,
+                                    pub,
+                                    sizeof(
+                                      struct GNUNET_CRYPTO_EcdsaPublicKey)))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -498,12 +498,12 @@ GNUNET_CRYPTO_ecdsa_public_key_from_string (
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_eddsa_public_key_from_string (
+GNUNET_CRYPTO_eddsa_public_key_from_string(
   const char *enc,
   size_t enclen,
   struct GNUNET_CRYPTO_EddsaPublicKey *pub)
 {
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
@@ -512,11 +512,11 @@ GNUNET_CRYPTO_eddsa_public_key_from_string (
     return GNUNET_SYSERR;
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (enc,
-                                     enclen,
-                                     pub,
-                                     sizeof (
-                                       struct GNUNET_CRYPTO_EddsaPublicKey)))
+      GNUNET_STRINGS_string_to_data(enc,
+                                    enclen,
+                                    pub,
+                                    sizeof(
+                                      struct GNUNET_CRYPTO_EddsaPublicKey)))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -531,12 +531,12 @@ GNUNET_CRYPTO_eddsa_public_key_from_string (
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_eddsa_private_key_from_string (
+GNUNET_CRYPTO_eddsa_private_key_from_string(
   const char *enc,
   size_t enclen,
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
 {
-  size_t keylen = (sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
 
   if (keylen % 5 > 0)
     keylen += 5 - keylen % 5;
@@ -545,18 +545,18 @@ GNUNET_CRYPTO_eddsa_private_key_from_string (
     return GNUNET_SYSERR;
 
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data (enc,
-                                     enclen,
-                                     priv,
-                                     sizeof (
-                                       struct GNUNET_CRYPTO_EddsaPrivateKey)))
+      GNUNET_STRINGS_string_to_data(enc,
+                                    enclen,
+                                    priv,
+                                    sizeof(
+                                      struct GNUNET_CRYPTO_EddsaPrivateKey)))
     return GNUNET_SYSERR;
 #if CRYPTO_BUG
-  if (GNUNET_OK != check_eddsa_key (priv))
-  {
-    GNUNET_break (0);
-    return GNUNET_OK;
-  }
+  if (GNUNET_OK != check_eddsa_key(priv))
+    {
+      GNUNET_break(0);
+      return GNUNET_OK;
+    }
 #endif
   return GNUNET_OK;
 }
@@ -569,9 +569,9 @@ GNUNET_CRYPTO_eddsa_private_key_from_string (
  * @param pk location of the key
  */
 void
-GNUNET_CRYPTO_ecdhe_key_clear (struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
+GNUNET_CRYPTO_ecdhe_key_clear(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
 {
-  memset (pk, 0, sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
+  memset(pk, 0, sizeof(struct GNUNET_CRYPTO_EcdhePrivateKey));
 }
 
 
@@ -582,9 +582,9 @@ GNUNET_CRYPTO_ecdhe_key_clear (struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
  * @param pk location of the key
  */
 void
-GNUNET_CRYPTO_ecdsa_key_clear (struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
+GNUNET_CRYPTO_ecdsa_key_clear(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
 {
-  memset (pk, 0, sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
+  memset(pk, 0, sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
 }
 
 
@@ -595,9 +595,9 @@ GNUNET_CRYPTO_ecdsa_key_clear (struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
  * @param pk location of the key
  */
 void
-GNUNET_CRYPTO_eddsa_key_clear (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
+GNUNET_CRYPTO_eddsa_key_clear(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
 {
-  memset (pk, 0, sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+  memset(pk, 0, sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey));
 }
 
 
@@ -607,16 +607,16 @@ GNUNET_CRYPTO_eddsa_key_clear (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
  * @return fresh private key
  */
 struct GNUNET_CRYPTO_EcdhePrivateKey *
-GNUNET_CRYPTO_ecdhe_key_create ()
+GNUNET_CRYPTO_ecdhe_key_create()
 {
   struct GNUNET_CRYPTO_EcdhePrivateKey *priv;
 
-  priv = GNUNET_new (struct GNUNET_CRYPTO_EcdhePrivateKey);
-  if (GNUNET_OK != GNUNET_CRYPTO_ecdhe_key_create2 (priv))
-  {
-    GNUNET_free (priv);
-    return NULL;
-  }
+  priv = GNUNET_new(struct GNUNET_CRYPTO_EcdhePrivateKey);
+  if (GNUNET_OK != GNUNET_CRYPTO_ecdhe_key_create2(priv))
+    {
+      GNUNET_free(priv);
+      return NULL;
+    }
   return priv;
 }
 
@@ -629,54 +629,54 @@ GNUNET_CRYPTO_ecdhe_key_create ()
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_CRYPTO_ecdhe_key_create2 (struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
+GNUNET_CRYPTO_ecdhe_key_create2(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
 {
   gcry_sexp_t priv_sexp;
   gcry_sexp_t s_keyparam;
   gcry_mpi_t d;
   int rc;
 
-  BENCHMARK_START (ecdhe_key_create);
+  BENCHMARK_START(ecdhe_key_create);
 
   /* NOTE: For libgcrypt >= 1.7, we do not need the 'eddsa' flag here,
      but should also be harmless. For libgcrypt < 1.7, using 'eddsa'
      disables an expensive key testing routine. We do not want to run
      the expensive check for ECDHE, as we generate TONS of keys to
      use for a very short time. */
-  if (0 != (rc = gcry_sexp_build (&s_keyparam,
-                                  NULL,
-                                  "(genkey(ecc(curve \"" CURVE "\")"
-                                  "(flags eddsa no-keytest)))")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return GNUNET_SYSERR;
-  }
-  if (0 != (rc = gcry_pk_genkey (&priv_sexp, s_keyparam)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
-    gcry_sexp_release (s_keyparam);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (s_keyparam);
+  if (0 != (rc = gcry_sexp_build(&s_keyparam,
+                                 NULL,
+                                 "(genkey(ecc(curve \"" CURVE "\")"
+                                 "(flags eddsa no-keytest)))")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return GNUNET_SYSERR;
+    }
+  if (0 != (rc = gcry_pk_genkey(&priv_sexp, s_keyparam)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
+      gcry_sexp_release(s_keyparam);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(s_keyparam);
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (priv_sexp)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    gcry_sexp_release (priv_sexp);
-    return GNUNET_SYSERR;
-  }
+  if (0 != (rc = gcry_pk_testkey(priv_sexp)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      gcry_sexp_release(priv_sexp);
+      return GNUNET_SYSERR;
+    }
 #endif
-  if (0 != (rc = key_from_sexp (&d, priv_sexp, "private-key", "d")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
-    gcry_sexp_release (priv_sexp);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (priv_sexp);
-  GNUNET_CRYPTO_mpi_print_unsigned (pk->d, sizeof (pk->d), d);
-  gcry_mpi_release (d);
+  if (0 != (rc = key_from_sexp(&d, priv_sexp, "private-key", "d")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
+      gcry_sexp_release(priv_sexp);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(priv_sexp);
+  GNUNET_CRYPTO_mpi_print_unsigned(pk->d, sizeof(pk->d), d);
+  gcry_mpi_release(d);
 
-  BENCHMARK_END (ecdhe_key_create);
+  BENCHMARK_END(ecdhe_key_create);
 
   return GNUNET_OK;
 }
@@ -688,7 +688,7 @@ GNUNET_CRYPTO_ecdhe_key_create2 (struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
  * @return fresh private key
  */
 struct GNUNET_CRYPTO_EcdsaPrivateKey *
-GNUNET_CRYPTO_ecdsa_key_create ()
+GNUNET_CRYPTO_ecdsa_key_create()
 {
   struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
   gcry_sexp_t priv_sexp;
@@ -696,43 +696,43 @@ GNUNET_CRYPTO_ecdsa_key_create ()
   gcry_mpi_t d;
   int rc;
 
-  BENCHMARK_START (ecdsa_key_create);
-
-  if (0 != (rc = gcry_sexp_build (&s_keyparam,
-                                  NULL,
-                                  "(genkey(ecc(curve \"" CURVE "\")"
-                                  "(flags)))")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
-  if (0 != (rc = gcry_pk_genkey (&priv_sexp, s_keyparam)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
-    gcry_sexp_release (s_keyparam);
-    return NULL;
-  }
-  gcry_sexp_release (s_keyparam);
+  BENCHMARK_START(ecdsa_key_create);
+
+  if (0 != (rc = gcry_sexp_build(&s_keyparam,
+                                 NULL,
+                                 "(genkey(ecc(curve \"" CURVE "\")"
+                                 "(flags)))")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
+  if (0 != (rc = gcry_pk_genkey(&priv_sexp, s_keyparam)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
+      gcry_sexp_release(s_keyparam);
+      return NULL;
+    }
+  gcry_sexp_release(s_keyparam);
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (priv_sexp)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    gcry_sexp_release (priv_sexp);
-    return NULL;
-  }
+  if (0 != (rc = gcry_pk_testkey(priv_sexp)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      gcry_sexp_release(priv_sexp);
+      return NULL;
+    }
 #endif
-  if (0 != (rc = key_from_sexp (&d, priv_sexp, "private-key", "d")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
-    gcry_sexp_release (priv_sexp);
-    return NULL;
-  }
-  gcry_sexp_release (priv_sexp);
-  priv = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
-  GNUNET_CRYPTO_mpi_print_unsigned (priv->d, sizeof (priv->d), d);
-  gcry_mpi_release (d);
-
-  BENCHMARK_END (ecdsa_key_create);
+  if (0 != (rc = key_from_sexp(&d, priv_sexp, "private-key", "d")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
+      gcry_sexp_release(priv_sexp);
+      return NULL;
+    }
+  gcry_sexp_release(priv_sexp);
+  priv = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPrivateKey);
+  GNUNET_CRYPTO_mpi_print_unsigned(priv->d, sizeof(priv->d), d);
+  gcry_mpi_release(d);
+
+  BENCHMARK_END(ecdsa_key_create);
 
   return priv;
 }
@@ -743,7 +743,7 @@ GNUNET_CRYPTO_ecdsa_key_create ()
  * @return fresh private key
  */
 struct GNUNET_CRYPTO_EddsaPrivateKey *
-GNUNET_CRYPTO_eddsa_key_create ()
+GNUNET_CRYPTO_eddsa_key_create()
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
   gcry_sexp_t priv_sexp;
@@ -751,55 +751,55 @@ GNUNET_CRYPTO_eddsa_key_create ()
   gcry_mpi_t d;
   int rc;
 
-  BENCHMARK_START (eddsa_key_create);
+  BENCHMARK_START(eddsa_key_create);
 
 #if CRYPTO_BUG
 again:
 #endif
-  if (0 != (rc = gcry_sexp_build (&s_keyparam,
-                                  NULL,
-                                  "(genkey(ecc(curve \"" CURVE "\")"
-                                  "(flags eddsa)))")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
-  if (0 != (rc = gcry_pk_genkey (&priv_sexp, s_keyparam)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
-    gcry_sexp_release (s_keyparam);
-    return NULL;
-  }
-  gcry_sexp_release (s_keyparam);
+  if (0 != (rc = gcry_sexp_build(&s_keyparam,
+                                 NULL,
+                                 "(genkey(ecc(curve \"" CURVE "\")"
+                                 "(flags eddsa)))")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
+  if (0 != (rc = gcry_pk_genkey(&priv_sexp, s_keyparam)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_genkey", rc);
+      gcry_sexp_release(s_keyparam);
+      return NULL;
+    }
+  gcry_sexp_release(s_keyparam);
 #if EXTRA_CHECKS
-  if (0 != (rc = gcry_pk_testkey (priv_sexp)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
-    gcry_sexp_release (priv_sexp);
-    return NULL;
-  }
+  if (0 != (rc = gcry_pk_testkey(priv_sexp)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      gcry_sexp_release(priv_sexp);
+      return NULL;
+    }
 #endif
-  if (0 != (rc = key_from_sexp (&d, priv_sexp, "private-key", "d")))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
-    gcry_sexp_release (priv_sexp);
-    return NULL;
-  }
-  gcry_sexp_release (priv_sexp);
-  priv = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
-  GNUNET_CRYPTO_mpi_print_unsigned (priv->d, sizeof (priv->d), d);
-  gcry_mpi_release (d);
+  if (0 != (rc = key_from_sexp(&d, priv_sexp, "private-key", "d")))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "key_from_sexp", rc);
+      gcry_sexp_release(priv_sexp);
+      return NULL;
+    }
+  gcry_sexp_release(priv_sexp);
+  priv = GNUNET_new(struct GNUNET_CRYPTO_EddsaPrivateKey);
+  GNUNET_CRYPTO_mpi_print_unsigned(priv->d, sizeof(priv->d), d);
+  gcry_mpi_release(d);
 
 #if CRYPTO_BUG
-  if (GNUNET_OK != check_eddsa_key (priv))
-  {
-    GNUNET_break (0);
-    GNUNET_free (priv);
-    goto again;
-  }
+  if (GNUNET_OK != check_eddsa_key(priv))
+    {
+      GNUNET_break(0);
+      GNUNET_free(priv);
+      goto again;
+    }
 #endif
 
-  BENCHMARK_END (eddsa_key_create);
+  BENCHMARK_END(eddsa_key_create);
 
   return priv;
 }
@@ -811,7 +811,7 @@ again:
  * @return "anonymous" private key
  */
 const struct GNUNET_CRYPTO_EcdsaPrivateKey *
-GNUNET_CRYPTO_ecdsa_key_get_anonymous ()
+GNUNET_CRYPTO_ecdsa_key_get_anonymous()
 {
   /**
    * 'anonymous' pseudonym (global static, d=1, public key = G
@@ -822,9 +822,9 @@ GNUNET_CRYPTO_ecdsa_key_get_anonymous ()
 
   if (once)
     return &anonymous;
-  GNUNET_CRYPTO_mpi_print_unsigned (anonymous.d,
-                                    sizeof (anonymous.d),
-                                    GCRYMPI_CONST_ONE);
+  GNUNET_CRYPTO_mpi_print_unsigned(anonymous.d,
+                                   sizeof(anonymous.d),
+                                   GCRYMPI_CONST_ONE);
   once = 1;
   return &anonymous;
 }
@@ -838,7 +838,7 @@ GNUNET_CRYPTO_ecdsa_key_get_anonymous ()
  * @return converted s-expression
  */
 static gcry_sexp_t
-data_to_eddsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
+data_to_eddsa_value(const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
 {
   gcry_sexp_t data;
   int rc;
@@ -847,29 +847,29 @@ data_to_eddsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
 #if 1
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (purpose, ntohl (purpose->size), &hc);
-  if (0 != (rc = gcry_sexp_build (&data,
-                                  NULL,
-                                  "(data(flags eddsa)(hash-algo %s)(value %b))",
-                                  "sha512",
-                                  (int) sizeof (hc),
-                                  &hc)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
+  GNUNET_CRYPTO_hash(purpose, ntohl(purpose->size), &hc);
+  if (0 != (rc = gcry_sexp_build(&data,
+                                 NULL,
+                                 "(data(flags eddsa)(hash-algo %s)(value %b))",
+                                 "sha512",
+                                 (int)sizeof(hc),
+                                 &hc)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
 #else
-  GNUNET_CRYPTO_hash (purpose, ntohl (purpose->size), &hc);
-  if (0 != (rc = gcry_sexp_build (&data,
-                                  NULL,
-                                  "(data(flags eddsa)(hash-algo %s)(value %b))",
-                                  "sha512",
-                                  ntohl (purpose->size),
-                                  purpose)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
+  GNUNET_CRYPTO_hash(purpose, ntohl(purpose->size), &hc);
+  if (0 != (rc = gcry_sexp_build(&data,
+                                 NULL,
+                                 "(data(flags eddsa)(hash-algo %s)(value %b))",
+                                 "sha512",
+                                 ntohl(purpose->size),
+                                 purpose)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
 #endif
   return data;
 }
@@ -883,7 +883,7 @@ data_to_eddsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
  * @return converted s-expression
  */
 static gcry_sexp_t
-data_to_ecdsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
+data_to_ecdsa_value(const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
 {
   gcry_sexp_t data;
   int rc;
@@ -892,28 +892,28 @@ data_to_ecdsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
 #if 1
   struct GNUNET_HashCode hc;
 
-  GNUNET_CRYPTO_hash (purpose, ntohl (purpose->size), &hc);
-  if (0 != (rc = gcry_sexp_build (&data,
-                                  NULL,
-                                  "(data(flags rfc6979)(hash %s %b))",
-                                  "sha512",
-                                  (int) sizeof (hc),
-                                  &hc)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
+  GNUNET_CRYPTO_hash(purpose, ntohl(purpose->size), &hc);
+  if (0 != (rc = gcry_sexp_build(&data,
+                                 NULL,
+                                 "(data(flags rfc6979)(hash %s %b))",
+                                 "sha512",
+                                 (int)sizeof(hc),
+                                 &hc)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
 #else
-  if (0 != (rc = gcry_sexp_build (&data,
-                                  NULL,
-                                  "(data(flags rfc6979)(hash %s %b))",
-                                  "sha512",
-                                  ntohl (purpose->size),
-                                  purpose)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return NULL;
-  }
+  if (0 != (rc = gcry_sexp_build(&data,
+                                 NULL,
+                                 "(data(flags rfc6979)(hash %s %b))",
+                                 "sha512",
+                                 ntohl(purpose->size),
+                                 purpose)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return NULL;
+    }
 #endif
   return data;
 }
@@ -928,7 +928,7 @@ data_to_ecdsa_value (const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose)
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecdsa_sign (
+GNUNET_CRYPTO_ecdsa_sign(
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
   const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
   struct GNUNET_CRYPTO_EcdsaSignature *sig)
@@ -939,39 +939,39 @@ GNUNET_CRYPTO_ecdsa_sign (
   int rc;
   gcry_mpi_t rs[2];
 
-  BENCHMARK_START (ecdsa_sign);
-
-  priv_sexp = decode_private_ecdsa_key (priv);
-  data = data_to_ecdsa_value (purpose);
-  if (0 != (rc = gcry_pk_sign (&sig_sexp, data, priv_sexp)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("ECC signing failed at %s:%d: %s\n"),
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    gcry_sexp_release (data);
-    gcry_sexp_release (priv_sexp);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (priv_sexp);
-  gcry_sexp_release (data);
+  BENCHMARK_START(ecdsa_sign);
+
+  priv_sexp = decode_private_ecdsa_key(priv);
+  data = data_to_ecdsa_value(purpose);
+  if (0 != (rc = gcry_pk_sign(&sig_sexp, data, priv_sexp)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("ECC signing failed at %s:%d: %s\n"),
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      gcry_sexp_release(data);
+      gcry_sexp_release(priv_sexp);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(priv_sexp);
+  gcry_sexp_release(data);
 
   /* extract 'r' and 's' values from sexpression 'sig_sexp' and store in
      'signature' */
-  if (0 != (rc = key_from_sexp (rs, sig_sexp, "sig-val", "rs")))
-  {
-    GNUNET_break (0);
-    gcry_sexp_release (sig_sexp);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (sig_sexp);
-  GNUNET_CRYPTO_mpi_print_unsigned (sig->r, sizeof (sig->r), rs[0]);
-  GNUNET_CRYPTO_mpi_print_unsigned (sig->s, sizeof (sig->s), rs[1]);
-  gcry_mpi_release (rs[0]);
-  gcry_mpi_release (rs[1]);
+  if (0 != (rc = key_from_sexp(rs, sig_sexp, "sig-val", "rs")))
+    {
+      GNUNET_break(0);
+      gcry_sexp_release(sig_sexp);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(sig_sexp);
+  GNUNET_CRYPTO_mpi_print_unsigned(sig->r, sizeof(sig->r), rs[0]);
+  GNUNET_CRYPTO_mpi_print_unsigned(sig->s, sizeof(sig->s), rs[1]);
+  gcry_mpi_release(rs[0]);
+  gcry_mpi_release(rs[1]);
 
-  BENCHMARK_END (ecdsa_sign);
+  BENCHMARK_END(ecdsa_sign);
 
   return GNUNET_OK;
 }
@@ -986,7 +986,7 @@ GNUNET_CRYPTO_ecdsa_sign (
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_eddsa_sign (
+GNUNET_CRYPTO_eddsa_sign(
   const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
   const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
   struct GNUNET_CRYPTO_EddsaSignature *sig)
@@ -997,39 +997,39 @@ GNUNET_CRYPTO_eddsa_sign (
   int rc;
   gcry_mpi_t rs[2];
 
-  BENCHMARK_START (eddsa_sign);
-
-  priv_sexp = decode_private_eddsa_key (priv);
-  data = data_to_eddsa_value (purpose);
-  if (0 != (rc = gcry_pk_sign (&sig_sexp, data, priv_sexp)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("EdDSA signing failed at %s:%d: %s\n"),
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    gcry_sexp_release (data);
-    gcry_sexp_release (priv_sexp);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (priv_sexp);
-  gcry_sexp_release (data);
+  BENCHMARK_START(eddsa_sign);
+
+  priv_sexp = decode_private_eddsa_key(priv);
+  data = data_to_eddsa_value(purpose);
+  if (0 != (rc = gcry_pk_sign(&sig_sexp, data, priv_sexp)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("EdDSA signing failed at %s:%d: %s\n"),
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      gcry_sexp_release(data);
+      gcry_sexp_release(priv_sexp);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(priv_sexp);
+  gcry_sexp_release(data);
 
   /* extract 'r' and 's' values from sexpression 'sig_sexp' and store in
      'signature' */
-  if (0 != (rc = key_from_sexp (rs, sig_sexp, "sig-val", "rs")))
-  {
-    GNUNET_break (0);
-    gcry_sexp_release (sig_sexp);
-    return GNUNET_SYSERR;
-  }
-  gcry_sexp_release (sig_sexp);
-  GNUNET_CRYPTO_mpi_print_unsigned (sig->r, sizeof (sig->r), rs[0]);
-  GNUNET_CRYPTO_mpi_print_unsigned (sig->s, sizeof (sig->s), rs[1]);
-  gcry_mpi_release (rs[0]);
-  gcry_mpi_release (rs[1]);
+  if (0 != (rc = key_from_sexp(rs, sig_sexp, "sig-val", "rs")))
+    {
+      GNUNET_break(0);
+      gcry_sexp_release(sig_sexp);
+      return GNUNET_SYSERR;
+    }
+  gcry_sexp_release(sig_sexp);
+  GNUNET_CRYPTO_mpi_print_unsigned(sig->r, sizeof(sig->r), rs[0]);
+  GNUNET_CRYPTO_mpi_print_unsigned(sig->s, sizeof(sig->s), rs[1]);
+  gcry_mpi_release(rs[0]);
+  gcry_mpi_release(rs[1]);
 
-  BENCHMARK_END (eddsa_sign);
+  BENCHMARK_END(eddsa_sign);
 
   return GNUNET_OK;
 }
@@ -1045,7 +1045,7 @@ GNUNET_CRYPTO_eddsa_sign (
  * @returns #GNUNET_OK if ok, #GNUNET_SYSERR if invalid
  */
 int
-GNUNET_CRYPTO_ecdsa_verify (
+GNUNET_CRYPTO_ecdsa_verify(
   uint32_t purpose,
   const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
   const struct GNUNET_CRYPTO_EcdsaSignature *sig,
@@ -1056,49 +1056,49 @@ GNUNET_CRYPTO_ecdsa_verify (
   gcry_sexp_t pub_sexpr;
   int rc;
 
-  BENCHMARK_START (ecdsa_verify);
+  BENCHMARK_START(ecdsa_verify);
 
-  if (purpose != ntohl (validate->purpose))
+  if (purpose != ntohl(validate->purpose))
     return GNUNET_SYSERR; /* purpose mismatch */
 
   /* build s-expression for signature */
-  if (0 != (rc = gcry_sexp_build (&sig_sexpr,
-                                  NULL,
-                                  "(sig-val(ecdsa(r %b)(s %b)))",
-                                  (int) sizeof (sig->r),
-                                  sig->r,
-                                  (int) sizeof (sig->s),
-                                  sig->s)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return GNUNET_SYSERR;
-  }
-  data = data_to_ecdsa_value (validate);
-  if (0 != (rc = gcry_sexp_build (&pub_sexpr,
-                                  NULL,
-                                  "(public-key(ecc(curve " CURVE ")(q %b)))",
-                                  (int) sizeof (pub->q_y),
-                                  pub->q_y)))
-  {
-    gcry_sexp_release (data);
-    gcry_sexp_release (sig_sexpr);
-    return GNUNET_SYSERR;
-  }
-  rc = gcry_pk_verify (sig_sexpr, data, pub_sexpr);
-  gcry_sexp_release (pub_sexpr);
-  gcry_sexp_release (data);
-  gcry_sexp_release (sig_sexpr);
+  if (0 != (rc = gcry_sexp_build(&sig_sexpr,
+                                 NULL,
+                                 "(sig-val(ecdsa(r %b)(s %b)))",
+                                 (int)sizeof(sig->r),
+                                 sig->r,
+                                 (int)sizeof(sig->s),
+                                 sig->s)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return GNUNET_SYSERR;
+    }
+  data = data_to_ecdsa_value(validate);
+  if (0 != (rc = gcry_sexp_build(&pub_sexpr,
+                                 NULL,
+                                 "(public-key(ecc(curve " CURVE ")(q %b)))",
+                                 (int)sizeof(pub->q_y),
+                                 pub->q_y)))
+    {
+      gcry_sexp_release(data);
+      gcry_sexp_release(sig_sexpr);
+      return GNUNET_SYSERR;
+    }
+  rc = gcry_pk_verify(sig_sexpr, data, pub_sexpr);
+  gcry_sexp_release(pub_sexpr);
+  gcry_sexp_release(data);
+  gcry_sexp_release(sig_sexpr);
   if (0 != rc)
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _ ("ECDSA signature verification failed at %s:%d: %s\n"),
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    BENCHMARK_END (ecdsa_verify);
-    return GNUNET_SYSERR;
-  }
-  BENCHMARK_END (ecdsa_verify);
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("ECDSA signature verification failed at %s:%d: %s\n"),
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      BENCHMARK_END(ecdsa_verify);
+      return GNUNET_SYSERR;
+    }
+  BENCHMARK_END(ecdsa_verify);
   return GNUNET_OK;
 }
 
@@ -1113,7 +1113,7 @@ GNUNET_CRYPTO_ecdsa_verify (
  * @returns #GNUNET_OK if ok, #GNUNET_SYSERR if invalid
  */
 int
-GNUNET_CRYPTO_eddsa_verify (
+GNUNET_CRYPTO_eddsa_verify(
   uint32_t purpose,
   const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
   const struct GNUNET_CRYPTO_EddsaSignature *sig,
@@ -1124,51 +1124,51 @@ GNUNET_CRYPTO_eddsa_verify (
   gcry_sexp_t pub_sexpr;
   int rc;
 
-  BENCHMARK_START (eddsa_verify);
+  BENCHMARK_START(eddsa_verify);
 
-  if (purpose != ntohl (validate->purpose))
+  if (purpose != ntohl(validate->purpose))
     return GNUNET_SYSERR; /* purpose mismatch */
 
   /* build s-expression for signature */
-  if (0 != (rc = gcry_sexp_build (&sig_sexpr,
-                                  NULL,
-                                  "(sig-val(eddsa(r %b)(s %b)))",
-                                  (int) sizeof (sig->r),
-                                  sig->r,
-                                  (int) sizeof (sig->s),
-                                  sig->s)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
-    return GNUNET_SYSERR;
-  }
-  data = data_to_eddsa_value (validate);
-  if (0 != (rc = gcry_sexp_build (&pub_sexpr,
-                                  NULL,
-                                  "(public-key(ecc(curve " CURVE
-                                  ")(flags eddsa)(q %b)))",
-                                  (int) sizeof (pub->q_y),
-                                  pub->q_y)))
-  {
-    gcry_sexp_release (data);
-    gcry_sexp_release (sig_sexpr);
-    return GNUNET_SYSERR;
-  }
-  rc = gcry_pk_verify (sig_sexpr, data, pub_sexpr);
-  gcry_sexp_release (pub_sexpr);
-  gcry_sexp_release (data);
-  gcry_sexp_release (sig_sexpr);
+  if (0 != (rc = gcry_sexp_build(&sig_sexpr,
+                                 NULL,
+                                 "(sig-val(eddsa(r %b)(s %b)))",
+                                 (int)sizeof(sig->r),
+                                 sig->r,
+                                 (int)sizeof(sig->s),
+                                 sig->s)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+      return GNUNET_SYSERR;
+    }
+  data = data_to_eddsa_value(validate);
+  if (0 != (rc = gcry_sexp_build(&pub_sexpr,
+                                 NULL,
+                                 "(public-key(ecc(curve " CURVE
+                                 ")(flags eddsa)(q %b)))",
+                                 (int)sizeof(pub->q_y),
+                                 pub->q_y)))
+    {
+      gcry_sexp_release(data);
+      gcry_sexp_release(sig_sexpr);
+      return GNUNET_SYSERR;
+    }
+  rc = gcry_pk_verify(sig_sexpr, data, pub_sexpr);
+  gcry_sexp_release(pub_sexpr);
+  gcry_sexp_release(data);
+  gcry_sexp_release(sig_sexpr);
   if (0 != rc)
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _ ("EdDSA signature verification of type %u failed at %s:%d: %s\n"),
-         (unsigned int) purpose,
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    BENCHMARK_END (eddsa_verify);
-    return GNUNET_SYSERR;
-  }
-  BENCHMARK_END (eddsa_verify);
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("EdDSA signature verification of type %u failed at %s:%d: %s\n"),
+          (unsigned int)purpose,
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      BENCHMARK_END(eddsa_verify);
+      return GNUNET_SYSERR;
+    }
+  BENCHMARK_END(eddsa_verify);
   return GNUNET_OK;
 }
 
@@ -1182,9 +1182,9 @@ GNUNET_CRYPTO_eddsa_verify (
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecc_ecdh (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
-                        const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
-                        struct GNUNET_HashCode *key_material)
+GNUNET_CRYPTO_ecc_ecdh(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
+                       const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
+                       struct GNUNET_HashCode *key_material)
 {
   gcry_mpi_point_t result;
   gcry_mpi_point_t q;
@@ -1195,51 +1195,51 @@ GNUNET_CRYPTO_ecc_ecdh (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
   unsigned char xbuf[256 / 8];
   size_t rsize;
 
-  BENCHMARK_START (ecc_ecdh);
+  BENCHMARK_START(ecc_ecdh);
 
   /* first, extract the q = dP value from the public key */
-  if (0 != gcry_sexp_build (&pub_sexpr,
-                            NULL,
-                            "(public-key(ecc(curve " CURVE ")(q %b)))",
-                            (int) sizeof (pub->q_y),
-                            pub->q_y))
+  if (0 != gcry_sexp_build(&pub_sexpr,
+                           NULL,
+                           "(public-key(ecc(curve " CURVE ")(q %b)))",
+                           (int)sizeof(pub->q_y),
+                           pub->q_y))
     return GNUNET_SYSERR;
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, pub_sexpr, NULL));
-  gcry_sexp_release (pub_sexpr);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, pub_sexpr, NULL));
+  gcry_sexp_release(pub_sexpr);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
 
   /* second, extract the d value from our private key */
-  GNUNET_CRYPTO_mpi_scan_unsigned (&d, priv->d, sizeof (priv->d));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&d, priv->d, sizeof(priv->d));
 
   /* then call the 'multiply' function, to compute the product */
-  result = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (result, d, q, ctx);
-  gcry_mpi_point_release (q);
-  gcry_mpi_release (d);
+  result = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(result, d, q, ctx);
+  gcry_mpi_point_release(q);
+  gcry_mpi_release(d);
 
   /* finally, convert point to string for hashing */
-  result_x = gcry_mpi_new (256);
-  if (gcry_mpi_ec_get_affine (result_x, NULL, result, ctx))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "get_affine failed", 0);
-    gcry_mpi_point_release (result);
-    gcry_ctx_release (ctx);
-    return GNUNET_SYSERR;
-  }
-  gcry_mpi_point_release (result);
-  gcry_ctx_release (ctx);
+  result_x = gcry_mpi_new(256);
+  if (gcry_mpi_ec_get_affine(result_x, NULL, result, ctx))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "get_affine failed", 0);
+      gcry_mpi_point_release(result);
+      gcry_ctx_release(ctx);
+      return GNUNET_SYSERR;
+    }
+  gcry_mpi_point_release(result);
+  gcry_ctx_release(ctx);
 
-  rsize = sizeof (xbuf);
-  GNUNET_assert (! gcry_mpi_get_flag (result_x, GCRYMPI_FLAG_OPAQUE));
+  rsize = sizeof(xbuf);
+  GNUNET_assert(!gcry_mpi_get_flag(result_x, GCRYMPI_FLAG_OPAQUE));
   /* result_x can be negative here, so we do not use 'GNUNET_CRYPTO_mpi_print_unsigned'
      as that does not include the sign bit; x should be a 255-bit
      value, so with the sign it should fit snugly into the 256-bit
      xbuf */
-  GNUNET_assert (
-    0 == gcry_mpi_print (GCRYMPI_FMT_STD, xbuf, rsize, &rsize, result_x));
-  GNUNET_CRYPTO_hash (xbuf, rsize, key_material);
-  gcry_mpi_release (result_x);
-  BENCHMARK_END (ecc_ecdh);
+  GNUNET_assert(
+    0 == gcry_mpi_print(GCRYMPI_FMT_STD, xbuf, rsize, &rsize, result_x));
+  GNUNET_CRYPTO_hash(xbuf, rsize, key_material);
+  gcry_mpi_release(result_x);
+  BENCHMARK_END(ecc_ecdh);
   return GNUNET_OK;
 }
 
@@ -1255,27 +1255,27 @@ GNUNET_CRYPTO_ecc_ecdh (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
  * @return h value
  */
 static gcry_mpi_t
-derive_h (const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
-          const char *label,
-          const char *context)
+derive_h(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
+         const char *label,
+         const char *context)
 {
   gcry_mpi_t h;
   struct GNUNET_HashCode hc;
   static const char *const salt = "key-derivation";
 
-  GNUNET_CRYPTO_kdf (&hc,
-                     sizeof (hc),
-                     salt,
-                     strlen (salt),
-                     pub,
-                     sizeof (*pub),
-                     label,
-                     strlen (label),
-                     context,
-                     strlen (context),
-                     NULL,
-                     0);
-  GNUNET_CRYPTO_mpi_scan_unsigned (&h, (unsigned char *) &hc, sizeof (hc));
+  GNUNET_CRYPTO_kdf(&hc,
+                    sizeof(hc),
+                    salt,
+                    strlen(salt),
+                    pub,
+                    sizeof(*pub),
+                    label,
+                    strlen(label),
+                    context,
+                    strlen(context),
+                    NULL,
+                    0);
+  GNUNET_CRYPTO_mpi_scan_unsigned(&h, (unsigned char *)&hc, sizeof(hc));
   return h;
 }
 
@@ -1293,7 +1293,7 @@ derive_h (const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
  * @return derived private key
  */
 struct GNUNET_CRYPTO_EcdsaPrivateKey *
-GNUNET_CRYPTO_ecdsa_private_key_derive (
+GNUNET_CRYPTO_ecdsa_private_key_derive(
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
   const char *label,
   const char *context)
@@ -1306,22 +1306,22 @@ GNUNET_CRYPTO_ecdsa_private_key_derive (
   gcry_mpi_t n;
   gcry_ctx_t ctx;
 
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, NULL, CURVE));
-
-  n = gcry_mpi_ec_get_mpi ("n", ctx, 1);
-  GNUNET_CRYPTO_ecdsa_key_get_public (priv, &pub);
-
-  h = derive_h (&pub, label, context);
-  GNUNET_CRYPTO_mpi_scan_unsigned (&x, priv->d, sizeof (priv->d));
-  d = gcry_mpi_new (256);
-  gcry_mpi_mulm (d, h, x, n);
-  gcry_mpi_release (h);
-  gcry_mpi_release (x);
-  gcry_mpi_release (n);
-  gcry_ctx_release (ctx);
-  ret = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
-  GNUNET_CRYPTO_mpi_print_unsigned (ret->d, sizeof (ret->d), d);
-  gcry_mpi_release (d);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, NULL, CURVE));
+
+  n = gcry_mpi_ec_get_mpi("n", ctx, 1);
+  GNUNET_CRYPTO_ecdsa_key_get_public(priv, &pub);
+
+  h = derive_h(&pub, label, context);
+  GNUNET_CRYPTO_mpi_scan_unsigned(&x, priv->d, sizeof(priv->d));
+  d = gcry_mpi_new(256);
+  gcry_mpi_mulm(d, h, x, n);
+  gcry_mpi_release(h);
+  gcry_mpi_release(x);
+  gcry_mpi_release(n);
+  gcry_ctx_release(ctx);
+  ret = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPrivateKey);
+  GNUNET_CRYPTO_mpi_print_unsigned(ret->d, sizeof(ret->d), d);
+  gcry_mpi_release(d);
   return ret;
 }
 
@@ -1337,7 +1337,7 @@ GNUNET_CRYPTO_ecdsa_private_key_derive (
  * @param result where to write the derived public key
  */
 void
-GNUNET_CRYPTO_ecdsa_public_key_derive (
+GNUNET_CRYPTO_ecdsa_public_key_derive(
   const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
   const char *label,
   const char *context,
@@ -1351,39 +1351,39 @@ GNUNET_CRYPTO_ecdsa_public_key_derive (
   gcry_mpi_point_t q;
   gcry_mpi_point_t v;
 
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, NULL, CURVE));
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, NULL, CURVE));
 
   /* obtain point 'q' from original public key.  The provided 'q' is
      compressed thus we first store it in the context and then get it
      back as a (decompresssed) point.  */
-  q_y = gcry_mpi_set_opaque_copy (NULL, pub->q_y, 8 * sizeof (pub->q_y));
-  GNUNET_assert (NULL != q_y);
-  GNUNET_assert (0 == gcry_mpi_ec_set_mpi ("q", q_y, ctx));
-  gcry_mpi_release (q_y);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
-  GNUNET_assert (q);
+  q_y = gcry_mpi_set_opaque_copy(NULL, pub->q_y, 8 * sizeof(pub->q_y));
+  GNUNET_assert(NULL != q_y);
+  GNUNET_assert(0 == gcry_mpi_ec_set_mpi("q", q_y, ctx));
+  gcry_mpi_release(q_y);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
+  GNUNET_assert(q);
 
   /* calculate h_mod_n = h % n */
-  h = derive_h (pub, label, context);
-  n = gcry_mpi_ec_get_mpi ("n", ctx, 1);
-  h_mod_n = gcry_mpi_new (256);
-  gcry_mpi_mod (h_mod_n, h, n);
+  h = derive_h(pub, label, context);
+  n = gcry_mpi_ec_get_mpi("n", ctx, 1);
+  h_mod_n = gcry_mpi_new(256);
+  gcry_mpi_mod(h_mod_n, h, n);
   /* calculate v = h_mod_n * q */
-  v = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (v, h_mod_n, q, ctx);
-  gcry_mpi_release (h_mod_n);
-  gcry_mpi_release (h);
-  gcry_mpi_release (n);
-  gcry_mpi_point_release (q);
+  v = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(v, h_mod_n, q, ctx);
+  gcry_mpi_release(h_mod_n);
+  gcry_mpi_release(h);
+  gcry_mpi_release(n);
+  gcry_mpi_point_release(q);
 
   /* convert point 'v' to public key that we return */
-  GNUNET_assert (0 == gcry_mpi_ec_set_point ("q", v, ctx));
-  gcry_mpi_point_release (v);
-  q_y = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-  GNUNET_assert (q_y);
-  GNUNET_CRYPTO_mpi_print_unsigned (result->q_y, sizeof (result->q_y), q_y);
-  gcry_mpi_release (q_y);
-  gcry_ctx_release (ctx);
+  GNUNET_assert(0 == gcry_mpi_ec_set_point("q", v, ctx));
+  gcry_mpi_point_release(v);
+  q_y = gcry_mpi_ec_get_mpi("q@eddsa", ctx, 0);
+  GNUNET_assert(q_y);
+  GNUNET_CRYPTO_mpi_print_unsigned(result->q_y, sizeof(result->q_y), q_y);
+  gcry_mpi_release(q_y);
+  gcry_ctx_release(ctx);
 }
 
 
@@ -1394,17 +1394,17 @@ GNUNET_CRYPTO_ecdsa_public_key_derive (
  * @param length number of bytes in @a buffer
  */
 static void
-reverse_buffer (unsigned char *buffer, size_t length)
+reverse_buffer(unsigned char *buffer, size_t length)
 {
   unsigned char tmp;
   size_t i;
 
   for (i = 0; i < length / 2; i++)
-  {
-    tmp = buffer[i];
-    buffer[i] = buffer[length - 1 - i];
-    buffer[length - 1 - i] = tmp;
-  }
+    {
+      tmp = buffer[i];
+      buffer[i] = buffer[length - 1 - i];
+      buffer[length - 1 - i] = tmp;
+    }
 }
 
 
@@ -1416,7 +1416,7 @@ reverse_buffer (unsigned char *buffer, size_t length)
  * @return value used for the calculation in EdDSA
  */
 static gcry_mpi_t
-eddsa_d_to_a (gcry_mpi_t d)
+eddsa_d_to_a(gcry_mpi_t d)
 {
   unsigned char rawmpi[32]; /* 256-bit value */
   size_t rawmpilen;
@@ -1429,25 +1429,25 @@ eddsa_d_to_a (gcry_mpi_t d)
 
   /* Note that we clear DIGEST so we can use it as input to left pad
      the key with zeroes for hashing.  */
-  memset (digest, 0, sizeof digest);
-  memset (hvec, 0, sizeof hvec);
-  rawmpilen = sizeof (rawmpi);
-  GNUNET_assert (
-    0 == gcry_mpi_print (GCRYMPI_FMT_USG, rawmpi, rawmpilen, &rawmpilen, d));
+  memset(digest, 0, sizeof digest);
+  memset(hvec, 0, sizeof hvec);
+  rawmpilen = sizeof(rawmpi);
+  GNUNET_assert(
+    0 == gcry_mpi_print(GCRYMPI_FMT_USG, rawmpi, rawmpilen, &rawmpilen, d));
   hvec[0].data = digest;
   hvec[0].off = 0;
   hvec[0].len = b > rawmpilen ? (b - rawmpilen) : 0;
   hvec[1].data = rawmpi;
   hvec[1].off = 0;
   hvec[1].len = rawmpilen;
-  GNUNET_assert (
-    0 == gcry_md_hash_buffers (GCRY_MD_SHA512, 0 /* flags */, digest, hvec, 2));
+  GNUNET_assert(
+    0 == gcry_md_hash_buffers(GCRY_MD_SHA512, 0 /* flags */, digest, hvec, 2));
   /* Compute the A value.  */
-  reverse_buffer (digest, 32); /* Only the first half of the hash.  */
+  reverse_buffer(digest, 32);  /* Only the first half of the hash.  */
   digest[0] = (digest[0] & 0x7f) | 0x40;
   digest[31] &= 0xf8;
 
-  GNUNET_CRYPTO_mpi_scan_unsigned (&a, digest, 32);
+  GNUNET_CRYPTO_mpi_scan_unsigned(&a, digest, 32);
   return a;
 }
 
@@ -1461,32 +1461,32 @@ eddsa_d_to_a (gcry_mpi_t d)
  * @return #GNUNET_OK on success
  */
 static int
-point_to_hash (gcry_mpi_point_t result,
-               gcry_ctx_t ctx,
-               struct GNUNET_HashCode *key_material)
+point_to_hash(gcry_mpi_point_t result,
+              gcry_ctx_t ctx,
+              struct GNUNET_HashCode *key_material)
 {
   gcry_mpi_t result_x;
   unsigned char xbuf[256 / 8];
   size_t rsize;
 
   /* finally, convert point to string for hashing */
-  result_x = gcry_mpi_new (256);
-  if (gcry_mpi_ec_get_affine (result_x, NULL, result, ctx))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "get_affine failed", 0);
-    return GNUNET_SYSERR;
-  }
+  result_x = gcry_mpi_new(256);
+  if (gcry_mpi_ec_get_affine(result_x, NULL, result, ctx))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "get_affine failed", 0);
+      return GNUNET_SYSERR;
+    }
 
-  rsize = sizeof (xbuf);
-  GNUNET_assert (! gcry_mpi_get_flag (result_x, GCRYMPI_FLAG_OPAQUE));
+  rsize = sizeof(xbuf);
+  GNUNET_assert(!gcry_mpi_get_flag(result_x, GCRYMPI_FLAG_OPAQUE));
   /* result_x can be negative here, so we do not use 'GNUNET_CRYPTO_mpi_print_unsigned'
      as that does not include the sign bit; x should be a 255-bit
      value, so with the sign it should fit snugly into the 256-bit
      xbuf */
-  GNUNET_assert (
-    0 == gcry_mpi_print (GCRYMPI_FMT_STD, xbuf, rsize, &rsize, result_x));
-  GNUNET_CRYPTO_hash (xbuf, rsize, key_material);
-  gcry_mpi_release (result_x);
+  GNUNET_assert(
+    0 == gcry_mpi_print(GCRYMPI_FMT_STD, xbuf, rsize, &rsize, result_x));
+  GNUNET_CRYPTO_hash(xbuf, rsize, key_material);
+  gcry_mpi_release(result_x);
   return GNUNET_OK;
 }
 
@@ -1502,9 +1502,9 @@ point_to_hash (gcry_mpi_point_t result,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_eddsa_ecdh (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
-                          const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
-                          struct GNUNET_HashCode *key_material)
+GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
+                         const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
+                         struct GNUNET_HashCode *key_material)
 {
   gcry_mpi_point_t result;
   gcry_mpi_point_t q;
@@ -1514,36 +1514,36 @@ GNUNET_CRYPTO_eddsa_ecdh (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
   gcry_sexp_t pub_sexpr;
   int ret;
 
-  BENCHMARK_START (eddsa_ecdh);
+  BENCHMARK_START(eddsa_ecdh);
 
   /* first, extract the q = dP value from the public key */
-  if (0 != gcry_sexp_build (&pub_sexpr,
-                            NULL,
-                            "(public-key(ecc(curve " CURVE ")(q %b)))",
-                            (int) sizeof (pub->q_y),
-                            pub->q_y))
+  if (0 != gcry_sexp_build(&pub_sexpr,
+                           NULL,
+                           "(public-key(ecc(curve " CURVE ")(q %b)))",
+                           (int)sizeof(pub->q_y),
+                           pub->q_y))
     return GNUNET_SYSERR;
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, pub_sexpr, NULL));
-  gcry_sexp_release (pub_sexpr);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, pub_sexpr, NULL));
+  gcry_sexp_release(pub_sexpr);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
 
   /* second, extract the d value from our private key */
-  GNUNET_CRYPTO_mpi_scan_unsigned (&d, priv->d, sizeof (priv->d));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&d, priv->d, sizeof(priv->d));
 
   /* NOW, because this is EdDSA, HASH 'd' first! */
-  a = eddsa_d_to_a (d);
-  gcry_mpi_release (d);
+  a = eddsa_d_to_a(d);
+  gcry_mpi_release(d);
 
   /* then call the 'multiply' function, to compute the product */
-  result = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (result, a, q, ctx);
-  gcry_mpi_point_release (q);
-  gcry_mpi_release (a);
-
-  ret = point_to_hash (result, ctx, key_material);
-  gcry_mpi_point_release (result);
-  gcry_ctx_release (ctx);
-  BENCHMARK_END (eddsa_ecdh);
+  result = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(result, a, q, ctx);
+  gcry_mpi_point_release(q);
+  gcry_mpi_release(a);
+
+  ret = point_to_hash(result, ctx, key_material);
+  gcry_mpi_point_release(result);
+  gcry_ctx_release(ctx);
+  BENCHMARK_END(eddsa_ecdh);
   return ret;
 }
 
@@ -1559,9 +1559,9 @@ GNUNET_CRYPTO_eddsa_ecdh (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecdsa_ecdh (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
-                          const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
-                          struct GNUNET_HashCode *key_material)
+GNUNET_CRYPTO_ecdsa_ecdh(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
+                         const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
+                         struct GNUNET_HashCode *key_material)
 {
   gcry_mpi_point_t result;
   gcry_mpi_point_t q;
@@ -1570,33 +1570,33 @@ GNUNET_CRYPTO_ecdsa_ecdh (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
   gcry_sexp_t pub_sexpr;
   int ret;
 
-  BENCHMARK_START (ecdsa_ecdh);
+  BENCHMARK_START(ecdsa_ecdh);
 
   /* first, extract the q = dP value from the public key */
-  if (0 != gcry_sexp_build (&pub_sexpr,
-                            NULL,
-                            "(public-key(ecc(curve " CURVE ")(q %b)))",
-                            (int) sizeof (pub->q_y),
-                            pub->q_y))
+  if (0 != gcry_sexp_build(&pub_sexpr,
+                           NULL,
+                           "(public-key(ecc(curve " CURVE ")(q %b)))",
+                           (int)sizeof(pub->q_y),
+                           pub->q_y))
     return GNUNET_SYSERR;
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, pub_sexpr, NULL));
-  gcry_sexp_release (pub_sexpr);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, pub_sexpr, NULL));
+  gcry_sexp_release(pub_sexpr);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
 
   /* second, extract the d value from our private key */
-  GNUNET_CRYPTO_mpi_scan_unsigned (&d, priv->d, sizeof (priv->d));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&d, priv->d, sizeof(priv->d));
 
   /* then call the 'multiply' function, to compute the product */
-  result = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (result, d, q, ctx);
-  gcry_mpi_point_release (q);
-  gcry_mpi_release (d);
+  result = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(result, d, q, ctx);
+  gcry_mpi_point_release(q);
+  gcry_mpi_release(d);
 
   /* finally, convert point to string for hashing */
-  ret = point_to_hash (result, ctx, key_material);
-  gcry_mpi_point_release (result);
-  gcry_ctx_release (ctx);
-  BENCHMARK_END (ecdsa_ecdh);
+  ret = point_to_hash(result, ctx, key_material);
+  gcry_mpi_point_release(result);
+  gcry_ctx_release(ctx);
+  BENCHMARK_END(ecdsa_ecdh);
   return ret;
 }
 
@@ -1612,9 +1612,9 @@ GNUNET_CRYPTO_ecdsa_ecdh (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecdh_eddsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
-                          const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
-                          struct GNUNET_HashCode *key_material)
+GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
+                         const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
+                         struct GNUNET_HashCode *key_material)
 {
   gcry_mpi_point_t result;
   gcry_mpi_point_t q;
@@ -1623,33 +1623,33 @@ GNUNET_CRYPTO_ecdh_eddsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
   gcry_sexp_t pub_sexpr;
   int ret;
 
-  BENCHMARK_START (ecdh_eddsa);
+  BENCHMARK_START(ecdh_eddsa);
 
   /* first, extract the q = dP value from the public key */
-  if (0 != gcry_sexp_build (&pub_sexpr,
-                            NULL,
-                            "(public-key(ecc(curve " CURVE ")(q %b)))",
-                            (int) sizeof (pub->q_y),
-                            pub->q_y))
+  if (0 != gcry_sexp_build(&pub_sexpr,
+                           NULL,
+                           "(public-key(ecc(curve " CURVE ")(q %b)))",
+                           (int)sizeof(pub->q_y),
+                           pub->q_y))
     return GNUNET_SYSERR;
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, pub_sexpr, NULL));
-  gcry_sexp_release (pub_sexpr);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, pub_sexpr, NULL));
+  gcry_sexp_release(pub_sexpr);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
 
   /* second, extract the d value from our private key */
-  GNUNET_CRYPTO_mpi_scan_unsigned (&d, priv->d, sizeof (priv->d));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&d, priv->d, sizeof(priv->d));
 
   /* then call the 'multiply' function, to compute the product */
-  result = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (result, d, q, ctx);
-  gcry_mpi_point_release (q);
-  gcry_mpi_release (d);
+  result = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(result, d, q, ctx);
+  gcry_mpi_point_release(q);
+  gcry_mpi_release(d);
 
   /* finally, convert point to string for hashing */
-  ret = point_to_hash (result, ctx, key_material);
-  gcry_mpi_point_release (result);
-  gcry_ctx_release (ctx);
-  BENCHMARK_END (ecdh_eddsa);
+  ret = point_to_hash(result, ctx, key_material);
+  gcry_mpi_point_release(result);
+  gcry_ctx_release(ctx);
+  BENCHMARK_END(ecdh_eddsa);
   return ret;
 }
 
@@ -1664,14 +1664,14 @@ GNUNET_CRYPTO_ecdh_eddsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_CRYPTO_ecdh_ecdsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
-                          const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
-                          struct GNUNET_HashCode *key_material)
+GNUNET_CRYPTO_ecdh_ecdsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
+                         const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
+                         struct GNUNET_HashCode *key_material)
 {
-  return GNUNET_CRYPTO_ecdh_eddsa (priv,
-                                   (const struct GNUNET_CRYPTO_EddsaPublicKey *)
-                                     pub,
-                                   key_material);
+  return GNUNET_CRYPTO_ecdh_eddsa(priv,
+                                  (const struct GNUNET_CRYPTO_EddsaPublicKey *)
+                                  pub,
+                                  key_material);
 }
 
 /* end of crypto_ecc.c */
diff --git a/src/util/crypto_ecc_dlog.c b/src/util/crypto_ecc_dlog.c
index 07777e377..8b4344b25 100644
--- a/src/util/crypto_ecc_dlog.c
+++ b/src/util/crypto_ecc_dlog.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 util/crypto_ecc_dlog.c
@@ -44,27 +44,26 @@
  *
  */
 static void
-extract_pk (gcry_mpi_point_t pt,
-            gcry_ctx_t ctx,
-            struct GNUNET_PeerIdentity *pid)
+extract_pk(gcry_mpi_point_t pt,
+           gcry_ctx_t ctx,
+           struct GNUNET_PeerIdentity *pid)
 {
   gcry_mpi_t q_y;
 
-  GNUNET_assert (0 == gcry_mpi_ec_set_point ("q", pt, ctx));
-  q_y = gcry_mpi_ec_get_mpi ("q@eddsa", ctx, 0);
-  GNUNET_assert (q_y);
-  GNUNET_CRYPTO_mpi_print_unsigned (pid->public_key.q_y,
-                                    sizeof (pid->public_key.q_y),
-                                    q_y);
-  gcry_mpi_release (q_y);
+  GNUNET_assert(0 == gcry_mpi_ec_set_point("q", pt, ctx));
+  q_y = gcry_mpi_ec_get_mpi("q@eddsa", ctx, 0);
+  GNUNET_assert(q_y);
+  GNUNET_CRYPTO_mpi_print_unsigned(pid->public_key.q_y,
+                                   sizeof(pid->public_key.q_y),
+                                   q_y);
+  gcry_mpi_release(q_y);
 }
 
 
 /**
  * Internal structure used to cache pre-calculated values for DLOG calculation.
  */
-struct GNUNET_CRYPTO_EccDlogContext
-{
+struct GNUNET_CRYPTO_EccDlogContext {
   /**
    * Maximum absolute value the calculation supports.
    */
@@ -87,7 +86,6 @@ struct GNUNET_CRYPTO_EccDlogContext
    * Context to use for operations on the elliptic curve.
    */
   gcry_ctx_t ctx;
-
 };
 
 
@@ -99,19 +97,19 @@ struct GNUNET_CRYPTO_EccDlogContext
  * @param[out] bin binary point representation
  */
 void
-GNUNET_CRYPTO_ecc_point_to_bin (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                                gcry_mpi_point_t point,
-                                struct GNUNET_CRYPTO_EccPoint *bin)
+GNUNET_CRYPTO_ecc_point_to_bin(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                               gcry_mpi_point_t point,
+                               struct GNUNET_CRYPTO_EccPoint *bin)
 {
   gcry_mpi_t q_y;
 
-  GNUNET_assert (0 == gcry_mpi_ec_set_point ("q", point, edc->ctx));
-  q_y = gcry_mpi_ec_get_mpi ("q@eddsa", edc->ctx, 0);
-  GNUNET_assert (q_y);
-  GNUNET_CRYPTO_mpi_print_unsigned (bin->q_y,
-                                    sizeof (bin->q_y),
-                                    q_y);
-  gcry_mpi_release (q_y);
+  GNUNET_assert(0 == gcry_mpi_ec_set_point("q", point, edc->ctx));
+  q_y = gcry_mpi_ec_get_mpi("q@eddsa", edc->ctx, 0);
+  GNUNET_assert(q_y);
+  GNUNET_CRYPTO_mpi_print_unsigned(bin->q_y,
+                                   sizeof(bin->q_y),
+                                   q_y);
+  gcry_mpi_release(q_y);
 }
 
 
@@ -123,26 +121,26 @@ GNUNET_CRYPTO_ecc_point_to_bin (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @return computational representation
  */
 gcry_mpi_point_t
-GNUNET_CRYPTO_ecc_bin_to_point (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                                const struct GNUNET_CRYPTO_EccPoint *bin)
+GNUNET_CRYPTO_ecc_bin_to_point(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                               const struct GNUNET_CRYPTO_EccPoint *bin)
 {
   gcry_sexp_t pub_sexpr;
   gcry_ctx_t ctx;
   gcry_mpi_point_t q;
 
-  (void) edc;
-  if (0 != gcry_sexp_build (&pub_sexpr, NULL,
-                            "(public-key(ecc(curve " CURVE ")(q %b)))",
-                            (int) sizeof (bin->q_y),
-                            bin->q_y))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, pub_sexpr, NULL));
-  gcry_sexp_release (pub_sexpr);
-  q = gcry_mpi_ec_get_point ("q", ctx, 0);
-  gcry_ctx_release (ctx);
+  (void)edc;
+  if (0 != gcry_sexp_build(&pub_sexpr, NULL,
+                           "(public-key(ecc(curve " CURVE ")(q %b)))",
+                           (int)sizeof(bin->q_y),
+                           bin->q_y))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, pub_sexpr, NULL));
+  gcry_sexp_release(pub_sexpr);
+  q = gcry_mpi_ec_get_point("q", ctx, 0);
+  gcry_ctx_release(ctx);
   return q;
 }
 
@@ -155,11 +153,11 @@ GNUNET_CRYPTO_ecc_bin_to_point (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @return NULL on error
  */
 struct GNUNET_CRYPTO_EccDlogContext *
-GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
-                                unsigned int mem)
+GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max,
+                               unsigned int mem)
 {
   struct GNUNET_CRYPTO_EccDlogContext *edc;
-  unsigned int K = ((max + (mem-1)) / mem);
+  unsigned int K = ((max + (mem - 1)) / mem);
   gcry_mpi_point_t g;
   struct GNUNET_PeerIdentity key;
   gcry_mpi_point_t gKi;
@@ -167,50 +165,50 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
   gcry_mpi_t n;
   unsigned int i;
 
-  GNUNET_assert (max < INT32_MAX);
-  edc = GNUNET_new (struct GNUNET_CRYPTO_EccDlogContext);
+  GNUNET_assert(max < INT32_MAX);
+  edc = GNUNET_new(struct GNUNET_CRYPTO_EccDlogContext);
   edc->max = max;
   edc->mem = mem;
 
-  edc->map = GNUNET_CONTAINER_multipeermap_create (mem * 2,
-                                                   GNUNET_NO);
-
-  GNUNET_assert (0 == gcry_mpi_ec_new (&edc->ctx,
-                                       NULL,
-                                       CURVE));
-  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
-  GNUNET_assert (NULL != g);
-  fact = gcry_mpi_new (0);
-  gKi = gcry_mpi_point_new (0);
-  for (i=0;i<=mem;i++)
-  {
-    gcry_mpi_set_ui (fact, i * K);
-    gcry_mpi_ec_mul (gKi, fact, g, edc->ctx);
-    extract_pk (gKi, edc->ctx, &key);
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONTAINER_multipeermap_put (edc->map,
-                                                      &key,
-                                                      (void*) (long) i + max,
-                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  }
+  edc->map = GNUNET_CONTAINER_multipeermap_create(mem * 2,
+                                                  GNUNET_NO);
+
+  GNUNET_assert(0 == gcry_mpi_ec_new(&edc->ctx,
+                                     NULL,
+                                     CURVE));
+  g = gcry_mpi_ec_get_point("g", edc->ctx, 0);
+  GNUNET_assert(NULL != g);
+  fact = gcry_mpi_new(0);
+  gKi = gcry_mpi_point_new(0);
+  for (i = 0; i <= mem; i++)
+    {
+      gcry_mpi_set_ui(fact, i * K);
+      gcry_mpi_ec_mul(gKi, fact, g, edc->ctx);
+      extract_pk(gKi, edc->ctx, &key);
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CONTAINER_multipeermap_put(edc->map,
+                                                      &key,
+                                                      (void*)(long)i + max,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    }
   /* negative values */
-  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
-  for (i=1;i<mem;i++)
-  {
-    gcry_mpi_set_ui (fact, i * K);
-    gcry_mpi_sub (fact, n, fact);
-    gcry_mpi_ec_mul (gKi, fact, g, edc->ctx);
-    extract_pk (gKi, edc->ctx, &key);
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONTAINER_multipeermap_put (edc->map,
-                                                      &key,
-                                                      (void*) (long) max - i,
-                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  }
-  gcry_mpi_release (fact);
-  gcry_mpi_release (n);
-  gcry_mpi_point_release (gKi);
-  gcry_mpi_point_release (g);
+  n = gcry_mpi_ec_get_mpi("n", edc->ctx, 1);
+  for (i = 1; i < mem; i++)
+    {
+      gcry_mpi_set_ui(fact, i * K);
+      gcry_mpi_sub(fact, n, fact);
+      gcry_mpi_ec_mul(gKi, fact, g, edc->ctx);
+      extract_pk(gKi, edc->ctx, &key);
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CONTAINER_multipeermap_put(edc->map,
+                                                      &key,
+                                                      (void*)(long)max - i,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    }
+  gcry_mpi_release(fact);
+  gcry_mpi_release(n);
+  gcry_mpi_point_release(gKi);
+  gcry_mpi_point_release(g);
   return edc;
 }
 
@@ -223,10 +221,10 @@ GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
  * @return INT_MAX if dlog failed, otherwise the factor
  */
 int
-GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                        gcry_mpi_point_t input)
+GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       gcry_mpi_point_t input)
 {
-  unsigned int K = ((edc->max + (edc->mem-1)) / edc->mem);
+  unsigned int K = ((edc->max + (edc->mem - 1)) / edc->mem);
   gcry_mpi_point_t g;
   struct GNUNET_PeerIdentity key;
   gcry_mpi_point_t q;
@@ -234,36 +232,36 @@ GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
   int res;
   void *retp;
 
-  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
-  GNUNET_assert (NULL != g);
-  q = gcry_mpi_point_new (0);
+  g = gcry_mpi_ec_get_point("g", edc->ctx, 0);
+  GNUNET_assert(NULL != g);
+  q = gcry_mpi_point_new(0);
 
   res = INT_MAX;
-  for (i=0;i<=edc->max/edc->mem;i++)
-  {
-    if (0 == i)
-      extract_pk (input, edc->ctx, &key);
-    else
-      extract_pk (q, edc->ctx, &key);
-    retp = GNUNET_CONTAINER_multipeermap_get (edc->map,
-                                              &key);
-    if (NULL != retp)
+  for (i = 0; i <= edc->max / edc->mem; i++)
     {
-      res = (((long) retp) - edc->max) * K - i;
-      /* we continue the loop here to make the implementation
-         "constant-time". If we do not care about this, we could just
-         'break' here and do fewer operations... */
+      if (0 == i)
+        extract_pk(input, edc->ctx, &key);
+      else
+        extract_pk(q, edc->ctx, &key);
+      retp = GNUNET_CONTAINER_multipeermap_get(edc->map,
+                                               &key);
+      if (NULL != retp)
+        {
+          res = (((long)retp) - edc->max) * K - i;
+          /* we continue the loop here to make the implementation
+             "constant-time". If we do not care about this, we could just
+             'break' here and do fewer operations... */
+        }
+      if (i == edc->max / edc->mem)
+        break;
+      /* q = q + g */
+      if (0 == i)
+        gcry_mpi_ec_add(q, input, g, edc->ctx);
+      else
+        gcry_mpi_ec_add(q, q, g, edc->ctx);
     }
-    if (i == edc->max/edc->mem)
-      break;
-    /* q = q + g */
-    if (0 == i)
-      gcry_mpi_ec_add (q, input, g, edc->ctx);
-    else
-      gcry_mpi_ec_add (q, q, g, edc->ctx);
-  }
-  gcry_mpi_point_release (g);
-  gcry_mpi_point_release (q);
+  gcry_mpi_point_release(g);
+  gcry_mpi_point_release(q);
 
   return res;
 }
@@ -276,29 +274,30 @@ GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @return random value mod n.
  */
 gcry_mpi_t
-GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccDlogContext *edc)
+GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccDlogContext *edc)
 {
   gcry_mpi_t n;
   unsigned int highbit;
   gcry_mpi_t r;
 
-  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
+  n = gcry_mpi_ec_get_mpi("n", edc->ctx, 1);
 
   /* check public key for number of bits, bail out if key is all zeros */
   highbit = 256; /* Curve25519 */
-  while ( (! gcry_mpi_test_bit (n, highbit)) &&
-          (0 != highbit) )
+  while ((!gcry_mpi_test_bit(n, highbit)) &&
+         (0 != highbit))
     highbit--;
-  GNUNET_assert (0 != highbit);
+  GNUNET_assert(0 != highbit);
   /* generate fact < n (without bias) */
-  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
-  do {
-    gcry_mpi_randomize (r,
-                        highbit + 1,
-                        GCRY_STRONG_RANDOM);
-  }
-  while (gcry_mpi_cmp (r, n) >= 0);
-  gcry_mpi_release (n);
+  GNUNET_assert(NULL != (r = gcry_mpi_new(0)));
+  do
+    {
+      gcry_mpi_randomize(r,
+                         highbit + 1,
+                         GCRY_STRONG_RANDOM);
+    }
+  while (gcry_mpi_cmp(r, n) >= 0);
+  gcry_mpi_release(n);
   return r;
 }
 
@@ -309,11 +308,11 @@ GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccDlogContext *edc)
  * @param edc dlog context
  */
 void
-GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *edc)
+GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *edc)
 {
-  gcry_ctx_release (edc->ctx);
-  GNUNET_CONTAINER_multipeermap_destroy (edc->map);
-  GNUNET_free (edc);
+  gcry_ctx_release(edc->ctx);
+  GNUNET_CONTAINER_multipeermap_destroy(edc->map);
+  GNUNET_free(edc);
 }
 
 
@@ -331,32 +330,32 @@ GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *edc)
  *         must be freed using #GNUNET_CRYPTO_ecc_free()
  */
 gcry_mpi_point_t
-GNUNET_CRYPTO_ecc_dexp (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                        int val)
+GNUNET_CRYPTO_ecc_dexp(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                       int val)
 {
   gcry_mpi_t fact;
   gcry_mpi_t n;
   gcry_mpi_point_t g;
   gcry_mpi_point_t r;
 
-  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
-  GNUNET_assert (NULL != g);
-  fact = gcry_mpi_new (0);
+  g = gcry_mpi_ec_get_point("g", edc->ctx, 0);
+  GNUNET_assert(NULL != g);
+  fact = gcry_mpi_new(0);
   if (val < 0)
-  {
-    n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
-    gcry_mpi_set_ui (fact, - val);
-    gcry_mpi_sub (fact, n, fact);
-    gcry_mpi_release (n);
-  }
+    {
+      n = gcry_mpi_ec_get_mpi("n", edc->ctx, 1);
+      gcry_mpi_set_ui(fact, -val);
+      gcry_mpi_sub(fact, n, fact);
+      gcry_mpi_release(n);
+    }
   else
-  {
-    gcry_mpi_set_ui (fact, val);
-  }
-  r = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (r, fact, g, edc->ctx);
-  gcry_mpi_release (fact);
-  gcry_mpi_point_release (g);
+    {
+      gcry_mpi_set_ui(fact, val);
+    }
+  r = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(r, fact, g, edc->ctx);
+  gcry_mpi_release(fact);
+  gcry_mpi_point_release(g);
   return r;
 }
 
@@ -371,17 +370,17 @@ GNUNET_CRYPTO_ecc_dexp (struct GNUNET_CRYPTO_EccDlogContext *edc,
  *         must be freed using #GNUNET_CRYPTO_ecc_free()
  */
 gcry_mpi_point_t
-GNUNET_CRYPTO_ecc_dexp_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                            gcry_mpi_t val)
+GNUNET_CRYPTO_ecc_dexp_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                           gcry_mpi_t val)
 {
   gcry_mpi_point_t g;
   gcry_mpi_point_t r;
 
-  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
-  GNUNET_assert (NULL != g);
-  r = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (r, val, g, edc->ctx);
-  gcry_mpi_point_release (g);
+  g = gcry_mpi_ec_get_point("g", edc->ctx, 0);
+  GNUNET_assert(NULL != g);
+  r = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(r, val, g, edc->ctx);
+  gcry_mpi_point_release(g);
   return r;
 }
 
@@ -395,14 +394,14 @@ GNUNET_CRYPTO_ecc_dexp_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @return @a a + @a b, must be freed using #GNUNET_CRYPTO_ecc_free()
  */
 gcry_mpi_point_t
-GNUNET_CRYPTO_ecc_add (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                       gcry_mpi_point_t a,
-                       gcry_mpi_point_t b)
+GNUNET_CRYPTO_ecc_add(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                      gcry_mpi_point_t a,
+                      gcry_mpi_point_t b)
 {
   gcry_mpi_point_t r;
 
-  r = gcry_mpi_point_new (0);
-  gcry_mpi_ec_add (r, a, b, edc->ctx);
+  r = gcry_mpi_point_new(0);
+  gcry_mpi_ec_add(r, a, b, edc->ctx);
   return r;
 }
 
@@ -417,14 +416,14 @@ GNUNET_CRYPTO_ecc_add (struct GNUNET_CRYPTO_EccDlogContext *edc,
  *         must be freed using #GNUNET_CRYPTO_ecc_free()
  */
 gcry_mpi_point_t
-GNUNET_CRYPTO_ecc_pmul_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                            gcry_mpi_point_t p,
-                            gcry_mpi_t val)
+GNUNET_CRYPTO_ecc_pmul_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                           gcry_mpi_point_t p,
+                           gcry_mpi_t val)
 {
   gcry_mpi_point_t r;
 
-  r = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (r, val, p, edc->ctx);
+  r = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(r, val, p, edc->ctx);
   return r;
 }
 
@@ -439,31 +438,31 @@ GNUNET_CRYPTO_ecc_pmul_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @param[out] r_inv set to the additive inverse of @a r
  */
 void
-GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                       gcry_mpi_point_t *r,
-                       gcry_mpi_point_t *r_inv)
+GNUNET_CRYPTO_ecc_rnd(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                      gcry_mpi_point_t *r,
+                      gcry_mpi_point_t *r_inv)
 {
   gcry_mpi_t fact;
   gcry_mpi_t n;
   gcry_mpi_point_t g;
 
-  fact = GNUNET_CRYPTO_ecc_random_mod_n (edc);
+  fact = GNUNET_CRYPTO_ecc_random_mod_n(edc);
 
   /* calculate 'r' */
-  g = gcry_mpi_ec_get_point ("g", edc->ctx, 0);
-  GNUNET_assert (NULL != g);
-  *r = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (*r, fact, g, edc->ctx);
+  g = gcry_mpi_ec_get_point("g", edc->ctx, 0);
+  GNUNET_assert(NULL != g);
+  *r = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(*r, fact, g, edc->ctx);
 
   /* calculate 'r_inv' */
-  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
-  gcry_mpi_sub (fact, n, fact); /* fact = n - fact = - fact */
-  *r_inv = gcry_mpi_point_new (0);
-  gcry_mpi_ec_mul (*r_inv, fact, g, edc->ctx);
-
-  gcry_mpi_release (n);
-  gcry_mpi_release (fact);
-  gcry_mpi_point_release (g);
+  n = gcry_mpi_ec_get_mpi("n", edc->ctx, 1);
+  gcry_mpi_sub(fact, n, fact);  /* fact = n - fact = - fact */
+  *r_inv = gcry_mpi_point_new(0);
+  gcry_mpi_ec_mul(*r_inv, fact, g, edc->ctx);
+
+  gcry_mpi_release(n);
+  gcry_mpi_release(fact);
+  gcry_mpi_point_release(g);
 }
 
 
@@ -476,17 +475,17 @@ GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @param[out] r_inv set to the multiplicative inverse of @a r
  */
 void
-GNUNET_CRYPTO_ecc_rnd_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
-                           gcry_mpi_t *r,
-                           gcry_mpi_t *r_inv)
+GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc,
+                          gcry_mpi_t *r,
+                          gcry_mpi_t *r_inv)
 {
   gcry_mpi_t n;
 
-  *r = GNUNET_CRYPTO_ecc_random_mod_n (edc);
+  *r = GNUNET_CRYPTO_ecc_random_mod_n(edc);
   /* r_inv = n - r = - r */
-  *r_inv = gcry_mpi_new (0);
-  n = gcry_mpi_ec_get_mpi ("n", edc->ctx, 1);
-  gcry_mpi_sub (*r_inv, n, *r);
+  *r_inv = gcry_mpi_new(0);
+  n = gcry_mpi_ec_get_mpi("n", edc->ctx, 1);
+  gcry_mpi_sub(*r_inv, n, *r);
 }
 
 
@@ -496,9 +495,9 @@ GNUNET_CRYPTO_ecc_rnd_mpi (struct GNUNET_CRYPTO_EccDlogContext *edc,
  * @param p point to free
  */
 void
-GNUNET_CRYPTO_ecc_free (gcry_mpi_point_t p)
+GNUNET_CRYPTO_ecc_free(gcry_mpi_point_t p)
 {
-  gcry_mpi_point_release (p);
+  gcry_mpi_point_release(p);
 }
 
 
diff --git a/src/util/crypto_ecc_setup.c b/src/util/crypto_ecc_setup.c
index c556d805d..af42df613 100644
--- a/src/util/crypto_ecc_setup.c
+++ b/src/util/crypto_ecc_setup.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 util/crypto_ecc_setup.c
@@ -27,13 +27,13 @@
 #include <gcrypt.h>
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-crypto-ecc", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-ecc", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-crypto-ecc", syscall)
+  GNUNET_log_from_strerror(kind, "util-crypto-ecc", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-crypto-ecc", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-crypto-ecc", syscall, filename)
 
 /**
  * Log an error message at log-level 'level' that indicates
@@ -42,14 +42,14 @@
  */
 #define LOG_GCRY(level, cmd, rc)                      \
   do                                                  \
-  {                                                   \
-    LOG (level,                                       \
-         _ ("`%s' failed at %s:%d with error: %s\n"), \
-         cmd,                                         \
-         __FILE__,                                    \
-         __LINE__,                                    \
-         gcry_strerror (rc));                         \
-  } while (0)
+    {                                                   \
+      LOG(level,                                       \
+          _("`%s' failed at %s:%d with error: %s\n"), \
+          cmd,                                         \
+          __FILE__,                                    \
+          __LINE__,                                    \
+          gcry_strerror(rc));                         \
+    } while (0)
 
 
 /**
@@ -60,12 +60,12 @@
  * some 'real' work).
  */
 static void
-short_wait ()
+short_wait()
 {
   struct GNUNET_TIME_Relative timeout;
 
-  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
-  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
+  timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100);
+  (void)GNUNET_NETWORK_socket_select(NULL, NULL, NULL, timeout);
 }
 
 
@@ -84,7 +84,7 @@ short_wait ()
  *   permission denied)
  */
 struct GNUNET_CRYPTO_EddsaPrivateKey *
-GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
+GNUNET_CRYPTO_eddsa_key_create_from_file(const char *filename)
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
   struct GNUNET_DISK_FileHandle *fd;
@@ -93,159 +93,159 @@ GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
   uint64_t fs;
   ssize_t sret;
 
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file(filename))
     return NULL;
-  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
-  {
-    fd =
-      GNUNET_DISK_file_open (filename,
-                             GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
-                               GNUNET_DISK_OPEN_FAILIFEXISTS,
-                             GNUNET_DISK_PERM_USER_READ |
-                               GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == fd)
+  while (GNUNET_YES != GNUNET_DISK_file_test(filename))
     {
-      if (EEXIST == errno)
-      {
-        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+      fd =
+        GNUNET_DISK_file_open(filename,
+                              GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
+                              GNUNET_DISK_OPEN_FAILIFEXISTS,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE);
+      if (NULL == fd)
         {
-          /* must exist but not be accessible, fail for good! */
-          if (0 != access (filename, R_OK))
-            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
-          else
-            GNUNET_break (0); /* what is going on!? */
+          if (EEXIST == errno)
+            {
+              if (GNUNET_YES != GNUNET_DISK_file_test(filename))
+                {
+                  /* must exist but not be accessible, fail for good! */
+                  if (0 != access(filename, R_OK))
+                    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "access", filename);
+                  else
+                    GNUNET_break(0); /* what is going on!? */
+                  return NULL;
+                }
+              continue;
+            }
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "open", filename);
           return NULL;
         }
-        continue;
-      }
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-      return NULL;
-    }
-    cnt = 0;
-    while (GNUNET_YES !=
-           GNUNET_DISK_file_lock (fd,
+      cnt = 0;
+      while (GNUNET_YES !=
+             GNUNET_DISK_file_lock(fd,
+                                   0,
+                                   sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey),
+                                   GNUNET_YES))
+        {
+          short_wait();
+          if (0 == ++cnt % 10)
+            {
+              ec = errno;
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not acquire lock on file `%s': %s...\n"),
+                  filename,
+                  strerror(ec));
+            }
+        }
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Creating a new private key.  This may take a while.\n"));
+      priv = GNUNET_CRYPTO_eddsa_key_create();
+      GNUNET_assert(NULL != priv);
+      GNUNET_assert(sizeof(*priv) ==
+                    GNUNET_DISK_file_write(fd, priv, sizeof(*priv)));
+      GNUNET_DISK_file_sync(fd);
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock(fd,
                                   0,
-                                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
-                                  GNUNET_YES))
-    {
-      short_wait ();
-      if (0 == ++cnt % 10)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("Could not acquire lock on file `%s': %s...\n"),
-             filename,
-             strerror (ec));
-      }
+                                  sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)))
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      GNUNET_assert(GNUNET_YES == GNUNET_DISK_file_close(fd));
+      return priv;
     }
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _ ("Creating a new private key.  This may take a while.\n"));
-    priv = GNUNET_CRYPTO_eddsa_key_create ();
-    GNUNET_assert (NULL != priv);
-    GNUNET_assert (sizeof (*priv) ==
-                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
-    GNUNET_DISK_file_sync (fd);
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_unlock (fd,
-                                 0,
-                                 sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-    return priv;
-  }
   /* key file exists already, read it! */
-  fd = GNUNET_DISK_file_open (filename,
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
+  fd = GNUNET_DISK_file_open(filename,
+                             GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (NULL == fd)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-    return NULL;
-  }
-  cnt = 0;
-  while (1)
-  {
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_lock (fd,
-                               0,
-                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
-                               GNUNET_NO))
     {
-      if (0 == ++cnt % 60)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("Could not acquire lock on file `%s': %s...\n"),
-             filename,
-             strerror (ec));
-        LOG (
-          GNUNET_ERROR_TYPE_ERROR,
-          _ (
-            "This may be ok if someone is currently generating a private key.\n"));
-      }
-      short_wait ();
-      continue;
-    }
-    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-    {
-      /* eh, what!? File we opened is now gone!? */
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd,
-                                   0,
-                                   sizeof (
-                                     struct GNUNET_CRYPTO_EddsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
-
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "open", filename);
       return NULL;
     }
-    if (GNUNET_OK !=
-        GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
-      fs = 0;
-    if (fs < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
+  cnt = 0;
+  while (1)
     {
-      /* maybe we got the read lock before the key generating
-       * process had a chance to get the write lock; give it up! */
       if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd,
-                                   0,
-                                   sizeof (
-                                     struct GNUNET_CRYPTO_EddsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      if (0 == ++cnt % 10)
-      {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ (
-               "When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
-             filename,
-             (unsigned int) fs,
-             (unsigned int) sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("This may be ok if someone is currently generating a key.\n"));
-      }
-      short_wait (); /* wait a bit longer! */
-      continue;
+          GNUNET_DISK_file_lock(fd,
+                                0,
+                                sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey),
+                                GNUNET_NO))
+        {
+          if (0 == ++cnt % 60)
+            {
+              ec = errno;
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not acquire lock on file `%s': %s...\n"),
+                  filename,
+                  strerror(ec));
+              LOG(
+                GNUNET_ERROR_TYPE_ERROR,
+                _(
+                  "This may be ok if someone is currently generating a private key.\n"));
+            }
+          short_wait();
+          continue;
+        }
+      if (GNUNET_YES != GNUNET_DISK_file_test(filename))
+        {
+          /* eh, what!? File we opened is now gone!? */
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+          if (GNUNET_YES !=
+              GNUNET_DISK_file_unlock(fd,
+                                      0,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EddsaPrivateKey)))
+            LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+          GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd));
+
+          return NULL;
+        }
+      if (GNUNET_OK !=
+          GNUNET_DISK_file_size(filename, &fs, GNUNET_YES, GNUNET_YES))
+        fs = 0;
+      if (fs < sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey))
+        {
+          /* maybe we got the read lock before the key generating
+           * process had a chance to get the write lock; give it up! */
+          if (GNUNET_YES !=
+              GNUNET_DISK_file_unlock(fd,
+                                      0,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EddsaPrivateKey)))
+            LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+          if (0 == ++cnt % 10)
+            {
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _(
+                    "When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
+                  filename,
+                  (unsigned int)fs,
+                  (unsigned int)sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey));
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("This may be ok if someone is currently generating a key.\n"));
+            }
+          short_wait(); /* wait a bit longer! */
+          continue;
+        }
+      break;
     }
-    break;
-  }
-  fs = sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
-  priv = GNUNET_malloc (fs);
-  sret = GNUNET_DISK_file_read (fd, priv, fs);
-  GNUNET_assert ((sret >= 0) && (fs == (size_t) sret));
+  fs = sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey);
+  priv = GNUNET_malloc(fs);
+  sret = GNUNET_DISK_file_read(fd, priv, fs);
+  GNUNET_assert((sret >= 0) && (fs == (size_t)sret));
   if (GNUNET_YES !=
-      GNUNET_DISK_file_unlock (fd,
-                               0,
-                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+      GNUNET_DISK_file_unlock(fd,
+                              0,
+                              sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)))
+    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+  GNUNET_assert(GNUNET_YES == GNUNET_DISK_file_close(fd));
 #if CRYPTO_BUG
-  if (GNUNET_OK != check_eddsa_key (priv))
-  {
-    GNUNET_break (0);
-    GNUNET_free (priv);
-    return NULL;
-  }
+  if (GNUNET_OK != check_eddsa_key(priv))
+    {
+      GNUNET_break(0);
+      GNUNET_free(priv);
+      return NULL;
+    }
 #endif
   return priv;
 }
@@ -266,7 +266,7 @@ GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
  *   permission denied)
  */
 struct GNUNET_CRYPTO_EcdsaPrivateKey *
-GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
+GNUNET_CRYPTO_ecdsa_key_create_from_file(const char *filename)
 {
   struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
   struct GNUNET_DISK_FileHandle *fd;
@@ -275,152 +275,152 @@ GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
   uint64_t fs;
   ssize_t sret;
 
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file(filename))
     return NULL;
-  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
-  {
-    fd =
-      GNUNET_DISK_file_open (filename,
-                             GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
-                               GNUNET_DISK_OPEN_FAILIFEXISTS,
-                             GNUNET_DISK_PERM_USER_READ |
-                               GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == fd)
+  while (GNUNET_YES != GNUNET_DISK_file_test(filename))
     {
-      if (EEXIST == errno)
-      {
-        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+      fd =
+        GNUNET_DISK_file_open(filename,
+                              GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
+                              GNUNET_DISK_OPEN_FAILIFEXISTS,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE);
+      if (NULL == fd)
         {
-          /* must exist but not be accessible, fail for good! */
-          if (0 != access (filename, R_OK))
-            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
-          else
-            GNUNET_break (0); /* what is going on!? */
+          if (EEXIST == errno)
+            {
+              if (GNUNET_YES != GNUNET_DISK_file_test(filename))
+                {
+                  /* must exist but not be accessible, fail for good! */
+                  if (0 != access(filename, R_OK))
+                    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "access", filename);
+                  else
+                    GNUNET_break(0); /* what is going on!? */
+                  return NULL;
+                }
+              continue;
+            }
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "open", filename);
           return NULL;
         }
-        continue;
-      }
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-      return NULL;
-    }
-    cnt = 0;
-    while (GNUNET_YES !=
-           GNUNET_DISK_file_lock (fd,
+      cnt = 0;
+      while (GNUNET_YES !=
+             GNUNET_DISK_file_lock(fd,
+                                   0,
+                                   sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                                   GNUNET_YES))
+        {
+          short_wait();
+          if (0 == ++cnt % 10)
+            {
+              ec = errno;
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not acquire lock on file `%s': %s...\n"),
+                  filename,
+                  strerror(ec));
+            }
+        }
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Creating a new private key.  This may take a while.\n"));
+      priv = GNUNET_CRYPTO_ecdsa_key_create();
+      GNUNET_assert(NULL != priv);
+      GNUNET_assert(sizeof(*priv) ==
+                    GNUNET_DISK_file_write(fd, priv, sizeof(*priv)));
+      GNUNET_DISK_file_sync(fd);
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock(fd,
                                   0,
-                                  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                                  GNUNET_YES))
-    {
-      short_wait ();
-      if (0 == ++cnt % 10)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("Could not acquire lock on file `%s': %s...\n"),
-             filename,
-             strerror (ec));
-      }
+                                  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      GNUNET_assert(GNUNET_YES == GNUNET_DISK_file_close(fd));
+      return priv;
     }
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _ ("Creating a new private key.  This may take a while.\n"));
-    priv = GNUNET_CRYPTO_ecdsa_key_create ();
-    GNUNET_assert (NULL != priv);
-    GNUNET_assert (sizeof (*priv) ==
-                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
-    GNUNET_DISK_file_sync (fd);
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_unlock (fd,
-                                 0,
-                                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-    return priv;
-  }
   /* key file exists already, read it! */
-  fd = GNUNET_DISK_file_open (filename,
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
+  fd = GNUNET_DISK_file_open(filename,
+                             GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (NULL == fd)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-    return NULL;
-  }
-  cnt = 0;
-  while (1)
-  {
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_lock (fd,
-                               0,
-                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                               GNUNET_NO))
     {
-      if (0 == ++cnt % 60)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("Could not acquire lock on file `%s': %s...\n"),
-             filename,
-             strerror (ec));
-        LOG (
-          GNUNET_ERROR_TYPE_ERROR,
-          _ (
-            "This may be ok if someone is currently generating a private key.\n"));
-      }
-      short_wait ();
-      continue;
-    }
-    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-    {
-      /* eh, what!? File we opened is now gone!? */
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd,
-                                   0,
-                                   sizeof (
-                                     struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
-
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "open", filename);
       return NULL;
     }
-    if (GNUNET_OK !=
-        GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
-      fs = 0;
-    if (fs < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
+  cnt = 0;
+  while (1)
     {
-      /* maybe we got the read lock before the key generating
-       * process had a chance to get the write lock; give it up! */
       if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd,
-                                   0,
-                                   sizeof (
-                                     struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      if (0 == ++cnt % 10)
-      {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ (
-               "When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
-             filename,
-             (unsigned int) fs,
-             (unsigned int) sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("This may be ok if someone is currently generating a key.\n"));
-      }
-      short_wait (); /* wait a bit longer! */
-      continue;
+          GNUNET_DISK_file_lock(fd,
+                                0,
+                                sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                                GNUNET_NO))
+        {
+          if (0 == ++cnt % 60)
+            {
+              ec = errno;
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not acquire lock on file `%s': %s...\n"),
+                  filename,
+                  strerror(ec));
+              LOG(
+                GNUNET_ERROR_TYPE_ERROR,
+                _(
+                  "This may be ok if someone is currently generating a private key.\n"));
+            }
+          short_wait();
+          continue;
+        }
+      if (GNUNET_YES != GNUNET_DISK_file_test(filename))
+        {
+          /* eh, what!? File we opened is now gone!? */
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+          if (GNUNET_YES !=
+              GNUNET_DISK_file_unlock(fd,
+                                      0,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+            LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+          GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd));
+
+          return NULL;
+        }
+      if (GNUNET_OK !=
+          GNUNET_DISK_file_size(filename, &fs, GNUNET_YES, GNUNET_YES))
+        fs = 0;
+      if (fs < sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey))
+        {
+          /* maybe we got the read lock before the key generating
+           * process had a chance to get the write lock; give it up! */
+          if (GNUNET_YES !=
+              GNUNET_DISK_file_unlock(fd,
+                                      0,
+                                      sizeof(
+                                        struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+            LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+          if (0 == ++cnt % 10)
+            {
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _(
+                    "When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
+                  filename,
+                  (unsigned int)fs,
+                  (unsigned int)sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _("This may be ok if someone is currently generating a key.\n"));
+            }
+          short_wait(); /* wait a bit longer! */
+          continue;
+        }
+      break;
     }
-    break;
-  }
-  fs = sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
-  priv = GNUNET_malloc (fs);
-  sret = GNUNET_DISK_file_read (fd, priv, fs);
-  GNUNET_assert ((sret >= 0) && (fs == (size_t) sret));
+  fs = sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey);
+  priv = GNUNET_malloc(fs);
+  sret = GNUNET_DISK_file_read(fd, priv, fs);
+  GNUNET_assert((sret >= 0) && (fs == (size_t)sret));
   if (GNUNET_YES !=
-      GNUNET_DISK_file_unlock (fd,
-                               0,
-                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+      GNUNET_DISK_file_unlock(fd,
+                              0,
+                              sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+  GNUNET_assert(GNUNET_YES == GNUNET_DISK_file_close(fd));
   return priv;
 }
 
@@ -434,17 +434,17 @@ GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
  *   permission denied)
  */
 struct GNUNET_CRYPTO_EddsaPrivateKey *
-GNUNET_CRYPTO_eddsa_key_create_from_configuration (
+GNUNET_CRYPTO_eddsa_key_create_from_configuration(
   const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
   char *fn;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY", &fn))
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "PEER", "PRIVATE_KEY", &fn))
     return NULL;
-  priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn);
-  GNUNET_free (fn);
+  priv = GNUNET_CRYPTO_eddsa_key_create_from_file(fn);
+  GNUNET_free(fn);
   return priv;
 }
 
@@ -458,19 +458,19 @@ GNUNET_CRYPTO_eddsa_key_create_from_configuration (
  *         could not be retrieved
  */
 int
-GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                 struct GNUNET_PeerIdentity *dst)
+GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                struct GNUNET_PeerIdentity *dst)
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
 
-  if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not load peer's private key\n"));
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CRYPTO_eddsa_key_get_public (priv, &dst->public_key);
-  GNUNET_free (priv);
+  if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not load peer's private key\n"));
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CRYPTO_eddsa_key_get_public(priv, &dst->public_key);
+  GNUNET_free(priv);
   return GNUNET_OK;
 }
 
@@ -484,17 +484,17 @@ GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param cfg_name name of the configuration file to use
  */
 void
-GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
+GNUNET_CRYPTO_eddsa_setup_key(const char *cfg_name)
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
 
-  cfg = GNUNET_CONFIGURATION_create ();
-  (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
-  priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  cfg = GNUNET_CONFIGURATION_create();
+  (void)GNUNET_CONFIGURATION_load(cfg, cfg_name);
+  priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
   if (NULL != priv)
-    GNUNET_free (priv);
-  GNUNET_CONFIGURATION_destroy (cfg);
+    GNUNET_free(priv);
+  GNUNET_CONFIGURATION_destroy(cfg);
 }
 
 /* end of crypto_ecc_setup.c */
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 925d6b94d..ebb1266b2 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -11,13 +11,13 @@
      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 util/crypto_hash.c
  * @brief SHA-512 #GNUNET_CRYPTO_hash() related functions
@@ -29,9 +29,9 @@
 #include "benchmark.h"
 #include <gcrypt.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-hash", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-hash", __VA_ARGS__)
 
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-crypto-hash", syscall, filename)
+#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util-crypto-hash", syscall, filename)
 
 /**
  * Hash block of given size.
@@ -41,13 +41,13 @@
  * @param ret pointer to where to write the hashcode
  */
 void
-GNUNET_CRYPTO_hash (const void *block,
-                    size_t size,
-                    struct GNUNET_HashCode *ret)
+GNUNET_CRYPTO_hash(const void *block,
+                   size_t size,
+                   struct GNUNET_HashCode *ret)
 {
-  BENCHMARK_START (hash);
-  gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
-  BENCHMARK_END (hash);
+  BENCHMARK_START(hash);
+  gcry_md_hash_buffer(GCRY_MD_SHA512, ret, block, size);
+  BENCHMARK_END(hash);
 }
 
 
@@ -66,16 +66,16 @@ GNUNET_CRYPTO_hash (const void *block,
  *  safely cast to char*, a '\\0' termination is set).
  */
 void
-GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
-                           struct GNUNET_CRYPTO_HashAsciiEncoded *result)
+GNUNET_CRYPTO_hash_to_enc(const struct GNUNET_HashCode *block,
+                          struct GNUNET_CRYPTO_HashAsciiEncoded *result)
 {
   char *np;
 
-  np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block,
-                                      sizeof (struct GNUNET_HashCode),
-                                      (char *) result,
-                                      sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
-  GNUNET_assert (NULL != np);
+  np = GNUNET_STRINGS_data_to_string((const unsigned char *)block,
+                                     sizeof(struct GNUNET_HashCode),
+                                     (char *)result,
+                                     sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
+  GNUNET_assert(NULL != np);
   *np = '\0';
 }
 
@@ -89,18 +89,18 @@ GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
  */
 int
-GNUNET_CRYPTO_hash_from_string2 (const char *enc,
-                                 size_t enclen,
-                                 struct GNUNET_HashCode *result)
+GNUNET_CRYPTO_hash_from_string2(const char *enc,
+                                size_t enclen,
+                                struct GNUNET_HashCode *result)
 {
   char upper_enc[enclen];
   char *up_ptr = upper_enc;
 
-  GNUNET_STRINGS_utf8_toupper (enc, up_ptr);
+  GNUNET_STRINGS_utf8_toupper(enc, up_ptr);
 
-  return GNUNET_STRINGS_string_to_data (upper_enc, enclen,
-                                        (unsigned char*) result,
-                                        sizeof (struct GNUNET_HashCode));
+  return GNUNET_STRINGS_string_to_data(upper_enc, enclen,
+                                       (unsigned char*)result,
+                                       sizeof(struct GNUNET_HashCode));
 }
 
 
@@ -118,13 +118,13 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc,
  *  hashcode proximity.
  */
 unsigned int
-GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
-                                 const struct GNUNET_HashCode *b)
+GNUNET_CRYPTO_hash_distance_u32(const struct GNUNET_HashCode *a,
+                                const struct GNUNET_HashCode *b)
 {
   unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
   unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;
 
-  return (x1 * x2);
+  return(x1 * x2);
 }
 
 
@@ -135,13 +135,13 @@ GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
  * @param result hash code that is randomized
  */
 void
-GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
-                                  struct GNUNET_HashCode *result)
+GNUNET_CRYPTO_hash_create_random(enum GNUNET_CRYPTO_Quality mode,
+                                 struct GNUNET_HashCode *result)
 {
   int i;
 
-  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
-    result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, UINT32_MAX);
+  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(uint32_t)) - 1; i >= 0; i--)
+    result->bits[i] = GNUNET_CRYPTO_random_u32(mode, UINT32_MAX);
 }
 
 
@@ -153,13 +153,13 @@ GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
  * @param result set to b - a
  */
 void
-GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
-                               const struct GNUNET_HashCode *b,
-                               struct GNUNET_HashCode *result)
+GNUNET_CRYPTO_hash_difference(const struct GNUNET_HashCode *a,
+                              const struct GNUNET_HashCode *b,
+                              struct GNUNET_HashCode *result)
 {
   int i;
 
-  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = b->bits[i] - a->bits[i];
 }
 
@@ -172,12 +172,12 @@ GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
  * @param result set to a + delta
  */
 void
-GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode * a,
-                        const struct GNUNET_HashCode * delta, struct GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_sum(const struct GNUNET_HashCode * a,
+                       const struct GNUNET_HashCode * delta, struct GNUNET_HashCode * result)
 {
   int i;
 
-  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = delta->bits[i] + a->bits[i];
 }
 
@@ -190,13 +190,13 @@ GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode * a,
  * @param result set to a ^ b
  */
 void
-GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a,
-                        const struct GNUNET_HashCode *b,
-                        struct GNUNET_HashCode *result)
+GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a,
+                       const struct GNUNET_HashCode *b,
+                       struct GNUNET_HashCode *result)
 {
   int i;
 
-  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = a->bits[i] ^ b->bits[i];
 }
 
@@ -209,20 +209,20 @@ GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a,
  * @param iv set to a valid initialization vector
  */
 void
-GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode *hc,
-                               struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
-                               struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
+GNUNET_CRYPTO_hash_to_aes_key(const struct GNUNET_HashCode *hc,
+                              struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
+                              struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
 {
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
-                                    "Hash key derivation", strlen ("Hash key derivation"),
-                                    hc, sizeof (struct GNUNET_HashCode),
-                                    NULL, 0));
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CRYPTO_kdf (iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector),
-                                    "Initialization vector derivation", strlen ("Initialization vector derivation"),
-                                    hc, sizeof (struct GNUNET_HashCode),
-                                    NULL, 0));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CRYPTO_kdf(skey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
+                                  "Hash key derivation", strlen("Hash key derivation"),
+                                  hc, sizeof(struct GNUNET_HashCode),
+                                  NULL, 0));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CRYPTO_kdf(iv, sizeof(struct GNUNET_CRYPTO_SymmetricInitializationVector),
+                                  "Initialization vector derivation", strlen("Initialization vector derivation"),
+                                  hc, sizeof(struct GNUNET_HashCode),
+                                  NULL, 0));
 }
 
 
@@ -233,10 +233,10 @@ GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode *hc,
  * @return Bit \a bit from hashcode \a code, -1 for invalid index
  */
 int
-GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode * code, unsigned int bit)
+GNUNET_CRYPTO_hash_get_bit(const struct GNUNET_HashCode * code, unsigned int bit)
 {
-  GNUNET_assert (bit < 8 * sizeof (struct GNUNET_HashCode));
-  return (((unsigned char *) code)[bit >> 3] & (1 << (bit & 7))) > 0;
+  GNUNET_assert(bit < 8 * sizeof(struct GNUNET_HashCode));
+  return (((unsigned char *)code)[bit >> 3] & (1 << (bit & 7))) > 0;
 }
 
 
@@ -253,16 +253,16 @@ GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode * code, unsigned int bi
  * @return the number of bits that match
  */
 unsigned int
-GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
-                                  const struct GNUNET_HashCode * second)
+GNUNET_CRYPTO_hash_matching_bits(const struct GNUNET_HashCode * first,
+                                 const struct GNUNET_HashCode * second)
 {
   unsigned int i;
 
-  for (i = 0; i < sizeof (struct GNUNET_HashCode) * 8; i++)
-    if (GNUNET_CRYPTO_hash_get_bit (first, i) !=
-        GNUNET_CRYPTO_hash_get_bit (second, i))
+  for (i = 0; i < sizeof(struct GNUNET_HashCode) * 8; i++)
+    if (GNUNET_CRYPTO_hash_get_bit(first, i) !=
+        GNUNET_CRYPTO_hash_get_bit(second, i))
       return i;
-  return sizeof (struct GNUNET_HashCode) * 8;
+  return sizeof(struct GNUNET_HashCode) * 8;
 }
 
 
@@ -275,22 +275,22 @@ GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
  * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
  */
 int
-GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
-                        const struct GNUNET_HashCode *h2)
+GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1,
+                       const struct GNUNET_HashCode *h2)
 {
   unsigned int *i1;
   unsigned int *i2;
   int i;
 
-  i1 = (unsigned int *) h1;
-  i2 = (unsigned int *) h2;
-  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
-  {
-    if (i1[i] > i2[i])
-      return 1;
-    if (i1[i] < i2[i])
-      return -1;
-  }
+  i1 = (unsigned int *)h1;
+  i2 = (unsigned int *)h2;
+  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
+    {
+      if (i1[i] > i2[i])
+        return 1;
+      if (i1[i] < i2[i])
+        return -1;
+    }
   return 0;
 }
 
@@ -305,23 +305,23 @@ GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
  * @return -1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.
  */
 int
-GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
-                           const struct GNUNET_HashCode *h2,
-                           const struct GNUNET_HashCode *target)
+GNUNET_CRYPTO_hash_xorcmp(const struct GNUNET_HashCode *h1,
+                          const struct GNUNET_HashCode *h2,
+                          const struct GNUNET_HashCode *target)
 {
   int i;
   unsigned int d1;
   unsigned int d2;
 
-  for (i = sizeof (struct GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
-  {
-    d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
-    d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
-    if (d1 > d2)
-      return 1;
-    else if (d1 < d2)
-      return -1;
-  }
+  for (i = sizeof(struct GNUNET_HashCode) / sizeof(unsigned int) - 1; i >= 0; i--)
+    {
+      d1 = ((unsigned int *)h1)[i] ^ ((unsigned int *)target)[i];
+      d2 = ((unsigned int *)h2)[i] ^ ((unsigned int *)target)[i];
+      if (d1 > d2)
+        return 1;
+      else if (d1 < d2)
+        return -1;
+    }
   return 0;
 }
 
@@ -335,15 +335,15 @@ GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
  * @param ... pair of void * & size_t for context chunks, terminated by NULL
  */
 void
-GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key,
-                               const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
-                               const void *salt, size_t salt_len, ...)
+GNUNET_CRYPTO_hmac_derive_key(struct GNUNET_CRYPTO_AuthKey *key,
+                              const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
+                              const void *salt, size_t salt_len, ...)
 {
   va_list argp;
 
-  va_start (argp, salt_len);
-  GNUNET_CRYPTO_hmac_derive_key_v (key, rkey, salt, salt_len, argp);
-  va_end (argp);
+  va_start(argp, salt_len);
+  GNUNET_CRYPTO_hmac_derive_key_v(key, rkey, salt, salt_len, argp);
+  va_end(argp);
 }
 
 
@@ -356,15 +356,15 @@ GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key,
  * @param argp pair of void * & size_t for context chunks, terminated by NULL
  */
 void
-GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
-                                 const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
-                                 const void *salt, size_t salt_len,
-                                 va_list argp)
+GNUNET_CRYPTO_hmac_derive_key_v(struct GNUNET_CRYPTO_AuthKey *key,
+                                const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
+                                const void *salt, size_t salt_len,
+                                va_list argp)
 {
-  GNUNET_CRYPTO_kdf_v (key->key, sizeof (key->key),
-                       salt, salt_len,
-                       rkey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
-                       argp);
+  GNUNET_CRYPTO_kdf_v(key->key, sizeof(key->key),
+                      salt, salt_len,
+                      rkey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
+                      argp);
 }
 
 
@@ -380,29 +380,29 @@ GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
  * @param hmac where to store the hmac
  */
 void
-GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len,
-                    const void *plaintext, size_t plaintext_len,
-                    struct GNUNET_HashCode *hmac)
+GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len,
+                       const void *plaintext, size_t plaintext_len,
+                       struct GNUNET_HashCode *hmac)
 {
   static int once;
   static gcry_md_hd_t md;
   const unsigned char *mc;
 
-  if (! once)
-  {
-    once = 1;
-    GNUNET_assert (GPG_ERR_NO_ERROR ==
-                   gcry_md_open (&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC));
-  }
+  if (!once)
+    {
+      once = 1;
+      GNUNET_assert(GPG_ERR_NO_ERROR ==
+                    gcry_md_open(&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC));
+    }
   else
-  {
-    gcry_md_reset (md);
-  }
-  gcry_md_setkey (md, key, key_len);
-  gcry_md_write (md, plaintext, plaintext_len);
-  mc = gcry_md_read (md, GCRY_MD_SHA512);
-  GNUNET_assert (NULL != mc);
-  GNUNET_memcpy (hmac->bits, mc, sizeof (hmac->bits));
+    {
+      gcry_md_reset(md);
+    }
+  gcry_md_setkey(md, key, key_len);
+  gcry_md_write(md, plaintext, plaintext_len);
+  mc = gcry_md_read(md, GCRY_MD_SHA512);
+  GNUNET_assert(NULL != mc);
+  GNUNET_memcpy(hmac->bits, mc, sizeof(hmac->bits));
 }
 
 
@@ -415,21 +415,20 @@ GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len,
  * @param hmac where to store the hmac
  */
 void
-GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
-                    const void *plaintext, size_t plaintext_len,
-                    struct GNUNET_HashCode *hmac)
+GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key,
+                   const void *plaintext, size_t plaintext_len,
+                   struct GNUNET_HashCode *hmac)
 {
-  GNUNET_CRYPTO_hmac_raw ((void*) key->key, sizeof (key->key),
-                          plaintext, plaintext_len,
-                          hmac);
+  GNUNET_CRYPTO_hmac_raw((void*)key->key, sizeof(key->key),
+                         plaintext, plaintext_len,
+                         hmac);
 }
 
 
 /**
  * Context for cummulative hashing.
  */
-struct GNUNET_HashContext
-{
+struct GNUNET_HashContext {
   /**
    * Internal state of the hash function.
    */
@@ -443,19 +442,19 @@ struct GNUNET_HashContext
  * @return context for incremental hash computation
  */
 struct GNUNET_HashContext *
-GNUNET_CRYPTO_hash_context_start ()
+GNUNET_CRYPTO_hash_context_start()
 {
   struct GNUNET_HashContext *hc;
 
-  BENCHMARK_START (hash_context_start);
+  BENCHMARK_START(hash_context_start);
 
-  hc = GNUNET_new (struct GNUNET_HashContext);
-  GNUNET_assert (0 ==
-                 gcry_md_open (&hc->hd,
-                               GCRY_MD_SHA512,
-                               0));
+  hc = GNUNET_new(struct GNUNET_HashContext);
+  GNUNET_assert(0 ==
+                gcry_md_open(&hc->hd,
+                             GCRY_MD_SHA512,
+                             0));
 
-  BENCHMARK_END (hash_context_start);
+  BENCHMARK_END(hash_context_start);
 
   return hc;
 }
@@ -469,13 +468,13 @@ GNUNET_CRYPTO_hash_context_start ()
  * @param size number of bytes in @a buf
  */
 void
-GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
-                                 const void *buf,
-                                 size_t size)
+GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc,
+                                const void *buf,
+                                size_t size)
 {
-  BENCHMARK_START (hash_context_read);
-  gcry_md_write (hc->hd, buf, size);
-  BENCHMARK_END (hash_context_read);
+  BENCHMARK_START(hash_context_read);
+  gcry_md_write(hc->hd, buf, size);
+  BENCHMARK_END(hash_context_read);
 }
 
 
@@ -486,20 +485,20 @@ GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
  * @param r_hash where to write the latest / final hash code
  */
 void
-GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
-                           struct GNUNET_HashCode *r_hash)
+GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc,
+                                  struct GNUNET_HashCode *r_hash)
 {
-  const void *res = gcry_md_read (hc->hd, 0);
+  const void *res = gcry_md_read(hc->hd, 0);
 
-  BENCHMARK_START (hash_context_finish);
+  BENCHMARK_START(hash_context_finish);
 
-  GNUNET_assert (NULL != res);
+  GNUNET_assert(NULL != res);
   if (NULL != r_hash)
-    GNUNET_memcpy (r_hash,
-            res,
-            sizeof (struct GNUNET_HashCode));
-  GNUNET_CRYPTO_hash_context_abort (hc);
-  BENCHMARK_END (hash_context_finish);
+    GNUNET_memcpy(r_hash,
+                  res,
+                  sizeof(struct GNUNET_HashCode));
+  GNUNET_CRYPTO_hash_context_abort(hc);
+  BENCHMARK_END(hash_context_finish);
 }
 
 
@@ -509,10 +508,10 @@ GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
  * @param hc hash context to destroy
  */
 void
-GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
+GNUNET_CRYPTO_hash_context_abort(struct GNUNET_HashContext *hc)
 {
-  gcry_md_close (hc->hd);
-  GNUNET_free (hc);
+  gcry_md_close(hc->hd);
+  GNUNET_free(hc);
 }
 
 
diff --git a/src/util/crypto_hash_file.c b/src/util/crypto_hash_file.c
index 83afe5e91..78d0d0a0d 100644
--- a/src/util/crypto_hash_file.c
+++ b/src/util/crypto_hash_file.c
@@ -11,13 +11,13 @@
      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 util/crypto_hash_file.c
  * @brief incremental hashing of files
@@ -27,17 +27,15 @@
 #include "gnunet_util_lib.h"
 #include <gcrypt.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-hash-file", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-hash-file", __VA_ARGS__)
 
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-crypto-hash-file", syscall, filename)
+#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util-crypto-hash-file", syscall, filename)
 
 
 /**
  * Context used when hashing a file.
  */
-struct GNUNET_CRYPTO_FileHashContext
-{
-
+struct GNUNET_CRYPTO_FileHashContext {
   /**
    * Function to call upon completion.
    */
@@ -92,7 +90,6 @@ struct GNUNET_CRYPTO_FileHashContext
    * Blocksize.
    */
   size_t bsize;
-
 };
 
 
@@ -101,15 +98,15 @@ struct GNUNET_CRYPTO_FileHashContext
  * and free associated resources.
  */
 static void
-file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
-                  const struct GNUNET_HashCode * res)
+file_hash_finish(struct GNUNET_CRYPTO_FileHashContext *fhc,
+                 const struct GNUNET_HashCode * res)
 {
-  fhc->callback (fhc->callback_cls, res);
-  GNUNET_free (fhc->filename);
-  if (!GNUNET_DISK_handle_invalid (fhc->fh))
-    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
-  gcry_md_close (fhc->md);
-  GNUNET_free (fhc);            /* also frees fhc->buffer */
+  fhc->callback(fhc->callback_cls, res);
+  GNUNET_free(fhc->filename);
+  if (!GNUNET_DISK_handle_invalid(fhc->fh))
+    GNUNET_break(GNUNET_OK == GNUNET_DISK_file_close(fhc->fh));
+  gcry_md_close(fhc->md);
+  GNUNET_free(fhc);             /* also frees fhc->buffer */
 }
 
 
@@ -119,7 +116,7 @@ file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
  * @param cls closure
  */
 static void
-file_hash_task (void *cls)
+file_hash_task(void *cls)
 {
   struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
   struct GNUNET_HashCode *res;
@@ -127,37 +124,37 @@ file_hash_task (void *cls)
   ssize_t sret;
 
   fhc->task = NULL;
-  GNUNET_assert (fhc->offset <= fhc->fsize);
+  GNUNET_assert(fhc->offset <= fhc->fsize);
   delta = fhc->bsize;
   if (fhc->fsize - fhc->offset < delta)
     delta = fhc->fsize - fhc->offset;
-  sret = GNUNET_DISK_file_read (fhc->fh,
-                                fhc->buffer,
-                                delta);
-  if ( (sret < 0) ||
-       (delta != (size_t) sret) )
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
-                       "read",
-                       fhc->filename);
-    file_hash_finish (fhc,
-                      NULL);
-    return;
-  }
-  gcry_md_write (fhc->md,
-                 fhc->buffer,
-                 delta);
+  sret = GNUNET_DISK_file_read(fhc->fh,
+                               fhc->buffer,
+                               delta);
+  if ((sret < 0) ||
+      (delta != (size_t)sret))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING,
+                        "read",
+                        fhc->filename);
+      file_hash_finish(fhc,
+                       NULL);
+      return;
+    }
+  gcry_md_write(fhc->md,
+                fhc->buffer,
+                delta);
   fhc->offset += delta;
   if (fhc->offset == fhc->fsize)
-  {
-    res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md,
-                                                   GCRY_MD_SHA512);
-    file_hash_finish (fhc, res);
-    return;
-  }
-  fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority,
-                                                  &file_hash_task,
-                                                  fhc);
+    {
+      res = (struct GNUNET_HashCode *)gcry_md_read(fhc->md,
+                                                   GCRY_MD_SHA512);
+      file_hash_finish(fhc, res);
+      return;
+    }
+  fhc->task = GNUNET_SCHEDULER_add_with_priority(fhc->priority,
+                                                 &file_hash_task,
+                                                 fhc);
 }
 
 
@@ -172,51 +169,51 @@ file_hash_task (void *cls)
  * @return NULL on (immediate) errror
  */
 struct GNUNET_CRYPTO_FileHashContext *
-GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
-                         const char *filename,
-                         size_t blocksize,
-                         GNUNET_CRYPTO_HashCompletedCallback callback,
-                         void *callback_cls)
+GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority,
+                        const char *filename,
+                        size_t blocksize,
+                        GNUNET_CRYPTO_HashCompletedCallback callback,
+                        void *callback_cls)
 {
   struct GNUNET_CRYPTO_FileHashContext *fhc;
 
-  GNUNET_assert (blocksize > 0);
+  GNUNET_assert(blocksize > 0);
   fhc =
-      GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
+    GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_FileHashContext) + blocksize);
   fhc->callback = callback;
   fhc->callback_cls = callback_cls;
-  fhc->buffer = (unsigned char *) &fhc[1];
-  fhc->filename = GNUNET_strdup (filename);
-  if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
-  {
-    GNUNET_break (0);
-    GNUNET_free (fhc);
-    return NULL;
-  }
+  fhc->buffer = (unsigned char *)&fhc[1];
+  fhc->filename = GNUNET_strdup(filename);
+  if (GPG_ERR_NO_ERROR != gcry_md_open(&fhc->md, GCRY_MD_SHA512, 0))
+    {
+      GNUNET_break(0);
+      GNUNET_free(fhc);
+      return NULL;
+    }
   fhc->bsize = blocksize;
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size (filename,
-                             &fhc->fsize,
-                             GNUNET_NO,
-                             GNUNET_YES))
-  {
-    GNUNET_free (fhc->filename);
-    GNUNET_free (fhc);
-    return NULL;
-  }
-  fhc->fh = GNUNET_DISK_file_open (filename,
-                                   GNUNET_DISK_OPEN_READ,
-                                   GNUNET_DISK_PERM_NONE);
-  if (! fhc->fh)
-  {
-    GNUNET_free (fhc->filename);
-    GNUNET_free (fhc);
-    return NULL;
-  }
+      GNUNET_DISK_file_size(filename,
+                            &fhc->fsize,
+                            GNUNET_NO,
+                            GNUNET_YES))
+    {
+      GNUNET_free(fhc->filename);
+      GNUNET_free(fhc);
+      return NULL;
+    }
+  fhc->fh = GNUNET_DISK_file_open(filename,
+                                  GNUNET_DISK_OPEN_READ,
+                                  GNUNET_DISK_PERM_NONE);
+  if (!fhc->fh)
+    {
+      GNUNET_free(fhc->filename);
+      GNUNET_free(fhc);
+      return NULL;
+    }
   fhc->priority = priority;
-  fhc->task = GNUNET_SCHEDULER_add_with_priority (priority,
-                                                  &file_hash_task,
-                                                  fhc);
+  fhc->task = GNUNET_SCHEDULER_add_with_priority(priority,
+                                                 &file_hash_task,
+                                                 fhc);
   return fhc;
 }
 
@@ -227,13 +224,13 @@ GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
  * @param fhc operation to cancel (callback must not yet have been invoked)
  */
 void
-GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
+GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
 {
-  GNUNET_SCHEDULER_cancel (fhc->task);
-  GNUNET_free (fhc->filename);
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_DISK_file_close (fhc->fh));
-  GNUNET_free (fhc);
+  GNUNET_SCHEDULER_cancel(fhc->task);
+  GNUNET_free(fhc->filename);
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_DISK_file_close(fhc->fh));
+  GNUNET_free(fhc);
 }
 
 /* end of crypto_hash_file.c */
diff --git a/src/util/crypto_hkdf.c b/src/util/crypto_hkdf.c
index 5ed22269f..58ae6c8ad 100644
--- a/src/util/crypto_hkdf.c
+++ b/src/util/crypto_hkdf.c
@@ -18,7 +18,7 @@
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
-*/
+ */
 
 /**
  * @file src/util/crypto_hkdf.c
@@ -36,7 +36,7 @@
  * - Matthias Wachs (08.10.2010)
  */
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-hkdf", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-hkdf", __VA_ARGS__)
 
 /**
  * Set this to 0 if you compile this code outside of GNUnet.
@@ -75,13 +75,13 @@
  * @return HMAC, freed by caller via gcry_md_close/_reset
  */
 static const void *
-doHMAC (gcry_md_hd_t mac, const void *key, size_t key_len, const void *buf,
-        size_t buf_len)
+doHMAC(gcry_md_hd_t mac, const void *key, size_t key_len, const void *buf,
+       size_t buf_len)
 {
-  gcry_md_setkey (mac, key, key_len);
-  gcry_md_write (mac, buf, buf_len);
+  gcry_md_setkey(mac, key, key_len);
+  gcry_md_write(mac, buf, buf_len);
 
-  return (const void *) gcry_md_read (mac, 0);
+  return (const void *)gcry_md_read(mac, 0);
 }
 
 /**
@@ -95,15 +95,15 @@ doHMAC (gcry_md_hd_t mac, const void *key, size_t key_len, const void *buf,
  * @return #GNUNET_YES on success
  */
 static int
-getPRK (gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm,
-        size_t skm_len, void *prk)
+getPRK(gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm,
+       size_t skm_len, void *prk)
 {
   const void *ret;
 
-  ret = doHMAC (mac, xts, xts_len, skm, skm_len);
+  ret = doHMAC(mac, xts, xts_len, skm, skm_len);
   if (ret == NULL)
     return GNUNET_SYSERR;
-  GNUNET_memcpy (prk, ret, gcry_md_get_algo_dlen (gcry_md_get_algo (mac)));
+  GNUNET_memcpy(prk, ret, gcry_md_get_algo_dlen(gcry_md_get_algo(mac)));
 
   return GNUNET_YES;
 }
@@ -111,16 +111,16 @@ getPRK (gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm,
 
 #if DEBUG_HKDF
 static void
-dump (const char *src, const void *p, unsigned int l)
+dump(const char *src, const void *p, unsigned int l)
 {
   unsigned int i;
 
-  printf ("\n%s: ", src);
+  printf("\n%s: ", src);
   for (i = 0; i < l; i++)
-  {
-    printf ("%2x", (int) ((const unsigned char *) p)[i]);
-  }
-  printf ("\n");
+    {
+      printf("%2x", (int)((const unsigned char *)p)[i]);
+    }
+  printf("\n");
 }
 #endif
 
@@ -139,9 +139,9 @@ dump (const char *src, const void *p, unsigned int l)
  * @return #GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
-                      const void *xts, size_t xts_len, const void *skm,
-                      size_t skm_len, va_list argp)
+GNUNET_CRYPTO_hkdf_v(void *result, size_t out_len, int xtr_algo, int prf_algo,
+                     const void *xts, size_t xts_len, const void *skm,
+                     size_t skm_len, va_list argp)
 {
   gcry_md_hd_t xtr;
   gcry_md_hd_t prf;
@@ -149,39 +149,39 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
   unsigned long i;
   unsigned long t;
   unsigned long d;
-  unsigned int k = gcry_md_get_algo_dlen (prf_algo);
-  unsigned int xtr_len = gcry_md_get_algo_dlen (xtr_algo);
+  unsigned int k = gcry_md_get_algo_dlen(prf_algo);
+  unsigned int xtr_len = gcry_md_get_algo_dlen(xtr_algo);
   char prk[xtr_len];
   int ret;
   size_t ctx_len;
   va_list args;
 
-  BENCHMARK_START (hkdf);
+  BENCHMARK_START(hkdf);
 
   if (0 == k)
     return GNUNET_SYSERR;
   if (GPG_ERR_NO_ERROR !=
-      gcry_md_open (&xtr, xtr_algo, GCRY_MD_FLAG_HMAC))
+      gcry_md_open(&xtr, xtr_algo, GCRY_MD_FLAG_HMAC))
     return GNUNET_SYSERR;
   if (GPG_ERR_NO_ERROR !=
-      gcry_md_open (&prf, prf_algo, GCRY_MD_FLAG_HMAC))
-  {
-    gcry_md_close (xtr);
-    return GNUNET_SYSERR;
-  }
-  va_copy (args, argp);
+      gcry_md_open(&prf, prf_algo, GCRY_MD_FLAG_HMAC))
+    {
+      gcry_md_close(xtr);
+      return GNUNET_SYSERR;
+    }
+  va_copy(args, argp);
 
   ctx_len = 0;
-  while (NULL != va_arg (args, void *))
-         ctx_len += va_arg (args, size_t);
+  while (NULL != va_arg(args, void *))
+    ctx_len += va_arg(args, size_t);
 
-  va_end (args);
+  va_end(args);
 
-  memset (result, 0, out_len);
-  if (getPRK (xtr, xts, xts_len, skm, skm_len, prk) != GNUNET_YES)
+  memset(result, 0, out_len);
+  if (getPRK(xtr, xts, xts_len, skm, skm_len, prk) != GNUNET_YES)
     goto hkdf_error;
 #if DEBUG_HKDF
-  dump ("PRK", prk, xtr_len);
+  dump("PRK", prk, xtr_len);
 #endif
 
   t = out_len / k;
@@ -195,69 +195,69 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
     char *dst;
 
     dst = plain + k;
-    va_copy (args, argp);
-    while ((ctx = va_arg (args, void *)))
-    {
-      size_t len;
+    va_copy(args, argp);
+    while ((ctx = va_arg(args, void *)))
+      {
+        size_t len;
 
-      len = va_arg (args, size_t);
-      GNUNET_memcpy (dst, ctx, len);
-      dst += len;
-    }
-    va_end (args);
+        len = va_arg(args, size_t);
+        GNUNET_memcpy(dst, ctx, len);
+        dst += len;
+      }
+    va_end(args);
 
     if (t > 0)
-    {
-      memset (plain + k + ctx_len, 1, 1);
+      {
+        memset(plain + k + ctx_len, 1, 1);
 #if DEBUG_HKDF
-      dump ("K(1)", plain, plain_len);
+        dump("K(1)", plain, plain_len);
 #endif
-      hc = doHMAC (prf, prk, xtr_len, &plain[k], ctx_len + 1);
-      if (hc == NULL)
-        goto hkdf_error;
-      GNUNET_memcpy (result, hc, k);
-      result += k;
-    }
+        hc = doHMAC(prf, prk, xtr_len, &plain[k], ctx_len + 1);
+        if (hc == NULL)
+          goto hkdf_error;
+        GNUNET_memcpy(result, hc, k);
+        result += k;
+      }
 
     /* K(i+1) */
     for (i = 1; i < t; i++)
-    {
-      GNUNET_memcpy (plain, result - k, k);
-      memset (plain + k + ctx_len, i + 1, 1);
-      gcry_md_reset (prf);
+      {
+        GNUNET_memcpy(plain, result - k, k);
+        memset(plain + k + ctx_len, i + 1, 1);
+        gcry_md_reset(prf);
 #if DEBUG_HKDF
-      dump ("K(i+1)", plain, plain_len);
+        dump("K(i+1)", plain, plain_len);
 #endif
-      hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
-      if (hc == NULL)
-        goto hkdf_error;
-      GNUNET_memcpy (result, hc, k);
-      result += k;
-    }
+        hc = doHMAC(prf, prk, xtr_len, plain, plain_len);
+        if (hc == NULL)
+          goto hkdf_error;
+        GNUNET_memcpy(result, hc, k);
+        result += k;
+      }
 
     /* K(t):d */
     if (d > 0)
-    {
-      if (t > 0)
       {
-        GNUNET_memcpy (plain, result - k, k);
-        i++;
-      }
-      memset (plain + k + ctx_len, i, 1);
-      gcry_md_reset (prf);
+        if (t > 0)
+          {
+            GNUNET_memcpy(plain, result - k, k);
+            i++;
+          }
+        memset(plain + k + ctx_len, i, 1);
+        gcry_md_reset(prf);
 #if DEBUG_HKDF
-      dump ("K(t):d", plain, plain_len);
+        dump("K(t):d", plain, plain_len);
 #endif
-      if (t > 0)
-        hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
-      else
-        hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k);
-      if (hc == NULL)
-        goto hkdf_error;
-      GNUNET_memcpy (result, hc, d);
-    }
+        if (t > 0)
+          hc = doHMAC(prf, prk, xtr_len, plain, plain_len);
+        else
+          hc = doHMAC(prf, prk, xtr_len, plain + k, plain_len - k);
+        if (hc == NULL)
+          goto hkdf_error;
+        GNUNET_memcpy(result, hc, d);
+      }
 #if DEBUG_HKDF
-    dump ("result", result - k, out_len);
+    dump("result", result - k, out_len);
 #endif
 
     ret = GNUNET_YES;
@@ -266,9 +266,9 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
 hkdf_error:
   ret = GNUNET_SYSERR;
 hkdf_ok:
-  gcry_md_close (xtr);
-  gcry_md_close (prf);
-  BENCHMARK_END (hkdf);
+  gcry_md_close(xtr);
+  gcry_md_close(prf);
+  BENCHMARK_END(hkdf);
   return ret;
 }
 
@@ -286,18 +286,18 @@ hkdf_ok:
  * @return #GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_hkdf (void *result, size_t out_len, int xtr_algo, int prf_algo,
-                    const void *xts, size_t xts_len, const void *skm,
-                    size_t skm_len, ...)
+GNUNET_CRYPTO_hkdf(void *result, size_t out_len, int xtr_algo, int prf_algo,
+                   const void *xts, size_t xts_len, const void *skm,
+                   size_t skm_len, ...)
 {
   va_list argp;
   int ret;
 
-  va_start (argp, skm_len);
+  va_start(argp, skm_len);
   ret =
-      GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts, xts_len,
-                            skm, skm_len, argp);
-  va_end (argp);
+    GNUNET_CRYPTO_hkdf_v(result, out_len, xtr_algo, prf_algo, xts, xts_len,
+                         skm, skm_len, argp);
+  va_end(argp);
 
   return ret;
 }
diff --git a/src/util/crypto_kdf.c b/src/util/crypto_kdf.c
index ac68ed7f1..ef96889b2 100644
--- a/src/util/crypto_kdf.c
+++ b/src/util/crypto_kdf.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file src/util/crypto_kdf.c
@@ -30,7 +30,7 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-kdf", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-kdf", __VA_ARGS__)
 
 /**
  * @brief Derive key
@@ -44,13 +44,13 @@
  * @return #GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_kdf_v (void *result,
-                     size_t out_len,
-                     const void *xts,
-                     size_t xts_len,
-                     const void *skm,
-                     size_t skm_len,
-                     va_list argp)
+GNUNET_CRYPTO_kdf_v(void *result,
+                    size_t out_len,
+                    const void *xts,
+                    size_t xts_len,
+                    const void *skm,
+                    size_t skm_len,
+                    va_list argp)
 {
   /*
    * "Finally, we point out to a particularly advantageous instantiation using
@@ -64,15 +64,15 @@ GNUNET_CRYPTO_kdf_v (void *result,
    * http://eprint.iacr.org/2010/264
    */
 
-  return GNUNET_CRYPTO_hkdf_v (result,
-                               out_len,
-                               GCRY_MD_SHA512,
-                               GCRY_MD_SHA256,
-                               xts,
-                               xts_len,
-                               skm,
-                               skm_len,
-                               argp);
+  return GNUNET_CRYPTO_hkdf_v(result,
+                              out_len,
+                              GCRY_MD_SHA512,
+                              GCRY_MD_SHA256,
+                              xts,
+                              xts_len,
+                              skm,
+                              skm_len,
+                              argp);
 }
 
 
@@ -88,25 +88,25 @@ GNUNET_CRYPTO_kdf_v (void *result,
  * @return #GNUNET_YES on success
  */
 int
-GNUNET_CRYPTO_kdf (void *result,
-                   size_t out_len,
-                   const void *xts,
-                   size_t xts_len,
-                   const void *skm,
-                   size_t skm_len, ...)
+GNUNET_CRYPTO_kdf(void *result,
+                  size_t out_len,
+                  const void *xts,
+                  size_t xts_len,
+                  const void *skm,
+                  size_t skm_len, ...)
 {
   va_list argp;
   int ret;
 
-  va_start (argp, skm_len);
-  ret = GNUNET_CRYPTO_kdf_v (result,
-                             out_len,
-                             xts,
-                             xts_len,
-                             skm,
-                             skm_len,
-                             argp);
-  va_end (argp);
+  va_start(argp, skm_len);
+  ret = GNUNET_CRYPTO_kdf_v(result,
+                            out_len,
+                            xts,
+                            xts_len,
+                            skm,
+                            skm_len,
+                            argp);
+  va_end(argp);
 
   return ret;
 }
@@ -125,50 +125,50 @@ GNUNET_CRYPTO_kdf (void *result,
  * @param ctx context string
  */
 void
-GNUNET_CRYPTO_kdf_mod_mpi (gcry_mpi_t *r,
-                           gcry_mpi_t n,
-                           const void *xts, size_t xts_len,
-                           const void *skm, size_t skm_len,
-                           const char *ctx)
+GNUNET_CRYPTO_kdf_mod_mpi(gcry_mpi_t *r,
+                          gcry_mpi_t n,
+                          const void *xts, size_t xts_len,
+                          const void *skm, size_t skm_len,
+                          const char *ctx)
 {
   gcry_error_t rc;
   unsigned int nbits;
   size_t rsize;
   unsigned int ctr;
 
-  nbits = gcry_mpi_get_nbits (n);
+  nbits = gcry_mpi_get_nbits(n);
   /* GNUNET_assert (nbits > 512); */
 
   ctr = 0;
   while (1)
-  {
-    /* Ain't clear if n is always divisible by 8 */
-    uint8_t buf[ (nbits-1)/8 + 1 ];
-
-    rc = GNUNET_CRYPTO_kdf (buf,
-                            sizeof (buf),
-                            xts, xts_len,
-                            skm, skm_len,
-                            ctx, strlen(ctx),
-                            &ctr, sizeof(ctr),
-                            NULL, 0);
-    GNUNET_assert (GNUNET_YES == rc);
-
-    rc = gcry_mpi_scan (r,
-                        GCRYMPI_FMT_USG,
-                        (const unsigned char *) buf,
-                        sizeof (buf),
-                        &rsize);
-    GNUNET_assert (0 == rc);  /* Allocation erro? */
-
-    gcry_mpi_clear_highbit (*r, nbits);
-    GNUNET_assert( 0 == gcry_mpi_test_bit (*r, nbits) );
-    ++ctr;
-    /* We reject this FDH if either *r > n and retry with another ctr */
-    if (0 > gcry_mpi_cmp(*r, n))
-      break;
-    gcry_mpi_release (*r);
-  }
+    {
+      /* Ain't clear if n is always divisible by 8 */
+      uint8_t buf[ (nbits - 1) / 8 + 1 ];
+
+      rc = GNUNET_CRYPTO_kdf(buf,
+                             sizeof(buf),
+                             xts, xts_len,
+                             skm, skm_len,
+                             ctx, strlen(ctx),
+                             &ctr, sizeof(ctr),
+                             NULL, 0);
+      GNUNET_assert(GNUNET_YES == rc);
+
+      rc = gcry_mpi_scan(r,
+                         GCRYMPI_FMT_USG,
+                         (const unsigned char *)buf,
+                         sizeof(buf),
+                         &rsize);
+      GNUNET_assert(0 == rc); /* Allocation erro? */
+
+      gcry_mpi_clear_highbit(*r, nbits);
+      GNUNET_assert(0 == gcry_mpi_test_bit(*r, nbits));
+      ++ctr;
+      /* We reject this FDH if either *r > n and retry with another ctr */
+      if (0 > gcry_mpi_cmp(*r, n))
+        break;
+      gcry_mpi_release(*r);
+    }
 }
 
 /* end of crypto_kdf.c */
diff --git a/src/util/crypto_mpi.c b/src/util/crypto_mpi.c
index 14c672383..2c402e95a 100644
--- a/src/util/crypto_mpi.c
+++ b/src/util/crypto_mpi.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 util/crypto_mpi.c
@@ -29,14 +29,14 @@
 #include "gnunet_crypto_lib.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-mpi", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-mpi", __VA_ARGS__)
 
 /**
  * Log an error message at log-level 'level' that indicates
  * a failure of the command 'cmd' with the message given
  * by gcry_strerror(rc).
  */
-#define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0)
+#define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while (0)
 
 
 /**
@@ -48,17 +48,17 @@
  * @param target target size of the buffer
  */
 static void
-adjust (void *buf,
-        size_t size,
-        size_t target)
+adjust(void *buf,
+       size_t size,
+       size_t target)
 {
   char *p = buf;
 
   if (size < target)
-  {
-    memmove (&p[target - size], buf, size);
-    memset (buf, 0, target - size);
-  }
+    {
+      memmove(&p[target - size], buf, size);
+      memset(buf, 0, target - size);
+    }
 }
 
 
@@ -72,46 +72,46 @@ adjust (void *buf,
  * @param val value to write to @a buf
  */
 void
-GNUNET_CRYPTO_mpi_print_unsigned (void *buf,
-                                  size_t size,
-                                  gcry_mpi_t val)
+GNUNET_CRYPTO_mpi_print_unsigned(void *buf,
+                                 size_t size,
+                                 gcry_mpi_t val)
 {
   size_t rsize;
   int rc;
 
-  if (gcry_mpi_get_flag (val, GCRYMPI_FLAG_OPAQUE))
-  {
-    /* Store opaque MPIs left aligned into the buffer.  */
-    unsigned int nbits;
-    const void *p;
-
-    p = gcry_mpi_get_opaque (val, &nbits);
-    GNUNET_assert (p);
-    rsize = (nbits+7)/8;
-    if (rsize > size)
-      rsize = size;
-    GNUNET_memcpy (buf, p, rsize);
-    if (rsize < size)
-      memset (buf+rsize, 0, size - rsize);
-  }
+  if (gcry_mpi_get_flag(val, GCRYMPI_FLAG_OPAQUE))
+    {
+      /* Store opaque MPIs left aligned into the buffer.  */
+      unsigned int nbits;
+      const void *p;
+
+      p = gcry_mpi_get_opaque(val, &nbits);
+      GNUNET_assert(p);
+      rsize = (nbits + 7) / 8;
+      if (rsize > size)
+        rsize = size;
+      GNUNET_memcpy(buf, p, rsize);
+      if (rsize < size)
+        memset(buf + rsize, 0, size - rsize);
+    }
   else
-  {
-    /* Store regular MPIs as unsigned integers right aligned into
-       the buffer.  */
-    rsize = size;
-    if (0 !=
-        (rc = gcry_mpi_print (GCRYMPI_FMT_USG,
-                              buf,
-                              rsize, &rsize,
-                              val)))
     {
-      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
-                "gcry_mpi_print",
-                rc);
-      GNUNET_assert (0);
+      /* Store regular MPIs as unsigned integers right aligned into
+         the buffer.  */
+      rsize = size;
+      if (0 !=
+          (rc = gcry_mpi_print(GCRYMPI_FMT_USG,
+                               buf,
+                               rsize, &rsize,
+                               val)))
+        {
+          LOG_GCRY(GNUNET_ERROR_TYPE_ERROR,
+                   "gcry_mpi_print",
+                   rc);
+          GNUNET_assert(0);
+        }
+      adjust(buf, rsize, size);
     }
-    adjust (buf, rsize, size);
-  }
 }
 
 
@@ -125,21 +125,21 @@ GNUNET_CRYPTO_mpi_print_unsigned (void *buf,
  * @param size number of bytes in @a data
  */
 void
-GNUNET_CRYPTO_mpi_scan_unsigned (gcry_mpi_t *result,
-                                 const void *data,
-                                 size_t size)
+GNUNET_CRYPTO_mpi_scan_unsigned(gcry_mpi_t *result,
+                                const void *data,
+                                size_t size)
 {
   int rc;
 
-  if (0 != (rc = gcry_mpi_scan (result,
-                                GCRYMPI_FMT_USG,
-                                data, size, &size)))
-  {
-    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
-              "gcry_mpi_scan",
-              rc);
-    GNUNET_assert (0);
-  }
+  if (0 != (rc = gcry_mpi_scan(result,
+                               GCRYMPI_FMT_USG,
+                               data, size, &size)))
+    {
+      LOG_GCRY(GNUNET_ERROR_TYPE_ERROR,
+               "gcry_mpi_scan",
+               rc);
+      GNUNET_assert(0);
+    }
 }
 
 /* end of crypto_mpi.c */
diff --git a/src/util/crypto_paillier.c b/src/util/crypto_paillier.c
index 622ce81fa..27a9af5de 100644
--- a/src/util/crypto_paillier.c
+++ b/src/util/crypto_paillier.c
@@ -11,7 +11,7 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -36,8 +36,8 @@
  * @param[out] private_key Where to store the private key?
  */
 void
-GNUNET_CRYPTO_paillier_create (struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
-                               struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
+GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
+                              struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
 {
   gcry_mpi_t p;
   gcry_mpi_t q;
@@ -49,55 +49,56 @@ GNUNET_CRYPTO_paillier_create (struct GNUNET_CRYPTO_PaillierPublicKey *public_ke
      is executed more than once is very very low... */
   p = NULL;
   q = NULL;
-  do {
-    if (NULL != p)
-      gcry_mpi_release (p);
-    if (NULL != q)
-      gcry_mpi_release (q);
-    GNUNET_assert (0 ==
-                   gcry_prime_generate (&p,
+  do
+    {
+      if (NULL != p)
+        gcry_mpi_release(p);
+      if (NULL != q)
+        gcry_mpi_release(q);
+      GNUNET_assert(0 ==
+                    gcry_prime_generate(&p,
                                         GNUNET_CRYPTO_PAILLIER_BITS / 2,
                                         0, NULL, NULL, NULL,
                                         GCRY_STRONG_RANDOM, 0));
-    GNUNET_assert (0 ==
-                   gcry_prime_generate (&q,
+      GNUNET_assert(0 ==
+                    gcry_prime_generate(&q,
                                         GNUNET_CRYPTO_PAILLIER_BITS / 2,
                                         0, NULL, NULL, NULL,
                                         GCRY_STRONG_RANDOM, 0));
-  }
-  while (0 == gcry_mpi_cmp (p, q));
+    }
+  while (0 == gcry_mpi_cmp(p, q));
   /* n = p * q */
-  GNUNET_assert (NULL != (n = gcry_mpi_new (0)));
-  gcry_mpi_mul (n,
-                p,
-                q);
-  GNUNET_CRYPTO_mpi_print_unsigned (public_key,
-                                    sizeof (struct GNUNET_CRYPTO_PaillierPublicKey),
-                                    n);
+  GNUNET_assert(NULL != (n = gcry_mpi_new(0)));
+  gcry_mpi_mul(n,
+               p,
+               q);
+  GNUNET_CRYPTO_mpi_print_unsigned(public_key,
+                                   sizeof(struct GNUNET_CRYPTO_PaillierPublicKey),
+                                   n);
 
   /* compute phi(n) = (p-1)(q-1) */
-  GNUNET_assert (NULL != (phi = gcry_mpi_new (0)));
-  gcry_mpi_sub_ui (p, p, 1);
-  gcry_mpi_sub_ui (q, q, 1);
-  gcry_mpi_mul (phi, p, q);
-  gcry_mpi_release (p);
-  gcry_mpi_release (q);
+  GNUNET_assert(NULL != (phi = gcry_mpi_new(0)));
+  gcry_mpi_sub_ui(p, p, 1);
+  gcry_mpi_sub_ui(q, q, 1);
+  gcry_mpi_mul(phi, p, q);
+  gcry_mpi_release(p);
+  gcry_mpi_release(q);
 
   /* lambda equals phi(n) in the simplified key generation */
-  GNUNET_CRYPTO_mpi_print_unsigned (private_key->lambda,
-                                    GNUNET_CRYPTO_PAILLIER_BITS / 8,
-                                    phi);
+  GNUNET_CRYPTO_mpi_print_unsigned(private_key->lambda,
+                                   GNUNET_CRYPTO_PAILLIER_BITS / 8,
+                                   phi);
   /* mu = phi^{-1} mod n, as we use g = n + 1 */
-  GNUNET_assert (NULL != (mu = gcry_mpi_new (0)));
-  GNUNET_assert (0 != gcry_mpi_invm (mu,
-                                     phi,
-                                     n));
-  gcry_mpi_release (phi);
-  gcry_mpi_release (n);
-  GNUNET_CRYPTO_mpi_print_unsigned (private_key->mu,
-                                    GNUNET_CRYPTO_PAILLIER_BITS / 8,
-                                    mu);
-  gcry_mpi_release (mu);
+  GNUNET_assert(NULL != (mu = gcry_mpi_new(0)));
+  GNUNET_assert(0 != gcry_mpi_invm(mu,
+                                   phi,
+                                   n));
+  gcry_mpi_release(phi);
+  gcry_mpi_release(n);
+  GNUNET_CRYPTO_mpi_print_unsigned(private_key->mu,
+                                   GNUNET_CRYPTO_PAILLIER_BITS / 8,
+                                   mu);
+  gcry_mpi_release(mu);
 }
 
 
@@ -113,7 +114,7 @@ GNUNET_CRYPTO_paillier_create (struct GNUNET_CRYPTO_PaillierPublicKey *public_ke
  *         or -1 if less than one homomorphic operation is possible
  */
 int
-GNUNET_CRYPTO_paillier_encrypt1 (const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
+GNUNET_CRYPTO_paillier_encrypt1(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
                                 const gcry_mpi_t m,
                                 int desired_ops,
                                 struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
@@ -129,69 +130,70 @@ GNUNET_CRYPTO_paillier_encrypt1 (const struct GNUNET_CRYPTO_PaillierPublicKey *p
 
   /* determine how many operations we could allow, if the other number
      has the same length. */
-  GNUNET_assert (NULL != (tmp1 = gcry_mpi_set_ui (NULL, 1)));
-  GNUNET_assert (NULL != (tmp2 = gcry_mpi_set_ui (NULL, 2)));
-  gcry_mpi_mul_2exp (tmp1, tmp1, GNUNET_CRYPTO_PAILLIER_BITS);
+  GNUNET_assert(NULL != (tmp1 = gcry_mpi_set_ui(NULL, 1)));
+  GNUNET_assert(NULL != (tmp2 = gcry_mpi_set_ui(NULL, 2)));
+  gcry_mpi_mul_2exp(tmp1, tmp1, GNUNET_CRYPTO_PAILLIER_BITS);
 
   /* count number of possible operations
      this would be nicer with gcry_mpi_get_nbits, however it does not return
      the BITLENGTH of the given MPI's value, but the bits required
      to represent the number as MPI. */
-  for (possible_opts = -2; gcry_mpi_cmp (tmp1, m) > 0; possible_opts++)
-    gcry_mpi_div (tmp1, NULL, tmp1, tmp2, 0);
-  gcry_mpi_release (tmp1);
-  gcry_mpi_release (tmp2);
+  for (possible_opts = -2; gcry_mpi_cmp(tmp1, m) > 0; possible_opts++)
+    gcry_mpi_div(tmp1, NULL, tmp1, tmp2, 0);
+  gcry_mpi_release(tmp1);
+  gcry_mpi_release(tmp2);
 
   if (possible_opts < 1)
     possible_opts = 0;
   /* soft-cap by caller */
-  possible_opts = (desired_ops < possible_opts)? desired_ops : possible_opts;
+  possible_opts = (desired_ops < possible_opts) ? desired_ops : possible_opts;
 
-  ciphertext->remaining_ops = htonl (possible_opts);
+  ciphertext->remaining_ops = htonl(possible_opts);
 
-  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
-                                   public_key,
-                                   sizeof (struct GNUNET_CRYPTO_PaillierPublicKey));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&n,
+                                  public_key,
+                                  sizeof(struct GNUNET_CRYPTO_PaillierPublicKey));
   highbit = GNUNET_CRYPTO_PAILLIER_BITS - 1;
-  while ( (! gcry_mpi_test_bit (n, highbit)) &&
-          (0 != highbit) )
+  while ((!gcry_mpi_test_bit(n, highbit)) &&
+         (0 != highbit))
     highbit--;
   if (0 == highbit)
-  {
-    /* invalid public key */
-    GNUNET_break_op (0);
-    gcry_mpi_release (n);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
-  GNUNET_assert (0 != (r = gcry_mpi_new (0)));
-  GNUNET_assert (0 != (c = gcry_mpi_new (0)));
-  gcry_mpi_mul (n_square, n, n);
+    {
+      /* invalid public key */
+      GNUNET_break_op(0);
+      gcry_mpi_release(n);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_assert(0 != (n_square = gcry_mpi_new(0)));
+  GNUNET_assert(0 != (r = gcry_mpi_new(0)));
+  GNUNET_assert(0 != (c = gcry_mpi_new(0)));
+  gcry_mpi_mul(n_square, n, n);
 
   /* generate r < n (without bias) */
-  do {
-    gcry_mpi_randomize (r, highbit + 1, GCRY_STRONG_RANDOM);
-  }
-  while (gcry_mpi_cmp (r, n) >= 0);
+  do
+    {
+      gcry_mpi_randomize(r, highbit + 1, GCRY_STRONG_RANDOM);
+    }
+  while (gcry_mpi_cmp(r, n) >= 0);
 
   /* c = (n+1)^m mod n^2 */
   /* c = n + 1 */
-  gcry_mpi_add_ui (c, n, 1);
+  gcry_mpi_add_ui(c, n, 1);
   /* c = (n+1)^m mod n^2 */
-  gcry_mpi_powm (c, c, m, n_square);
+  gcry_mpi_powm(c, c, m, n_square);
   /* r <- r^n mod n^2 */
-  gcry_mpi_powm (r, r, n, n_square);
+  gcry_mpi_powm(r, r, n, n_square);
   /* c <- r*c mod n^2 */
-  gcry_mpi_mulm (c, r, c, n_square);
+  gcry_mpi_mulm(c, r, c, n_square);
 
-  GNUNET_CRYPTO_mpi_print_unsigned (ciphertext->bits,
-                                    sizeof ciphertext->bits,
-                                    c);
+  GNUNET_CRYPTO_mpi_print_unsigned(ciphertext->bits,
+                                   sizeof ciphertext->bits,
+                                   c);
 
-  gcry_mpi_release (n_square);
-  gcry_mpi_release (n);
-  gcry_mpi_release (r);
-  gcry_mpi_release (c);
+  gcry_mpi_release(n_square);
+  gcry_mpi_release(n);
+  gcry_mpi_release(r);
+  gcry_mpi_release(c);
 
   return possible_opts;
 }
@@ -209,10 +211,10 @@ GNUNET_CRYPTO_paillier_encrypt1 (const struct GNUNET_CRYPTO_PaillierPublicKey *p
  *         or -1 if less than one homomorphic operation is possible
  */
 int
-GNUNET_CRYPTO_paillier_encrypt (const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
-                                const gcry_mpi_t m,
-                                int desired_ops,
-                                struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
+GNUNET_CRYPTO_paillier_encrypt(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
+                               const gcry_mpi_t m,
+                               int desired_ops,
+                               struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
 {
   int possible_opts;
   gcry_mpi_t n_square;
@@ -227,86 +229,87 @@ GNUNET_CRYPTO_paillier_encrypt (const struct GNUNET_CRYPTO_PaillierPublicKey *pu
 
   /* set max_num = 2^{GNUNET_CRYPTO_PAILLIER_BITS}, the largest
      number we can have as a result */
-  GNUNET_assert (NULL != (max_num = gcry_mpi_set_ui (NULL, 1)));
-  gcry_mpi_mul_2exp (max_num,
-                     max_num,
-                     GNUNET_CRYPTO_PAILLIER_BITS);
+  GNUNET_assert(NULL != (max_num = gcry_mpi_set_ui(NULL, 1)));
+  gcry_mpi_mul_2exp(max_num,
+                    max_num,
+                    GNUNET_CRYPTO_PAILLIER_BITS);
 
   /* Determine how many operations we could allow, assuming the other
      number has the same length (or is smaller), by counting the
      number of possible operations.  We essentially divide max_num by
      2 until the result is no longer larger than 'm', incrementing the
      maximum number of operations in each round, starting at -2 */
-  for (possible_opts = -2; gcry_mpi_cmp (max_num, m) > 0; possible_opts++)
-    gcry_mpi_div (max_num,
-                  NULL,
-                  max_num,
-                  GCRYMPI_CONST_TWO,
-                  0);
-  gcry_mpi_release (max_num);
+  for (possible_opts = -2; gcry_mpi_cmp(max_num, m) > 0; possible_opts++)
+    gcry_mpi_div(max_num,
+                 NULL,
+                 max_num,
+                 GCRYMPI_CONST_TWO,
+                 0);
+  gcry_mpi_release(max_num);
 
   if (possible_opts < 1)
     possible_opts = 0;
   /* Enforce soft-cap by caller */
-  possible_opts = GNUNET_MIN (desired_ops, possible_opts);
-  ciphertext->remaining_ops = htonl (possible_opts);
+  possible_opts = GNUNET_MIN(desired_ops, possible_opts);
+  ciphertext->remaining_ops = htonl(possible_opts);
 
-  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
-                                   public_key,
-                                   sizeof (struct GNUNET_CRYPTO_PaillierPublicKey));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&n,
+                                  public_key,
+                                  sizeof(struct GNUNET_CRYPTO_PaillierPublicKey));
 
   /* check public key for number of bits, bail out if key is all zeros */
   highbit = GNUNET_CRYPTO_PAILLIER_BITS - 1;
-  while ( (! gcry_mpi_test_bit (n, highbit)) &&
-          (0 != highbit) )
+  while ((!gcry_mpi_test_bit(n, highbit)) &&
+         (0 != highbit))
     highbit--;
   if (0 == highbit)
-  {
-    /* invalid public key */
-    GNUNET_break_op (0);
-    gcry_mpi_release (n);
-    return GNUNET_SYSERR;
-  }
+    {
+      /* invalid public key */
+      GNUNET_break_op(0);
+      gcry_mpi_release(n);
+      return GNUNET_SYSERR;
+    }
 
   /* generate r < n (without bias) */
-  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
-  do {
-    gcry_mpi_randomize (r, highbit + 1, GCRY_STRONG_RANDOM);
-  }
-  while (gcry_mpi_cmp (r, n) >= 0);
+  GNUNET_assert(NULL != (r = gcry_mpi_new(0)));
+  do
+    {
+      gcry_mpi_randomize(r, highbit + 1, GCRY_STRONG_RANDOM);
+    }
+  while (gcry_mpi_cmp(r, n) >= 0);
 
   /* g = n + 1 */
-  GNUNET_assert (0 != (g = gcry_mpi_new (0)));
-  gcry_mpi_add_ui (g, n, 1);
+  GNUNET_assert(0 != (g = gcry_mpi_new(0)));
+  gcry_mpi_add_ui(g, n, 1);
 
   /* n_square = n^2 */
-  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
-  gcry_mpi_mul (n_square,
-                n,
-                n);
+  GNUNET_assert(0 != (n_square = gcry_mpi_new(0)));
+  gcry_mpi_mul(n_square,
+               n,
+               n);
 
   /* gm = g^m mod n^2 */
-  GNUNET_assert (0 != (gm = gcry_mpi_new (0)));
-  gcry_mpi_powm (gm, g, m, n_square);
-  gcry_mpi_release (g);
+  GNUNET_assert(0 != (gm = gcry_mpi_new(0)));
+  gcry_mpi_powm(gm, g, m, n_square);
+  gcry_mpi_release(g);
 
   /* rn <- r^n mod n^2 */
-  GNUNET_assert (0 != (rn = gcry_mpi_new (0)));
-  gcry_mpi_powm (rn, r, n, n_square);
-  gcry_mpi_release (r);
-  gcry_mpi_release (n);
+  GNUNET_assert(0 != (rn = gcry_mpi_new(0)));
+  gcry_mpi_powm(rn, r, n, n_square);
+  gcry_mpi_release(r);
+  gcry_mpi_release(n);
 
   /* c <- rn * gm mod n^2 */
-  GNUNET_assert (0 != (c = gcry_mpi_new (0)));
-  gcry_mpi_mulm (c, rn, gm, n_square);
-  gcry_mpi_release (n_square);
-  gcry_mpi_release (gm);
-  gcry_mpi_release (rn);
+  GNUNET_assert(0 != (c = gcry_mpi_new(0)));
+  gcry_mpi_mulm(c, rn, gm, n_square);
+  gcry_mpi_release(n_square);
+  gcry_mpi_release(gm);
+  gcry_mpi_release(rn);
 
-  GNUNET_CRYPTO_mpi_print_unsigned (ciphertext->bits,
-                                    sizeof (ciphertext->bits),
-                                    c);
-  gcry_mpi_release (c);
+  GNUNET_CRYPTO_mpi_print_unsigned(ciphertext->bits,
+                                   sizeof(ciphertext->bits),
+                                   c);
+  gcry_mpi_release(c);
 
   return possible_opts;
 }
@@ -321,10 +324,10 @@ GNUNET_CRYPTO_paillier_encrypt (const struct GNUNET_CRYPTO_PaillierPublicKey *pu
  * @param[out] m Decryption of @a ciphertext with @private_key.
  */
 void
-GNUNET_CRYPTO_paillier_decrypt (const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key,
-                                const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
-                                const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext,
-                                gcry_mpi_t m)
+GNUNET_CRYPTO_paillier_decrypt(const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key,
+                               const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
+                               const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext,
+                               gcry_mpi_t m)
 {
   gcry_mpi_t mu;
   gcry_mpi_t lambda;
@@ -335,48 +338,48 @@ GNUNET_CRYPTO_paillier_decrypt (const struct GNUNET_CRYPTO_PaillierPrivateKey *p
   gcry_mpi_t cmum1;
   gcry_mpi_t mod;
 
-  GNUNET_CRYPTO_mpi_scan_unsigned (&lambda,
-                                   private_key->lambda,
-                                   sizeof (private_key->lambda));
-  GNUNET_CRYPTO_mpi_scan_unsigned (&mu,
-                                   private_key->mu,
-                                   sizeof (private_key->mu));
-  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
-                                   public_key,
-                                   sizeof (struct GNUNET_CRYPTO_PaillierPublicKey));
-  GNUNET_CRYPTO_mpi_scan_unsigned (&c,
-                                   ciphertext->bits,
-                                   sizeof (ciphertext->bits));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&lambda,
+                                  private_key->lambda,
+                                  sizeof(private_key->lambda));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&mu,
+                                  private_key->mu,
+                                  sizeof(private_key->mu));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&n,
+                                  public_key,
+                                  sizeof(struct GNUNET_CRYPTO_PaillierPublicKey));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&c,
+                                  ciphertext->bits,
+                                  sizeof(ciphertext->bits));
 
   /* n_square = n * n */
-  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
-  gcry_mpi_mul (n_square, n, n);
+  GNUNET_assert(0 != (n_square = gcry_mpi_new(0)));
+  gcry_mpi_mul(n_square, n, n);
 
   /* cmu = c^lambda mod n^2 */
-  GNUNET_assert (0 != (cmu = gcry_mpi_new (0)));
-  gcry_mpi_powm (cmu,
-                 c,
-                 lambda,
-                 n_square);
-  gcry_mpi_release (n_square);
-  gcry_mpi_release (lambda);
-  gcry_mpi_release (c);
+  GNUNET_assert(0 != (cmu = gcry_mpi_new(0)));
+  gcry_mpi_powm(cmu,
+                c,
+                lambda,
+                n_square);
+  gcry_mpi_release(n_square);
+  gcry_mpi_release(lambda);
+  gcry_mpi_release(c);
 
   /* cmum1 = cmu - 1 */
-  GNUNET_assert (0 != (cmum1 = gcry_mpi_new (0)));
-  gcry_mpi_sub_ui (cmum1, cmu, 1);
-  gcry_mpi_release (cmu);
+  GNUNET_assert(0 != (cmum1 = gcry_mpi_new(0)));
+  gcry_mpi_sub_ui(cmum1, cmu, 1);
+  gcry_mpi_release(cmu);
 
   /* mod = cmum1 / n (mod n) */
-  GNUNET_assert (0 != (mod = gcry_mpi_new (0)));
-  gcry_mpi_div (mod, NULL, cmum1, n, 0);
-  gcry_mpi_release (cmum1);
+  GNUNET_assert(0 != (mod = gcry_mpi_new(0)));
+  gcry_mpi_div(mod, NULL, cmum1, n, 0);
+  gcry_mpi_release(cmum1);
 
   /* m = mod * mu mod n */
-  gcry_mpi_mulm (m, mod, mu, n);
-  gcry_mpi_release (mod);
-  gcry_mpi_release (mu);
-  gcry_mpi_release (n);
+  gcry_mpi_mulm(m, mod, mu, n);
+  gcry_mpi_release(mod);
+  gcry_mpi_release(mu);
+  gcry_mpi_release(n);
 }
 
 
@@ -395,10 +398,10 @@ GNUNET_CRYPTO_paillier_decrypt (const struct GNUNET_CRYPTO_PaillierPrivateKey *p
  *         #GNUNET_SYSERR if no more homomorphic operations are remaining.
  */
 int
-GNUNET_CRYPTO_paillier_hom_add (const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
-                                const struct GNUNET_CRYPTO_PaillierCiphertext *c1,
-                                const struct GNUNET_CRYPTO_PaillierCiphertext *c2,
-                                struct GNUNET_CRYPTO_PaillierCiphertext *result)
+GNUNET_CRYPTO_paillier_hom_add(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
+                               const struct GNUNET_CRYPTO_PaillierCiphertext *c1,
+                               const struct GNUNET_CRYPTO_PaillierCiphertext *c2,
+                               struct GNUNET_CRYPTO_PaillierCiphertext *result)
 {
   gcry_mpi_t a;
   gcry_mpi_t b;
@@ -408,42 +411,42 @@ GNUNET_CRYPTO_paillier_hom_add (const struct GNUNET_CRYPTO_PaillierPublicKey *pu
   int32_t o1;
   int32_t o2;
 
-  o1 = (int32_t) ntohl (c1->remaining_ops);
-  o2 = (int32_t) ntohl (c2->remaining_ops);
-  if ( (0 >= o1) || (0 >= o2) )
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-
-  GNUNET_CRYPTO_mpi_scan_unsigned (&a,
-                                   c1->bits,
-                                   sizeof (c1->bits));
-  GNUNET_CRYPTO_mpi_scan_unsigned (&b,
-                                   c2->bits,
-                                   sizeof (c2->bits));
-  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
-                                   public_key,
-                                   sizeof (struct GNUNET_CRYPTO_PaillierPublicKey));
+  o1 = (int32_t)ntohl(c1->remaining_ops);
+  o2 = (int32_t)ntohl(c2->remaining_ops);
+  if ((0 >= o1) || (0 >= o2))
+    {
+      GNUNET_break_op(0);
+      return GNUNET_SYSERR;
+    }
+
+  GNUNET_CRYPTO_mpi_scan_unsigned(&a,
+                                  c1->bits,
+                                  sizeof(c1->bits));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&b,
+                                  c2->bits,
+                                  sizeof(c2->bits));
+  GNUNET_CRYPTO_mpi_scan_unsigned(&n,
+                                  public_key,
+                                  sizeof(struct GNUNET_CRYPTO_PaillierPublicKey));
 
   /* n_square = n * n */
-  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
-  gcry_mpi_mul (n_square, n, n);
-  gcry_mpi_release (n);
+  GNUNET_assert(0 != (n_square = gcry_mpi_new(0)));
+  gcry_mpi_mul(n_square, n, n);
+  gcry_mpi_release(n);
 
   /* c = a * b mod n_square */
-  GNUNET_assert (0 != (c = gcry_mpi_new (0)));
-  gcry_mpi_mulm (c, a, b, n_square);
-  gcry_mpi_release (n_square);
-  gcry_mpi_release (a);
-  gcry_mpi_release (b);
-
-  result->remaining_ops = htonl (GNUNET_MIN (o1, o2) - 1);
-  GNUNET_CRYPTO_mpi_print_unsigned (result->bits,
-                                    sizeof (result->bits),
-                                    c);
-  gcry_mpi_release (c);
-  return ntohl (result->remaining_ops);
+  GNUNET_assert(0 != (c = gcry_mpi_new(0)));
+  gcry_mpi_mulm(c, a, b, n_square);
+  gcry_mpi_release(n_square);
+  gcry_mpi_release(a);
+  gcry_mpi_release(b);
+
+  result->remaining_ops = htonl(GNUNET_MIN(o1, o2) - 1);
+  GNUNET_CRYPTO_mpi_print_unsigned(result->bits,
+                                   sizeof(result->bits),
+                                   c);
+  gcry_mpi_release(c);
+  return ntohl(result->remaining_ops);
 }
 
 
@@ -454,10 +457,10 @@ GNUNET_CRYPTO_paillier_hom_add (const struct GNUNET_CRYPTO_PaillierPublicKey *pu
  * @return the number of remaining homomorphic operations
  */
 int
-GNUNET_CRYPTO_paillier_hom_get_remaining (const struct GNUNET_CRYPTO_PaillierCiphertext *c)
+GNUNET_CRYPTO_paillier_hom_get_remaining(const struct GNUNET_CRYPTO_PaillierCiphertext *c)
 {
-  GNUNET_assert (NULL != c);
-  return ntohl (c->remaining_ops);
+  GNUNET_assert(NULL != c);
+  return ntohl(c->remaining_ops);
 }
 
 /* end of crypto_paillier.c */
diff --git a/src/util/crypto_random.c b/src/util/crypto_random.c
index 58cab082e..d16ba2412 100644
--- a/src/util/crypto_random.c
+++ b/src/util/crypto_random.c
@@ -17,7 +17,7 @@
 
      SPDX-License-Identifier: AGPL3.0-or-later
 
-*/
+ */
 
 /**
  * @file util/crypto_random.c
@@ -28,23 +28,23 @@
 #include "gnunet_crypto_lib.h"
 #include <gcrypt.h>
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-crypto-random", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-random", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-crypto-random", syscall)
+  GNUNET_log_from_strerror(kind, "util-crypto-random", syscall)
 
 
 /* TODO: ndurner, move this to plibc? */
 /* The code is derived from glibc, obviously */
-#if ! HAVE_RANDOM || ! HAVE_SRANDOM
+#if !HAVE_RANDOM || !HAVE_SRANDOM
 #ifdef RANDOM
 #undef RANDOM
 #endif
 #ifdef SRANDOM
 #undef SRANDOM
 #endif
-#define RANDOM() glibc_weak_rand32 ()
-#define SRANDOM(s) glibc_weak_srand32 (s)
+#define RANDOM() glibc_weak_rand32()
+#define SRANDOM(s) glibc_weak_srand32(s)
 #if defined(RAND_MAX)
 #undef RAND_MAX
 #endif
@@ -55,14 +55,14 @@ static int32_t glibc_weak_rand32_state = 1;
 
 
 void
-glibc_weak_srand32 (int32_t s)
+glibc_weak_srand32(int32_t s)
 {
   glibc_weak_rand32_state = s;
 }
 
 
 int32_t
-glibc_weak_rand32 ()
+glibc_weak_rand32()
 {
   int32_t val = glibc_weak_rand32_state;
 
@@ -78,9 +78,9 @@ glibc_weak_rand32 ()
  * @return number between 0 and 1.
  */
 static double
-get_weak_random ()
+get_weak_random()
 {
-  return ((double) random () / RAND_MAX);
+  return((double)random() / RAND_MAX);
 }
 
 
@@ -91,9 +91,9 @@ get_weak_random ()
  * @param seed the seed to use
  */
 void
-GNUNET_CRYPTO_seed_weak_random (int32_t seed)
+GNUNET_CRYPTO_seed_weak_random(int32_t seed)
 {
-  srandom (seed);
+  srandom(seed);
 }
 
 
@@ -106,12 +106,12 @@ GNUNET_CRYPTO_seed_weak_random (int32_t seed)
  * @param length buffer length
  */
 void
-GNUNET_CRYPTO_zero_keys (void *buffer, size_t length)
+GNUNET_CRYPTO_zero_keys(void *buffer, size_t length)
 {
 #if HAVE_MEMSET_S
-  memset_s (buffer, length, 0, length);
+  memset_s(buffer, length, 0, length);
 #elif HAVE_EXPLICIT_BZERO
-  explicit_bzero (buffer, length);
+  explicit_bzero(buffer, length);
 #else
   volatile unsigned char *p = buffer;
   while (length--)
@@ -129,37 +129,40 @@ GNUNET_CRYPTO_zero_keys (void *buffer, size_t length)
  * @param length buffer length
  */
 void
-GNUNET_CRYPTO_random_block (enum GNUNET_CRYPTO_Quality mode,
-                            void *buffer,
-                            size_t length)
+GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode,
+                           void *buffer,
+                           size_t length)
 {
 #ifdef gcry_fast_random_poll
   static unsigned int invokeCount;
 #endif
   switch (mode)
-  {
-  case GNUNET_CRYPTO_QUALITY_STRONG:
-    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
+    {
+    case GNUNET_CRYPTO_QUALITY_STRONG:
+      /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
 #ifdef gcry_fast_random_poll
-    if ((invokeCount++ % 256) == 0)
-      gcry_fast_random_poll ();
+      if ((invokeCount++ % 256) == 0)
+        gcry_fast_random_poll();
 #endif
-    gcry_randomize (buffer, length, GCRY_STRONG_RANDOM);
-    return;
-  case GNUNET_CRYPTO_QUALITY_NONCE:
-    gcry_create_nonce (buffer, length);
-    return;
-  case GNUNET_CRYPTO_QUALITY_WEAK:
-    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
+      gcry_randomize(buffer, length, GCRY_STRONG_RANDOM);
+      return;
+
+    case GNUNET_CRYPTO_QUALITY_NONCE:
+      gcry_create_nonce(buffer, length);
+      return;
+
+    case GNUNET_CRYPTO_QUALITY_WEAK:
+      /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
 #ifdef gcry_fast_random_poll
-    if ((invokeCount++ % 256) == 0)
-      gcry_fast_random_poll ();
+      if ((invokeCount++ % 256) == 0)
+        gcry_fast_random_poll();
 #endif
-    gcry_randomize (buffer, length, GCRY_WEAK_RANDOM);
-    return;
-  default:
-    GNUNET_assert (0);
-  }
+      gcry_randomize(buffer, length, GCRY_WEAK_RANDOM);
+      return;
+
+    default:
+      GNUNET_assert(0);
+    }
 }
 
 
@@ -171,7 +174,7 @@ GNUNET_CRYPTO_random_block (enum GNUNET_CRYPTO_Quality mode,
  * @return a random value in the interval [0,i[.
  */
 uint32_t
-GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
+GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
 {
 #ifdef gcry_fast_random_poll
   static unsigned int invokeCount;
@@ -179,39 +182,44 @@ GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
   uint32_t ret;
   uint32_t ul;
 
-  GNUNET_assert (i > 0);
+  GNUNET_assert(i > 0);
 
   switch (mode)
-  {
-  case GNUNET_CRYPTO_QUALITY_STRONG:
-    /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
+    {
+    case GNUNET_CRYPTO_QUALITY_STRONG:
+      /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
 #ifdef gcry_fast_random_poll
-    if ((invokeCount++ % 256) == 0)
-      gcry_fast_random_poll ();
+      if ((invokeCount++ % 256) == 0)
+        gcry_fast_random_poll();
 #endif
-    ul = UINT32_MAX - (UINT32_MAX % i);
-    do
-    {
-      gcry_randomize ((unsigned char *) &ret,
-                      sizeof (uint32_t),
-                      GCRY_STRONG_RANDOM);
-    } while (ret >= ul);
-    return ret % i;
-  case GNUNET_CRYPTO_QUALITY_NONCE:
-    ul = UINT32_MAX - (UINT32_MAX % i);
-    do
-    {
-      gcry_create_nonce (&ret, sizeof (ret));
-    } while (ret >= ul);
-    return ret % i;
-  case GNUNET_CRYPTO_QUALITY_WEAK:
-    ret = i * get_weak_random ();
-    if (ret >= i)
-      ret = i - 1;
-    return ret;
-  default:
-    GNUNET_assert (0);
-  }
+      ul = UINT32_MAX - (UINT32_MAX % i);
+      do
+        {
+          gcry_randomize((unsigned char *)&ret,
+                         sizeof(uint32_t),
+                         GCRY_STRONG_RANDOM);
+        }
+      while (ret >= ul);
+      return ret % i;
+
+    case GNUNET_CRYPTO_QUALITY_NONCE:
+      ul = UINT32_MAX - (UINT32_MAX % i);
+      do
+        {
+          gcry_create_nonce(&ret, sizeof(ret));
+        }
+      while (ret >= ul);
+      return ret % i;
+
+    case GNUNET_CRYPTO_QUALITY_WEAK:
+      ret = i * get_weak_random();
+      if (ret >= i)
+        ret = i - 1;
+      return ret;
+
+    default:
+      GNUNET_assert(0);
+    }
   return 0;
 }
 
@@ -225,24 +233,24 @@ GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i)
  * @return the permutation array (allocated from heap)
  */
 unsigned int *
-GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n)
+GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
 {
   unsigned int *ret;
   unsigned int i;
   unsigned int tmp;
   uint32_t x;
 
-  GNUNET_assert (n > 0);
-  ret = GNUNET_malloc (n * sizeof (unsigned int));
+  GNUNET_assert(n > 0);
+  ret = GNUNET_malloc(n * sizeof(unsigned int));
   for (i = 0; i < n; i++)
     ret[i] = i;
   for (i = n - 1; i > 0; i--)
-  {
-    x = GNUNET_CRYPTO_random_u32 (mode, i + 1);
-    tmp = ret[x];
-    ret[x] = ret[i];
-    ret[i] = tmp;
-  }
+    {
+      x = GNUNET_CRYPTO_random_u32(mode, i + 1);
+      tmp = ret[x];
+      ret[x] = ret[i];
+      ret[i] = tmp;
+    }
   return ret;
 }
 
@@ -255,39 +263,44 @@ GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n)
  * @return random 64-bit number
  */
 uint64_t
-GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
+GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
 {
   uint64_t ret;
   uint64_t ul;
 
-  GNUNET_assert (max > 0);
+  GNUNET_assert(max > 0);
   switch (mode)
-  {
-  case GNUNET_CRYPTO_QUALITY_STRONG:
-    ul = UINT64_MAX - (UINT64_MAX % max);
-    do
     {
-      gcry_randomize ((unsigned char *) &ret,
-                      sizeof (uint64_t),
-                      GCRY_STRONG_RANDOM);
-    } while (ret >= ul);
-    return ret % max;
-  case GNUNET_CRYPTO_QUALITY_NONCE:
-    ul = UINT64_MAX - (UINT64_MAX % max);
-    do
-    {
-      gcry_create_nonce (&ret, sizeof (ret));
-    } while (ret >= ul);
-
-    return ret % max;
-  case GNUNET_CRYPTO_QUALITY_WEAK:
-    ret = max * get_weak_random ();
-    if (ret >= max)
-      ret = max - 1;
-    return ret;
-  default:
-    GNUNET_assert (0);
-  }
+    case GNUNET_CRYPTO_QUALITY_STRONG:
+      ul = UINT64_MAX - (UINT64_MAX % max);
+      do
+        {
+          gcry_randomize((unsigned char *)&ret,
+                         sizeof(uint64_t),
+                         GCRY_STRONG_RANDOM);
+        }
+      while (ret >= ul);
+      return ret % max;
+
+    case GNUNET_CRYPTO_QUALITY_NONCE:
+      ul = UINT64_MAX - (UINT64_MAX % max);
+      do
+        {
+          gcry_create_nonce(&ret, sizeof(ret));
+        }
+      while (ret >= ul);
+
+      return ret % max;
+
+    case GNUNET_CRYPTO_QUALITY_WEAK:
+      ret = max * get_weak_random();
+      if (ret >= max)
+        ret = max - 1;
+      return ret;
+
+    default:
+      GNUNET_assert(0);
+    }
   return 0;
 }
 
@@ -297,9 +310,9 @@ GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max)
  * strategy of libgcrypt implementation.
  */
 static void *
-w_malloc (size_t n)
+w_malloc(size_t n)
 {
-  return calloc (n, 1);
+  return calloc(n, 1);
 }
 
 
@@ -308,9 +321,9 @@ w_malloc (size_t n)
  * strategy of libgcrypt implementation.
  */
 static int
-w_check (const void *p)
+w_check(const void *p)
 {
-  (void) p;
+  (void)p;
   return 0; /* not secure memory */
 }
 
@@ -318,49 +331,49 @@ w_check (const void *p)
 /**
  * Initialize libgcrypt.
  */
-void __attribute__ ((constructor)) GNUNET_CRYPTO_random_init ()
+void __attribute__ ((constructor)) GNUNET_CRYPTO_random_init()
 {
   gcry_error_t rc;
 
-  if (! gcry_check_version (NEED_LIBGCRYPT_VERSION))
-  {
-    fprintf (
-      stderr,
-      _ ("libgcrypt has not the expected version (version %s is required).\n"),
-      NEED_LIBGCRYPT_VERSION);
-    GNUNET_assert (0);
-  }
+  if (!gcry_check_version(NEED_LIBGCRYPT_VERSION))
+    {
+      fprintf(
+        stderr,
+        _("libgcrypt has not the expected version (version %s is required).\n"),
+        NEED_LIBGCRYPT_VERSION);
+      GNUNET_assert(0);
+    }
   /* set custom allocators */
-  gcry_set_allocation_handler (&w_malloc, &w_malloc, &w_check, &realloc, &free);
+  gcry_set_allocation_handler(&w_malloc, &w_malloc, &w_check, &realloc, &free);
   /* Disable use of secure memory */
-  if ((rc = gcry_control (GCRYCTL_DISABLE_SECMEM, 0)))
-    fprintf (stderr,
-             "Failed to set libgcrypt option %s: %s\n",
-             "DISABLE_SECMEM",
-             gcry_strerror (rc));
+  if ((rc = gcry_control(GCRYCTL_DISABLE_SECMEM, 0)))
+    fprintf(stderr,
+            "Failed to set libgcrypt option %s: %s\n",
+            "DISABLE_SECMEM",
+            gcry_strerror(rc));
   /* Otherwise gnunet-ecc takes forever to complete, besides
      we are fine with "just" using GCRY_STRONG_RANDOM */
-  if ((rc = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
-    fprintf (stderr,
-             "Failed to set libgcrypt option %s: %s\n",
-             "ENABLE_QUICK_RANDOM",
-             gcry_strerror (rc));
-  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
-  gcry_fast_random_poll ();
-  GNUNET_CRYPTO_seed_weak_random (
-    time (NULL) ^
-    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
+  if ((rc = gcry_control(GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
+    fprintf(stderr,
+            "Failed to set libgcrypt option %s: %s\n",
+            "ENABLE_QUICK_RANDOM",
+            gcry_strerror(rc));
+  gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
+  gcry_fast_random_poll();
+  GNUNET_CRYPTO_seed_weak_random(
+    time(NULL) ^
+    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX));
 }
 
 
 /**
  * Nicely shut down libgcrypt.
  */
-void __attribute__ ((destructor)) GNUNET_CRYPTO_random_fini ()
+void __attribute__ ((destructor)) GNUNET_CRYPTO_random_fini()
 {
-  gcry_set_progress_handler (NULL, NULL);
+  gcry_set_progress_handler(NULL, NULL);
 #ifdef GCRYCTL_CLOSE_RANDOM_DEVICE
-  (void) gcry_control (GCRYCTL_CLOSE_RANDOM_DEVICE, 0);
+  (void)gcry_control(GCRYCTL_CLOSE_RANDOM_DEVICE, 0);
 #endif
 }
 
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
index 8cb0fe6c6..0a20fdffa 100644
--- a/src/util/crypto_rsa.c
+++ b/src/util/crypto_rsa.c
@@ -1,22 +1,22 @@
 /*
-  This file is part of GNUnet
-  Copyright (C) 2014,2016 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/>.
+   This file is part of GNUnet
+   Copyright (C) 2014,2016 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 util/crypto_rsa.c
@@ -30,14 +30,13 @@
 #include "gnunet_crypto_lib.h"
 #include "benchmark.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-rsa", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-rsa", __VA_ARGS__)
 
 
 /**
  * The private information of an RSA key pair.
  */
-struct GNUNET_CRYPTO_RsaPrivateKey
-{
+struct GNUNET_CRYPTO_RsaPrivateKey {
   /**
    * Libgcrypt S-expression for the RSA private key.
    */
@@ -48,8 +47,7 @@ struct GNUNET_CRYPTO_RsaPrivateKey
 /**
  * The public information of an RSA key pair.
  */
-struct GNUNET_CRYPTO_RsaPublicKey
-{
+struct GNUNET_CRYPTO_RsaPublicKey {
   /**
    * Libgcrypt S-expression for the RSA public key.
    */
@@ -60,8 +58,7 @@ struct GNUNET_CRYPTO_RsaPublicKey
 /**
  * @brief an RSA signature
  */
-struct GNUNET_CRYPTO_RsaSignature
-{
+struct GNUNET_CRYPTO_RsaSignature {
   /**
    * Libgcrypt S-expression for the RSA signature.
    */
@@ -72,8 +69,7 @@ struct GNUNET_CRYPTO_RsaSignature
 /**
  * @brief RSA blinding key
  */
-struct RsaBlindingKey
-{
+struct RsaBlindingKey {
   /**
    * Random value used for blinding.
    */
@@ -91,50 +87,50 @@ struct RsaBlindingKey
  * @return 0 on success
  */
 static int
-key_from_sexp (gcry_mpi_t *array,
-               gcry_sexp_t sexp,
-               const char *topname,
-               const char *elems)
+key_from_sexp(gcry_mpi_t *array,
+              gcry_sexp_t sexp,
+              const char *topname,
+              const char *elems)
 {
   gcry_sexp_t list;
   gcry_sexp_t l2;
   const char *s;
   unsigned int idx;
 
-  if (! (list = gcry_sexp_find_token (sexp, topname, 0)))
+  if (!(list = gcry_sexp_find_token(sexp, topname, 0)))
     return 1;
-  l2 = gcry_sexp_cadr (list);
-  gcry_sexp_release (list);
+  l2 = gcry_sexp_cadr(list);
+  gcry_sexp_release(list);
   list = l2;
-  if (! list)
+  if (!list)
     return 2;
   idx = 0;
   for (s = elems; *s; s++, idx++)
-  {
-    if (! (l2 = gcry_sexp_find_token (list, s, 1)))
-    {
-      for (unsigned int i = 0; i < idx; i++)
-      {
-        gcry_free (array[i]);
-        array[i] = NULL;
-      }
-      gcry_sexp_release (list);
-      return 3;                 /* required parameter not found */
-    }
-    array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
-    gcry_sexp_release (l2);
-    if (! array[idx])
     {
-      for (unsigned int i = 0; i < idx; i++)
-      {
-        gcry_free (array[i]);
-        array[i] = NULL;
-      }
-      gcry_sexp_release (list);
-      return 4;                 /* required parameter is invalid */
+      if (!(l2 = gcry_sexp_find_token(list, s, 1)))
+        {
+          for (unsigned int i = 0; i < idx; i++)
+            {
+              gcry_free(array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release(list);
+          return 3;             /* required parameter not found */
+        }
+      array[idx] = gcry_sexp_nth_mpi(l2, 1, GCRYMPI_FMT_USG);
+      gcry_sexp_release(l2);
+      if (!array[idx])
+        {
+          for (unsigned int i = 0; i < idx; i++)
+            {
+              gcry_free(array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release(list);
+          return 4;             /* required parameter is invalid */
+        }
     }
-  }
-  gcry_sexp_release (list);
+  gcry_sexp_release(list);
   return 0;
 }
 
@@ -146,30 +142,30 @@ key_from_sexp (gcry_mpi_t *array,
  * @return fresh private key
  */
 struct GNUNET_CRYPTO_RsaPrivateKey *
-GNUNET_CRYPTO_rsa_private_key_create (unsigned int len)
+GNUNET_CRYPTO_rsa_private_key_create(unsigned int len)
 {
   struct GNUNET_CRYPTO_RsaPrivateKey *ret;
   gcry_sexp_t s_key;
   gcry_sexp_t s_keyparam;
 
-  BENCHMARK_START (rsa_private_key_create);
-
-  GNUNET_assert (0 ==
-                 gcry_sexp_build (&s_keyparam,
-                                  NULL,
-                                  "(genkey(rsa(nbits %d)))",
-                                  len));
-  GNUNET_assert (0 ==
-                 gcry_pk_genkey (&s_key,
-                                 s_keyparam));
-  gcry_sexp_release (s_keyparam);
+  BENCHMARK_START(rsa_private_key_create);
+
+  GNUNET_assert(0 ==
+                gcry_sexp_build(&s_keyparam,
+                                NULL,
+                                "(genkey(rsa(nbits %d)))",
+                                len));
+  GNUNET_assert(0 ==
+                gcry_pk_genkey(&s_key,
+                               s_keyparam));
+  gcry_sexp_release(s_keyparam);
 #if EXTRA_CHECKS
-  GNUNET_assert (0 ==
-                 gcry_pk_testkey (s_key));
+  GNUNET_assert(0 ==
+                gcry_pk_testkey(s_key));
 #endif
-  ret = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
+  ret = GNUNET_new(struct GNUNET_CRYPTO_RsaPrivateKey);
   ret->sexp = s_key;
-  BENCHMARK_END (rsa_private_key_create);
+  BENCHMARK_END(rsa_private_key_create);
   return ret;
 }
 
@@ -180,10 +176,10 @@ GNUNET_CRYPTO_rsa_private_key_create (unsigned int len)
  * @param key pointer to the memory to free
  */
 void
-GNUNET_CRYPTO_rsa_private_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *key)
+GNUNET_CRYPTO_rsa_private_key_free(struct GNUNET_CRYPTO_RsaPrivateKey *key)
 {
-  gcry_sexp_release (key->sexp);
-  GNUNET_free (key);
+  gcry_sexp_release(key->sexp);
+  GNUNET_free(key);
 }
 
 
@@ -196,22 +192,22 @@ GNUNET_CRYPTO_rsa_private_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *key)
  * @return size of memory allocated in @a buffer
  */
 size_t
-GNUNET_CRYPTO_rsa_private_key_encode (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
-                                      char **buffer)
+GNUNET_CRYPTO_rsa_private_key_encode(const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                                     char **buffer)
 {
   size_t n;
   char *b;
 
-  n = gcry_sexp_sprint (key->sexp,
-                        GCRYSEXP_FMT_DEFAULT,
-                        NULL,
-                        0);
-  b = GNUNET_malloc (n);
-  GNUNET_assert ((n - 1) ==     /* since the last byte is \0 */
-                 gcry_sexp_sprint (key->sexp,
-                                   GCRYSEXP_FMT_DEFAULT,
-                                   b,
-                                   n));
+  n = gcry_sexp_sprint(key->sexp,
+                       GCRYSEXP_FMT_DEFAULT,
+                       NULL,
+                       0);
+  b = GNUNET_malloc(n);
+  GNUNET_assert((n - 1) ==      /* since the last byte is \0 */
+                gcry_sexp_sprint(key->sexp,
+                                 GCRYSEXP_FMT_DEFAULT,
+                                 b,
+                                 n));
   *buffer = b;
   return n;
 }
@@ -226,29 +222,30 @@ GNUNET_CRYPTO_rsa_private_key_encode (const struct GNUNET_CRYPTO_RsaPrivateKey *
  * @return NULL on error
  */
 struct GNUNET_CRYPTO_RsaPrivateKey *
-GNUNET_CRYPTO_rsa_private_key_decode (const char *buf,
-                                      size_t len)
+GNUNET_CRYPTO_rsa_private_key_decode(const char *buf,
+                                     size_t len)
 {
   struct GNUNET_CRYPTO_RsaPrivateKey *key;
-  key = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
+
+  key = GNUNET_new(struct GNUNET_CRYPTO_RsaPrivateKey);
   if (0 !=
-      gcry_sexp_new (&key->sexp,
-                     buf,
-                     len,
-                     0))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Decoded private key is not valid\n");
-    GNUNET_free (key);
-    return NULL;
-  }
-  if (0 != gcry_pk_testkey (key->sexp))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Decoded private key is not valid\n");
-    GNUNET_CRYPTO_rsa_private_key_free (key);
-    return NULL;
-  }
+      gcry_sexp_new(&key->sexp,
+                    buf,
+                    len,
+                    0))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Decoded private key is not valid\n");
+      GNUNET_free(key);
+      return NULL;
+    }
+  if (0 != gcry_pk_testkey(key->sexp))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Decoded private key is not valid\n");
+      GNUNET_CRYPTO_rsa_private_key_free(key);
+      return NULL;
+    }
   return key;
 }
 
@@ -260,35 +257,35 @@ GNUNET_CRYPTO_rsa_private_key_decode (const char *buf,
  * @retur NULL on error, otherwise the public key
  */
 struct GNUNET_CRYPTO_RsaPublicKey *
-GNUNET_CRYPTO_rsa_private_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey *priv)
+GNUNET_CRYPTO_rsa_private_key_get_public(const struct GNUNET_CRYPTO_RsaPrivateKey *priv)
 {
   struct GNUNET_CRYPTO_RsaPublicKey *pub;
   gcry_mpi_t ne[2];
   int rc;
   gcry_sexp_t result;
 
-  BENCHMARK_START (rsa_private_key_get_public);
+  BENCHMARK_START(rsa_private_key_get_public);
 
-  rc = key_from_sexp (ne, priv->sexp, "public-key", "ne");
+  rc = key_from_sexp(ne, priv->sexp, "public-key", "ne");
   if (0 != rc)
-    rc = key_from_sexp (ne, priv->sexp, "private-key", "ne");
+    rc = key_from_sexp(ne, priv->sexp, "private-key", "ne");
   if (0 != rc)
-    rc = key_from_sexp (ne, priv->sexp, "rsa", "ne");
+    rc = key_from_sexp(ne, priv->sexp, "rsa", "ne");
   if (0 != rc)
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-  rc = gcry_sexp_build (&result,
-                        NULL,
-                        "(public-key(rsa(n %m)(e %m)))",
-                        ne[0],
-                        ne[1]);
-  gcry_mpi_release (ne[0]);
-  gcry_mpi_release (ne[1]);
-  pub = GNUNET_new (struct GNUNET_CRYPTO_RsaPublicKey);
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
+  rc = gcry_sexp_build(&result,
+                       NULL,
+                       "(public-key(rsa(n %m)(e %m)))",
+                       ne[0],
+                       ne[1]);
+  gcry_mpi_release(ne[0]);
+  gcry_mpi_release(ne[1]);
+  pub = GNUNET_new(struct GNUNET_CRYPTO_RsaPublicKey);
   pub->sexp = result;
-  BENCHMARK_END (rsa_private_key_get_public);
+  BENCHMARK_END(rsa_private_key_get_public);
   return pub;
 }
 
@@ -299,10 +296,10 @@ GNUNET_CRYPTO_rsa_private_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateK
  * @param key pointer to the memory to free
  */
 void
-GNUNET_CRYPTO_rsa_public_key_free (struct GNUNET_CRYPTO_RsaPublicKey *key)
+GNUNET_CRYPTO_rsa_public_key_free(struct GNUNET_CRYPTO_RsaPublicKey *key)
 {
-  gcry_sexp_release (key->sexp);
-  GNUNET_free (key);
+  gcry_sexp_release(key->sexp);
+  GNUNET_free(key);
 }
 
 
@@ -315,22 +312,22 @@ GNUNET_CRYPTO_rsa_public_key_free (struct GNUNET_CRYPTO_RsaPublicKey *key)
  * @return size of memory allocated in @a buffer
  */
 size_t
-GNUNET_CRYPTO_rsa_public_key_encode (const struct GNUNET_CRYPTO_RsaPublicKey *key,
-                                     char **buffer)
+GNUNET_CRYPTO_rsa_public_key_encode(const struct GNUNET_CRYPTO_RsaPublicKey *key,
+                                    char **buffer)
 {
   size_t n;
   char *b;
 
-  n = gcry_sexp_sprint (key->sexp,
-                        GCRYSEXP_FMT_ADVANCED,
-                        NULL,
-                        0);
-  b = GNUNET_malloc (n);
-  GNUNET_assert ((n -1) ==      /* since the last byte is \0 */
-                 gcry_sexp_sprint (key->sexp,
-                                   GCRYSEXP_FMT_ADVANCED,
-                                   b,
-                                   n));
+  n = gcry_sexp_sprint(key->sexp,
+                       GCRYSEXP_FMT_ADVANCED,
+                       NULL,
+                       0);
+  b = GNUNET_malloc(n);
+  GNUNET_assert((n - 1) ==      /* since the last byte is \0 */
+                gcry_sexp_sprint(key->sexp,
+                                 GCRYSEXP_FMT_ADVANCED,
+                                 b,
+                                 n));
   *buffer = b;
   return n;
 }
@@ -343,18 +340,18 @@ GNUNET_CRYPTO_rsa_public_key_encode (const struct GNUNET_CRYPTO_RsaPublicKey *ke
  * @param hc where to store the hash code
  */
 void
-GNUNET_CRYPTO_rsa_public_key_hash (const struct GNUNET_CRYPTO_RsaPublicKey *key,
-                                   struct GNUNET_HashCode *hc)
+GNUNET_CRYPTO_rsa_public_key_hash(const struct GNUNET_CRYPTO_RsaPublicKey *key,
+                                  struct GNUNET_HashCode *hc)
 {
   char *buf;
   size_t buf_size;
 
-  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (key,
-                                                  &buf);
-  GNUNET_CRYPTO_hash (buf,
-                      buf_size,
-                      hc);
-  GNUNET_free (buf);
+  buf_size = GNUNET_CRYPTO_rsa_public_key_encode(key,
+                                                 &buf);
+  GNUNET_CRYPTO_hash(buf,
+                     buf_size,
+                     hc);
+  GNUNET_free(buf);
 }
 
 
@@ -367,37 +364,37 @@ GNUNET_CRYPTO_rsa_public_key_hash (const struct GNUNET_CRYPTO_RsaPublicKey *key,
  * @return NULL on error
  */
 struct GNUNET_CRYPTO_RsaPublicKey *
-GNUNET_CRYPTO_rsa_public_key_decode (const char *buf,
-                                     size_t len)
+GNUNET_CRYPTO_rsa_public_key_decode(const char *buf,
+                                    size_t len)
 {
   struct GNUNET_CRYPTO_RsaPublicKey *key;
   gcry_mpi_t n;
   int ret;
 
-  key = GNUNET_new (struct GNUNET_CRYPTO_RsaPublicKey);
+  key = GNUNET_new(struct GNUNET_CRYPTO_RsaPublicKey);
   if (0 !=
-      gcry_sexp_new (&key->sexp,
-                     buf,
-                     len,
-                     0))
-  {
-    GNUNET_break_op (0);
-    GNUNET_free (key);
-    return NULL;
-  }
+      gcry_sexp_new(&key->sexp,
+                    buf,
+                    len,
+                    0))
+    {
+      GNUNET_break_op(0);
+      GNUNET_free(key);
+      return NULL;
+    }
   /* verify that this is an RSA public key */
-  ret = key_from_sexp (&n, key->sexp, "public-key", "n");
+  ret = key_from_sexp(&n, key->sexp, "public-key", "n");
   if (0 != ret)
-    ret = key_from_sexp (&n, key->sexp, "rsa", "n");
+    ret = key_from_sexp(&n, key->sexp, "rsa", "n");
   if (0 != ret)
-  {
-    /* this is no public RSA key */
-    GNUNET_break (0);
-    gcry_sexp_release (key->sexp);
-    GNUNET_free (key);
-    return NULL;
-  }
-  gcry_mpi_release (n);
+    {
+      /* this is no public RSA key */
+      GNUNET_break(0);
+      gcry_sexp_release(key->sexp);
+      GNUNET_free(key);
+      return NULL;
+    }
+  gcry_mpi_release(n);
   return key;
 }
 
@@ -419,9 +416,9 @@ rsa_gcd_validate(gcry_mpi_t r, gcry_mpi_t n)
   gcry_mpi_t g;
   int t;
 
-  g = gcry_mpi_new (0);
-  t = gcry_mpi_gcd(g,r,n);
-  gcry_mpi_release (g);
+  g = gcry_mpi_new(0);
+  t = gcry_mpi_gcd(g, r, n);
+  gcry_mpi_release(g);
   return t;
 }
 
@@ -434,77 +431,78 @@ rsa_gcd_validate(gcry_mpi_t r, gcry_mpi_t n)
  * @return the newly created blinding key, NULL if RSA key is malicious
  */
 static struct RsaBlindingKey *
-rsa_blinding_key_derive (const struct GNUNET_CRYPTO_RsaPublicKey *pkey,
-                         const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks)
+rsa_blinding_key_derive(const struct GNUNET_CRYPTO_RsaPublicKey *pkey,
+                        const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks)
 {
   char *xts = "Blinding KDF extrator HMAC key";  /* Trusts bks' randomness more */
   struct RsaBlindingKey *blind;
   gcry_mpi_t n;
 
-  blind = GNUNET_new (struct RsaBlindingKey);
-  GNUNET_assert( NULL != blind );
+  blind = GNUNET_new(struct RsaBlindingKey);
+  GNUNET_assert(NULL != blind);
 
   /* Extract the composite n from the RSA public key */
-  GNUNET_assert( 0 == key_from_sexp (&n, pkey->sexp, "rsa", "n") );
+  GNUNET_assert(0 == key_from_sexp(&n, pkey->sexp, "rsa", "n"));
   /* Assert that it at least looks like an RSA key */
-  GNUNET_assert( 0 == gcry_mpi_get_flag(n, GCRYMPI_FLAG_OPAQUE) );
-
-  GNUNET_CRYPTO_kdf_mod_mpi (&blind->r,
-                             n,
-                             xts,  strlen(xts),
-                             bks,  sizeof(*bks),
-                             "Blinding KDF");
-  if (0 == rsa_gcd_validate(blind->r, n))  {
-    GNUNET_free (blind);
-    blind = NULL;
-  }
-
-  gcry_mpi_release (n);
+  GNUNET_assert(0 == gcry_mpi_get_flag(n, GCRYMPI_FLAG_OPAQUE));
+
+  GNUNET_CRYPTO_kdf_mod_mpi(&blind->r,
+                            n,
+                            xts, strlen(xts),
+                            bks, sizeof(*bks),
+                            "Blinding KDF");
+  if (0 == rsa_gcd_validate(blind->r, n))
+    {
+      GNUNET_free(blind);
+      blind = NULL;
+    }
+
+  gcry_mpi_release(n);
   return blind;
 }
 
 
 /*
-We originally added GNUNET_CRYPTO_kdf_mod_mpi for the benifit of the
-previous routine.
-
-There was previously a call to GNUNET_CRYPTO_kdf in
-  bkey = rsa_blinding_key_derive (len, bks);
-that gives exactly len bits where
-  len = GNUNET_CRYPTO_rsa_public_key_len (pkey);
-
-Now r = 2^(len-1)/pkey.n is the probability that a set high bit being
-okay, meaning bkey < pkey.n.  It follows that (1-r)/2 of the time bkey >
-pkey.n making the effective bkey be
-  bkey mod pkey.n = bkey - pkey.n
-so the effective bkey has its high bit set with probability r/2.
-
-We expect r to be close to 1/2 if the exchange is honest, but the
-exchange can choose r otherwise.
-
-In blind signing, the exchange sees
-  B = bkey * S mod pkey.n
-On deposit, the exchange sees S so they can compute bkey' = B/S mod
-pkey.n for all B they recorded to see if bkey' has it's high bit set.
-Also, note the exchange can compute 1/S efficiently since they know the
-factors of pkey.n.
-
-I suppose that happens with probability r/(1+r) if its the wrong B, not
-completely sure.  If otoh we've the right B, then we've the probability
-r/2 of a set high bit in the effective bkey.
-
-Interestingly, r^2-r has a maximum at the default r=1/2 anyways, giving
-the wrong and right probabilities 1/3 and 1/4, respectively.
-
-I feared this gives the exchange a meaningful fraction of a bit of
-information per coin involved in the transaction.  It sounds damaging if
-numerous coins were involved.  And it could run across transactions in
-some scenarios.
-
-We fixed this by using a more uniform deterministic pseudo-random number
-generator for blinding factors.  I do not believe this to be a problem
-for the rsa_full_domain_hash routine, but better safe than sorry.
-*/
+   We originally added GNUNET_CRYPTO_kdf_mod_mpi for the benifit of the
+   previous routine.
+
+   There was previously a call to GNUNET_CRYPTO_kdf in
+   bkey = rsa_blinding_key_derive (len, bks);
+   that gives exactly len bits where
+   len = GNUNET_CRYPTO_rsa_public_key_len (pkey);
+
+   Now r = 2^(len-1)/pkey.n is the probability that a set high bit being
+   okay, meaning bkey < pkey.n.  It follows that (1-r)/2 of the time bkey >
+   pkey.n making the effective bkey be
+   bkey mod pkey.n = bkey - pkey.n
+   so the effective bkey has its high bit set with probability r/2.
+
+   We expect r to be close to 1/2 if the exchange is honest, but the
+   exchange can choose r otherwise.
+
+   In blind signing, the exchange sees
+   B = bkey * S mod pkey.n
+   On deposit, the exchange sees S so they can compute bkey' = B/S mod
+   pkey.n for all B they recorded to see if bkey' has it's high bit set.
+   Also, note the exchange can compute 1/S efficiently since they know the
+   factors of pkey.n.
+
+   I suppose that happens with probability r/(1+r) if its the wrong B, not
+   completely sure.  If otoh we've the right B, then we've the probability
+   r/2 of a set high bit in the effective bkey.
+
+   Interestingly, r^2-r has a maximum at the default r=1/2 anyways, giving
+   the wrong and right probabilities 1/3 and 1/4, respectively.
+
+   I feared this gives the exchange a meaningful fraction of a bit of
+   information per coin involved in the transaction.  It sounds damaging if
+   numerous coins were involved.  And it could run across transactions in
+   some scenarios.
+
+   We fixed this by using a more uniform deterministic pseudo-random number
+   generator for blinding factors.  I do not believe this to be a problem
+   for the rsa_full_domain_hash routine, but better safe than sorry.
+ */
 
 
 /**
@@ -515,8 +513,8 @@ for the rsa_full_domain_hash routine, but better safe than sorry.
  * @return 0 if the two are equal
  */
 int
-GNUNET_CRYPTO_rsa_signature_cmp (struct GNUNET_CRYPTO_RsaSignature *s1,
-                                 struct GNUNET_CRYPTO_RsaSignature *s2)
+GNUNET_CRYPTO_rsa_signature_cmp(struct GNUNET_CRYPTO_RsaSignature *s1,
+                                struct GNUNET_CRYPTO_RsaSignature *s2)
 {
   char *b1;
   char *b2;
@@ -524,18 +522,18 @@ GNUNET_CRYPTO_rsa_signature_cmp (struct GNUNET_CRYPTO_RsaSignature *s1,
   size_t z2;
   int ret;
 
-  z1 = GNUNET_CRYPTO_rsa_signature_encode (s1,
-                                           &b1);
-  z2 = GNUNET_CRYPTO_rsa_signature_encode (s2,
-                                           &b2);
+  z1 = GNUNET_CRYPTO_rsa_signature_encode(s1,
+                                          &b1);
+  z2 = GNUNET_CRYPTO_rsa_signature_encode(s2,
+                                          &b2);
   if (z1 != z2)
     ret = 1;
   else
-    ret = memcmp (b1,
-                  b2,
-                  z1);
-  GNUNET_free (b1);
-  GNUNET_free (b2);
+    ret = memcmp(b1,
+                 b2,
+                 z1);
+  GNUNET_free(b1);
+  GNUNET_free(b2);
   return ret;
 }
 
@@ -548,8 +546,8 @@ GNUNET_CRYPTO_rsa_signature_cmp (struct GNUNET_CRYPTO_RsaSignature *s1,
  * @return 0 if the two are equal
  */
 int
-GNUNET_CRYPTO_rsa_public_key_cmp (struct GNUNET_CRYPTO_RsaPublicKey *p1,
-                                  struct GNUNET_CRYPTO_RsaPublicKey *p2)
+GNUNET_CRYPTO_rsa_public_key_cmp(struct GNUNET_CRYPTO_RsaPublicKey *p1,
+                                 struct GNUNET_CRYPTO_RsaPublicKey *p2)
 {
   char *b1;
   char *b2;
@@ -557,18 +555,18 @@ GNUNET_CRYPTO_rsa_public_key_cmp (struct GNUNET_CRYPTO_RsaPublicKey *p1,
   size_t z2;
   int ret;
 
-  z1 = GNUNET_CRYPTO_rsa_public_key_encode (p1,
-                                            &b1);
-  z2 = GNUNET_CRYPTO_rsa_public_key_encode (p2,
-                                            &b2);
+  z1 = GNUNET_CRYPTO_rsa_public_key_encode(p1,
+                                           &b1);
+  z2 = GNUNET_CRYPTO_rsa_public_key_encode(p2,
+                                           &b2);
   if (z1 != z2)
     ret = 1;
   else
-    ret = memcmp (b1,
-                  b2,
-                  z1);
-  GNUNET_free (b1);
-  GNUNET_free (b2);
+    ret = memcmp(b1,
+                 b2,
+                 z1);
+  GNUNET_free(b1);
+  GNUNET_free(b2);
   return ret;
 }
 
@@ -581,8 +579,8 @@ GNUNET_CRYPTO_rsa_public_key_cmp (struct GNUNET_CRYPTO_RsaPublicKey *p1,
  * @return 0 if the two are equal
  */
 int
-GNUNET_CRYPTO_rsa_private_key_cmp (struct GNUNET_CRYPTO_RsaPrivateKey *p1,
-                                   struct GNUNET_CRYPTO_RsaPrivateKey *p2)
+GNUNET_CRYPTO_rsa_private_key_cmp(struct GNUNET_CRYPTO_RsaPrivateKey *p1,
+                                  struct GNUNET_CRYPTO_RsaPrivateKey *p2)
 {
   char *b1;
   char *b2;
@@ -590,18 +588,18 @@ GNUNET_CRYPTO_rsa_private_key_cmp (struct GNUNET_CRYPTO_RsaPrivateKey *p1,
   size_t z2;
   int ret;
 
-  z1 = GNUNET_CRYPTO_rsa_private_key_encode (p1,
-                                            &b1);
-  z2 = GNUNET_CRYPTO_rsa_private_key_encode (p2,
-                                            &b2);
+  z1 = GNUNET_CRYPTO_rsa_private_key_encode(p1,
+                                            &b1);
+  z2 = GNUNET_CRYPTO_rsa_private_key_encode(p2,
+                                            &b2);
   if (z1 != z2)
     ret = 1;
   else
-    ret = memcmp (b1,
-                  b2,
-                  z1);
-  GNUNET_free (b1);
-  GNUNET_free (b2);
+    ret = memcmp(b1,
+                 b2,
+                 z1);
+  GNUNET_free(b1);
+  GNUNET_free(b2);
   return ret;
 }
 
@@ -613,18 +611,18 @@ GNUNET_CRYPTO_rsa_private_key_cmp (struct GNUNET_CRYPTO_RsaPrivateKey *p1,
  * @return length of the key in bits
  */
 unsigned int
-GNUNET_CRYPTO_rsa_public_key_len (const struct GNUNET_CRYPTO_RsaPublicKey *key)
+GNUNET_CRYPTO_rsa_public_key_len(const struct GNUNET_CRYPTO_RsaPublicKey *key)
 {
   gcry_mpi_t n;
   unsigned int rval;
 
-  if (0 != key_from_sexp (&n, key->sexp, "rsa", "n"))
-  { /* Not an RSA public key */
-    GNUNET_break (0);
-    return 0;
-  }
-  rval = gcry_mpi_get_nbits (n);
-  gcry_mpi_release (n);
+  if (0 != key_from_sexp(&n, key->sexp, "rsa", "n"))
+    { /* Not an RSA public key */
+      GNUNET_break(0);
+      return 0;
+    }
+  rval = gcry_mpi_get_nbits(n);
+  gcry_mpi_release(n);
   return rval;
 }
 
@@ -635,10 +633,10 @@ GNUNET_CRYPTO_rsa_public_key_len (const struct GNUNET_CRYPTO_RsaPublicKey *key)
  * @param bkey the blinding key to destroy
  */
 static void
-rsa_blinding_key_free (struct RsaBlindingKey *bkey)
+rsa_blinding_key_free(struct RsaBlindingKey *bkey)
 {
-  gcry_mpi_release (bkey->r);
-  GNUNET_free (bkey);
+  gcry_mpi_release(bkey->r);
+  GNUNET_free(bkey);
 }
 
 
@@ -650,25 +648,25 @@ rsa_blinding_key_free (struct RsaBlindingKey *bkey)
  * @return number of bytes stored in @a buffer
  */
 static size_t
-numeric_mpi_alloc_n_print (gcry_mpi_t v,
-                           char **buffer)
+numeric_mpi_alloc_n_print(gcry_mpi_t v,
+                          char **buffer)
 {
   size_t n;
   char *b;
   size_t rsize;
 
-  gcry_mpi_print (GCRYMPI_FMT_USG,
-                  NULL,
-                  0,
-                  &n,
-                  v);
-  b = GNUNET_malloc (n);
-  GNUNET_assert (0 ==
-                 gcry_mpi_print (GCRYMPI_FMT_USG,
-                                 (unsigned char *) b,
-                                 n,
-                                 &rsize,
-                                 v));
+  gcry_mpi_print(GCRYMPI_FMT_USG,
+                 NULL,
+                 0,
+                 &n,
+                 v);
+  b = GNUNET_malloc(n);
+  GNUNET_assert(0 ==
+                gcry_mpi_print(GCRYMPI_FMT_USG,
+                               (unsigned char *)b,
+                               n,
+                               &rsize,
+                               v));
   *buffer = b;
   return n;
 }
@@ -687,37 +685,37 @@ numeric_mpi_alloc_n_print (gcry_mpi_t v,
  * @return MPI value set to the FDH, NULL if RSA key is malicious
  */
 static gcry_mpi_t
-rsa_full_domain_hash (const struct GNUNET_CRYPTO_RsaPublicKey *pkey,
-                      const struct GNUNET_HashCode *hash)
+rsa_full_domain_hash(const struct GNUNET_CRYPTO_RsaPublicKey *pkey,
+                     const struct GNUNET_HashCode *hash)
 {
-  gcry_mpi_t r,n;
+  gcry_mpi_t r, n;
   char *xts;
   size_t xts_len;
   int ok;
 
   /* Extract the composite n from the RSA public key */
-  GNUNET_assert( 0 == key_from_sexp (&n, pkey->sexp, "rsa", "n") );
+  GNUNET_assert(0 == key_from_sexp(&n, pkey->sexp, "rsa", "n"));
   /* Assert that it at least looks like an RSA key */
-  GNUNET_assert( 0 == gcry_mpi_get_flag(n, GCRYMPI_FLAG_OPAQUE) );
+  GNUNET_assert(0 == gcry_mpi_get_flag(n, GCRYMPI_FLAG_OPAQUE));
 
   /* We key with the public denomination key as a homage to RSA-PSS by  *
-   * Mihir Bellare and Phillip Rogaway.  Doing this lowers the degree   *
-   * of the hypothetical polyomial-time attack on RSA-KTI created by a  *
-   * polynomial-time one-more forgary attack.  Yey seeding!             */
-  xts_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey, &xts);
-
-  GNUNET_CRYPTO_kdf_mod_mpi (&r,
-                             n,
-                             xts,  xts_len,
-                             hash,  sizeof(*hash),
-                             "RSA-FDA FTpsW!");
-  GNUNET_free (xts);
-
-  ok = rsa_gcd_validate(r,n);
-  gcry_mpi_release (n);
+  * Mihir Bellare and Phillip Rogaway.  Doing this lowers the degree   *
+  * of the hypothetical polyomial-time attack on RSA-KTI created by a  *
+  * polynomial-time one-more forgary attack.  Yey seeding!             */
+  xts_len = GNUNET_CRYPTO_rsa_public_key_encode(pkey, &xts);
+
+  GNUNET_CRYPTO_kdf_mod_mpi(&r,
+                            n,
+                            xts, xts_len,
+                            hash, sizeof(*hash),
+                            "RSA-FDA FTpsW!");
+  GNUNET_free(xts);
+
+  ok = rsa_gcd_validate(r, n);
+  gcry_mpi_release(n);
   if (ok)
     return r;
-  gcry_mpi_release (r);
+  gcry_mpi_release(r);
   return NULL;
 }
 
@@ -733,10 +731,10 @@ rsa_full_domain_hash (const struct GNUNET_CRYPTO_RsaPublicKey *pkey,
  * @return #GNUNET_YES if successful, #GNUNET_NO if RSA key is malicious
  */
 int
-GNUNET_CRYPTO_rsa_blind (const struct GNUNET_HashCode *hash,
-                         const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
-                         struct GNUNET_CRYPTO_RsaPublicKey *pkey,
-                         char **buf, size_t *buf_size)
+GNUNET_CRYPTO_rsa_blind(const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
+                        struct GNUNET_CRYPTO_RsaPublicKey *pkey,
+                        char **buf, size_t *buf_size)
 {
   struct RsaBlindingKey *bkey;
   gcry_mpi_t data;
@@ -745,58 +743,59 @@ GNUNET_CRYPTO_rsa_blind (const struct GNUNET_HashCode *hash,
   gcry_mpi_t data_r_e;
   int ret;
 
-  BENCHMARK_START (rsa_blind);
+  BENCHMARK_START(rsa_blind);
 
-  GNUNET_assert (buf != NULL && buf_size != NULL);
-  ret = key_from_sexp (ne, pkey->sexp, "public-key", "ne");
+  GNUNET_assert(buf != NULL && buf_size != NULL);
+  ret = key_from_sexp(ne, pkey->sexp, "public-key", "ne");
   if (0 != ret)
-    ret = key_from_sexp (ne, pkey->sexp, "rsa", "ne");
+    ret = key_from_sexp(ne, pkey->sexp, "rsa", "ne");
   if (0 != ret)
-  {
-    GNUNET_break (0);
-    *buf = NULL;
-    *buf_size = 0;
-    return 0;
-  }
-
-  data = rsa_full_domain_hash (pkey, hash);
+    {
+      GNUNET_break(0);
+      *buf = NULL;
+      *buf_size = 0;
+      return 0;
+    }
+
+  data = rsa_full_domain_hash(pkey, hash);
   if (NULL == data)
     goto rsa_gcd_validate_failure;
 
-  bkey = rsa_blinding_key_derive (pkey, bks);
-  if (NULL == bkey) {
-    gcry_mpi_release (data);
-    goto rsa_gcd_validate_failure;
-  }
-
-  r_e = gcry_mpi_new (0);
-  gcry_mpi_powm (r_e,
-                 bkey->r,
-                 ne[1],
-                 ne[0]);
-  data_r_e = gcry_mpi_new (0);
-  gcry_mpi_mulm (data_r_e,
-                 data,
-                 r_e,
-                 ne[0]);
-  gcry_mpi_release (data);
-  gcry_mpi_release (ne[0]);
-  gcry_mpi_release (ne[1]);
-  gcry_mpi_release (r_e);
-  rsa_blinding_key_free (bkey);
-
-  *buf_size = numeric_mpi_alloc_n_print (data_r_e, buf);
-  gcry_mpi_release (data_r_e);
-
-  BENCHMARK_END (rsa_blind);
+  bkey = rsa_blinding_key_derive(pkey, bks);
+  if (NULL == bkey)
+    {
+      gcry_mpi_release(data);
+      goto rsa_gcd_validate_failure;
+    }
+
+  r_e = gcry_mpi_new(0);
+  gcry_mpi_powm(r_e,
+                bkey->r,
+                ne[1],
+                ne[0]);
+  data_r_e = gcry_mpi_new(0);
+  gcry_mpi_mulm(data_r_e,
+                data,
+                r_e,
+                ne[0]);
+  gcry_mpi_release(data);
+  gcry_mpi_release(ne[0]);
+  gcry_mpi_release(ne[1]);
+  gcry_mpi_release(r_e);
+  rsa_blinding_key_free(bkey);
+
+  *buf_size = numeric_mpi_alloc_n_print(data_r_e, buf);
+  gcry_mpi_release(data_r_e);
+
+  BENCHMARK_END(rsa_blind);
 
   return GNUNET_YES;
 
 rsa_gcd_validate_failure:
   /* We know the RSA key is malicious here, so warn the wallet. */
   /* GNUNET_break_op (0); */
-  gcry_mpi_release (ne[0]);
-  gcry_mpi_release (ne[1]);
+  gcry_mpi_release(ne[0]);
+  gcry_mpi_release(ne[1]);
   *buf = NULL;
   *buf_size = 0;
   return GNUNET_NO;
@@ -810,15 +809,15 @@ rsa_gcd_validate_failure:
  * @return converted s-expression
  */
 static gcry_sexp_t
-mpi_to_sexp (gcry_mpi_t value)
+mpi_to_sexp(gcry_mpi_t value)
 {
   gcry_sexp_t data = NULL;
 
-  GNUNET_assert (0 ==
-                 gcry_sexp_build (&data,
-                                  NULL,
-                                  "(data (flags raw) (value %M))",
-                                  value));
+  GNUNET_assert(0 ==
+                gcry_sexp_build(&data,
+                                NULL,
+                                "(data (flags raw) (value %M))",
+                                value));
   return data;
 }
 
@@ -831,53 +830,53 @@ mpi_to_sexp (gcry_mpi_t value)
  * @return NULL on error, signature on success
  */
 static struct GNUNET_CRYPTO_RsaSignature *
-rsa_sign_mpi (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
-              gcry_mpi_t value)
+rsa_sign_mpi(const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+             gcry_mpi_t value)
 {
   struct GNUNET_CRYPTO_RsaSignature *sig;
   gcry_sexp_t data;
   gcry_sexp_t result;
   int rc;
 
-  data = mpi_to_sexp (value);
+  data = mpi_to_sexp(value);
 
   if (0 !=
-      (rc = gcry_pk_sign (&result,
-                          data,
-                          key->sexp)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("RSA signing failed at %s:%d: %s\n"),
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    GNUNET_break (0);
-    return NULL;
-  }
+      (rc = gcry_pk_sign(&result,
+                         data,
+                         key->sexp)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("RSA signing failed at %s:%d: %s\n"),
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      GNUNET_break(0);
+      return NULL;
+    }
 
   /* Lenstra protection was first added to libgcrypt 1.6.4
    * with commit c17f84bd02d7ee93845e92e20f6ddba814961588.
    */
 #if GCRYPT_VERSION_NUMBER < 0x010604
   /* verify signature (guards against Lenstra's attack with fault injection...) */
-  struct GNUNET_CRYPTO_RsaPublicKey *public_key = GNUNET_CRYPTO_rsa_private_key_get_public (key);
+  struct GNUNET_CRYPTO_RsaPublicKey *public_key = GNUNET_CRYPTO_rsa_private_key_get_public(key);
   if (0 !=
-      gcry_pk_verify (result,
-                      data,
-                      public_key->sexp))
-  {
-    GNUNET_break (0);
-    GNUNET_CRYPTO_rsa_public_key_free (public_key);
-    gcry_sexp_release (data);
-    gcry_sexp_release (result);
-    return NULL;
-  }
-  GNUNET_CRYPTO_rsa_public_key_free (public_key);
+      gcry_pk_verify(result,
+                     data,
+                     public_key->sexp))
+    {
+      GNUNET_break(0);
+      GNUNET_CRYPTO_rsa_public_key_free(public_key);
+      gcry_sexp_release(data);
+      gcry_sexp_release(result);
+      return NULL;
+    }
+  GNUNET_CRYPTO_rsa_public_key_free(public_key);
 #endif
 
   /* return signature */
-  gcry_sexp_release (data);
-  sig = GNUNET_new (struct GNUNET_CRYPTO_RsaSignature);
+  gcry_sexp_release(data);
+  sig = GNUNET_new(struct GNUNET_CRYPTO_RsaSignature);
   sig->sexp = result;
   return sig;
 }
@@ -892,25 +891,25 @@ rsa_sign_mpi (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
  * @return NULL on error, signature on success
  */
 struct GNUNET_CRYPTO_RsaSignature *
-GNUNET_CRYPTO_rsa_sign_blinded (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
-                                const void *msg,
-                                size_t msg_len)
+GNUNET_CRYPTO_rsa_sign_blinded(const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                               const void *msg,
+                               size_t msg_len)
 {
   gcry_mpi_t v = NULL;
   struct GNUNET_CRYPTO_RsaSignature *sig;
 
-  BENCHMARK_START (rsa_sign_blinded);
+  BENCHMARK_START(rsa_sign_blinded);
 
-  GNUNET_assert (0 ==
-                 gcry_mpi_scan (&v,
-                                GCRYMPI_FMT_USG,
-                                msg,
-                                msg_len,
-                                NULL));
+  GNUNET_assert(0 ==
+                gcry_mpi_scan(&v,
+                              GCRYMPI_FMT_USG,
+                              msg,
+                              msg_len,
+                              NULL));
 
-  sig = rsa_sign_mpi (key, v);
-  gcry_mpi_release (v);
-  BENCHMARK_END (rsa_sign_blinded);
+  sig = rsa_sign_mpi(key, v);
+  gcry_mpi_release(v);
+  BENCHMARK_END(rsa_sign_blinded);
   return sig;
 }
 
@@ -923,21 +922,21 @@ GNUNET_CRYPTO_rsa_sign_blinded (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
  * @return NULL on error, including a malicious RSA key, signature on success
  */
 struct GNUNET_CRYPTO_RsaSignature *
-GNUNET_CRYPTO_rsa_sign_fdh (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
-                            const struct GNUNET_HashCode *hash)
+GNUNET_CRYPTO_rsa_sign_fdh(const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+                           const struct GNUNET_HashCode *hash)
 {
   struct GNUNET_CRYPTO_RsaPublicKey *pkey;
   gcry_mpi_t v = NULL;
   struct GNUNET_CRYPTO_RsaSignature *sig;
 
-  pkey = GNUNET_CRYPTO_rsa_private_key_get_public (key);
-  v = rsa_full_domain_hash (pkey, hash);
-  GNUNET_CRYPTO_rsa_public_key_free (pkey);
+  pkey = GNUNET_CRYPTO_rsa_private_key_get_public(key);
+  v = rsa_full_domain_hash(pkey, hash);
+  GNUNET_CRYPTO_rsa_public_key_free(pkey);
   if (NULL == v)   /* rsa_gcd_validate failed meaning */
     return NULL;   /* our *own* RSA key is malicious. */
 
-  sig = rsa_sign_mpi (key, v);
-  gcry_mpi_release (v);
+  sig = rsa_sign_mpi(key, v);
+  gcry_mpi_release(v);
   return sig;
 }
 
@@ -948,10 +947,10 @@ GNUNET_CRYPTO_rsa_sign_fdh (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
  * @param sig memory to freee
  */
 void
-GNUNET_CRYPTO_rsa_signature_free (struct GNUNET_CRYPTO_RsaSignature *sig)
+GNUNET_CRYPTO_rsa_signature_free(struct GNUNET_CRYPTO_RsaSignature *sig)
 {
-  gcry_sexp_release (sig->sexp);
-  GNUNET_free (sig);
+  gcry_sexp_release(sig->sexp);
+  GNUNET_free(sig);
 }
 
 
@@ -963,22 +962,22 @@ GNUNET_CRYPTO_rsa_signature_free (struct GNUNET_CRYPTO_RsaSignature *sig)
  * @return size of memory allocated in @a buffer
  */
 size_t
-GNUNET_CRYPTO_rsa_signature_encode (const struct GNUNET_CRYPTO_RsaSignature *sig,
-                                    char **buffer)
+GNUNET_CRYPTO_rsa_signature_encode(const struct GNUNET_CRYPTO_RsaSignature *sig,
+                                   char **buffer)
 {
   size_t n;
   char *b;
 
-  n = gcry_sexp_sprint (sig->sexp,
-                        GCRYSEXP_FMT_ADVANCED,
-                        NULL,
-                        0);
-  b = GNUNET_malloc (n);
-  GNUNET_assert ((n - 1) ==     /* since the last byte is \0 */
-                 gcry_sexp_sprint (sig->sexp,
-                                   GCRYSEXP_FMT_ADVANCED,
-                                   b,
-                                   n));
+  n = gcry_sexp_sprint(sig->sexp,
+                       GCRYSEXP_FMT_ADVANCED,
+                       NULL,
+                       0);
+  b = GNUNET_malloc(n);
+  GNUNET_assert((n - 1) ==      /* since the last byte is \0 */
+                gcry_sexp_sprint(sig->sexp,
+                                 GCRYSEXP_FMT_ADVANCED,
+                                 b,
+                                 n));
   *buffer = b;
   return n;
 }
@@ -993,37 +992,37 @@ GNUNET_CRYPTO_rsa_signature_encode (const struct GNUNET_CRYPTO_RsaSignature *sig
  * @return NULL on error
  */
 struct GNUNET_CRYPTO_RsaSignature *
-GNUNET_CRYPTO_rsa_signature_decode (const char *buf,
-                                    size_t len)
+GNUNET_CRYPTO_rsa_signature_decode(const char *buf,
+                                   size_t len)
 {
   struct GNUNET_CRYPTO_RsaSignature *sig;
   int ret;
   gcry_mpi_t s;
 
-  sig = GNUNET_new (struct GNUNET_CRYPTO_RsaSignature);
+  sig = GNUNET_new(struct GNUNET_CRYPTO_RsaSignature);
   if (0 !=
-      gcry_sexp_new (&sig->sexp,
-                     buf,
-                     len,
-                     0))
-  {
-    GNUNET_break_op (0);
-    GNUNET_free (sig);
-    return NULL;
-  }
+      gcry_sexp_new(&sig->sexp,
+                    buf,
+                    len,
+                    0))
+    {
+      GNUNET_break_op(0);
+      GNUNET_free(sig);
+      return NULL;
+    }
   /* verify that this is an RSA signature */
-  ret = key_from_sexp (&s, sig->sexp, "sig-val", "s");
+  ret = key_from_sexp(&s, sig->sexp, "sig-val", "s");
   if (0 != ret)
-    ret = key_from_sexp (&s, sig->sexp, "rsa", "s");
+    ret = key_from_sexp(&s, sig->sexp, "rsa", "s");
   if (0 != ret)
-  {
-    /* this is no RSA Signature */
-    GNUNET_break_op (0);
-    gcry_sexp_release (sig->sexp);
-    GNUNET_free (sig);
-    return NULL;
-  }
-  gcry_mpi_release (s);
+    {
+      /* this is no RSA Signature */
+      GNUNET_break_op(0);
+      gcry_sexp_release(sig->sexp);
+      GNUNET_free(sig);
+      return NULL;
+    }
+  gcry_mpi_release(s);
   return sig;
 }
 
@@ -1035,19 +1034,19 @@ GNUNET_CRYPTO_rsa_signature_decode (const char *buf,
  * @return the duplicate key; NULL upon error
  */
 struct GNUNET_CRYPTO_RsaPublicKey *
-GNUNET_CRYPTO_rsa_public_key_dup (const struct GNUNET_CRYPTO_RsaPublicKey *key)
+GNUNET_CRYPTO_rsa_public_key_dup(const struct GNUNET_CRYPTO_RsaPublicKey *key)
 {
   struct GNUNET_CRYPTO_RsaPublicKey *dup;
   gcry_sexp_t dup_sexp;
   size_t erroff;
 
   /* check if we really are exporting a public key */
-  dup_sexp = gcry_sexp_find_token (key->sexp, "public-key", 0);
-  GNUNET_assert (NULL != dup_sexp);
-  gcry_sexp_release (dup_sexp);
+  dup_sexp = gcry_sexp_find_token(key->sexp, "public-key", 0);
+  GNUNET_assert(NULL != dup_sexp);
+  gcry_sexp_release(dup_sexp);
   /* copy the sexp */
-  GNUNET_assert (0 == gcry_sexp_build (&dup_sexp, &erroff, "%S", key->sexp));
-  dup = GNUNET_new (struct GNUNET_CRYPTO_RsaPublicKey);
+  GNUNET_assert(0 == gcry_sexp_build(&dup_sexp, &erroff, "%S", key->sexp));
+  dup = GNUNET_new(struct GNUNET_CRYPTO_RsaPublicKey);
   dup->sexp = dup_sexp;
   return dup;
 }
@@ -1064,9 +1063,9 @@ GNUNET_CRYPTO_rsa_public_key_dup (const struct GNUNET_CRYPTO_RsaPublicKey *key)
  * @return unblinded signature on success, NULL if RSA key is bad or malicious.
  */
 struct GNUNET_CRYPTO_RsaSignature *
-GNUNET_CRYPTO_rsa_unblind (const struct GNUNET_CRYPTO_RsaSignature *sig,
-                           const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
-                           struct GNUNET_CRYPTO_RsaPublicKey *pkey)
+GNUNET_CRYPTO_rsa_unblind(const struct GNUNET_CRYPTO_RsaSignature *sig,
+                          const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
+                          struct GNUNET_CRYPTO_RsaPublicKey *pkey)
 {
   struct RsaBlindingKey *bkey;
   gcry_mpi_t n;
@@ -1076,70 +1075,70 @@ GNUNET_CRYPTO_rsa_unblind (const struct GNUNET_CRYPTO_RsaSignature *sig,
   int ret;
   struct GNUNET_CRYPTO_RsaSignature *sret;
 
-  BENCHMARK_START (rsa_unblind);
+  BENCHMARK_START(rsa_unblind);
 
-  ret = key_from_sexp (&n, pkey->sexp, "public-key", "n");
+  ret = key_from_sexp(&n, pkey->sexp, "public-key", "n");
   if (0 != ret)
-    ret = key_from_sexp (&n, pkey->sexp, "rsa", "n");
+    ret = key_from_sexp(&n, pkey->sexp, "rsa", "n");
   if (0 != ret)
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-  ret = key_from_sexp (&s, sig->sexp, "sig-val", "s");
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
+  ret = key_from_sexp(&s, sig->sexp, "sig-val", "s");
   if (0 != ret)
-    ret = key_from_sexp (&s, sig->sexp, "rsa", "s");
+    ret = key_from_sexp(&s, sig->sexp, "rsa", "s");
   if (0 != ret)
-  {
-    gcry_mpi_release (n);
-    GNUNET_break_op (0);
-    return NULL;
-  }
+    {
+      gcry_mpi_release(n);
+      GNUNET_break_op(0);
+      return NULL;
+    }
 
-  bkey = rsa_blinding_key_derive (pkey, bks);
+  bkey = rsa_blinding_key_derive(pkey, bks);
   if (NULL == bkey)
-  {
-    /* RSA key is malicious since rsa_gcd_validate failed here.
-     * It should have failed during GNUNET_CRYPTO_rsa_blind too though,
-     * so the exchange is being malicious in an unfamilair way, maybe
-     * just trying to crash us.  */
-    GNUNET_break_op (0);
-    gcry_mpi_release (n);
-    gcry_mpi_release (s);
-    return NULL;
-  }
-
-  r_inv = gcry_mpi_new (0);
+    {
+      /* RSA key is malicious since rsa_gcd_validate failed here.
+       * It should have failed during GNUNET_CRYPTO_rsa_blind too though,
+       * so the exchange is being malicious in an unfamilair way, maybe
+       * just trying to crash us.  */
+      GNUNET_break_op(0);
+      gcry_mpi_release(n);
+      gcry_mpi_release(s);
+      return NULL;
+    }
+
+  r_inv = gcry_mpi_new(0);
   if (1 !=
-      gcry_mpi_invm (r_inv,
-                     bkey->r,
-                     n))
-  {
-    /* We cannot find r mod n, so gcd(r,n) != 1, which should get *
-     * caught above, but we handle it the same here.              */
-    GNUNET_break_op (0);
-    gcry_mpi_release (r_inv);
-    rsa_blinding_key_free (bkey);
-    gcry_mpi_release (n);
-    gcry_mpi_release (s);
-    return NULL;
-  }
-
-  ubsig = gcry_mpi_new (0);
-  gcry_mpi_mulm (ubsig, s, r_inv, n);
-  gcry_mpi_release (n);
-  gcry_mpi_release (r_inv);
-  gcry_mpi_release (s);
-  rsa_blinding_key_free (bkey);
-
-  sret = GNUNET_new (struct GNUNET_CRYPTO_RsaSignature);
-  GNUNET_assert (0 ==
-                 gcry_sexp_build (&sret->sexp,
-                                  NULL,
-                                  "(sig-val (rsa (s %M)))",
-                                  ubsig));
-  gcry_mpi_release (ubsig);
-  BENCHMARK_END (rsa_unblind);
+      gcry_mpi_invm(r_inv,
+                    bkey->r,
+                    n))
+    {
+      /* We cannot find r mod n, so gcd(r,n) != 1, which should get *
+      * caught above, but we handle it the same here.              */
+      GNUNET_break_op(0);
+      gcry_mpi_release(r_inv);
+      rsa_blinding_key_free(bkey);
+      gcry_mpi_release(n);
+      gcry_mpi_release(s);
+      return NULL;
+    }
+
+  ubsig = gcry_mpi_new(0);
+  gcry_mpi_mulm(ubsig, s, r_inv, n);
+  gcry_mpi_release(n);
+  gcry_mpi_release(r_inv);
+  gcry_mpi_release(s);
+  rsa_blinding_key_free(bkey);
+
+  sret = GNUNET_new(struct GNUNET_CRYPTO_RsaSignature);
+  GNUNET_assert(0 ==
+                gcry_sexp_build(&sret->sexp,
+                                NULL,
+                                "(sig-val (rsa (s %M)))",
+                                ubsig));
+  gcry_mpi_release(ubsig);
+  BENCHMARK_END(rsa_unblind);
   return sret;
 }
 
@@ -1154,46 +1153,47 @@ GNUNET_CRYPTO_rsa_unblind (const struct GNUNET_CRYPTO_RsaSignature *sig,
  * @returns #GNUNET_YES if ok, #GNUNET_NO if RSA key is malicious, #GNUNET_SYSERR if signature is invalid
  */
 int
-GNUNET_CRYPTO_rsa_verify (const struct GNUNET_HashCode *hash,
-                          const struct GNUNET_CRYPTO_RsaSignature *sig,
-                          const struct GNUNET_CRYPTO_RsaPublicKey *pkey)
+GNUNET_CRYPTO_rsa_verify(const struct GNUNET_HashCode *hash,
+                         const struct GNUNET_CRYPTO_RsaSignature *sig,
+                         const struct GNUNET_CRYPTO_RsaPublicKey *pkey)
 {
   gcry_sexp_t data;
   gcry_mpi_t r;
   int rc;
 
-  BENCHMARK_START (rsa_verify);
+  BENCHMARK_START(rsa_verify);
 
-  r = rsa_full_domain_hash (pkey, hash);
-  if (NULL == r) {
-    GNUNET_break_op (0);
-    /* RSA key is malicious since rsa_gcd_validate failed here.
-     * It should have failed during GNUNET_CRYPTO_rsa_blind too though,
-     * so the exchange is being malicious in an unfamilair way, maybe
-     * just trying to crash us.  Arguably, we've only an internal error
-     * though because we should've detected this in our previous call
-     * to GNUNET_CRYPTO_rsa_unblind. */
-    return GNUNET_NO;
-  }
+  r = rsa_full_domain_hash(pkey, hash);
+  if (NULL == r)
+    {
+      GNUNET_break_op(0);
+      /* RSA key is malicious since rsa_gcd_validate failed here.
+       * It should have failed during GNUNET_CRYPTO_rsa_blind too though,
+       * so the exchange is being malicious in an unfamilair way, maybe
+       * just trying to crash us.  Arguably, we've only an internal error
+       * though because we should've detected this in our previous call
+       * to GNUNET_CRYPTO_rsa_unblind. */
+      return GNUNET_NO;
+    }
 
   data = mpi_to_sexp(r);
-  gcry_mpi_release (r);
+  gcry_mpi_release(r);
 
-  rc = gcry_pk_verify (sig->sexp,
-                       data,
-                       pkey->sexp);
-  gcry_sexp_release (data);
+  rc = gcry_pk_verify(sig->sexp,
+                      data,
+                      pkey->sexp);
+  gcry_sexp_release(data);
   if (0 != rc)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("RSA signature verification failed at %s:%d: %s\n"),
-         __FILE__,
-         __LINE__,
-         gcry_strerror (rc));
-    return GNUNET_SYSERR;
-    BENCHMARK_END (rsa_verify);
-  }
-  BENCHMARK_END (rsa_verify);
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("RSA signature verification failed at %s:%d: %s\n"),
+          __FILE__,
+          __LINE__,
+          gcry_strerror(rc));
+      return GNUNET_SYSERR;
+      BENCHMARK_END(rsa_verify);
+    }
+  BENCHMARK_END(rsa_verify);
   return GNUNET_OK;
 }
 
@@ -1205,19 +1205,19 @@ GNUNET_CRYPTO_rsa_verify (const struct GNUNET_HashCode *hash,
  * @return the duplicate key; NULL upon error
  */
 struct GNUNET_CRYPTO_RsaPrivateKey *
-GNUNET_CRYPTO_rsa_private_key_dup (const struct GNUNET_CRYPTO_RsaPrivateKey *key)
+GNUNET_CRYPTO_rsa_private_key_dup(const struct GNUNET_CRYPTO_RsaPrivateKey *key)
 {
   struct GNUNET_CRYPTO_RsaPrivateKey *dup;
   gcry_sexp_t dup_sexp;
   size_t erroff;
 
   /* check if we really are exporting a private key */
-  dup_sexp = gcry_sexp_find_token (key->sexp, "private-key", 0);
-  GNUNET_assert (NULL != dup_sexp);
-  gcry_sexp_release (dup_sexp);
+  dup_sexp = gcry_sexp_find_token(key->sexp, "private-key", 0);
+  GNUNET_assert(NULL != dup_sexp);
+  gcry_sexp_release(dup_sexp);
   /* copy the sexp */
-  GNUNET_assert (0 == gcry_sexp_build (&dup_sexp, &erroff, "%S", key->sexp));
-  dup = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
+  GNUNET_assert(0 == gcry_sexp_build(&dup_sexp, &erroff, "%S", key->sexp));
+  dup = GNUNET_new(struct GNUNET_CRYPTO_RsaPrivateKey);
   dup->sexp = dup_sexp;
   return dup;
 }
@@ -1230,7 +1230,7 @@ GNUNET_CRYPTO_rsa_private_key_dup (const struct GNUNET_CRYPTO_RsaPrivateKey *key
  * @return the duplicate key; NULL upon error
  */
 struct GNUNET_CRYPTO_RsaSignature *
-GNUNET_CRYPTO_rsa_signature_dup (const struct GNUNET_CRYPTO_RsaSignature *sig)
+GNUNET_CRYPTO_rsa_signature_dup(const struct GNUNET_CRYPTO_RsaSignature *sig)
 {
   struct GNUNET_CRYPTO_RsaSignature *dup;
   gcry_sexp_t dup_sexp;
@@ -1239,14 +1239,14 @@ GNUNET_CRYPTO_rsa_signature_dup (const struct GNUNET_CRYPTO_RsaSignature *sig)
   int ret;
 
   /* verify that this is an RSA signature */
-  ret = key_from_sexp (&s, sig->sexp, "sig-val", "s");
+  ret = key_from_sexp(&s, sig->sexp, "sig-val", "s");
   if (0 != ret)
-    ret = key_from_sexp (&s, sig->sexp, "rsa", "s");
-  GNUNET_assert (0 == ret);
-  gcry_mpi_release (s);
+    ret = key_from_sexp(&s, sig->sexp, "rsa", "s");
+  GNUNET_assert(0 == ret);
+  gcry_mpi_release(s);
   /* copy the sexp */
-  GNUNET_assert (0 == gcry_sexp_build (&dup_sexp, &erroff, "%S", sig->sexp));
-  dup = GNUNET_new (struct GNUNET_CRYPTO_RsaSignature);
+  GNUNET_assert(0 == gcry_sexp_build(&dup_sexp, &erroff, "%S", sig->sexp));
+  dup = GNUNET_new(struct GNUNET_CRYPTO_RsaSignature);
   dup->sexp = dup_sexp;
   return dup;
 }
diff --git a/src/util/crypto_symmetric.c b/src/util/crypto_symmetric.c
index 18784d127..7fad2a884 100644
--- a/src/util/crypto_symmetric.c
+++ b/src/util/crypto_symmetric.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 util/crypto_symmetric.c
@@ -29,7 +29,7 @@
 #include "gnunet_crypto_lib.h"
 #include <gcrypt.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-symmetric", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-symmetric", __VA_ARGS__)
 
 /**
  * Create a new SessionKey (for symmetric encryption).
@@ -37,14 +37,14 @@
  * @param key session key to initialize
  */
 void
-GNUNET_CRYPTO_symmetric_create_session_key (struct GNUNET_CRYPTO_SymmetricSessionKey *key)
+GNUNET_CRYPTO_symmetric_create_session_key(struct GNUNET_CRYPTO_SymmetricSessionKey *key)
 {
-  gcry_randomize (key->aes_key,
-                  GNUNET_CRYPTO_AES_KEY_LENGTH,
-                  GCRY_STRONG_RANDOM);
-  gcry_randomize (key->twofish_key,
-                  GNUNET_CRYPTO_AES_KEY_LENGTH,
-                  GCRY_STRONG_RANDOM);
+  gcry_randomize(key->aes_key,
+                 GNUNET_CRYPTO_AES_KEY_LENGTH,
+                 GCRY_STRONG_RANDOM);
+  gcry_randomize(key->twofish_key,
+                 GNUNET_CRYPTO_AES_KEY_LENGTH,
+                 GCRY_STRONG_RANDOM);
 }
 
 
@@ -57,23 +57,23 @@ GNUNET_CRYPTO_symmetric_create_session_key (struct GNUNET_CRYPTO_SymmetricSessio
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-setup_cipher_aes (gcry_cipher_hd_t *handle,
-                  const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
-                  const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
+setup_cipher_aes(gcry_cipher_hd_t *handle,
+                 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
+                 const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
 {
   int rc;
 
-  GNUNET_assert (0 ==
-                 gcry_cipher_open (handle, GCRY_CIPHER_AES256,
-                                   GCRY_CIPHER_MODE_CFB, 0));
-  rc = gcry_cipher_setkey (*handle,
-                           sessionkey->aes_key,
-                           sizeof (sessionkey->aes_key));
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
-  rc = gcry_cipher_setiv (*handle,
-                          iv->aes_iv,
-                          sizeof (iv->aes_iv));
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  GNUNET_assert(0 ==
+                gcry_cipher_open(handle, GCRY_CIPHER_AES256,
+                                 GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey(*handle,
+                          sessionkey->aes_key,
+                          sizeof(sessionkey->aes_key));
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
+  rc = gcry_cipher_setiv(*handle,
+                         iv->aes_iv,
+                         sizeof(iv->aes_iv));
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
   return GNUNET_OK;
 }
 
@@ -87,23 +87,23 @@ setup_cipher_aes (gcry_cipher_hd_t *handle,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-setup_cipher_twofish (gcry_cipher_hd_t *handle,
-                      const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
-                      const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
+setup_cipher_twofish(gcry_cipher_hd_t *handle,
+                     const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
+                     const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
 {
   int rc;
 
-  GNUNET_assert (0 ==
-                 gcry_cipher_open (handle, GCRY_CIPHER_TWOFISH,
-                                   GCRY_CIPHER_MODE_CFB, 0));
-  rc = gcry_cipher_setkey (*handle,
-                           sessionkey->twofish_key,
-                           sizeof (sessionkey->twofish_key));
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
-  rc = gcry_cipher_setiv (*handle,
-                          iv->twofish_iv,
-                          sizeof (iv->twofish_iv));
-  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  GNUNET_assert(0 ==
+                gcry_cipher_open(handle, GCRY_CIPHER_TWOFISH,
+                                 GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey(*handle,
+                          sessionkey->twofish_key,
+                          sizeof(sessionkey->twofish_key));
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
+  rc = gcry_cipher_setiv(*handle,
+                         iv->twofish_iv,
+                         sizeof(iv->twofish_iv));
+  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
   return GNUNET_OK;
 }
 
@@ -122,24 +122,24 @@ setup_cipher_twofish (gcry_cipher_hd_t *handle,
  *          this size should be the same as @c len.
  */
 ssize_t
-GNUNET_CRYPTO_symmetric_encrypt (const void *block,
-                                 size_t size,
-                                 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
-                                 const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
-                                 void *result)
+GNUNET_CRYPTO_symmetric_encrypt(const void *block,
+                                size_t size,
+                                const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
+                                const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+                                void *result)
 {
   gcry_cipher_hd_t handle;
   char tmp[size];
 
-  if (GNUNET_OK != setup_cipher_aes (&handle, sessionkey, iv))
+  if (GNUNET_OK != setup_cipher_aes(&handle, sessionkey, iv))
     return -1;
-  GNUNET_assert (0 == gcry_cipher_encrypt (handle, tmp, size, block, size));
-  gcry_cipher_close (handle);
-  if (GNUNET_OK != setup_cipher_twofish (&handle, sessionkey, iv))
+  GNUNET_assert(0 == gcry_cipher_encrypt(handle, tmp, size, block, size));
+  gcry_cipher_close(handle);
+  if (GNUNET_OK != setup_cipher_twofish(&handle, sessionkey, iv))
     return -1;
-  GNUNET_assert (0 == gcry_cipher_encrypt (handle, result, size, tmp, size));
-  gcry_cipher_close (handle);
-  memset (tmp, 0, sizeof (tmp));
+  GNUNET_assert(0 == gcry_cipher_encrypt(handle, result, size, tmp, size));
+  gcry_cipher_close(handle);
+  memset(tmp, 0, sizeof(tmp));
   return size;
 }
 
@@ -158,24 +158,24 @@ GNUNET_CRYPTO_symmetric_encrypt (const void *block,
  *         this size should be the same as @c size.
  */
 ssize_t
-GNUNET_CRYPTO_symmetric_decrypt (const void *block,
-                                 size_t size,
-                                 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
-                                 const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
-                                 void *result)
+GNUNET_CRYPTO_symmetric_decrypt(const void *block,
+                                size_t size,
+                                const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
+                                const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+                                void *result)
 {
   gcry_cipher_hd_t handle;
   char tmp[size];
 
-  if (GNUNET_OK != setup_cipher_twofish (&handle, sessionkey, iv))
+  if (GNUNET_OK != setup_cipher_twofish(&handle, sessionkey, iv))
     return -1;
-  GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, block, size));
-  gcry_cipher_close (handle);
-  if (GNUNET_OK != setup_cipher_aes (&handle, sessionkey, iv))
+  GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, block, size));
+  gcry_cipher_close(handle);
+  if (GNUNET_OK != setup_cipher_aes(&handle, sessionkey, iv))
     return -1;
-  GNUNET_assert (0 == gcry_cipher_decrypt (handle, result, size, tmp, size));
-  gcry_cipher_close (handle);
-  memset (tmp, 0, sizeof (tmp));
+  GNUNET_assert(0 == gcry_cipher_decrypt(handle, result, size, tmp, size));
+  gcry_cipher_close(handle);
+  memset(tmp, 0, sizeof(tmp));
   return size;
 }
 
@@ -190,17 +190,17 @@ GNUNET_CRYPTO_symmetric_decrypt (const void *block,
  * @param ... pairs of void * & size_t for context chunks, terminated by NULL
  */
 void
-GNUNET_CRYPTO_symmetric_derive_iv (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
-                                   const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
-                                   const void *salt,
-                                   size_t salt_len,
-                                   ...)
+GNUNET_CRYPTO_symmetric_derive_iv(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+                                  const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
+                                  const void *salt,
+                                  size_t salt_len,
+                                  ...)
 {
   va_list argp;
 
-  va_start (argp, salt_len);
-  GNUNET_CRYPTO_symmetric_derive_iv_v (iv, skey, salt, salt_len, argp);
-  va_end (argp);
+  va_start(argp, salt_len);
+  GNUNET_CRYPTO_symmetric_derive_iv_v(iv, skey, salt, salt_len, argp);
+  va_end(argp);
 }
 
 
@@ -214,33 +214,33 @@ GNUNET_CRYPTO_symmetric_derive_iv (struct GNUNET_CRYPTO_SymmetricInitializationV
  * @param argp pairs of void * & size_t for context chunks, terminated by NULL
  */
 void
-GNUNET_CRYPTO_symmetric_derive_iv_v (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
-                                     const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
-                                     const void *salt,
-                                     size_t salt_len,
-                                     va_list argp)
+GNUNET_CRYPTO_symmetric_derive_iv_v(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
+                                    const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
+                                    const void *salt,
+                                    size_t salt_len,
+                                    va_list argp)
 {
   char aes_salt[salt_len + 4];
   char twofish_salt[salt_len + 4];
 
-  GNUNET_memcpy (aes_salt, salt, salt_len);
-  GNUNET_memcpy (&aes_salt[salt_len], "AES!", 4);
-  GNUNET_memcpy (twofish_salt, salt, salt_len);
-  GNUNET_memcpy (&twofish_salt[salt_len], "FISH", 4);
-  GNUNET_CRYPTO_kdf_v (iv->aes_iv,
-                       sizeof (iv->aes_iv),
-                       aes_salt,
-                       salt_len + 4,
-                       skey->aes_key,
-                       sizeof (skey->aes_key),
-                       argp);
-  GNUNET_CRYPTO_kdf_v (iv->twofish_iv,
-                       sizeof (iv->twofish_iv),
-                       twofish_salt,
-                       salt_len + 4,
-                       skey->twofish_key,
-                       sizeof (skey->twofish_key),
-                       argp);
+  GNUNET_memcpy(aes_salt, salt, salt_len);
+  GNUNET_memcpy(&aes_salt[salt_len], "AES!", 4);
+  GNUNET_memcpy(twofish_salt, salt, salt_len);
+  GNUNET_memcpy(&twofish_salt[salt_len], "FISH", 4);
+  GNUNET_CRYPTO_kdf_v(iv->aes_iv,
+                      sizeof(iv->aes_iv),
+                      aes_salt,
+                      salt_len + 4,
+                      skey->aes_key,
+                      sizeof(skey->aes_key),
+                      argp);
+  GNUNET_CRYPTO_kdf_v(iv->twofish_iv,
+                      sizeof(iv->twofish_iv),
+                      twofish_salt,
+                      salt_len + 4,
+                      skey->twofish_key,
+                      sizeof(skey->twofish_key),
+                      argp);
 }
 
 /* end of crypto_symmetric.c */
diff --git a/src/util/disk.c b/src/util/disk.c
index 959cb62cf..450a19ab1 100644
--- a/src/util/disk.c
+++ b/src/util/disk.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 util/disk.c
  * @brief disk IO convenience methods
@@ -28,13 +28,13 @@
 #include "gnunet_strings_lib.h"
 #include "gnunet_disk_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-disk", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-disk", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-disk", syscall)
+  GNUNET_log_from_strerror(kind, "util-disk", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-disk", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-disk", syscall, filename)
 
 /**
  * Block size for IO for copying files.
@@ -58,15 +58,14 @@
 #ifndef S_ISLNK
 #define _IFMT 0170000 /* type of file */
 #define _IFLNK 0120000 /* symbolic link */
-#define S_ISLNK(m) (((m) &_IFMT) == _IFLNK)
+#define S_ISLNK(m) (((m) & _IFMT) == _IFLNK)
 #endif
 
 
 /**
  * Handle used to manage a pipe.
  */
-struct GNUNET_DISK_PipeHandle
-{
+struct GNUNET_DISK_PipeHandle {
   /**
    * File descriptors for the pipe.
    * One or both of them could be NULL.
@@ -79,8 +78,7 @@ struct GNUNET_DISK_PipeHandle
  * Closure for the recursion to determine the file size
  * of a directory.
  */
-struct GetFileSizeData
-{
+struct GetFileSizeData {
   /**
    * Set to the total file size.
    */
@@ -107,7 +105,7 @@ struct GetFileSizeData
  * @return file permissions, UNIX style
  */
 static int
-translate_unix_perms (enum GNUNET_DISK_AccessPermissions perm)
+translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
 {
   int mode;
 
@@ -145,41 +143,41 @@ translate_unix_perms (enum GNUNET_DISK_AccessPermissions perm)
  * @return #GNUNET_SYSERR on serious errors, otherwise #GNUNET_OK
  */
 static int
-getSizeRec (void *cls, const char *fn)
+getSizeRec(void *cls, const char *fn)
 {
   struct GetFileSizeData *gfsd = cls;
 
 #if defined(HAVE_STAT64) && \
-  ! (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
+  !(defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
   STRUCT_STAT64 buf;
 
-  if (0 != stat64 (fn, &buf))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "stat64", fn);
-    return GNUNET_SYSERR;
-  }
+  if (0 != stat64(fn, &buf))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "stat64", fn);
+      return GNUNET_SYSERR;
+    }
 #else
   struct stat buf;
 
-  if (0 != stat (fn, &buf))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "stat", fn);
-    return GNUNET_SYSERR;
-  }
+  if (0 != stat(fn, &buf))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "stat", fn);
+      return GNUNET_SYSERR;
+    }
 #endif
-  if ((S_ISDIR (buf.st_mode)) && (gfsd->single_file_mode == GNUNET_YES))
-  {
-    errno = EISDIR;
-    return GNUNET_SYSERR;
-  }
-  if ((! S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES))
-    gfsd->total += buf.st_size;
-  if ((S_ISDIR (buf.st_mode)) && (0 == access (fn, X_OK)) &&
-      ((! S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES)))
-  {
-    if (GNUNET_SYSERR == GNUNET_DISK_directory_scan (fn, &getSizeRec, gfsd))
+  if ((S_ISDIR(buf.st_mode)) && (gfsd->single_file_mode == GNUNET_YES))
+    {
+      errno = EISDIR;
       return GNUNET_SYSERR;
-  }
+    }
+  if ((!S_ISLNK(buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES))
+    gfsd->total += buf.st_size;
+  if ((S_ISDIR(buf.st_mode)) && (0 == access(fn, X_OK)) &&
+      ((!S_ISLNK(buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES)))
+    {
+      if (GNUNET_SYSERR == GNUNET_DISK_directory_scan(fn, &getSizeRec, gfsd))
+        return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -191,12 +189,12 @@ getSizeRec (void *cls, const char *fn)
  * @return #GNUNET_YES if invalid, #GNUNET_NO if valid
  */
 int
-GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h)
 {
 #ifdef MINGW
-  return ((! h) || (h->h == INVALID_HANDLE_VALUE)) ? GNUNET_YES : GNUNET_NO;
+  return ((!h) || (h->h == INVALID_HANDLE_VALUE)) ? GNUNET_YES : GNUNET_NO;
 #else
-  return ((! h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
+  return ((!h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
 #endif
 }
 
@@ -208,22 +206,22 @@ GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, off_t *size)
+GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
 {
 #if WINDOWS
   BOOL b;
   LARGE_INTEGER li;
-  b = GetFileSizeEx (fh->h, &li);
-  if (! b)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
-  *size = (off_t) li.QuadPart;
+  b = GetFileSizeEx(fh->h, &li);
+  if (!b)
+    {
+      SetErrnoFromWinError(GetLastError());
+      return GNUNET_SYSERR;
+    }
+  *size = (off_t)li.QuadPart;
 #else
   struct stat sbuf;
 
-  if (0 != fstat (fh->fd, &sbuf))
+  if (0 != fstat(fh->fd, &sbuf))
     return GNUNET_SYSERR;
   *size = sbuf.st_size;
 #endif
@@ -240,35 +238,35 @@ GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, off_t *size)
  * @return the new position on success, #GNUNET_SYSERR otherwise
  */
 off_t
-GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h,
-                       off_t offset,
-                       enum GNUNET_DISK_Seek whence)
+GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h,
+                      off_t offset,
+                      enum GNUNET_DISK_Seek whence)
 {
   if (h == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   LARGE_INTEGER li;
   LARGE_INTEGER new_pos;
   BOOL b;
 
-  static DWORD t[] = {FILE_BEGIN, FILE_CURRENT, FILE_END};
+  static DWORD t[] = { FILE_BEGIN, FILE_CURRENT, FILE_END };
   li.QuadPart = offset;
 
-  b = SetFilePointerEx (h->h, li, &new_pos, t[whence]);
+  b = SetFilePointerEx(h->h, li, &new_pos, t[whence]);
   if (b == 0)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
-  return (off_t) new_pos.QuadPart;
+    {
+      SetErrnoFromWinError(GetLastError());
+      return GNUNET_SYSERR;
+    }
+  return (off_t)new_pos.QuadPart;
 #else
-  static int t[] = {SEEK_SET, SEEK_CUR, SEEK_END};
+  static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
 
-  return lseek (h->fd, offset, t[whence]);
+  return lseek(h->fd, offset, t[whence]);
 #endif
 }
 
@@ -288,19 +286,19 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_size (const char *filename,
-                       uint64_t *size,
-                       int include_symbolic_links,
-                       int single_file_mode)
+GNUNET_DISK_file_size(const char *filename,
+                      uint64_t *size,
+                      int include_symbolic_links,
+                      int single_file_mode)
 {
   struct GetFileSizeData gfsd;
   int ret;
 
-  GNUNET_assert (size != NULL);
+  GNUNET_assert(size != NULL);
   gfsd.total = 0;
   gfsd.include_sym_links = include_symbolic_links;
   gfsd.single_file_mode = single_file_mode;
-  ret = getSizeRec (&gfsd, filename);
+  ret = getSizeRec(&gfsd, filename);
   *size = gfsd.total;
   return ret;
 }
@@ -322,9 +320,9 @@ GNUNET_DISK_file_size (const char *filename,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_get_identifiers (const char *filename,
-                                  uint64_t *dev,
-                                  uint64_t *ino)
+GNUNET_DISK_file_get_identifiers(const char *filename,
+                                 uint64_t *dev,
+                                 uint64_t *ino)
 {
 #if WINDOWS
   {
@@ -333,19 +331,19 @@ GNUNET_DISK_file_get_identifiers (const char *filename,
     BY_HANDLE_FILE_INFORMATION info;
     int succ;
 
-    fh = GNUNET_DISK_file_open (filename,
-                                GNUNET_DISK_OPEN_READ,
-                                GNUNET_DISK_PERM_NONE);
+    fh = GNUNET_DISK_file_open(filename,
+                               GNUNET_DISK_OPEN_READ,
+                               GNUNET_DISK_PERM_NONE);
     if (NULL == fh)
       return GNUNET_SYSERR;
-    succ = GetFileInformationByHandle (fh->h, &info);
-    GNUNET_DISK_file_close (fh);
-    if (! succ)
-    {
-      return GNUNET_SYSERR;
-    }
+    succ = GetFileInformationByHandle(fh->h, &info);
+    GNUNET_DISK_file_close(fh);
+    if (!succ)
+      {
+        return GNUNET_SYSERR;
+      }
     *dev = info.dwVolumeSerialNumber;
-    *ino = ((((uint64_t) info.nFileIndexHigh) << (sizeof (DWORD) * 8)) |
+    *ino = ((((uint64_t)info.nFileIndexHigh) << (sizeof(DWORD) * 8)) |
             info.nFileIndexLow);
   }
 #else /* !WINDOWS */
@@ -353,11 +351,11 @@ GNUNET_DISK_file_get_identifiers (const char *filename,
   {
     struct stat sbuf;
 
-    if (0 != stat (filename, &sbuf))
-    {
-      return GNUNET_SYSERR;
-    }
-    *ino = (uint64_t) sbuf.st_ino;
+    if (0 != stat(filename, &sbuf))
+      {
+        return GNUNET_SYSERR;
+      }
+    *ino = (uint64_t)sbuf.st_ino;
   }
 #else
   *ino = 0;
@@ -366,22 +364,22 @@ GNUNET_DISK_file_get_identifiers (const char *filename,
   {
     struct statvfs fbuf;
 
-    if (0 != statvfs (filename, &fbuf))
-    {
-      return GNUNET_SYSERR;
-    }
-    *dev = (uint64_t) fbuf.f_fsid;
+    if (0 != statvfs(filename, &fbuf))
+      {
+        return GNUNET_SYSERR;
+      }
+    *dev = (uint64_t)fbuf.f_fsid;
   }
 #elif HAVE_STATFS
   {
     struct statfs fbuf;
 
-    if (0 != statfs (filename, &fbuf))
-    {
-      return GNUNET_SYSERR;
-    }
+    if (0 != statfs(filename, &fbuf))
+      {
+        return GNUNET_SYSERR;
+      }
     *dev =
-      ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
+      ((uint64_t)fbuf.f_fsid.val[0]) << 32 || ((uint64_t)fbuf.f_fsid.val[1]);
   }
 #else
   *dev = 0;
@@ -398,7 +396,7 @@ GNUNET_DISK_file_get_identifiers (const char *filename,
  * @return name ready for passing to 'mktemp' or 'mkdtemp', NULL on error
  */
 static char *
-mktemp_name (const char *t)
+mktemp_name(const char *t)
 {
   const char *tmpdir;
   char *tmpl;
@@ -406,33 +404,33 @@ mktemp_name (const char *t)
 
   if ((t[0] != '/') && (t[0] != '\\')
 #if WINDOWS
-      && ! (isalpha ((int) t[0]) && (t[0] != '\0') && (t[1] == ':'))
+      && !(isalpha((int)t[0]) && (t[0] != '\0') && (t[1] == ':'))
 #endif
-  )
-  {
-    /* FIXME: This uses system codepage on W32, not UTF-8 */
-    tmpdir = getenv ("TMPDIR");
-    if (NULL == tmpdir)
-      tmpdir = getenv ("TMP");
-    if (NULL == tmpdir)
-      tmpdir = getenv ("TEMP");
-    if (NULL == tmpdir)
-      tmpdir = "/tmp";
-    GNUNET_asprintf (&tmpl, "%s/%s%s", tmpdir, t, "XXXXXX");
-  }
+      )
+    {
+      /* FIXME: This uses system codepage on W32, not UTF-8 */
+      tmpdir = getenv("TMPDIR");
+      if (NULL == tmpdir)
+        tmpdir = getenv("TMP");
+      if (NULL == tmpdir)
+        tmpdir = getenv("TEMP");
+      if (NULL == tmpdir)
+        tmpdir = "/tmp";
+      GNUNET_asprintf(&tmpl, "%s/%s%s", tmpdir, t, "XXXXXX");
+    }
   else
-  {
-    GNUNET_asprintf (&tmpl, "%s%s", t, "XXXXXX");
-  }
+    {
+      GNUNET_asprintf(&tmpl, "%s%s", t, "XXXXXX");
+    }
 #ifdef MINGW
-  fn = (char *) GNUNET_malloc (MAX_PATH + 1);
-  if (ERROR_SUCCESS != plibc_conv_to_win_path (tmpl, fn))
-  {
-    GNUNET_free (fn);
-    GNUNET_free (tmpl);
-    return NULL;
-  }
-  GNUNET_free (tmpl);
+  fn = (char *)GNUNET_malloc(MAX_PATH + 1);
+  if (ERROR_SUCCESS != plibc_conv_to_win_path(tmpl, fn))
+    {
+      GNUNET_free(fn);
+      GNUNET_free(tmpl);
+      return NULL;
+    }
+  GNUNET_free(tmpl);
 #else
   fn = tmpl;
 #endif
@@ -442,32 +440,32 @@ mktemp_name (const char *t)
 
 #if WINDOWS
 static char *
-mkdtemp (char *fn)
+mkdtemp(char *fn)
 {
   char *random_fn;
   char *tfn;
 
   while (1)
-  {
-    tfn = GNUNET_strdup (fn);
-    random_fn = _mktemp (tfn);
-    if (NULL == random_fn)
-    {
-      GNUNET_free (tfn);
-      return NULL;
-    }
-    /* FIXME: assume fn to be UTF-8-encoded and do the right thing */
-    if (0 == CreateDirectoryA (tfn, NULL))
     {
-      DWORD error = GetLastError ();
-      GNUNET_free (tfn);
-      if (ERROR_ALREADY_EXISTS == error)
-        continue;
-      return NULL;
+      tfn = GNUNET_strdup(fn);
+      random_fn = _mktemp(tfn);
+      if (NULL == random_fn)
+        {
+          GNUNET_free(tfn);
+          return NULL;
+        }
+      /* FIXME: assume fn to be UTF-8-encoded and do the right thing */
+      if (0 == CreateDirectoryA(tfn, NULL))
+        {
+          DWORD error = GetLastError();
+          GNUNET_free(tfn);
+          if (ERROR_ALREADY_EXISTS == error)
+            continue;
+          return NULL;
+        }
+      break;
     }
-    break;
-  }
-  strcpy (fn, tfn);
+  strcpy(fn, tfn);
   return fn;
 }
 
@@ -481,9 +479,9 @@ mkdtemp (char *fn)
  * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set
  */
 void
-GNUNET_DISK_fix_permissions (const char *fn,
-                             int require_uid_match,
-                             int require_gid_match)
+GNUNET_DISK_fix_permissions(const char *fn,
+                            int require_uid_match,
+                            int require_gid_match)
 {
   /* nothing on W32 */
 }
@@ -499,9 +497,9 @@ GNUNET_DISK_fix_permissions (const char *fn,
  * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set
  */
 void
-GNUNET_DISK_fix_permissions (const char *fn,
-                             int require_uid_match,
-                             int require_gid_match)
+GNUNET_DISK_fix_permissions(const char *fn,
+                            int require_uid_match,
+                            int require_gid_match)
 {
   mode_t mode;
 
@@ -512,8 +510,8 @@ GNUNET_DISK_fix_permissions (const char *fn,
   else
     mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH |
            S_IWOTH | S_IXOTH;
-  if (0 != chmod (fn, mode))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
+  if (0 != chmod(fn, mode))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
 }
 
 #endif
@@ -530,21 +528,21 @@ GNUNET_DISK_fix_permissions (const char *fn,
  *         file on disk in directory for temporary files
  */
 char *
-GNUNET_DISK_mkdtemp (const char *t)
+GNUNET_DISK_mkdtemp(const char *t)
 {
   char *fn;
   mode_t omask;
 
-  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
-  fn = mktemp_name (t);
-  if (fn != mkdtemp (fn))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkdtemp", fn);
-    GNUNET_free (fn);
-    umask (omask);
-    return NULL;
-  }
-  umask (omask);
+  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
+  fn = mktemp_name(t);
+  if (fn != mkdtemp(fn))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkdtemp", fn);
+      GNUNET_free(fn);
+      umask(omask);
+      return NULL;
+    }
+  umask(omask);
   return fn;
 }
 
@@ -557,22 +555,23 @@ GNUNET_DISK_mkdtemp (const char *t)
  * @param fil name of the file to back up
  */
 void
-GNUNET_DISK_file_backup (const char *fil)
+GNUNET_DISK_file_backup(const char *fil)
 {
   size_t slen;
   char *target;
   unsigned int num;
 
-  slen = strlen (fil) + 20;
-  target = GNUNET_malloc (slen);
+  slen = strlen(fil) + 20;
+  target = GNUNET_malloc(slen);
   num = 0;
   do
-  {
-    GNUNET_snprintf (target, slen, "%s.%u~", fil, num++);
-  } while (0 == access (target, F_OK));
-  if (0 != rename (fil, target))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "rename", fil);
-  GNUNET_free (target);
+    {
+      GNUNET_snprintf(target, slen, "%s.%u~", fil, num++);
+    }
+  while (0 == access(target, F_OK));
+  if (0 != rename(fil, target))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "rename", fil);
+  GNUNET_free(target);
 }
 
 
@@ -588,24 +587,24 @@ GNUNET_DISK_file_backup (const char *fil)
  *         file on disk in directory for temporary files
  */
 char *
-GNUNET_DISK_mktemp (const char *t)
+GNUNET_DISK_mktemp(const char *t)
 {
   int fd;
   char *fn;
   mode_t omask;
 
-  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
-  fn = mktemp_name (t);
-  if (-1 == (fd = mkstemp (fn)))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
-    GNUNET_free (fn);
-    umask (omask);
-    return NULL;
-  }
-  umask (omask);
-  if (0 != close (fd))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "close", fn);
+  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
+  fn = mktemp_name(t);
+  if (-1 == (fd = mkstemp(fn)))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
+      GNUNET_free(fn);
+      umask(omask);
+      return NULL;
+    }
+  umask(omask);
+  if (0 != close(fd))
+    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "close", fn);
   return fn;
 }
 
@@ -623,34 +622,34 @@ GNUNET_DISK_mktemp (const char *t)
  *           does not exist or stat'ed
  */
 int
-GNUNET_DISK_directory_test (const char *fil, int is_readable)
+GNUNET_DISK_directory_test(const char *fil, int is_readable)
 {
   struct stat filestat;
   int ret;
 
-  ret = stat (fil, &filestat);
+  ret = stat(fil, &filestat);
   if (ret != 0)
-  {
-    if (errno != ENOENT)
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", fil);
-    return GNUNET_SYSERR;
-  }
-  if (! S_ISDIR (filestat.st_mode))
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         "A file already exits with the same name %s\n",
-         fil);
-    return GNUNET_NO;
-  }
+    {
+      if (errno != ENOENT)
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", fil);
+      return GNUNET_SYSERR;
+    }
+  if (!S_ISDIR(filestat.st_mode))
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          "A file already exits with the same name %s\n",
+          fil);
+      return GNUNET_NO;
+    }
   if (GNUNET_YES == is_readable)
-    ret = access (fil, R_OK | X_OK);
+    ret = access(fil, R_OK | X_OK);
   else
-    ret = access (fil, X_OK);
+    ret = access(fil, X_OK);
   if (ret < 0)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", fil);
-    return GNUNET_NO;
-  }
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "access", fil);
+      return GNUNET_NO;
+    }
   return GNUNET_YES;
 }
 
@@ -664,40 +663,40 @@ GNUNET_DISK_directory_test (const char *fil, int is_readable)
  * else (will print an error message in that case, too).
  */
 int
-GNUNET_DISK_file_test (const char *fil)
+GNUNET_DISK_file_test(const char *fil)
 {
   struct stat filestat;
   int ret;
   char *rdir;
 
-  rdir = GNUNET_STRINGS_filename_expand (fil);
+  rdir = GNUNET_STRINGS_filename_expand(fil);
   if (rdir == NULL)
     return GNUNET_SYSERR;
 
-  ret = stat (rdir, &filestat);
+  ret = stat(rdir, &filestat);
   if (ret != 0)
-  {
-    if (errno != ENOENT)
     {
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", rdir);
-      GNUNET_free (rdir);
+      if (errno != ENOENT)
+        {
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", rdir);
+          GNUNET_free(rdir);
+          return GNUNET_SYSERR;
+        }
+      GNUNET_free(rdir);
+      return GNUNET_NO;
+    }
+  if (!S_ISREG(filestat.st_mode))
+    {
+      GNUNET_free(rdir);
+      return GNUNET_NO;
+    }
+  if (access(rdir, F_OK) < 0)
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "access", rdir);
+      GNUNET_free(rdir);
       return GNUNET_SYSERR;
     }
-    GNUNET_free (rdir);
-    return GNUNET_NO;
-  }
-  if (! S_ISREG (filestat.st_mode))
-  {
-    GNUNET_free (rdir);
-    return GNUNET_NO;
-  }
-  if (access (rdir, F_OK) < 0)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", rdir);
-    GNUNET_free (rdir);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (rdir);
+  GNUNET_free(rdir);
   return GNUNET_YES;
 }
 
@@ -709,7 +708,7 @@ GNUNET_DISK_file_test (const char *fil)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_DISK_directory_create (const char *dir)
+GNUNET_DISK_directory_create(const char *dir)
 {
   char *rdir;
   unsigned int len;
@@ -717,105 +716,105 @@ GNUNET_DISK_directory_create (const char *dir)
   unsigned int pos2;
   int ret = GNUNET_OK;
 
-  rdir = GNUNET_STRINGS_filename_expand (dir);
+  rdir = GNUNET_STRINGS_filename_expand(dir);
   if (rdir == NULL)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
 
-  len = strlen (rdir);
+  len = strlen(rdir);
 #ifndef MINGW
   pos = 1; /* skip heading '/' */
 #else
   /* Local or Network path? */
-  if (strncmp (rdir, "\\\\", 2) == 0)
-  {
-    pos = 2;
-    while (rdir[pos])
+  if (strncmp(rdir, "\\\\", 2) == 0)
     {
-      if (rdir[pos] == '\\')
-      {
-        pos++;
-        break;
-      }
-      pos++;
+      pos = 2;
+      while (rdir[pos])
+        {
+          if (rdir[pos] == '\\')
+            {
+              pos++;
+              break;
+            }
+          pos++;
+        }
     }
-  }
   else
-  {
-    pos = 3; /* strlen("C:\\") */
-  }
+    {
+      pos = 3; /* strlen("C:\\") */
+    }
 #endif
   /* Check which low level directories already exist */
   pos2 = len;
   rdir[len] = DIR_SEPARATOR;
   while (pos <= pos2)
-  {
-    if (DIR_SEPARATOR == rdir[pos2])
     {
-      rdir[pos2] = '\0';
-      ret = GNUNET_DISK_directory_test (rdir, GNUNET_NO);
-      if (GNUNET_NO == ret)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Creating directory `%s' failed",
-                    rdir);
-        GNUNET_free (rdir);
-        return GNUNET_SYSERR;
-      }
-      rdir[pos2] = DIR_SEPARATOR;
-      if (GNUNET_YES == ret)
-      {
-        pos2++;
-        break;
-      }
+      if (DIR_SEPARATOR == rdir[pos2])
+        {
+          rdir[pos2] = '\0';
+          ret = GNUNET_DISK_directory_test(rdir, GNUNET_NO);
+          if (GNUNET_NO == ret)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Creating directory `%s' failed",
+                         rdir);
+              GNUNET_free(rdir);
+              return GNUNET_SYSERR;
+            }
+          rdir[pos2] = DIR_SEPARATOR;
+          if (GNUNET_YES == ret)
+            {
+              pos2++;
+              break;
+            }
+        }
+      pos2--;
     }
-    pos2--;
-  }
   rdir[len] = '\0';
   if (pos < pos2)
     pos = pos2;
   /* Start creating directories */
   while (pos <= len)
-  {
-    if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
     {
-      rdir[pos] = '\0';
-      ret = GNUNET_DISK_directory_test (rdir, GNUNET_NO);
-      if (GNUNET_NO == ret)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Creating directory `%s' failed",
-                    rdir);
-        GNUNET_free (rdir);
-        return GNUNET_SYSERR;
-      }
-      if (GNUNET_SYSERR == ret)
-      {
+      if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
+        {
+          rdir[pos] = '\0';
+          ret = GNUNET_DISK_directory_test(rdir, GNUNET_NO);
+          if (GNUNET_NO == ret)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Creating directory `%s' failed",
+                         rdir);
+              GNUNET_free(rdir);
+              return GNUNET_SYSERR;
+            }
+          if (GNUNET_SYSERR == ret)
+            {
 #ifndef MINGW
-        ret = mkdir (rdir,
-                     S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH |
-                       S_IXOTH); /* 755 */
+              ret = mkdir(rdir,
+                          S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH |
+                          S_IXOTH); /* 755 */
 #else
-        wchar_t wrdir[MAX_PATH + 1];
-        if (ERROR_SUCCESS == plibc_conv_to_win_pathwconv (rdir, wrdir))
-          ret = ! CreateDirectoryW (wrdir, NULL);
-        else
-          ret = 1;
+              wchar_t wrdir[MAX_PATH + 1];
+              if (ERROR_SUCCESS == plibc_conv_to_win_pathwconv(rdir, wrdir))
+                ret = !CreateDirectoryW(wrdir, NULL);
+              else
+                ret = 1;
 #endif
-        if ((ret != 0) && (errno != EEXIST))
-        {
-          LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkdir", rdir);
-          GNUNET_free (rdir);
-          return GNUNET_SYSERR;
+              if ((ret != 0) && (errno != EEXIST))
+                {
+                  LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkdir", rdir);
+                  GNUNET_free(rdir);
+                  return GNUNET_SYSERR;
+                }
+            }
+          rdir[pos] = DIR_SEPARATOR;
         }
-      }
-      rdir[pos] = DIR_SEPARATOR;
+      pos++;
     }
-    pos++;
-  }
-  GNUNET_free (rdir);
+  GNUNET_free(rdir);
   return GNUNET_OK;
 }
 
@@ -830,40 +829,40 @@ GNUNET_DISK_directory_create (const char *dir)
  *          exists but is not writeable for us
  */
 int
-GNUNET_DISK_directory_create_for_file (const char *filename)
+GNUNET_DISK_directory_create_for_file(const char *filename)
 {
   char *rdir;
   size_t len;
   int ret;
   int eno;
 
-  rdir = GNUNET_STRINGS_filename_expand (filename);
+  rdir = GNUNET_STRINGS_filename_expand(filename);
   if (NULL == rdir)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
-  if (0 == access (rdir, W_OK))
-  {
-    GNUNET_free (rdir);
-    return GNUNET_OK;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+  if (0 == access(rdir, W_OK))
+    {
+      GNUNET_free(rdir);
+      return GNUNET_OK;
+    }
 
-  len = strlen (rdir);
+  len = strlen(rdir);
   while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
     len--;
   rdir[len] = '\0';
   /* The empty path is invalid and in this case refers to / */
   if (0 == len)
-  {
-    GNUNET_free (rdir);
-    rdir = GNUNET_strdup ("/");
-  }
-  ret = GNUNET_DISK_directory_create (rdir);
-  if ((GNUNET_OK == ret) && (0 != access (rdir, W_OK)))
+    {
+      GNUNET_free(rdir);
+      rdir = GNUNET_strdup("/");
+    }
+  ret = GNUNET_DISK_directory_create(rdir);
+  if ((GNUNET_OK == ret) && (0 != access(rdir, W_OK)))
     ret = GNUNET_NO;
   eno = errno;
-  GNUNET_free (rdir);
+  GNUNET_free(rdir);
   errno = eno;
   return ret;
 }
@@ -878,51 +877,51 @@ GNUNET_DISK_directory_create_for_file (const char *filename)
  * @return the number of bytes read on success, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h,
-                       void *result,
-                       size_t len)
+GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h,
+                      void *result,
+                      size_t len)
 {
   if (NULL == h)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   DWORD bytes_read;
 
   if (h->type == GNUNET_DISK_HANLDE_TYPE_FILE)
-  {
-    if (! ReadFile (h->h, result, len, &bytes_read, NULL))
     {
-      SetErrnoFromWinError (GetLastError ());
-      return GNUNET_SYSERR;
+      if (!ReadFile(h->h, result, len, &bytes_read, NULL))
+        {
+          SetErrnoFromWinError(GetLastError());
+          return GNUNET_SYSERR;
+        }
     }
-  }
   else if (h->type == GNUNET_DISK_HANLDE_TYPE_PIPE)
-  {
-    if (! ReadFile (h->h, result, len, &bytes_read, h->oOverlapRead))
     {
-      if (GetLastError () != ERROR_IO_PENDING)
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Error reading from pipe: %u\n",
-             GetLastError ());
-        SetErrnoFromWinError (GetLastError ());
-        return GNUNET_SYSERR;
-      }
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
-      GetOverlappedResult (h->h, h->oOverlapRead, &bytes_read, TRUE);
+      if (!ReadFile(h->h, result, len, &bytes_read, h->oOverlapRead))
+        {
+          if (GetLastError() != ERROR_IO_PENDING)
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Error reading from pipe: %u\n",
+                  GetLastError());
+              SetErrnoFromWinError(GetLastError());
+              return GNUNET_SYSERR;
+            }
+          LOG(GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
+          GetOverlappedResult(h->h, h->oOverlapRead, &bytes_read, TRUE);
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes from pipe\n", bytes_read);
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes from pipe\n", bytes_read);
-  }
   else
-  {
-    bytes_read = 0;
-  }
+    {
+      bytes_read = 0;
+    }
   return bytes_read;
 #else
-  return read (h->fd, result, len);
+  return read(h->fd, result, len);
 #endif
 }
 
@@ -938,69 +937,69 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h,
  * @return the number of bytes read on success, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h,
-                                    void *result,
-                                    size_t len)
+GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle *h,
+                                   void *result,
+                                   size_t len)
 {
   if (NULL == h)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   DWORD bytes_read;
 
   if (h->type == GNUNET_DISK_HANLDE_TYPE_FILE)
-  {
-    if (! ReadFile (h->h, result, len, &bytes_read, NULL))
     {
-      SetErrnoFromWinError (GetLastError ());
-      return GNUNET_SYSERR;
+      if (!ReadFile(h->h, result, len, &bytes_read, NULL))
+        {
+          SetErrnoFromWinError(GetLastError());
+          return GNUNET_SYSERR;
+        }
     }
-  }
   else if (h->type == GNUNET_DISK_HANLDE_TYPE_PIPE)
-  {
-    if (! ReadFile (h->h, result, len, &bytes_read, h->oOverlapRead))
     {
-      if (GetLastError () != ERROR_IO_PENDING)
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Error reading from pipe: %u\n",
-             GetLastError ());
-        SetErrnoFromWinError (GetLastError ());
-        return GNUNET_SYSERR;
-      }
-      else
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG, "ReadFile() queued a read, cancelling\n");
-        CancelIo (h->h);
-        errno = EAGAIN;
-        return GNUNET_SYSERR;
-      }
+      if (!ReadFile(h->h, result, len, &bytes_read, h->oOverlapRead))
+        {
+          if (GetLastError() != ERROR_IO_PENDING)
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Error reading from pipe: %u\n",
+                  GetLastError());
+              SetErrnoFromWinError(GetLastError());
+              return GNUNET_SYSERR;
+            }
+          else
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG, "ReadFile() queued a read, cancelling\n");
+              CancelIo(h->h);
+              errno = EAGAIN;
+              return GNUNET_SYSERR;
+            }
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes\n", bytes_read);
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes\n", bytes_read);
-  }
   else
-  {
-    bytes_read = 0;
-  }
+    {
+      bytes_read = 0;
+    }
   return bytes_read;
 #else
   int flags;
   ssize_t ret;
 
   /* set to non-blocking, read, then set back */
-  flags = fcntl (h->fd, F_GETFL);
+  flags = fcntl(h->fd, F_GETFL);
   if (0 == (flags & O_NONBLOCK))
-    (void) fcntl (h->fd, F_SETFL, flags | O_NONBLOCK);
-  ret = read (h->fd, result, len);
+    (void)fcntl(h->fd, F_SETFL, flags | O_NONBLOCK);
+  ret = read(h->fd, result, len);
   if (0 == (flags & O_NONBLOCK))
-  {
-    int eno = errno;
-    (void) fcntl (h->fd, F_SETFL, flags);
-    errno = eno;
-  }
+    {
+      int eno = errno;
+      (void)fcntl(h->fd, F_SETFL, flags);
+      errno = eno;
+    }
   return ret;
 #endif
 }
@@ -1015,18 +1014,18 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes read, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
+GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
 {
   struct GNUNET_DISK_FileHandle *fh;
   ssize_t ret;
   int eno;
 
-  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  fh = GNUNET_DISK_file_open(fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
   if (NULL == fh)
     return GNUNET_SYSERR;
-  ret = GNUNET_DISK_file_read (fh, result, len);
+  ret = GNUNET_DISK_file_read(fh, result, len);
   eno = errno;
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
   errno = eno;
   return ret;
 }
@@ -1041,87 +1040,87 @@ GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h,
-                        const void *buffer,
-                        size_t n)
+GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h,
+                       const void *buffer,
+                       size_t n)
 {
   if (NULL == h)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   DWORD bytes_written;
 
   if (h->type == GNUNET_DISK_HANLDE_TYPE_FILE)
-  {
-    if (! WriteFile (h->h, buffer, n, &bytes_written, NULL))
     {
-      SetErrnoFromWinError (GetLastError ());
-      return GNUNET_SYSERR;
+      if (!WriteFile(h->h, buffer, n, &bytes_written, NULL))
+        {
+          SetErrnoFromWinError(GetLastError());
+          return GNUNET_SYSERR;
+        }
     }
-  }
   else if (h->type == GNUNET_DISK_HANLDE_TYPE_PIPE)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "It is a pipe trying to write %u bytes\n", n);
-    if (! WriteFile (h->h, buffer, n, &bytes_written, h->oOverlapWrite))
-    {
-      if (GetLastError () != ERROR_IO_PENDING)
-      {
-        SetErrnoFromWinError (GetLastError ());
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Error writing to pipe: %u\n",
-             GetLastError ());
-        return GNUNET_SYSERR;
-      }
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
-      if (! GetOverlappedResult (h->h, h->oOverlapWrite, &bytes_written, TRUE))
-      {
-        SetErrnoFromWinError (GetLastError ());
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Error getting overlapped result while writing to pipe: %u\n",
-             GetLastError ());
-        return GNUNET_SYSERR;
-      }
-    }
-    else
     {
-      DWORD ovr;
-      if (! GetOverlappedResult (h->h, h->oOverlapWrite, &ovr, TRUE))
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Error getting control overlapped result while writing to pipe: %u\n",
-             GetLastError ());
-      }
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "It is a pipe trying to write %u bytes\n", n);
+      if (!WriteFile(h->h, buffer, n, &bytes_written, h->oOverlapWrite))
+        {
+          if (GetLastError() != ERROR_IO_PENDING)
+            {
+              SetErrnoFromWinError(GetLastError());
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Error writing to pipe: %u\n",
+                  GetLastError());
+              return GNUNET_SYSERR;
+            }
+          LOG(GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
+          if (!GetOverlappedResult(h->h, h->oOverlapWrite, &bytes_written, TRUE))
+            {
+              SetErrnoFromWinError(GetLastError());
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Error getting overlapped result while writing to pipe: %u\n",
+                  GetLastError());
+              return GNUNET_SYSERR;
+            }
+        }
       else
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Wrote %u bytes (ovr says %u), picking the greatest\n",
-             bytes_written,
-             ovr);
-      }
+        {
+          DWORD ovr;
+          if (!GetOverlappedResult(h->h, h->oOverlapWrite, &ovr, TRUE))
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Error getting control overlapped result while writing to pipe: %u\n",
+                  GetLastError());
+            }
+          else
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Wrote %u bytes (ovr says %u), picking the greatest\n",
+                  bytes_written,
+                  ovr);
+            }
+        }
+      if (bytes_written == 0)
+        {
+          if (n > 0)
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Wrote %u bytes, returning -1 with EAGAIN\n",
+                  bytes_written);
+              errno = EAGAIN;
+              return GNUNET_SYSERR;
+            }
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytes_written);
     }
-    if (bytes_written == 0)
+  else
     {
-      if (n > 0)
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Wrote %u bytes, returning -1 with EAGAIN\n",
-             bytes_written);
-        errno = EAGAIN;
-        return GNUNET_SYSERR;
-      }
+      bytes_written = 0;
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytes_written);
-  }
-  else
-  {
-    bytes_written = 0;
-  }
   return bytes_written;
 #else
-  return write (h->fd, buffer, n);
+  return write(h->fd, buffer, n);
 #endif
 }
 
@@ -1135,54 +1134,54 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h,
-                                 const void *buffer,
-                                 size_t n)
+GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h,
+                                const void *buffer,
+                                size_t n)
 {
   if (NULL == h)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   DWORD bytes_written;
   /* We do a non-overlapped write, which is as blocking as it gets */
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Writing %u bytes\n", n);
-  if (! WriteFile (h->h, buffer, n, &bytes_written, NULL))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Error writing to pipe: %u\n",
-         GetLastError ());
-    return GNUNET_SYSERR;
-  }
-  if (bytes_written == 0 && n > 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Waiting for pipe to clean\n");
-    WaitForSingleObject (h->h, INFINITE);
-    if (! WriteFile (h->h, buffer, n, &bytes_written, NULL))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Error writing to pipe: %u\n",
-           GetLastError ());
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Writing %u bytes\n", n);
+  if (!WriteFile(h->h, buffer, n, &bytes_written, NULL))
+    {
+      SetErrnoFromWinError(GetLastError());
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Error writing to pipe: %u\n",
+          GetLastError());
       return GNUNET_SYSERR;
     }
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytes_written);
+  if (bytes_written == 0 && n > 0)
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Waiting for pipe to clean\n");
+      WaitForSingleObject(h->h, INFINITE);
+      if (!WriteFile(h->h, buffer, n, &bytes_written, NULL))
+        {
+          SetErrnoFromWinError(GetLastError());
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Error writing to pipe: %u\n",
+              GetLastError());
+          return GNUNET_SYSERR;
+        }
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytes_written);
   return bytes_written;
 #else
   int flags;
   ssize_t ret;
 
   /* set to blocking, write, then set back */
-  flags = fcntl (h->fd, F_GETFL);
+  flags = fcntl(h->fd, F_GETFL);
   if (0 != (flags & O_NONBLOCK))
-    (void) fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
-  ret = write (h->fd, buffer, n);
+    (void)fcntl(h->fd, F_SETFL, flags - O_NONBLOCK);
+  ret = write(h->fd, buffer, n);
   if (0 == (flags & O_NONBLOCK))
-    (void) fcntl (h->fd, F_SETFL, flags);
+    (void)fcntl(h->fd, F_SETFL, flags);
   return ret;
 #endif
 }
@@ -1199,23 +1198,23 @@ GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_fn_write (const char *fn,
-                      const void *buffer,
-                      size_t n,
-                      enum GNUNET_DISK_AccessPermissions mode)
+GNUNET_DISK_fn_write(const char *fn,
+                     const void *buffer,
+                     size_t n,
+                     enum GNUNET_DISK_AccessPermissions mode)
 {
   struct GNUNET_DISK_FileHandle *fh;
   ssize_t ret;
 
   fh =
-    GNUNET_DISK_file_open (fn,
-                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE |
-                             GNUNET_DISK_OPEN_CREATE,
-                           mode);
-  if (! fh)
+    GNUNET_DISK_file_open(fn,
+                          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE |
+                          GNUNET_DISK_OPEN_CREATE,
+                          mode);
+  if (!fh)
     return GNUNET_SYSERR;
-  ret = GNUNET_DISK_file_write (fh, buffer, n);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  ret = GNUNET_DISK_file_write(fh, buffer, n);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
   return ret;
 }
 
@@ -1231,9 +1230,9 @@ GNUNET_DISK_fn_write (const char *fn,
  *         ieration aborted by callback returning #GNUNET_SYSERR
  */
 int
-GNUNET_DISK_directory_scan (const char *dir_name,
-                            GNUNET_FileNameCallback callback,
-                            void *callback_cls)
+GNUNET_DISK_directory_scan(const char *dir_name,
+                           GNUNET_FileNameCallback callback,
+                           void *callback_cls)
 {
   DIR *dinfo;
   struct dirent *finfo;
@@ -1245,80 +1244,80 @@ GNUNET_DISK_directory_scan (const char *dir_name,
   unsigned int name_len;
   unsigned int n_size;
 
-  GNUNET_assert (NULL != dir_name);
-  dname = GNUNET_STRINGS_filename_expand (dir_name);
+  GNUNET_assert(NULL != dir_name);
+  dname = GNUNET_STRINGS_filename_expand(dir_name);
   if (NULL == dname)
     return GNUNET_SYSERR;
-  while ((strlen (dname) > 0) && (dname[strlen (dname) - 1] == DIR_SEPARATOR))
-    dname[strlen (dname) - 1] = '\0';
-  if (0 != stat (dname, &istat))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", dname);
-    GNUNET_free (dname);
-    return GNUNET_SYSERR;
-  }
-  if (! S_ISDIR (istat.st_mode))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Expected `%s' to be a directory!\n"),
-         dir_name);
-    GNUNET_free (dname);
-    return GNUNET_SYSERR;
-  }
+  while ((strlen(dname) > 0) && (dname[strlen(dname) - 1] == DIR_SEPARATOR))
+    dname[strlen(dname) - 1] = '\0';
+  if (0 != stat(dname, &istat))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", dname);
+      GNUNET_free(dname);
+      return GNUNET_SYSERR;
+    }
+  if (!S_ISDIR(istat.st_mode))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Expected `%s' to be a directory!\n"),
+          dir_name);
+      GNUNET_free(dname);
+      return GNUNET_SYSERR;
+    }
   errno = 0;
-  dinfo = opendir (dname);
+  dinfo = opendir(dname);
   if ((EACCES == errno) || (NULL == dinfo))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
-    if (NULL != dinfo)
-      closedir (dinfo);
-    GNUNET_free (dname);
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
+      if (NULL != dinfo)
+        closedir(dinfo);
+      GNUNET_free(dname);
+      return GNUNET_SYSERR;
+    }
   name_len = 256;
-  n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
-  name = GNUNET_malloc (n_size);
-  while (NULL != (finfo = readdir (dinfo)))
-  {
-    if ((0 == strcmp (finfo->d_name, ".")) ||
-        (0 == strcmp (finfo->d_name, "..")))
-      continue;
-    if (NULL != callback)
+  n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
+  name = GNUNET_malloc(n_size);
+  while (NULL != (finfo = readdir(dinfo)))
     {
-      if (name_len < strlen (finfo->d_name))
-      {
-        GNUNET_free (name);
-        name_len = strlen (finfo->d_name);
-        n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
-        name = GNUNET_malloc (n_size);
-      }
-      /* dname can end in "/" only if dname == "/";
-       * if dname does not end in "/", we need to add
-       * a "/" (otherwise, we must not!) */
-      GNUNET_snprintf (name,
-                       n_size,
-                       "%s%s%s",
-                       dname,
-                       (0 == strcmp (dname, DIR_SEPARATOR_STR))
-                         ? ""
-                         : DIR_SEPARATOR_STR,
-                       finfo->d_name);
-      ret = callback (callback_cls, name);
-      if (GNUNET_OK != ret)
-      {
-        closedir (dinfo);
-        GNUNET_free (name);
-        GNUNET_free (dname);
-        if (GNUNET_NO == ret)
-          return count;
-        return GNUNET_SYSERR;
-      }
+      if ((0 == strcmp(finfo->d_name, ".")) ||
+          (0 == strcmp(finfo->d_name, "..")))
+        continue;
+      if (NULL != callback)
+        {
+          if (name_len < strlen(finfo->d_name))
+            {
+              GNUNET_free(name);
+              name_len = strlen(finfo->d_name);
+              n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
+              name = GNUNET_malloc(n_size);
+            }
+          /* dname can end in "/" only if dname == "/";
+           * if dname does not end in "/", we need to add
+           * a "/" (otherwise, we must not!) */
+          GNUNET_snprintf(name,
+                          n_size,
+                          "%s%s%s",
+                          dname,
+                          (0 == strcmp(dname, DIR_SEPARATOR_STR))
+                          ? ""
+                          : DIR_SEPARATOR_STR,
+                          finfo->d_name);
+          ret = callback(callback_cls, name);
+          if (GNUNET_OK != ret)
+            {
+              closedir(dinfo);
+              GNUNET_free(name);
+              GNUNET_free(dname);
+              if (GNUNET_NO == ret)
+                return count;
+              return GNUNET_SYSERR;
+            }
+        }
+      count++;
     }
-    count++;
-  }
-  closedir (dinfo);
-  GNUNET_free (name);
-  GNUNET_free (dname);
+  closedir(dinfo);
+  GNUNET_free(name);
+  GNUNET_free(dname);
   return count;
 }
 
@@ -1332,10 +1331,10 @@ GNUNET_DISK_directory_scan (const char *dir_name,
  * @return #GNUNET_OK
  */
 static int
-remove_helper (void *unused, const char *fn)
+remove_helper(void *unused, const char *fn)
 {
-  (void) unused;
-  (void) GNUNET_DISK_directory_remove (fn);
+  (void)unused;
+  (void)GNUNET_DISK_directory_remove(fn);
   return GNUNET_OK;
 }
 
@@ -1348,37 +1347,37 @@ remove_helper (void *unused, const char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_directory_remove (const char *filename)
+GNUNET_DISK_directory_remove(const char *filename)
 {
   struct stat istat;
 
   if (NULL == filename)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  if (0 != lstat (filename, &istat))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  if (0 != lstat(filename, &istat))
     return GNUNET_NO; /* file may not exist... */
-  (void) chmod (filename, S_IWUSR | S_IRUSR | S_IXUSR);
-  if (0 == unlink (filename))
+  (void)chmod(filename, S_IWUSR | S_IRUSR | S_IXUSR);
+  if (0 == unlink(filename))
     return GNUNET_OK;
   if ((errno != EISDIR) &&
       /* EISDIR is not sufficient in all cases, e.g.
-        * sticky /tmp directory may result in EPERM on BSD.
-        * So we also explicitly check "isDirectory" */
-      (GNUNET_YES != GNUNET_DISK_directory_test (filename, GNUNET_YES)))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
-    return GNUNET_SYSERR;
-  }
+      * sticky /tmp directory may result in EPERM on BSD.
+      * So we also explicitly check "isDirectory" */
+      (GNUNET_YES != GNUNET_DISK_directory_test(filename, GNUNET_YES)))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_directory_scan (filename, &remove_helper, NULL))
+      GNUNET_DISK_directory_scan(filename, &remove_helper, NULL))
     return GNUNET_SYSERR;
-  if (0 != rmdir (filename))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
-    return GNUNET_SYSERR;
-  }
+  if (0 != rmdir(filename))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -1391,7 +1390,7 @@ GNUNET_DISK_directory_remove (const char *filename)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_copy (const char *src, const char *dst)
+GNUNET_DISK_file_copy(const char *src, const char *dst)
 {
   char *buf;
   uint64_t pos;
@@ -1401,55 +1400,55 @@ GNUNET_DISK_file_copy (const char *src, const char *dst)
   struct GNUNET_DISK_FileHandle *in;
   struct GNUNET_DISK_FileHandle *out;
 
-  if (GNUNET_OK != GNUNET_DISK_file_size (src, &size, GNUNET_YES, GNUNET_YES))
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "stat", src);
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_OK != GNUNET_DISK_file_size(src, &size, GNUNET_YES, GNUNET_YES))
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "stat", src);
+      return GNUNET_SYSERR;
+    }
   pos = 0;
   in =
-    GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
-  if (! in)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", src);
-    return GNUNET_SYSERR;
-  }
+    GNUNET_DISK_file_open(src, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  if (!in)
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", src);
+      return GNUNET_SYSERR;
+    }
   out =
-    GNUNET_DISK_file_open (dst,
-                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
-                             GNUNET_DISK_OPEN_FAILIFEXISTS,
-                           GNUNET_DISK_PERM_USER_READ |
-                             GNUNET_DISK_PERM_USER_WRITE |
-                             GNUNET_DISK_PERM_GROUP_READ |
-                             GNUNET_DISK_PERM_GROUP_WRITE);
-  if (! out)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", dst);
-    GNUNET_DISK_file_close (in);
-    return GNUNET_SYSERR;
-  }
-  buf = GNUNET_malloc (COPY_BLK_SIZE);
+    GNUNET_DISK_file_open(dst,
+                          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
+                          GNUNET_DISK_OPEN_FAILIFEXISTS,
+                          GNUNET_DISK_PERM_USER_READ |
+                          GNUNET_DISK_PERM_USER_WRITE |
+                          GNUNET_DISK_PERM_GROUP_READ |
+                          GNUNET_DISK_PERM_GROUP_WRITE);
+  if (!out)
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", dst);
+      GNUNET_DISK_file_close(in);
+      return GNUNET_SYSERR;
+    }
+  buf = GNUNET_malloc(COPY_BLK_SIZE);
   while (pos < size)
-  {
-    len = COPY_BLK_SIZE;
-    if (len > size - pos)
-      len = size - pos;
-    sret = GNUNET_DISK_file_read (in, buf, len);
-    if ((sret < 0) || (len != (size_t) sret))
-      goto FAIL;
-    sret = GNUNET_DISK_file_write (out, buf, len);
-    if ((sret < 0) || (len != (size_t) sret))
-      goto FAIL;
-    pos += len;
-  }
-  GNUNET_free (buf);
-  GNUNET_DISK_file_close (in);
-  GNUNET_DISK_file_close (out);
+    {
+      len = COPY_BLK_SIZE;
+      if (len > size - pos)
+        len = size - pos;
+      sret = GNUNET_DISK_file_read(in, buf, len);
+      if ((sret < 0) || (len != (size_t)sret))
+        goto FAIL;
+      sret = GNUNET_DISK_file_write(out, buf, len);
+      if ((sret < 0) || (len != (size_t)sret))
+        goto FAIL;
+      pos += len;
+    }
+  GNUNET_free(buf);
+  GNUNET_DISK_file_close(in);
+  GNUNET_DISK_file_close(out);
   return GNUNET_OK;
 FAIL:
-  GNUNET_free (buf);
-  GNUNET_DISK_file_close (in);
-  GNUNET_DISK_file_close (out);
+  GNUNET_free(buf);
+  GNUNET_DISK_file_close(in);
+  GNUNET_DISK_file_close(out);
   return GNUNET_SYSERR;
 }
 
@@ -1459,21 +1458,21 @@ FAIL:
  * @param fn the filename to canonicalize
  */
 void
-GNUNET_DISK_filename_canonicalize (char *fn)
+GNUNET_DISK_filename_canonicalize(char *fn)
 {
   char *idx;
   char c;
 
   for (idx = fn; *idx; idx++)
-  {
-    c = *idx;
-
-    if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' ||
-        c == '<' || c == '>' || c == '|')
     {
-      *idx = '_';
+      c = *idx;
+
+      if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' ||
+          c == '<' || c == '>' || c == '|')
+        {
+          *idx = '_';
+        }
     }
-  }
 }
 
 
@@ -1485,25 +1484,25 @@ GNUNET_DISK_filename_canonicalize (char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_DISK_file_change_owner (const char *filename, const char *user)
+GNUNET_DISK_file_change_owner(const char *filename, const char *user)
 {
 #ifndef MINGW
   struct passwd *pws;
 
-  pws = getpwnam (user);
+  pws = getpwnam(user);
   if (NULL == pws)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Cannot obtain information about user `%s': %s\n"),
-         user,
-         strerror (errno));
-    return GNUNET_SYSERR;
-  }
-  if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "chown", filename);
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Cannot obtain information about user `%s': %s\n"),
+          user,
+          strerror(errno));
+      return GNUNET_SYSERR;
+    }
+  if (0 != chown(filename, pws->pw_uid, pws->pw_gid))
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "chown", filename);
+      return GNUNET_SYSERR;
+    }
 #endif
   return GNUNET_OK;
 }
@@ -1519,51 +1518,51 @@ GNUNET_DISK_file_change_owner (const char *filename, const char *user)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh,
-                       off_t lock_start,
-                       off_t lock_end,
-                       int excl)
+GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh,
+                      off_t lock_start,
+                      off_t lock_end,
+                      int excl)
 {
   if (fh == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifndef MINGW
   struct flock fl;
 
-  memset (&fl, 0, sizeof (struct flock));
+  memset(&fl, 0, sizeof(struct flock));
   fl.l_type = excl ? F_WRLCK : F_RDLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = lock_start;
   fl.l_len = lock_end;
 
-  return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
 #else
   OVERLAPPED o;
   off_t diff = lock_end - lock_start;
   DWORD diff_low, diff_high;
-  diff_low = (DWORD) (diff & 0xFFFFFFFF);
-  diff_high = (DWORD) ((diff >> (sizeof (DWORD) * 8)) & 0xFFFFFFFF);
+  diff_low = (DWORD)(diff & 0xFFFFFFFF);
+  diff_high = (DWORD)((diff >> (sizeof(DWORD) * 8)) & 0xFFFFFFFF);
 
-  memset (&o, 0, sizeof (OVERLAPPED));
-  o.Offset = (DWORD) (lock_start & 0xFFFFFFFF);
+  memset(&o, 0, sizeof(OVERLAPPED));
+  o.Offset = (DWORD)(lock_start & 0xFFFFFFFF);
   ;
   o.OffsetHigh =
-    (DWORD) (((lock_start & ~0xFFFFFFFF) >> (sizeof (DWORD) * 8)) & 0xFFFFFFFF);
-
-  if (! LockFileEx (fh->h,
-                    (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0) |
-                      LOCKFILE_FAIL_IMMEDIATELY,
-                    0,
-                    diff_low,
-                    diff_high,
-                    &o))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
+    (DWORD)(((lock_start & ~0xFFFFFFFF) >> (sizeof(DWORD) * 8)) & 0xFFFFFFFF);
+
+  if (!LockFileEx(fh->h,
+                  (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0) |
+                  LOCKFILE_FAIL_IMMEDIATELY,
+                  0,
+                  diff_low,
+                  diff_high,
+                  &o))
+    {
+      SetErrnoFromWinError(GetLastError());
+      return GNUNET_SYSERR;
+    }
 
   return GNUNET_OK;
 #endif
@@ -1579,44 +1578,44 @@ GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh,
-                         off_t unlock_start,
-                         off_t unlock_end)
+GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh,
+                        off_t unlock_start,
+                        off_t unlock_end)
 {
   if (fh == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifndef MINGW
   struct flock fl;
 
-  memset (&fl, 0, sizeof (struct flock));
+  memset(&fl, 0, sizeof(struct flock));
   fl.l_type = F_UNLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = unlock_start;
   fl.l_len = unlock_end;
 
-  return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
 #else
   OVERLAPPED o;
   off_t diff = unlock_end - unlock_start;
   DWORD diff_low, diff_high;
-  diff_low = (DWORD) (diff & 0xFFFFFFFF);
-  diff_high = (DWORD) ((diff >> (sizeof (DWORD) * 8)) & 0xFFFFFFFF);
+  diff_low = (DWORD)(diff & 0xFFFFFFFF);
+  diff_high = (DWORD)((diff >> (sizeof(DWORD) * 8)) & 0xFFFFFFFF);
 
-  memset (&o, 0, sizeof (OVERLAPPED));
-  o.Offset = (DWORD) (unlock_start & 0xFFFFFFFF);
+  memset(&o, 0, sizeof(OVERLAPPED));
+  o.Offset = (DWORD)(unlock_start & 0xFFFFFFFF);
   ;
-  o.OffsetHigh = (DWORD) (
-    ((unlock_start & ~0xFFFFFFFF) >> (sizeof (DWORD) * 8)) & 0xFFFFFFFF);
+  o.OffsetHigh = (DWORD)(
+    ((unlock_start & ~0xFFFFFFFF) >> (sizeof(DWORD) * 8)) & 0xFFFFFFFF);
 
-  if (! UnlockFileEx (fh->h, 0, diff_low, diff_high, &o))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
+  if (!UnlockFileEx(fh->h, 0, diff_low, diff_high, &o))
+    {
+      SetErrnoFromWinError(GetLastError());
+      return GNUNET_SYSERR;
+    }
 
   return GNUNET_OK;
 #endif
@@ -1636,9 +1635,9 @@ GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh,
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_file_open (const char *fn,
-                       enum GNUNET_DISK_OpenFlags flags,
-                       enum GNUNET_DISK_AccessPermissions perm)
+GNUNET_DISK_file_open(const char *fn,
+                      enum GNUNET_DISK_OpenFlags flags,
+                      enum GNUNET_DISK_AccessPermissions perm)
 {
   char *expfn;
   struct GNUNET_DISK_FileHandle *ret;
@@ -1654,7 +1653,7 @@ GNUNET_DISK_file_open (const char *fn,
   int fd;
 #endif
 
-  expfn = GNUNET_STRINGS_filename_expand (fn);
+  expfn = GNUNET_STRINGS_filename_expand(fn);
   if (NULL == expfn)
     return NULL;
 #ifndef MINGW
@@ -1666,43 +1665,43 @@ GNUNET_DISK_file_open (const char *fn,
   else if (flags & GNUNET_DISK_OPEN_WRITE)
     oflags = O_WRONLY;
   else
-  {
-    GNUNET_break (0);
-    GNUNET_free (expfn);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      GNUNET_free(expfn);
+      return NULL;
+    }
   if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
     oflags |= (O_CREAT | O_EXCL);
   if (flags & GNUNET_DISK_OPEN_TRUNCATE)
     oflags |= O_TRUNC;
   if (flags & GNUNET_DISK_OPEN_APPEND)
     oflags |= O_APPEND;
-  if (GNUNET_NO == GNUNET_DISK_file_test (fn))
-  {
-    if (flags & GNUNET_DISK_OPEN_CREATE)
+  if (GNUNET_NO == GNUNET_DISK_file_test(fn))
     {
-      (void) GNUNET_DISK_directory_create_for_file (expfn);
-      oflags |= O_CREAT;
-      mode = translate_unix_perms (perm);
+      if (flags & GNUNET_DISK_OPEN_CREATE)
+        {
+          (void)GNUNET_DISK_directory_create_for_file(expfn);
+          oflags |= O_CREAT;
+          mode = translate_unix_perms(perm);
+        }
     }
-  }
 
-  fd = open (expfn,
-             oflags
+  fd = open(expfn,
+            oflags
 #if O_CLOEXEC
-               | O_CLOEXEC
+            | O_CLOEXEC
 #endif
-               | O_LARGEFILE,
-             mode);
+            | O_LARGEFILE,
+            mode);
   if (fd == -1)
-  {
-    if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
-    else
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
-    GNUNET_free (expfn);
-    return NULL;
-  }
+    {
+      if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+      else
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
+      GNUNET_free(expfn);
+      return NULL;
+    }
 #else
   access = 0;
   disp = OPEN_ALWAYS;
@@ -1715,66 +1714,66 @@ GNUNET_DISK_file_open (const char *fn,
     access = FILE_WRITE_DATA;
 
   if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
-  {
-    disp = CREATE_NEW;
-  }
+    {
+      disp = CREATE_NEW;
+    }
   else if (flags & GNUNET_DISK_OPEN_CREATE)
-  {
-    (void) GNUNET_DISK_directory_create_for_file (expfn);
-    if (flags & GNUNET_DISK_OPEN_TRUNCATE)
-      disp = CREATE_ALWAYS;
-    else
-      disp = OPEN_ALWAYS;
-  }
+    {
+      (void)GNUNET_DISK_directory_create_for_file(expfn);
+      if (flags & GNUNET_DISK_OPEN_TRUNCATE)
+        disp = CREATE_ALWAYS;
+      else
+        disp = OPEN_ALWAYS;
+    }
   else if (flags & GNUNET_DISK_OPEN_TRUNCATE)
-  {
-    disp = TRUNCATE_EXISTING;
-  }
+    {
+      disp = TRUNCATE_EXISTING;
+    }
   else
-  {
-    disp = OPEN_EXISTING;
-  }
+    {
+      disp = OPEN_EXISTING;
+    }
 
-  if (ERROR_SUCCESS == plibc_conv_to_win_pathwconv (expfn, wexpfn))
-    h = CreateFileW (wexpfn,
-                     access,
-                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
-                     NULL,
-                     disp,
-                     FILE_ATTRIBUTE_NORMAL,
-                     NULL);
+  if (ERROR_SUCCESS == plibc_conv_to_win_pathwconv(expfn, wexpfn))
+    h = CreateFileW(wexpfn,
+                    access,
+                    FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                    NULL,
+                    disp,
+                    FILE_ATTRIBUTE_NORMAL,
+                    NULL);
   else
     h = INVALID_HANDLE_VALUE;
   if (h == INVALID_HANDLE_VALUE)
-  {
-    int err;
-    SetErrnoFromWinError (GetLastError ());
-    err = errno;
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_INFO, "open", expfn);
-    GNUNET_free (expfn);
-    errno = err;
-    return NULL;
-  }
-
-  if (flags & GNUNET_DISK_OPEN_APPEND)
-    if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
     {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer", expfn);
-      CloseHandle (h);
-      GNUNET_free (expfn);
+      int err;
+      SetErrnoFromWinError(GetLastError());
+      err = errno;
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_INFO, "open", expfn);
+      GNUNET_free(expfn);
+      errno = err;
       return NULL;
     }
+
+  if (flags & GNUNET_DISK_OPEN_APPEND)
+    if (SetFilePointer(h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
+      {
+        SetErrnoFromWinError(GetLastError());
+        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "SetFilePointer", expfn);
+        CloseHandle(h);
+        GNUNET_free(expfn);
+        return NULL;
+      }
 #endif
 
-  ret = GNUNET_new (struct GNUNET_DISK_FileHandle);
+  ret = GNUNET_new(struct GNUNET_DISK_FileHandle);
 #ifdef MINGW
   ret->h = h;
   ret->type = GNUNET_DISK_HANLDE_TYPE_FILE;
 #else
   ret->fd = fd;
 #endif
-  GNUNET_free (expfn);
+  GNUNET_free(expfn);
   return ret;
 }
 
@@ -1786,52 +1785,53 @@ GNUNET_DISK_file_open (const char *fn,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
 {
   int ret;
+
   if (h == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
   ret = GNUNET_OK;
 
 #if MINGW
-  if (! CloseHandle (h->h))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "close");
-    ret = GNUNET_SYSERR;
-  }
-  if (h->oOverlapRead)
-  {
-    if (! CloseHandle (h->oOverlapRead->hEvent))
+  if (!CloseHandle(h->h))
     {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "close");
+      SetErrnoFromWinError(GetLastError());
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "close");
       ret = GNUNET_SYSERR;
     }
-    GNUNET_free (h->oOverlapRead);
-  }
+  if (h->oOverlapRead)
+    {
+      if (!CloseHandle(h->oOverlapRead->hEvent))
+        {
+          SetErrnoFromWinError(GetLastError());
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "close");
+          ret = GNUNET_SYSERR;
+        }
+      GNUNET_free(h->oOverlapRead);
+    }
   if (h->oOverlapWrite)
-  {
-    if (! CloseHandle (h->oOverlapWrite->hEvent))
     {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "close");
-      ret = GNUNET_SYSERR;
+      if (!CloseHandle(h->oOverlapWrite->hEvent))
+        {
+          SetErrnoFromWinError(GetLastError());
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "close");
+          ret = GNUNET_SYSERR;
+        }
+      GNUNET_free(h->oOverlapWrite);
     }
-    GNUNET_free (h->oOverlapWrite);
-  }
 #else
-  if (close (h->fd) != 0)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "close");
-    ret = GNUNET_SYSERR;
-  }
+  if (close(h->fd) != 0)
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "close");
+      ret = GNUNET_SYSERR;
+    }
 #endif
-  GNUNET_free (h);
+  GNUNET_free(h);
   return ret;
 }
 
@@ -1844,56 +1844,59 @@ GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
  * @return GNUnet file handle corresponding to the W32 handle
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_get_handle_from_w32_handle (HANDLE osfh)
+GNUNET_DISK_get_handle_from_w32_handle(HANDLE osfh)
 {
   struct GNUNET_DISK_FileHandle *fh;
   DWORD dwret;
   enum GNUNET_FILE_Type ftype;
 
-  dwret = GetFileType (osfh);
+  dwret = GetFileType(osfh);
   switch (dwret)
-  {
-  case FILE_TYPE_DISK:
-    ftype = GNUNET_DISK_HANLDE_TYPE_FILE;
-    break;
-  case FILE_TYPE_PIPE:
-    ftype = GNUNET_DISK_HANLDE_TYPE_PIPE;
-    break;
-  case FILE_TYPE_UNKNOWN:
-    if ((GetLastError () == NO_ERROR) ||
-        (GetLastError () == ERROR_INVALID_HANDLE))
-    {
-      if (0 != ResetEvent (osfh))
-        ftype = GNUNET_DISK_HANLDE_TYPE_EVENT;
+    {
+    case FILE_TYPE_DISK:
+      ftype = GNUNET_DISK_HANLDE_TYPE_FILE;
+      break;
+
+    case FILE_TYPE_PIPE:
+      ftype = GNUNET_DISK_HANLDE_TYPE_PIPE;
+      break;
+
+    case FILE_TYPE_UNKNOWN:
+      if ((GetLastError() == NO_ERROR) ||
+          (GetLastError() == ERROR_INVALID_HANDLE))
+        {
+          if (0 != ResetEvent(osfh))
+            ftype = GNUNET_DISK_HANLDE_TYPE_EVENT;
+          else
+            return NULL;
+        }
       else
         return NULL;
-    }
-    else
+      break;
+
+    default:
       return NULL;
-    break;
-  default:
-    return NULL;
-  }
+    }
 
-  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
+  fh = GNUNET_new(struct GNUNET_DISK_FileHandle);
 
   fh->h = osfh;
   fh->type = ftype;
   if (ftype == GNUNET_DISK_HANLDE_TYPE_PIPE)
-  {
-    /**
-     * Note that we can't make it overlapped if it isn't already.
-     * (ReOpenFile() is only available in 2003/Vista).
-     * The process that opened this file in the first place (usually a parent
-     * process, if this is stdin/stdout/stderr) must make it overlapped,
-     * otherwise we're screwed, as selecting on non-overlapped handle
-     * will block.
-     */
-    fh->oOverlapRead = GNUNET_new (OVERLAPPED);
-    fh->oOverlapWrite = GNUNET_new (OVERLAPPED);
-    fh->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-    fh->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-  }
+    {
+      /**
+       * Note that we can't make it overlapped if it isn't already.
+       * (ReOpenFile() is only available in 2003/Vista).
+       * The process that opened this file in the first place (usually a parent
+       * process, if this is stdin/stdout/stderr) must make it overlapped,
+       * otherwise we're screwed, as selecting on non-overlapped handle
+       * will block.
+       */
+      fh->oOverlapRead = GNUNET_new(OVERLAPPED);
+      fh->oOverlapWrite = GNUNET_new(OVERLAPPED);
+      fh->oOverlapRead->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+      fh->oOverlapWrite->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    }
 
   return fh;
 }
@@ -1906,25 +1909,25 @@ GNUNET_DISK_get_handle_from_w32_handle (HANDLE osfh)
  * @return file handle corresponding to the descriptor, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_get_handle_from_int_fd (int fno)
+GNUNET_DISK_get_handle_from_int_fd(int fno)
 {
   struct GNUNET_DISK_FileHandle *fh;
 
-  if ((((off_t) -1) == lseek (fno, 0, SEEK_CUR)) && (EBADF == errno))
+  if ((((off_t)-1) == lseek(fno, 0, SEEK_CUR)) && (EBADF == errno))
     return NULL; /* invalid FD */
 
 #ifndef WINDOWS
-  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
+  fh = GNUNET_new(struct GNUNET_DISK_FileHandle);
 
   fh->fd = fno;
 #else
   intptr_t osfh;
 
-  osfh = _get_osfhandle (fno);
-  if (INVALID_HANDLE_VALUE == (HANDLE) osfh)
+  osfh = _get_osfhandle(fno);
+  if (INVALID_HANDLE_VALUE == (HANDLE)osfh)
     return NULL;
 
-  fh = GNUNET_DISK_get_handle_from_w32_handle ((HANDLE) osfh);
+  fh = GNUNET_DISK_get_handle_from_w32_handle((HANDLE)osfh);
 #endif
 
   return fh;
@@ -1938,23 +1941,22 @@ GNUNET_DISK_get_handle_from_int_fd (int fno)
  * @return file handle corresponding to the descriptor
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_get_handle_from_native (FILE *fd)
+GNUNET_DISK_get_handle_from_native(FILE *fd)
 {
   int fno;
 
-  fno = fileno (fd);
+  fno = fileno(fd);
   if (-1 == fno)
     return NULL;
 
-  return GNUNET_DISK_get_handle_from_int_fd (fno);
+  return GNUNET_DISK_get_handle_from_int_fd(fno);
 }
 
 
 /**
  * Handle for a memory-mapping operation.
  */
-struct GNUNET_DISK_MapHandle
-{
+struct GNUNET_DISK_MapHandle {
   /**
    * Address where the map is in memory.
    */
@@ -1975,7 +1977,7 @@ struct GNUNET_DISK_MapHandle
 
 
 #ifndef MAP_FAILED
-#define MAP_FAILED ((void *) -1)
+#define MAP_FAILED ((void *)-1)
 #endif
 
 /**
@@ -1988,58 +1990,58 @@ struct GNUNET_DISK_MapHandle
  * @return pointer to the mapped memory region, NULL on failure
  */
 void *
-GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
-                      struct GNUNET_DISK_MapHandle **m,
-                      enum GNUNET_DISK_MapType access,
-                      size_t len)
+GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h,
+                     struct GNUNET_DISK_MapHandle **m,
+                     enum GNUNET_DISK_MapType access,
+                     size_t len)
 {
   if (NULL == h)
-  {
-    errno = EINVAL;
-    return NULL;
-  }
+    {
+      errno = EINVAL;
+      return NULL;
+    }
 
 #ifdef MINGW
   DWORD mapAccess, protect;
 
   if ((access & GNUNET_DISK_MAP_TYPE_READ) &&
       (access & GNUNET_DISK_MAP_TYPE_WRITE))
-  {
-    protect = PAGE_READWRITE;
-    mapAccess = FILE_MAP_ALL_ACCESS;
-  }
+    {
+      protect = PAGE_READWRITE;
+      mapAccess = FILE_MAP_ALL_ACCESS;
+    }
   else if (access & GNUNET_DISK_MAP_TYPE_READ)
-  {
-    protect = PAGE_READONLY;
-    mapAccess = FILE_MAP_READ;
-  }
+    {
+      protect = PAGE_READONLY;
+      mapAccess = FILE_MAP_READ;
+    }
   else if (access & GNUNET_DISK_MAP_TYPE_WRITE)
-  {
-    protect = PAGE_READWRITE;
-    mapAccess = FILE_MAP_WRITE;
-  }
+    {
+      protect = PAGE_READWRITE;
+      mapAccess = FILE_MAP_WRITE;
+    }
   else
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
 
-  *m = GNUNET_new (struct GNUNET_DISK_MapHandle);
-  (*m)->h = CreateFileMapping (h->h, NULL, protect, 0, 0, NULL);
+  *m = GNUNET_new(struct GNUNET_DISK_MapHandle);
+  (*m)->h = CreateFileMapping(h->h, NULL, protect, 0, 0, NULL);
   if ((*m)->h == INVALID_HANDLE_VALUE)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    GNUNET_free (*m);
-    return NULL;
-  }
+    {
+      SetErrnoFromWinError(GetLastError());
+      GNUNET_free(*m);
+      return NULL;
+    }
 
-  (*m)->addr = MapViewOfFile ((*m)->h, mapAccess, 0, 0, len);
-  if (! (*m)->addr)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    CloseHandle ((*m)->h);
-    GNUNET_free (*m);
-  }
+  (*m)->addr = MapViewOfFile((*m)->h, mapAccess, 0, 0, len);
+  if (!(*m)->addr)
+    {
+      SetErrnoFromWinError(GetLastError());
+      CloseHandle((*m)->h);
+      GNUNET_free(*m);
+    }
 
   return (*m)->addr;
 #else
@@ -2050,14 +2052,14 @@ GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
     prot = PROT_READ;
   if (access & GNUNET_DISK_MAP_TYPE_WRITE)
     prot |= PROT_WRITE;
-  *m = GNUNET_new (struct GNUNET_DISK_MapHandle);
-  (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
-  GNUNET_assert (NULL != (*m)->addr);
+  *m = GNUNET_new(struct GNUNET_DISK_MapHandle);
+  (*m)->addr = mmap(NULL, len, prot, MAP_SHARED, h->fd, 0);
+  GNUNET_assert(NULL != (*m)->addr);
   if (MAP_FAILED == (*m)->addr)
-  {
-    GNUNET_free (*m);
-    return NULL;
-  }
+    {
+      GNUNET_free(*m);
+      return NULL;
+    }
   (*m)->len = len;
   return (*m)->addr;
 #endif
@@ -2069,29 +2071,29 @@ GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
+GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
 {
   int ret;
 
   if (h == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
-  ret = UnmapViewOfFile (h->addr) ? GNUNET_OK : GNUNET_SYSERR;
+  ret = UnmapViewOfFile(h->addr) ? GNUNET_OK : GNUNET_SYSERR;
   if (ret != GNUNET_OK)
-    SetErrnoFromWinError (GetLastError ());
-  if (! CloseHandle (h->h) && (ret == GNUNET_OK))
-  {
-    ret = GNUNET_SYSERR;
-    SetErrnoFromWinError (GetLastError ());
-  }
+    SetErrnoFromWinError(GetLastError());
+  if (!CloseHandle(h->h) && (ret == GNUNET_OK))
+    {
+      ret = GNUNET_SYSERR;
+      SetErrnoFromWinError(GetLastError());
+    }
 #else
-  ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
+  ret = munmap(h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
 #endif
-  GNUNET_free (h);
+  GNUNET_free(h);
   return ret;
 }
 
@@ -2102,25 +2104,25 @@ GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
 {
   if (h == NULL)
-  {
-    errno = EINVAL;
-    return GNUNET_SYSERR;
-  }
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
 #ifdef MINGW
   int ret;
 
-  ret = FlushFileBuffers (h->h) ? GNUNET_OK : GNUNET_SYSERR;
+  ret = FlushFileBuffers(h->h) ? GNUNET_OK : GNUNET_SYSERR;
   if (ret != GNUNET_OK)
-    SetErrnoFromWinError (GetLastError ());
+    SetErrnoFromWinError(GetLastError());
   return ret;
 #elif defined(FREEBSD) || defined(OPENBSD) || defined(DARWIN)
-  return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+  return fsync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
 #else
-  return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+  return fdatasync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
 #endif
 }
 
@@ -2131,7 +2133,7 @@ GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
 #endif
 /* Copyright Bob Byrnes  <byrnes <at> curl.com>
    http://permalink.gmane.org/gmane.os.cygwin.patches/2121
-*/
+ */
 /* Create a pipe, and return handles to the read and write ends,
    just like CreatePipe, but ensure that the write end permits
    FILE_READ_ATTRIBUTES access, on later versions of win32 where
@@ -2140,12 +2142,12 @@ GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
    Note that the return value is either NO_ERROR or GetLastError,
    unlike CreatePipe, which returns a bool for success or failure.  */
 static int
-create_selectable_pipe (PHANDLE read_pipe_ptr,
-                        PHANDLE write_pipe_ptr,
-                        LPSECURITY_ATTRIBUTES sa_ptr,
-                        DWORD psize,
-                        DWORD dwReadMode,
-                        DWORD dwWriteMode)
+create_selectable_pipe(PHANDLE read_pipe_ptr,
+                       PHANDLE write_pipe_ptr,
+                       LPSECURITY_ATTRIBUTES sa_ptr,
+                       DWORD psize,
+                       DWORD dwReadMode,
+                       DWORD dwWriteMode)
 {
   /* Default to error. */
   *read_pipe_ptr = *write_pipe_ptr = INVALID_HANDLE_VALUE;
@@ -2163,102 +2165,105 @@ create_selectable_pipe (PHANDLE read_pipe_ptr,
    * Retrying will probably never be necessary, but we want
    * to be as robust as possible.  */
   while (1)
-  {
-    static volatile LONG pipe_unique_id;
-
-    snprintf (pipename,
-              sizeof pipename,
-              "\\\\.\\pipe\\gnunet-%d-%ld",
-              getpid (),
-              InterlockedIncrement ((LONG *) &pipe_unique_id));
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "CreateNamedPipe: name = %s, size = %lu\n",
-         pipename,
-         psize);
-    /* Use CreateNamedPipe instead of CreatePipe, because the latter
-     * returns a write handle that does not permit FILE_READ_ATTRIBUTES
-     * access, on versions of win32 earlier than WinXP SP2.
-     * CreatePipe also stupidly creates a full duplex pipe, which is
-     * a waste, since only a single direction is actually used.
-     * It's important to only allow a single instance, to ensure that
-     * the pipe was not created earlier by some other process, even if
-     * the pid has been reused.  */
-    read_pipe = CreateNamedPipeA (pipename,
-                                  PIPE_ACCESS_INBOUND |
-                                    FILE_FLAG_FIRST_PIPE_INSTANCE | dwReadMode,
-                                  PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
-                                  1, /* max instances */
-                                  psize, /* output buffer size */
-                                  psize, /* input buffer size */
-                                  NMPWAIT_USE_DEFAULT_WAIT,
-                                  sa_ptr);
-
-    if (read_pipe != INVALID_HANDLE_VALUE)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "pipe read handle = %p\n", read_pipe);
-      break;
-    }
+    {
+      static volatile LONG pipe_unique_id;
+
+      snprintf(pipename,
+               sizeof pipename,
+               "\\\\.\\pipe\\gnunet-%d-%ld",
+               getpid(),
+               InterlockedIncrement((LONG *)&pipe_unique_id));
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "CreateNamedPipe: name = %s, size = %lu\n",
+          pipename,
+          psize);
+      /* Use CreateNamedPipe instead of CreatePipe, because the latter
+       * returns a write handle that does not permit FILE_READ_ATTRIBUTES
+       * access, on versions of win32 earlier than WinXP SP2.
+       * CreatePipe also stupidly creates a full duplex pipe, which is
+       * a waste, since only a single direction is actually used.
+       * It's important to only allow a single instance, to ensure that
+       * the pipe was not created earlier by some other process, even if
+       * the pid has been reused.  */
+      read_pipe = CreateNamedPipeA(pipename,
+                                   PIPE_ACCESS_INBOUND |
+                                   FILE_FLAG_FIRST_PIPE_INSTANCE | dwReadMode,
+                                   PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
+                                   1, /* max instances */
+                                   psize, /* output buffer size */
+                                   psize, /* input buffer size */
+                                   NMPWAIT_USE_DEFAULT_WAIT,
+                                   sa_ptr);
+
+      if (read_pipe != INVALID_HANDLE_VALUE)
+        {
+          LOG(GNUNET_ERROR_TYPE_DEBUG, "pipe read handle = %p\n", read_pipe);
+          break;
+        }
 
-    DWORD err = GetLastError ();
-
-    switch (err)
-    {
-    case ERROR_PIPE_BUSY:
-      /* The pipe is already open with compatible parameters.
-       * Pick a new name and retry.  */
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "pipe busy, retrying\n");
-      continue;
-    case ERROR_ACCESS_DENIED:
-      /* The pipe is already open with incompatible parameters.
-       * Pick a new name and retry.  */
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "pipe access denied, retrying\n");
-      continue;
-    case ERROR_CALL_NOT_IMPLEMENTED:
-      /* We are on an older Win9x platform without named pipes.
-       * Return an anonymous pipe as the best approximation.  */
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "CreateNamedPipe not implemented, resorting to "
-           "CreatePipe: size = %lu\n",
-           psize);
-      if (CreatePipe (read_pipe_ptr, write_pipe_ptr, sa_ptr, psize))
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "pipe read handle = %p, write handle = %p\n",
-             *read_pipe_ptr,
-             *write_pipe_ptr);
-        return GNUNET_OK;
-      }
-      err = GetLastError ();
-      LOG (GNUNET_ERROR_TYPE_ERROR, "CreatePipe failed: %d\n", err);
-      return err;
-    default:
-      LOG (GNUNET_ERROR_TYPE_ERROR, "CreateNamedPipe failed: %d\n", err);
-      return err;
+      DWORD err = GetLastError();
+
+      switch (err)
+        {
+        case ERROR_PIPE_BUSY:
+          /* The pipe is already open with compatible parameters.
+           * Pick a new name and retry.  */
+          LOG(GNUNET_ERROR_TYPE_DEBUG, "pipe busy, retrying\n");
+          continue;
+
+        case ERROR_ACCESS_DENIED:
+          /* The pipe is already open with incompatible parameters.
+           * Pick a new name and retry.  */
+          LOG(GNUNET_ERROR_TYPE_DEBUG, "pipe access denied, retrying\n");
+          continue;
+
+        case ERROR_CALL_NOT_IMPLEMENTED:
+          /* We are on an older Win9x platform without named pipes.
+          * Return an anonymous pipe as the best approximation.  */
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "CreateNamedPipe not implemented, resorting to "
+              "CreatePipe: size = %lu\n",
+              psize);
+          if (CreatePipe(read_pipe_ptr, write_pipe_ptr, sa_ptr, psize))
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "pipe read handle = %p, write handle = %p\n",
+                  *read_pipe_ptr,
+                  *write_pipe_ptr);
+              return GNUNET_OK;
+            }
+          err = GetLastError();
+          LOG(GNUNET_ERROR_TYPE_ERROR, "CreatePipe failed: %d\n", err);
+          return err;
+
+        default:
+          LOG(GNUNET_ERROR_TYPE_ERROR, "CreateNamedPipe failed: %d\n", err);
+          return err;
+        }
+      /* NOTREACHED */
     }
-    /* NOTREACHED */
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "CreateFile: name = %s\n", pipename);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "CreateFile: name = %s\n", pipename);
 
   /* Open the named pipe for writing.
    * Be sure to permit FILE_READ_ATTRIBUTES access.  */
-  write_pipe = CreateFileA (pipename,
-                            GENERIC_WRITE | FILE_READ_ATTRIBUTES,
-                            0, /* share mode */
-                            sa_ptr,
-                            OPEN_EXISTING,
-                            dwWriteMode, /* flags and attributes */
-                            0); /* handle to template file */
+  write_pipe = CreateFileA(pipename,
+                           GENERIC_WRITE | FILE_READ_ATTRIBUTES,
+                           0,  /* share mode */
+                           sa_ptr,
+                           OPEN_EXISTING,
+                           dwWriteMode,  /* flags and attributes */
+                           0);  /* handle to template file */
 
   if (write_pipe == INVALID_HANDLE_VALUE)
-  {
-    /* Failure. */
-    DWORD err = GetLastError ();
+    {
+      /* Failure. */
+      DWORD err = GetLastError();
 
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "CreateFile failed: %d\n", err);
-    CloseHandle (read_pipe);
-    return err;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "pipe write handle = %p\n", write_pipe);
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "CreateFile failed: %d\n", err);
+      CloseHandle(read_pipe);
+      return err;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "pipe write handle = %p\n", write_pipe);
   /* Success. */
   *read_pipe_ptr = read_pipe;
   *write_pipe_ptr = write_pipe;
@@ -2277,36 +2282,36 @@ create_selectable_pipe (PHANDLE read_pipe_ptr,
  * @return handle to the new pipe, NULL on error
  */
 struct GNUNET_DISK_PipeHandle *
-GNUNET_DISK_pipe (int blocking_read,
-                  int blocking_write,
-                  int inherit_read,
-                  int inherit_write)
+GNUNET_DISK_pipe(int blocking_read,
+                 int blocking_write,
+                 int inherit_read,
+                 int inherit_write)
 {
 #ifndef MINGW
   int fd[2];
   int ret;
   int eno;
 
-  (void) inherit_read;
-  (void) inherit_write;
-  ret = pipe (fd);
+  (void)inherit_read;
+  (void)inherit_write;
+  ret = pipe(fd);
   if (ret == -1)
-  {
-    eno = errno;
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe");
-    errno = eno;
-    return NULL;
-  }
-  return GNUNET_DISK_pipe_from_fd (blocking_read, blocking_write, fd);
+    {
+      eno = errno;
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "pipe");
+      errno = eno;
+      return NULL;
+    }
+  return GNUNET_DISK_pipe_from_fd(blocking_read, blocking_write, fd);
 #else
   struct GNUNET_DISK_PipeHandle *p;
   BOOL ret;
   HANDLE tmp_handle;
   int save_errno;
 
-  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
-  p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
-  p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
+  p = GNUNET_new(struct GNUNET_DISK_PipeHandle);
+  p->fd[0] = GNUNET_new(struct GNUNET_DISK_FileHandle);
+  p->fd[1] = GNUNET_new(struct GNUNET_DISK_FileHandle);
 
   /* All pipes are overlapped. If you want them to block - just
    * call WriteFile() and ReadFile() with NULL overlapped pointer.
@@ -2317,77 +2322,77 @@ GNUNET_DISK_pipe (int blocking_read,
    * Pipes are not seekable, and need no offsets, which is
    * probably why it works for them.
    */
-  ret = create_selectable_pipe (&p->fd[0]->h,
-                                &p->fd[1]->h,
-                                NULL,
-                                0,
-                                FILE_FLAG_OVERLAPPED,
-                                FILE_FLAG_OVERLAPPED);
-  if (! ret)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    save_errno = errno;
-    GNUNET_free (p->fd[0]);
-    GNUNET_free (p->fd[1]);
-    GNUNET_free (p);
-    errno = save_errno;
-    return NULL;
-  }
-  if (! DuplicateHandle (GetCurrentProcess (),
-                         p->fd[0]->h,
-                         GetCurrentProcess (),
-                         &tmp_handle,
-                         0,
-                         inherit_read == GNUNET_YES ? TRUE : FALSE,
-                         DUPLICATE_SAME_ACCESS))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    save_errno = errno;
-    CloseHandle (p->fd[0]->h);
-    CloseHandle (p->fd[1]->h);
-    GNUNET_free (p->fd[0]);
-    GNUNET_free (p->fd[1]);
-    GNUNET_free (p);
-    errno = save_errno;
-    return NULL;
-  }
-  CloseHandle (p->fd[0]->h);
+  ret = create_selectable_pipe(&p->fd[0]->h,
+                               &p->fd[1]->h,
+                               NULL,
+                               0,
+                               FILE_FLAG_OVERLAPPED,
+                               FILE_FLAG_OVERLAPPED);
+  if (!ret)
+    {
+      SetErrnoFromWinError(GetLastError());
+      save_errno = errno;
+      GNUNET_free(p->fd[0]);
+      GNUNET_free(p->fd[1]);
+      GNUNET_free(p);
+      errno = save_errno;
+      return NULL;
+    }
+  if (!DuplicateHandle(GetCurrentProcess(),
+                       p->fd[0]->h,
+                       GetCurrentProcess(),
+                       &tmp_handle,
+                       0,
+                       inherit_read == GNUNET_YES ? TRUE : FALSE,
+                       DUPLICATE_SAME_ACCESS))
+    {
+      SetErrnoFromWinError(GetLastError());
+      save_errno = errno;
+      CloseHandle(p->fd[0]->h);
+      CloseHandle(p->fd[1]->h);
+      GNUNET_free(p->fd[0]);
+      GNUNET_free(p->fd[1]);
+      GNUNET_free(p);
+      errno = save_errno;
+      return NULL;
+    }
+  CloseHandle(p->fd[0]->h);
   p->fd[0]->h = tmp_handle;
 
-  if (! DuplicateHandle (GetCurrentProcess (),
-                         p->fd[1]->h,
-                         GetCurrentProcess (),
-                         &tmp_handle,
-                         0,
-                         inherit_write == GNUNET_YES ? TRUE : FALSE,
-                         DUPLICATE_SAME_ACCESS))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    save_errno = errno;
-    CloseHandle (p->fd[0]->h);
-    CloseHandle (p->fd[1]->h);
-    GNUNET_free (p->fd[0]);
-    GNUNET_free (p->fd[1]);
-    GNUNET_free (p);
-    errno = save_errno;
-    return NULL;
-  }
-  CloseHandle (p->fd[1]->h);
+  if (!DuplicateHandle(GetCurrentProcess(),
+                       p->fd[1]->h,
+                       GetCurrentProcess(),
+                       &tmp_handle,
+                       0,
+                       inherit_write == GNUNET_YES ? TRUE : FALSE,
+                       DUPLICATE_SAME_ACCESS))
+    {
+      SetErrnoFromWinError(GetLastError());
+      save_errno = errno;
+      CloseHandle(p->fd[0]->h);
+      CloseHandle(p->fd[1]->h);
+      GNUNET_free(p->fd[0]);
+      GNUNET_free(p->fd[1]);
+      GNUNET_free(p);
+      errno = save_errno;
+      return NULL;
+    }
+  CloseHandle(p->fd[1]->h);
   p->fd[1]->h = tmp_handle;
 
   p->fd[0]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
   p->fd[1]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
 
-  p->fd[0]->oOverlapRead = GNUNET_new (OVERLAPPED);
-  p->fd[0]->oOverlapWrite = GNUNET_new (OVERLAPPED);
-  p->fd[1]->oOverlapRead = GNUNET_new (OVERLAPPED);
-  p->fd[1]->oOverlapWrite = GNUNET_new (OVERLAPPED);
+  p->fd[0]->oOverlapRead = GNUNET_new(OVERLAPPED);
+  p->fd[0]->oOverlapWrite = GNUNET_new(OVERLAPPED);
+  p->fd[1]->oOverlapRead = GNUNET_new(OVERLAPPED);
+  p->fd[1]->oOverlapWrite = GNUNET_new(OVERLAPPED);
 
-  p->fd[0]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-  p->fd[0]->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+  p->fd[0]->oOverlapRead->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  p->fd[0]->oOverlapWrite->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
-  p->fd[1]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-  p->fd[1]->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+  p->fd[1]->oOverlapRead->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  p->fd[1]->oOverlapWrite->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
   return p;
 #endif
@@ -2405,11 +2410,11 @@ GNUNET_DISK_pipe (int blocking_read,
  * @return handle to the new pipe, NULL on error
  */
 struct GNUNET_DISK_PipeHandle *
-GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
+GNUNET_DISK_pipe_from_fd(int blocking_read, int blocking_write, int fd[2])
 {
   struct GNUNET_DISK_PipeHandle *p;
 
-  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
+  p = GNUNET_new(struct GNUNET_DISK_PipeHandle);
 
 #ifndef MINGW
   int ret;
@@ -2418,102 +2423,101 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 
   ret = 0;
   if (fd[0] >= 0)
-  {
-    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
-    p->fd[0]->fd = fd[0];
-    if (! blocking_read)
     {
-      flags = fcntl (fd[0], F_GETFL);
-      flags |= O_NONBLOCK;
-      if (0 > fcntl (fd[0], F_SETFL, flags))
-      {
-        ret = -1;
-        eno = errno;
-      }
-    }
-    flags = fcntl (fd[0], F_GETFD);
-    flags |= FD_CLOEXEC;
-    if (0 > fcntl (fd[0], F_SETFD, flags))
-    {
-      ret = -1;
-      eno = errno;
+      p->fd[0] = GNUNET_new(struct GNUNET_DISK_FileHandle);
+      p->fd[0]->fd = fd[0];
+      if (!blocking_read)
+        {
+          flags = fcntl(fd[0], F_GETFL);
+          flags |= O_NONBLOCK;
+          if (0 > fcntl(fd[0], F_SETFL, flags))
+            {
+              ret = -1;
+              eno = errno;
+            }
+        }
+      flags = fcntl(fd[0], F_GETFD);
+      flags |= FD_CLOEXEC;
+      if (0 > fcntl(fd[0], F_SETFD, flags))
+        {
+          ret = -1;
+          eno = errno;
+        }
     }
-  }
 
   if (fd[1] >= 0)
-  {
-    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
-    p->fd[1]->fd = fd[1];
-    if (! blocking_write)
     {
-      flags = fcntl (fd[1], F_GETFL);
-      flags |= O_NONBLOCK;
-      if (0 > fcntl (fd[1], F_SETFL, flags))
-      {
-        ret = -1;
-        eno = errno;
-      }
+      p->fd[1] = GNUNET_new(struct GNUNET_DISK_FileHandle);
+      p->fd[1]->fd = fd[1];
+      if (!blocking_write)
+        {
+          flags = fcntl(fd[1], F_GETFL);
+          flags |= O_NONBLOCK;
+          if (0 > fcntl(fd[1], F_SETFL, flags))
+            {
+              ret = -1;
+              eno = errno;
+            }
+        }
+      flags = fcntl(fd[1], F_GETFD);
+      flags |= FD_CLOEXEC;
+      if (0 > fcntl(fd[1], F_SETFD, flags))
+        {
+          ret = -1;
+          eno = errno;
+        }
     }
-    flags = fcntl (fd[1], F_GETFD);
-    flags |= FD_CLOEXEC;
-    if (0 > fcntl (fd[1], F_SETFD, flags))
+  if (ret == -1)
     {
-      ret = -1;
-      eno = errno;
+      errno = eno;
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fcntl");
+      if (p->fd[0]->fd >= 0)
+        GNUNET_break(0 == close(p->fd[0]->fd));
+      if (p->fd[1]->fd >= 0)
+        GNUNET_break(0 == close(p->fd[1]->fd));
+      GNUNET_free_non_null(p->fd[0]);
+      GNUNET_free_non_null(p->fd[1]);
+      GNUNET_free(p);
+      errno = eno;
+      return NULL;
     }
-  }
-  if (ret == -1)
-  {
-    errno = eno;
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fcntl");
-    if (p->fd[0]->fd >= 0)
-      GNUNET_break (0 == close (p->fd[0]->fd));
-    if (p->fd[1]->fd >= 0)
-      GNUNET_break (0 == close (p->fd[1]->fd));
-    GNUNET_free_non_null (p->fd[0]);
-    GNUNET_free_non_null (p->fd[1]);
-    GNUNET_free (p);
-    errno = eno;
-    return NULL;
-  }
 #else
   if (fd[0] >= 0)
-  {
-    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
-    p->fd[0]->h = (HANDLE) _get_osfhandle (fd[0]);
-    if (p->fd[0]->h != INVALID_HANDLE_VALUE)
-    {
-      p->fd[0]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
-      p->fd[0]->oOverlapRead = GNUNET_new (OVERLAPPED);
-      p->fd[0]->oOverlapWrite = GNUNET_new (OVERLAPPED);
-      p->fd[0]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-      p->fd[0]->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-    }
-    else
     {
-      GNUNET_free (p->fd[0]);
-      p->fd[0] = NULL;
+      p->fd[0] = GNUNET_new(struct GNUNET_DISK_FileHandle);
+      p->fd[0]->h = (HANDLE)_get_osfhandle(fd[0]);
+      if (p->fd[0]->h != INVALID_HANDLE_VALUE)
+        {
+          p->fd[0]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
+          p->fd[0]->oOverlapRead = GNUNET_new(OVERLAPPED);
+          p->fd[0]->oOverlapWrite = GNUNET_new(OVERLAPPED);
+          p->fd[0]->oOverlapRead->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+          p->fd[0]->oOverlapWrite->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        }
+      else
+        {
+          GNUNET_free(p->fd[0]);
+          p->fd[0] = NULL;
+        }
     }
-  }
   if (fd[1] >= 0)
-  {
-    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
-    p->fd[1]->h = (HANDLE) _get_osfhandle (fd[1]);
-    if (p->fd[1]->h != INVALID_HANDLE_VALUE)
-    {
-      p->fd[1]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
-      p->fd[1]->oOverlapRead = GNUNET_new (OVERLAPPED);
-      p->fd[1]->oOverlapWrite = GNUNET_new (OVERLAPPED);
-      p->fd[1]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-      p->fd[1]->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
-    }
-    else
     {
-      GNUNET_free (p->fd[1]);
-      p->fd[1] = NULL;
+      p->fd[1] = GNUNET_new(struct GNUNET_DISK_FileHandle);
+      p->fd[1]->h = (HANDLE)_get_osfhandle(fd[1]);
+      if (p->fd[1]->h != INVALID_HANDLE_VALUE)
+        {
+          p->fd[1]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
+          p->fd[1]->oOverlapRead = GNUNET_new(OVERLAPPED);
+          p->fd[1]->oOverlapWrite = GNUNET_new(OVERLAPPED);
+          p->fd[1]->oOverlapRead->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+          p->fd[1]->oOverlapWrite->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        }
+      else
+        {
+          GNUNET_free(p->fd[1]);
+          p->fd[1] = NULL;
+        }
     }
-  }
-
 #endif
   return p;
 }
@@ -2527,27 +2531,27 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
-                            enum GNUNET_DISK_PipeEnd end)
+GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p,
+                           enum GNUNET_DISK_PipeEnd end)
 {
   int ret = GNUNET_OK;
 
   if (end == GNUNET_DISK_PIPE_END_READ)
-  {
-    if (p->fd[0])
     {
-      ret = GNUNET_DISK_file_close (p->fd[0]);
-      p->fd[0] = NULL;
+      if (p->fd[0])
+        {
+          ret = GNUNET_DISK_file_close(p->fd[0]);
+          p->fd[0] = NULL;
+        }
     }
-  }
   else if (end == GNUNET_DISK_PIPE_END_WRITE)
-  {
-    if (p->fd[1])
     {
-      ret = GNUNET_DISK_file_close (p->fd[1]);
-      p->fd[1] = NULL;
+      if (p->fd[1])
+        {
+          ret = GNUNET_DISK_file_close(p->fd[1]);
+          p->fd[1] = NULL;
+        }
     }
-  }
 
   return ret;
 }
@@ -2565,27 +2569,27 @@ GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
  * (or if that end is not present or is closed).
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p,
-                             enum GNUNET_DISK_PipeEnd end)
+GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p,
+                            enum GNUNET_DISK_PipeEnd end)
 {
   struct GNUNET_DISK_FileHandle *ret = NULL;
 
   if (end == GNUNET_DISK_PIPE_END_READ)
-  {
-    if (p->fd[0])
     {
-      ret = p->fd[0];
-      p->fd[0] = NULL;
+      if (p->fd[0])
+        {
+          ret = p->fd[0];
+          p->fd[0] = NULL;
+        }
     }
-  }
   else if (end == GNUNET_DISK_PIPE_END_WRITE)
-  {
-    if (p->fd[1])
     {
-      ret = p->fd[1];
-      p->fd[1] = NULL;
+      if (p->fd[1])
+        {
+          ret = p->fd[1];
+          p->fd[1] = NULL;
+        }
     }
-  }
 
   return ret;
 }
@@ -2598,7 +2602,7 @@ GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p,
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
+GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
 {
   int ret = GNUNET_OK;
 
@@ -2607,22 +2611,22 @@ GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
   int read_end_close_errno;
   int write_end_close_errno;
 
-  read_end_close = GNUNET_DISK_pipe_close_end (p, GNUNET_DISK_PIPE_END_READ);
+  read_end_close = GNUNET_DISK_pipe_close_end(p, GNUNET_DISK_PIPE_END_READ);
   read_end_close_errno = errno;
-  write_end_close = GNUNET_DISK_pipe_close_end (p, GNUNET_DISK_PIPE_END_WRITE);
+  write_end_close = GNUNET_DISK_pipe_close_end(p, GNUNET_DISK_PIPE_END_WRITE);
   write_end_close_errno = errno;
-  GNUNET_free (p);
+  GNUNET_free(p);
 
   if (GNUNET_OK != read_end_close)
-  {
-    errno = read_end_close_errno;
-    ret = read_end_close;
-  }
+    {
+      errno = read_end_close_errno;
+      ret = read_end_close;
+    }
   else if (GNUNET_OK != write_end_close)
-  {
-    errno = write_end_close_errno;
-    ret = write_end_close;
-  }
+    {
+      errno = write_end_close_errno;
+      ret = write_end_close;
+    }
 
   return ret;
 }
@@ -2636,18 +2640,19 @@ GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
  * @return handle for the respective end
  */
 const struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
-                         enum GNUNET_DISK_PipeEnd n)
+GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p,
+                        enum GNUNET_DISK_PipeEnd n)
 {
   switch (n)
-  {
-  case GNUNET_DISK_PIPE_END_READ:
-  case GNUNET_DISK_PIPE_END_WRITE:
-    return p->fd[n];
-  default:
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+    case GNUNET_DISK_PIPE_END_READ:
+    case GNUNET_DISK_PIPE_END_WRITE:
+      return p->fd[n];
+
+    default:
+      GNUNET_break(0);
+      return NULL;
+    }
 }
 
 
@@ -2660,20 +2665,20 @@ GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
-                                   void *dst,
-                                   size_t dst_len)
+GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh,
+                                  void *dst,
+                                  size_t dst_len)
 {
   if (NULL == fh)
     return GNUNET_SYSERR;
 #ifdef MINGW
-  if (dst_len < sizeof (HANDLE))
+  if (dst_len < sizeof(HANDLE))
     return GNUNET_SYSERR;
-  *((HANDLE *) dst) = fh->h;
+  *((HANDLE *)dst) = fh->h;
 #else
-  if (dst_len < sizeof (int))
+  if (dst_len < sizeof(int))
     return GNUNET_SYSERR;
-  *((int *) dst) = fh->fd;
+  *((int *)dst) = fh->fd;
 #endif
 
   return GNUNET_OK;
@@ -2688,24 +2693,24 @@ GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
  * @return #GNUNET_OK on success
  */
 static int
-purge_cfg_dir (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+purge_cfg_dir(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *option = cls;
   char *tmpname;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "PATHS", option, &tmpname))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "PATHS", option);
-    return GNUNET_NO;
-  }
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_remove (tmpname))
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "remove", tmpname);
-    GNUNET_free (tmpname);
-    return GNUNET_OK;
-  }
-  GNUNET_free (tmpname);
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "PATHS", option, &tmpname))
+    {
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "PATHS", option);
+      return GNUNET_NO;
+    }
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_remove(tmpname))
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "remove", tmpname);
+      GNUNET_free(tmpname);
+      return GNUNET_OK;
+    }
+  GNUNET_free(tmpname);
   return GNUNET_OK;
 }
 
@@ -2718,12 +2723,12 @@ purge_cfg_dir (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param option option with the dir name to purge
  */
 void
-GNUNET_DISK_purge_cfg_dir (const char *cfg_filename, const char *option)
+GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, const char *option)
 {
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_CONFIGURATION_parse_and_run (cfg_filename,
-                                                    &purge_cfg_dir,
-                                                    (void *) option));
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_CONFIGURATION_parse_and_run(cfg_filename,
+                                                  &purge_cfg_dir,
+                                                  (void *)option));
 }
 
 
diff --git a/src/util/disk.h b/src/util/disk.h
index aee028ade..c6014617c 100644
--- a/src/util/disk.h
+++ b/src/util/disk.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 util/disk.h
@@ -39,7 +39,7 @@
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
-                                   void *dst, size_t dst_len);
+GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh,
+                                  void *dst, size_t dst_len);
 
 #endif /* GNUNET_DISK_H_ */
diff --git a/src/util/dnsparser.c b/src/util/dnsparser.c
index ec10e3ec3..fcec0d4f1 100644
--- a/src/util/dnsparser.c
+++ b/src/util/dnsparser.c
@@ -53,22 +53,22 @@
  *         #GNUNET_SYSERR if the label is not valid for DNS names
  */
 int
-GNUNET_DNSPARSER_check_label (const char *label)
+GNUNET_DNSPARSER_check_label(const char *label)
 {
   char *output;
   size_t slen;
 
-  if (NULL != strchr (label, '.'))
+  if (NULL != strchr(label, '.'))
     return GNUNET_SYSERR; /* not a label! Did you mean GNUNET_DNSPARSER_check_name? */
-  if (0 == strcmp (label, "@")) /* '@' is reserved for the empty label, see #GNUNET_GNS_EMPTY_LABEL_AT */
+  if (0 == strcmp(label, "@"))  /* '@' is reserved for the empty label, see #GNUNET_GNS_EMPTY_LABEL_AT */
     return GNUNET_SYSERR;
-  if (IDNA_SUCCESS != idna_to_ascii_8z (label, &output, IDNA_ALLOW_UNASSIGNED))
+  if (IDNA_SUCCESS != idna_to_ascii_8z(label, &output, IDNA_ALLOW_UNASSIGNED))
     return GNUNET_SYSERR;
-  slen = strlen (output);
+  slen = strlen(output);
 #if WINDOWS
-  idn_free (output);
+  idn_free(output);
 #else
-  free (output);
+  free(output);
 #endif
   return (slen > 63) ? GNUNET_SYSERR : GNUNET_OK;
 }
@@ -83,28 +83,28 @@ GNUNET_DNSPARSER_check_label (const char *label)
  *         #GNUNET_SYSERR if the label is not valid for DNS names
  */
 int
-GNUNET_DNSPARSER_check_name (const char *name)
+GNUNET_DNSPARSER_check_name(const char *name)
 {
   char *ldup;
   char *output;
   size_t slen;
   char *tok;
 
-  ldup = GNUNET_strdup (name);
-  for (tok = strtok (ldup, "."); NULL != tok; tok = strtok (NULL, "."))
-    if (GNUNET_OK != GNUNET_DNSPARSER_check_label (tok))
-    {
-      GNUNET_free (ldup);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free (ldup);
-  if (IDNA_SUCCESS != idna_to_ascii_8z (name, &output, IDNA_ALLOW_UNASSIGNED))
+  ldup = GNUNET_strdup(name);
+  for (tok = strtok(ldup, "."); NULL != tok; tok = strtok(NULL, "."))
+    if (GNUNET_OK != GNUNET_DNSPARSER_check_label(tok))
+      {
+        GNUNET_free(ldup);
+        return GNUNET_SYSERR;
+      }
+  GNUNET_free(ldup);
+  if (IDNA_SUCCESS != idna_to_ascii_8z(name, &output, IDNA_ALLOW_UNASSIGNED))
     return GNUNET_SYSERR;
-  slen = strlen (output);
+  slen = strlen(output);
 #if WINDOWS
-  idn_free (output);
+  idn_free(output);
 #else
-  free (output);
+  free(output);
 #endif
   return (slen > 253) ? GNUNET_SYSERR : GNUNET_OK;
 }
@@ -116,13 +116,13 @@ GNUNET_DNSPARSER_check_name (const char *name)
  * @param soa record to free
  */
 void
-GNUNET_DNSPARSER_free_soa (struct GNUNET_DNSPARSER_SoaRecord *soa)
+GNUNET_DNSPARSER_free_soa(struct GNUNET_DNSPARSER_SoaRecord *soa)
 {
   if (NULL == soa)
     return;
-  GNUNET_free_non_null (soa->mname);
-  GNUNET_free_non_null (soa->rname);
-  GNUNET_free (soa);
+  GNUNET_free_non_null(soa->mname);
+  GNUNET_free_non_null(soa->rname);
+  GNUNET_free(soa);
 }
 
 
@@ -132,12 +132,12 @@ GNUNET_DNSPARSER_free_soa (struct GNUNET_DNSPARSER_SoaRecord *soa)
  * @param cert record to free
  */
 void
-GNUNET_DNSPARSER_free_cert (struct GNUNET_DNSPARSER_CertRecord *cert)
+GNUNET_DNSPARSER_free_cert(struct GNUNET_DNSPARSER_CertRecord *cert)
 {
   if (NULL == cert)
     return;
-  GNUNET_free_non_null (cert->certificate_data);
-  GNUNET_free (cert);
+  GNUNET_free_non_null(cert->certificate_data);
+  GNUNET_free(cert);
 }
 
 
@@ -147,12 +147,12 @@ GNUNET_DNSPARSER_free_cert (struct GNUNET_DNSPARSER_CertRecord *cert)
  * @param srv record to free
  */
 void
-GNUNET_DNSPARSER_free_srv (struct GNUNET_DNSPARSER_SrvRecord *srv)
+GNUNET_DNSPARSER_free_srv(struct GNUNET_DNSPARSER_SrvRecord *srv)
 {
   if (NULL == srv)
     return;
-  GNUNET_free_non_null (srv->target);
-  GNUNET_free (srv);
+  GNUNET_free_non_null(srv->target);
+  GNUNET_free(srv);
 }
 
 
@@ -162,12 +162,12 @@ GNUNET_DNSPARSER_free_srv (struct GNUNET_DNSPARSER_SrvRecord *srv)
  * @param mx record to free
  */
 void
-GNUNET_DNSPARSER_free_mx (struct GNUNET_DNSPARSER_MxRecord *mx)
+GNUNET_DNSPARSER_free_mx(struct GNUNET_DNSPARSER_MxRecord *mx)
 {
   if (NULL == mx)
     return;
-  GNUNET_free_non_null (mx->mxhost);
-  GNUNET_free (mx);
+  GNUNET_free_non_null(mx->mxhost);
+  GNUNET_free(mx);
 }
 
 
@@ -177,32 +177,37 @@ GNUNET_DNSPARSER_free_mx (struct GNUNET_DNSPARSER_MxRecord *mx)
  * @param r record to free
  */
 void
-GNUNET_DNSPARSER_free_record (struct GNUNET_DNSPARSER_Record *r)
+GNUNET_DNSPARSER_free_record(struct GNUNET_DNSPARSER_Record *r)
 {
-  GNUNET_free_non_null (r->name);
+  GNUNET_free_non_null(r->name);
   switch (r->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_MX:
-    GNUNET_DNSPARSER_free_mx (r->data.mx);
-    break;
-  case GNUNET_DNSPARSER_TYPE_SOA:
-    GNUNET_DNSPARSER_free_soa (r->data.soa);
-    break;
-  case GNUNET_DNSPARSER_TYPE_SRV:
-    GNUNET_DNSPARSER_free_srv (r->data.srv);
-    break;
-  case GNUNET_DNSPARSER_TYPE_CERT:
-    GNUNET_DNSPARSER_free_cert (r->data.cert);
-    break;
-  case GNUNET_DNSPARSER_TYPE_NS:
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-  case GNUNET_DNSPARSER_TYPE_PTR:
-    GNUNET_free_non_null (r->data.hostname);
-    break;
-  default:
-    GNUNET_free_non_null (r->data.raw.data);
-    break;
-  }
+    {
+    case GNUNET_DNSPARSER_TYPE_MX:
+      GNUNET_DNSPARSER_free_mx(r->data.mx);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SOA:
+      GNUNET_DNSPARSER_free_soa(r->data.soa);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SRV:
+      GNUNET_DNSPARSER_free_srv(r->data.srv);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_CERT:
+      GNUNET_DNSPARSER_free_cert(r->data.cert);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_NS:
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+    case GNUNET_DNSPARSER_TYPE_PTR:
+      GNUNET_free_non_null(r->data.hostname);
+      break;
+
+    default:
+      GNUNET_free_non_null(r->data.raw.data);
+      break;
+    }
 }
 
 
@@ -217,12 +222,12 @@ GNUNET_DNSPARSER_free_record (struct GNUNET_DNSPARSER_Record *r)
  * @return name as 0-terminated C string on success, NULL if the payload is malformed
  */
 static char *
-parse_name (const char *udp_payload,
-            size_t udp_payload_length,
-            size_t *off,
-            unsigned int depth)
+parse_name(const char *udp_payload,
+           size_t udp_payload_length,
+           size_t *off,
+           unsigned int depth)
 {
-  const uint8_t *input = (const uint8_t *) udp_payload;
+  const uint8_t *input = (const uint8_t *)udp_payload;
   char *ret;
   char *tmp;
   char *xstr;
@@ -231,102 +236,102 @@ parse_name (const char *udp_payload,
   char *utf8;
   Idna_rc rc;
 
-  ret = GNUNET_strdup ("");
+  ret = GNUNET_strdup("");
   while (1)
-  {
-    if (*off >= udp_payload_length)
-    {
-      GNUNET_break_op (0);
-      goto error;
-    }
-    len = input[*off];
-    if (0 == len)
-    {
-      (*off)++;
-      break;
-    }
-    if (len < 64)
     {
-      if (*off + 1 + len > udp_payload_length)
-      {
-        GNUNET_break_op (0);
-        goto error;
-      }
-      GNUNET_asprintf (&tmp, "%.*s", (int) len, &udp_payload[*off + 1]);
-      if (IDNA_SUCCESS !=
-          (rc = idna_to_unicode_8z8z (tmp, &utf8, IDNA_ALLOW_UNASSIGNED)))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                    _ ("Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"),
-                    tmp,
-                    idna_strerror (rc));
-        GNUNET_free (tmp);
-        GNUNET_asprintf (&tmp,
-                         "%s%.*s.",
-                         ret,
-                         (int) len,
-                         &udp_payload[*off + 1]);
-      }
-      else
-      {
-        GNUNET_free (tmp);
-        GNUNET_asprintf (&tmp, "%s%s.", ret, utf8);
+      if (*off >= udp_payload_length)
+        {
+          GNUNET_break_op(0);
+          goto error;
+        }
+      len = input[*off];
+      if (0 == len)
+        {
+          (*off)++;
+          break;
+        }
+      if (len < 64)
+        {
+          if (*off + 1 + len > udp_payload_length)
+            {
+              GNUNET_break_op(0);
+              goto error;
+            }
+          GNUNET_asprintf(&tmp, "%.*s", (int)len, &udp_payload[*off + 1]);
+          if (IDNA_SUCCESS !=
+              (rc = idna_to_unicode_8z8z(tmp, &utf8, IDNA_ALLOW_UNASSIGNED)))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                         _("Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"),
+                         tmp,
+                         idna_strerror(rc));
+              GNUNET_free(tmp);
+              GNUNET_asprintf(&tmp,
+                              "%s%.*s.",
+                              ret,
+                              (int)len,
+                              &udp_payload[*off + 1]);
+            }
+          else
+            {
+              GNUNET_free(tmp);
+              GNUNET_asprintf(&tmp, "%s%s.", ret, utf8);
 #if WINDOWS
-        idn_free (utf8);
+              idn_free(utf8);
 #else
-        free (utf8);
+              free(utf8);
 #endif
-      }
-      GNUNET_free (ret);
-      ret = tmp;
-      *off += 1 + len;
-    }
-    else if ((64 | 128) == (len & (64 | 128)))
-    {
-      if (depth > 32)
-      {
-        GNUNET_break_op (0);
-        goto error; /* hard bound on stack to prevent "infinite" recursion, disallow! */
-      }
-      /* pointer to string */
-      if (*off + 1 > udp_payload_length)
-      {
-        GNUNET_break_op (0);
-        goto error;
-      }
-      xoff = ((len - (64 | 128)) << 8) + input[*off + 1];
-      xstr = parse_name (udp_payload, udp_payload_length, &xoff, depth + 1);
-      if (NULL == xstr)
-      {
-        GNUNET_break_op (0);
-        goto error;
-      }
-      GNUNET_asprintf (&tmp, "%s%s.", ret, xstr);
-      GNUNET_free (ret);
-      GNUNET_free (xstr);
-      ret = tmp;
-      if (strlen (ret) > udp_payload_length)
-      {
-        GNUNET_break_op (0);
-        goto error; /* we are looping (building an infinite string) */
-      }
-      *off += 2;
-      /* pointers always terminate names */
-      break;
-    }
-    else
-    {
-      /* neither pointer nor inline string, not supported... */
-      GNUNET_break_op (0);
-      goto error;
+            }
+          GNUNET_free(ret);
+          ret = tmp;
+          *off += 1 + len;
+        }
+      else if ((64 | 128) == (len & (64 | 128)))
+        {
+          if (depth > 32)
+            {
+              GNUNET_break_op(0);
+              goto error; /* hard bound on stack to prevent "infinite" recursion, disallow! */
+            }
+          /* pointer to string */
+          if (*off + 1 > udp_payload_length)
+            {
+              GNUNET_break_op(0);
+              goto error;
+            }
+          xoff = ((len - (64 | 128)) << 8) + input[*off + 1];
+          xstr = parse_name(udp_payload, udp_payload_length, &xoff, depth + 1);
+          if (NULL == xstr)
+            {
+              GNUNET_break_op(0);
+              goto error;
+            }
+          GNUNET_asprintf(&tmp, "%s%s.", ret, xstr);
+          GNUNET_free(ret);
+          GNUNET_free(xstr);
+          ret = tmp;
+          if (strlen(ret) > udp_payload_length)
+            {
+              GNUNET_break_op(0);
+              goto error; /* we are looping (building an infinite string) */
+            }
+          *off += 2;
+          /* pointers always terminate names */
+          break;
+        }
+      else
+        {
+          /* neither pointer nor inline string, not supported... */
+          GNUNET_break_op(0);
+          goto error;
+        }
     }
-  }
-  if (0 < strlen (ret))
-    ret[strlen (ret) - 1] = '\0'; /* eat tailing '.' */
+  if (0 < strlen(ret))
+    ret[strlen(ret) - 1] = '\0';  /* eat tailing '.' */
   return ret;
 error:
-  GNUNET_break_op (0);
-  GNUNET_free (ret);
+  GNUNET_break_op(0);
+  GNUNET_free(ret);
   return NULL;
 }
 
@@ -341,11 +346,11 @@ error:
  * @return name as 0-terminated C string on success, NULL if the payload is malformed
  */
 char *
-GNUNET_DNSPARSER_parse_name (const char *udp_payload,
-                             size_t udp_payload_length,
-                             size_t *off)
+GNUNET_DNSPARSER_parse_name(const char *udp_payload,
+                            size_t udp_payload_length,
+                            size_t *off)
 {
-  return parse_name (udp_payload, udp_payload_length, off, 0);
+  return parse_name(udp_payload, udp_payload_length, off, 0);
 }
 
 
@@ -360,30 +365,30 @@ GNUNET_DNSPARSER_parse_name (const char *udp_payload,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the query is malformed
  */
 int
-GNUNET_DNSPARSER_parse_query (const char *udp_payload,
-                              size_t udp_payload_length,
-                              size_t *off,
-                              struct GNUNET_DNSPARSER_Query *q)
+GNUNET_DNSPARSER_parse_query(const char *udp_payload,
+                             size_t udp_payload_length,
+                             size_t *off,
+                             struct GNUNET_DNSPARSER_Query *q)
 {
   char *name;
   struct GNUNET_TUN_DnsQueryLine ql;
 
-  name = GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+  name = GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   if (NULL == name)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break_op(0);
+      return GNUNET_SYSERR;
+    }
   q->name = name;
-  if (*off + sizeof (struct GNUNET_TUN_DnsQueryLine) > udp_payload_length)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_memcpy (&ql, &udp_payload[*off], sizeof (ql));
-  *off += sizeof (ql);
-  q->type = ntohs (ql.type);
-  q->dns_traffic_class = ntohs (ql.dns_traffic_class);
+  if (*off + sizeof(struct GNUNET_TUN_DnsQueryLine) > udp_payload_length)
+    {
+      GNUNET_break_op(0);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_memcpy(&ql, &udp_payload[*off], sizeof(ql));
+  *off += sizeof(ql);
+  q->type = ntohs(ql.type);
+  q->dns_traffic_class = ntohs(ql.dns_traffic_class);
   return GNUNET_OK;
 }
 
@@ -398,37 +403,37 @@ GNUNET_DNSPARSER_parse_query (const char *udp_payload,
  * @return the parsed SOA record, NULL on error
  */
 struct GNUNET_DNSPARSER_SoaRecord *
-GNUNET_DNSPARSER_parse_soa (const char *udp_payload,
-                            size_t udp_payload_length,
-                            size_t *off)
+GNUNET_DNSPARSER_parse_soa(const char *udp_payload,
+                           size_t udp_payload_length,
+                           size_t *off)
 {
   struct GNUNET_DNSPARSER_SoaRecord *soa;
   struct GNUNET_TUN_DnsSoaRecord soa_bin;
   size_t old_off;
 
   old_off = *off;
-  soa = GNUNET_new (struct GNUNET_DNSPARSER_SoaRecord);
+  soa = GNUNET_new(struct GNUNET_DNSPARSER_SoaRecord);
   soa->mname =
-    GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+    GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   soa->rname =
-    GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+    GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   if ((NULL == soa->mname) || (NULL == soa->rname) ||
-      (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > udp_payload_length))
-  {
-    GNUNET_break_op (0);
-    GNUNET_DNSPARSER_free_soa (soa);
-    *off = old_off;
-    return NULL;
-  }
-  GNUNET_memcpy (&soa_bin,
-                 &udp_payload[*off],
-                 sizeof (struct GNUNET_TUN_DnsSoaRecord));
-  soa->serial = ntohl (soa_bin.serial);
-  soa->refresh = ntohl (soa_bin.refresh);
-  soa->retry = ntohl (soa_bin.retry);
-  soa->expire = ntohl (soa_bin.expire);
-  soa->minimum_ttl = ntohl (soa_bin.minimum);
-  (*off) += sizeof (struct GNUNET_TUN_DnsSoaRecord);
+      (*off + sizeof(struct GNUNET_TUN_DnsSoaRecord) > udp_payload_length))
+    {
+      GNUNET_break_op(0);
+      GNUNET_DNSPARSER_free_soa(soa);
+      *off = old_off;
+      return NULL;
+    }
+  GNUNET_memcpy(&soa_bin,
+                &udp_payload[*off],
+                sizeof(struct GNUNET_TUN_DnsSoaRecord));
+  soa->serial = ntohl(soa_bin.serial);
+  soa->refresh = ntohl(soa_bin.refresh);
+  soa->retry = ntohl(soa_bin.retry);
+  soa->expire = ntohl(soa_bin.expire);
+  soa->minimum_ttl = ntohl(soa_bin.minimum);
+  (*off) += sizeof(struct GNUNET_TUN_DnsSoaRecord);
   return soa;
 }
 
@@ -443,33 +448,33 @@ GNUNET_DNSPARSER_parse_soa (const char *udp_payload,
  * @return the parsed MX record, NULL on error
  */
 struct GNUNET_DNSPARSER_MxRecord *
-GNUNET_DNSPARSER_parse_mx (const char *udp_payload,
-                           size_t udp_payload_length,
-                           size_t *off)
+GNUNET_DNSPARSER_parse_mx(const char *udp_payload,
+                          size_t udp_payload_length,
+                          size_t *off)
 {
   struct GNUNET_DNSPARSER_MxRecord *mx;
   uint16_t mxpref;
   size_t old_off;
 
   old_off = *off;
-  if (*off + sizeof (uint16_t) > udp_payload_length)
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-  GNUNET_memcpy (&mxpref, &udp_payload[*off], sizeof (uint16_t));
-  (*off) += sizeof (uint16_t);
-  mx = GNUNET_new (struct GNUNET_DNSPARSER_MxRecord);
-  mx->preference = ntohs (mxpref);
+  if (*off + sizeof(uint16_t) > udp_payload_length)
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
+  GNUNET_memcpy(&mxpref, &udp_payload[*off], sizeof(uint16_t));
+  (*off) += sizeof(uint16_t);
+  mx = GNUNET_new(struct GNUNET_DNSPARSER_MxRecord);
+  mx->preference = ntohs(mxpref);
   mx->mxhost =
-    GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+    GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   if (NULL == mx->mxhost)
-  {
-    GNUNET_break_op (0);
-    GNUNET_DNSPARSER_free_mx (mx);
-    *off = old_off;
-    return NULL;
-  }
+    {
+      GNUNET_break_op(0);
+      GNUNET_DNSPARSER_free_mx(mx);
+      *off = old_off;
+      return NULL;
+    }
   return mx;
 }
 
@@ -484,33 +489,33 @@ GNUNET_DNSPARSER_parse_mx (const char *udp_payload,
  * @return the parsed SRV record, NULL on error
  */
 struct GNUNET_DNSPARSER_SrvRecord *
-GNUNET_DNSPARSER_parse_srv (const char *udp_payload,
-                            size_t udp_payload_length,
-                            size_t *off)
+GNUNET_DNSPARSER_parse_srv(const char *udp_payload,
+                           size_t udp_payload_length,
+                           size_t *off)
 {
   struct GNUNET_DNSPARSER_SrvRecord *srv;
   struct GNUNET_TUN_DnsSrvRecord srv_bin;
   size_t old_off;
 
   old_off = *off;
-  if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > udp_payload_length)
+  if (*off + sizeof(struct GNUNET_TUN_DnsSrvRecord) > udp_payload_length)
     return NULL;
-  GNUNET_memcpy (&srv_bin,
-                 &udp_payload[*off],
-                 sizeof (struct GNUNET_TUN_DnsSrvRecord));
-  (*off) += sizeof (struct GNUNET_TUN_DnsSrvRecord);
-  srv = GNUNET_new (struct GNUNET_DNSPARSER_SrvRecord);
-  srv->priority = ntohs (srv_bin.prio);
-  srv->weight = ntohs (srv_bin.weight);
-  srv->port = ntohs (srv_bin.port);
+  GNUNET_memcpy(&srv_bin,
+                &udp_payload[*off],
+                sizeof(struct GNUNET_TUN_DnsSrvRecord));
+  (*off) += sizeof(struct GNUNET_TUN_DnsSrvRecord);
+  srv = GNUNET_new(struct GNUNET_DNSPARSER_SrvRecord);
+  srv->priority = ntohs(srv_bin.prio);
+  srv->weight = ntohs(srv_bin.weight);
+  srv->port = ntohs(srv_bin.port);
   srv->target =
-    GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+    GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   if (NULL == srv->target)
-  {
-    GNUNET_DNSPARSER_free_srv (srv);
-    *off = old_off;
-    return NULL;
-  }
+    {
+      GNUNET_DNSPARSER_free_srv(srv);
+      *off = old_off;
+      return NULL;
+    }
   return srv;
 }
 
@@ -525,31 +530,31 @@ GNUNET_DNSPARSER_parse_srv (const char *udp_payload,
  * @return the parsed CERT record, NULL on error
  */
 struct GNUNET_DNSPARSER_CertRecord *
-GNUNET_DNSPARSER_parse_cert (const char *udp_payload,
-                             size_t udp_payload_length,
-                             size_t *off)
+GNUNET_DNSPARSER_parse_cert(const char *udp_payload,
+                            size_t udp_payload_length,
+                            size_t *off)
 {
   struct GNUNET_DNSPARSER_CertRecord *cert;
   struct GNUNET_TUN_DnsCertRecord dcert;
 
-  if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) >= udp_payload_length)
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-  GNUNET_memcpy (&dcert,
-                 &udp_payload[*off],
-                 sizeof (struct GNUNET_TUN_DnsCertRecord));
-  (*off) += sizeof (struct GNUNET_TUN_DnsCertRecord);
-  cert = GNUNET_new (struct GNUNET_DNSPARSER_CertRecord);
-  cert->cert_type = ntohs (dcert.cert_type);
-  cert->cert_tag = ntohs (dcert.cert_tag);
+  if (*off + sizeof(struct GNUNET_TUN_DnsCertRecord) >= udp_payload_length)
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
+  GNUNET_memcpy(&dcert,
+                &udp_payload[*off],
+                sizeof(struct GNUNET_TUN_DnsCertRecord));
+  (*off) += sizeof(struct GNUNET_TUN_DnsCertRecord);
+  cert = GNUNET_new(struct GNUNET_DNSPARSER_CertRecord);
+  cert->cert_type = ntohs(dcert.cert_type);
+  cert->cert_tag = ntohs(dcert.cert_tag);
   cert->algorithm = dcert.algorithm;
   cert->certificate_size = udp_payload_length - (*off);
-  cert->certificate_data = GNUNET_malloc (cert->certificate_size);
-  GNUNET_memcpy (cert->certificate_data,
-                 &udp_payload[*off],
-                 cert->certificate_size);
+  cert->certificate_data = GNUNET_malloc(cert->certificate_size);
+  GNUNET_memcpy(cert->certificate_data,
+                &udp_payload[*off],
+                cert->certificate_size);
   (*off) += cert->certificate_size;
   return cert;
 }
@@ -566,85 +571,89 @@ GNUNET_DNSPARSER_parse_cert (const char *udp_payload,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the record is malformed
  */
 int
-GNUNET_DNSPARSER_parse_record (const char *udp_payload,
-                               size_t udp_payload_length,
-                               size_t *off,
-                               struct GNUNET_DNSPARSER_Record *r)
+GNUNET_DNSPARSER_parse_record(const char *udp_payload,
+                              size_t udp_payload_length,
+                              size_t *off,
+                              struct GNUNET_DNSPARSER_Record *r)
 {
   char *name;
   struct GNUNET_TUN_DnsRecordLine rl;
   size_t old_off;
   uint16_t data_len;
 
-  name = GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
+  name = GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
   if (NULL == name)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-  r->name = name;
-  if (*off + sizeof (struct GNUNET_TUN_DnsRecordLine) > udp_payload_length)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_memcpy (&rl, &udp_payload[*off], sizeof (rl));
-  (*off) += sizeof (rl);
-  r->type = ntohs (rl.type);
-  r->dns_traffic_class = ntohs (rl.dns_traffic_class);
-  r->expiration_time = GNUNET_TIME_relative_to_absolute (
-    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, ntohl (rl.ttl)));
-  data_len = ntohs (rl.data_len);
-  if (*off + data_len > udp_payload_length)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-  old_off = *off;
-  switch (r->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_NS:
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-  case GNUNET_DNSPARSER_TYPE_DNAME:
-  case GNUNET_DNSPARSER_TYPE_PTR:
-    r->data.hostname =
-      GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off);
-    if ((NULL == r->data.hostname) || (old_off + data_len != *off))
-      return GNUNET_SYSERR;
-    return GNUNET_OK;
-  case GNUNET_DNSPARSER_TYPE_SOA:
-    r->data.soa =
-      GNUNET_DNSPARSER_parse_soa (udp_payload, udp_payload_length, off);
-    if ((NULL == r->data.soa) || (old_off + data_len != *off))
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_SYSERR;
     }
-    return GNUNET_OK;
-  case GNUNET_DNSPARSER_TYPE_MX:
-    r->data.mx =
-      GNUNET_DNSPARSER_parse_mx (udp_payload, udp_payload_length, off);
-    if ((NULL == r->data.mx) || (old_off + data_len != *off))
+  r->name = name;
+  if (*off + sizeof(struct GNUNET_TUN_DnsRecordLine) > udp_payload_length)
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_SYSERR;
     }
-    return GNUNET_OK;
-  case GNUNET_DNSPARSER_TYPE_SRV:
-    r->data.srv =
-      GNUNET_DNSPARSER_parse_srv (udp_payload, udp_payload_length, off);
-    if ((NULL == r->data.srv) || (old_off + data_len != *off))
+  GNUNET_memcpy(&rl, &udp_payload[*off], sizeof(rl));
+  (*off) += sizeof(rl);
+  r->type = ntohs(rl.type);
+  r->dns_traffic_class = ntohs(rl.dns_traffic_class);
+  r->expiration_time = GNUNET_TIME_relative_to_absolute(
+    GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, ntohl(rl.ttl)));
+  data_len = ntohs(rl.data_len);
+  if (*off + data_len > udp_payload_length)
     {
-      GNUNET_break_op (0);
+      GNUNET_break_op(0);
       return GNUNET_SYSERR;
     }
-    return GNUNET_OK;
-  default:
-    r->data.raw.data = GNUNET_malloc (data_len);
-    r->data.raw.data_len = data_len;
-    GNUNET_memcpy (r->data.raw.data, &udp_payload[*off], data_len);
-    break;
-  }
+  old_off = *off;
+  switch (r->type)
+    {
+    case GNUNET_DNSPARSER_TYPE_NS:
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+    case GNUNET_DNSPARSER_TYPE_DNAME:
+    case GNUNET_DNSPARSER_TYPE_PTR:
+      r->data.hostname =
+        GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off);
+      if ((NULL == r->data.hostname) || (old_off + data_len != *off))
+        return GNUNET_SYSERR;
+      return GNUNET_OK;
+
+    case GNUNET_DNSPARSER_TYPE_SOA:
+      r->data.soa =
+        GNUNET_DNSPARSER_parse_soa(udp_payload, udp_payload_length, off);
+      if ((NULL == r->data.soa) || (old_off + data_len != *off))
+        {
+          GNUNET_break_op(0);
+          return GNUNET_SYSERR;
+        }
+      return GNUNET_OK;
+
+    case GNUNET_DNSPARSER_TYPE_MX:
+      r->data.mx =
+        GNUNET_DNSPARSER_parse_mx(udp_payload, udp_payload_length, off);
+      if ((NULL == r->data.mx) || (old_off + data_len != *off))
+        {
+          GNUNET_break_op(0);
+          return GNUNET_SYSERR;
+        }
+      return GNUNET_OK;
+
+    case GNUNET_DNSPARSER_TYPE_SRV:
+      r->data.srv =
+        GNUNET_DNSPARSER_parse_srv(udp_payload, udp_payload_length, off);
+      if ((NULL == r->data.srv) || (old_off + data_len != *off))
+        {
+          GNUNET_break_op(0);
+          return GNUNET_SYSERR;
+        }
+      return GNUNET_OK;
+
+    default:
+      r->data.raw.data = GNUNET_malloc(data_len);
+      r->data.raw.data_len = data_len;
+      GNUNET_memcpy(r->data.raw.data, &udp_payload[*off], data_len);
+      break;
+    }
   (*off) += data_len;
   return GNUNET_OK;
 }
@@ -659,76 +668,76 @@ GNUNET_DNSPARSER_parse_record (const char *udp_payload,
  * @return NULL on error, otherwise the parsed packet
  */
 struct GNUNET_DNSPARSER_Packet *
-GNUNET_DNSPARSER_parse (const char *udp_payload, size_t udp_payload_length)
+GNUNET_DNSPARSER_parse(const char *udp_payload, size_t udp_payload_length)
 {
   struct GNUNET_DNSPARSER_Packet *p;
   const struct GNUNET_TUN_DnsHeader *dns;
   size_t off;
   unsigned int n;
 
-  if (udp_payload_length < sizeof (struct GNUNET_TUN_DnsHeader))
+  if (udp_payload_length < sizeof(struct GNUNET_TUN_DnsHeader))
     return NULL;
-  dns = (const struct GNUNET_TUN_DnsHeader *) udp_payload;
-  off = sizeof (struct GNUNET_TUN_DnsHeader);
-  p = GNUNET_new (struct GNUNET_DNSPARSER_Packet);
+  dns = (const struct GNUNET_TUN_DnsHeader *)udp_payload;
+  off = sizeof(struct GNUNET_TUN_DnsHeader);
+  p = GNUNET_new(struct GNUNET_DNSPARSER_Packet);
   p->flags = dns->flags;
   p->id = dns->id;
-  n = ntohs (dns->query_count);
+  n = ntohs(dns->query_count);
   if (n > 0)
-  {
-    p->queries = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Query);
-    p->num_queries = n;
-    for (unsigned int i = 0; i < n; i++)
-      if (GNUNET_OK != GNUNET_DNSPARSER_parse_query (udp_payload,
-                                                     udp_payload_length,
-                                                     &off,
-                                                     &p->queries[i]))
-        goto error;
-  }
-  n = ntohs (dns->answer_rcount);
-  if (n > 0)
-  {
-    p->answers = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record);
-    p->num_answers = n;
-    for (unsigned int i = 0; i < n; i++)
-      if (GNUNET_OK != GNUNET_DNSPARSER_parse_record (udp_payload,
+    {
+      p->queries = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Query);
+      p->num_queries = n;
+      for (unsigned int i = 0; i < n; i++)
+        if (GNUNET_OK != GNUNET_DNSPARSER_parse_query(udp_payload,
                                                       udp_payload_length,
                                                       &off,
-                                                      &p->answers[i]))
-        goto error;
-  }
-  n = ntohs (dns->authority_rcount);
+                                                      &p->queries[i]))
+          goto error;
+    }
+  n = ntohs(dns->answer_rcount);
   if (n > 0)
-  {
-    p->authority_records = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record);
-    p->num_authority_records = n;
-    for (unsigned int i = 0; i < n; i++)
-      if (GNUNET_OK != GNUNET_DNSPARSER_parse_record (udp_payload,
-                                                      udp_payload_length,
-                                                      &off,
-                                                      &p->authority_records[i]))
-        goto error;
-  }
-  n = ntohs (dns->additional_rcount);
+    {
+      p->answers = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record);
+      p->num_answers = n;
+      for (unsigned int i = 0; i < n; i++)
+        if (GNUNET_OK != GNUNET_DNSPARSER_parse_record(udp_payload,
+                                                       udp_payload_length,
+                                                       &off,
+                                                       &p->answers[i]))
+          goto error;
+    }
+  n = ntohs(dns->authority_rcount);
   if (n > 0)
-  {
-    p->additional_records =
-      GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record);
-    p->num_additional_records = n;
-    for (unsigned int i = 0; i < n; i++)
     {
-      if (GNUNET_OK !=
-          GNUNET_DNSPARSER_parse_record (udp_payload,
-                                         udp_payload_length,
-                                         &off,
-                                         &p->additional_records[i]))
-        goto error;
+      p->authority_records = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record);
+      p->num_authority_records = n;
+      for (unsigned int i = 0; i < n; i++)
+        if (GNUNET_OK != GNUNET_DNSPARSER_parse_record(udp_payload,
+                                                       udp_payload_length,
+                                                       &off,
+                                                       &p->authority_records[i]))
+          goto error;
+    }
+  n = ntohs(dns->additional_rcount);
+  if (n > 0)
+    {
+      p->additional_records =
+        GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record);
+      p->num_additional_records = n;
+      for (unsigned int i = 0; i < n; i++)
+        {
+          if (GNUNET_OK !=
+              GNUNET_DNSPARSER_parse_record(udp_payload,
+                                            udp_payload_length,
+                                            &off,
+                                            &p->additional_records[i]))
+            goto error;
+        }
     }
-  }
   return p;
 error:
-  GNUNET_break_op (0);
-  GNUNET_DNSPARSER_free_packet (p);
+  GNUNET_break_op(0);
+  GNUNET_DNSPARSER_free_packet(p);
   return NULL;
 }
 
@@ -740,39 +749,44 @@ error:
  * @return the newly allocated record
  */
 struct GNUNET_DNSPARSER_Record *
-GNUNET_DNSPARSER_duplicate_record (const struct GNUNET_DNSPARSER_Record *r)
+GNUNET_DNSPARSER_duplicate_record(const struct GNUNET_DNSPARSER_Record *r)
 {
-  struct GNUNET_DNSPARSER_Record *dup = GNUNET_memdup (r, sizeof (*r));
+  struct GNUNET_DNSPARSER_Record *dup = GNUNET_memdup(r, sizeof(*r));
 
-  dup->name = GNUNET_strdup (r->name);
+  dup->name = GNUNET_strdup(r->name);
   switch (r->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_NS:
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-  case GNUNET_DNSPARSER_TYPE_PTR: {
-    dup->data.hostname = GNUNET_strdup (r->data.hostname);
-    break;
-  }
-  case GNUNET_DNSPARSER_TYPE_SOA: {
-    dup->data.soa = GNUNET_DNSPARSER_duplicate_soa_record (r->data.soa);
-    break;
-  }
-  case GNUNET_DNSPARSER_TYPE_CERT: {
-    dup->data.cert = GNUNET_DNSPARSER_duplicate_cert_record (r->data.cert);
-    break;
-  }
-  case GNUNET_DNSPARSER_TYPE_MX: {
-    dup->data.mx = GNUNET_DNSPARSER_duplicate_mx_record (r->data.mx);
-    break;
-  }
-  case GNUNET_DNSPARSER_TYPE_SRV: {
-    dup->data.srv = GNUNET_DNSPARSER_duplicate_srv_record (r->data.srv);
-    break;
-  }
-  default: {
-    dup->data.raw.data = GNUNET_memdup (r->data.raw.data, r->data.raw.data_len);
-  }
-  }
+    {
+    case GNUNET_DNSPARSER_TYPE_NS:
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+    case GNUNET_DNSPARSER_TYPE_PTR: {
+      dup->data.hostname = GNUNET_strdup(r->data.hostname);
+      break;
+    }
+
+    case GNUNET_DNSPARSER_TYPE_SOA: {
+      dup->data.soa = GNUNET_DNSPARSER_duplicate_soa_record(r->data.soa);
+      break;
+    }
+
+    case GNUNET_DNSPARSER_TYPE_CERT: {
+      dup->data.cert = GNUNET_DNSPARSER_duplicate_cert_record(r->data.cert);
+      break;
+    }
+
+    case GNUNET_DNSPARSER_TYPE_MX: {
+      dup->data.mx = GNUNET_DNSPARSER_duplicate_mx_record(r->data.mx);
+      break;
+    }
+
+    case GNUNET_DNSPARSER_TYPE_SRV: {
+      dup->data.srv = GNUNET_DNSPARSER_duplicate_srv_record(r->data.srv);
+      break;
+    }
+
+    default: {
+      dup->data.raw.data = GNUNET_memdup(r->data.raw.data, r->data.raw.data_len);
+    }
+    }
   return dup;
 }
 
@@ -784,13 +798,13 @@ GNUNET_DNSPARSER_duplicate_record (const struct GNUNET_DNSPARSER_Record *r)
  * @return the newly allocated record
  */
 struct GNUNET_DNSPARSER_SoaRecord *
-GNUNET_DNSPARSER_duplicate_soa_record (
+GNUNET_DNSPARSER_duplicate_soa_record(
   const struct GNUNET_DNSPARSER_SoaRecord *r)
 {
-  struct GNUNET_DNSPARSER_SoaRecord *dup = GNUNET_memdup (r, sizeof (*r));
+  struct GNUNET_DNSPARSER_SoaRecord *dup = GNUNET_memdup(r, sizeof(*r));
 
-  dup->mname = GNUNET_strdup (r->mname);
-  dup->rname = GNUNET_strdup (r->rname);
+  dup->mname = GNUNET_strdup(r->mname);
+  dup->rname = GNUNET_strdup(r->rname);
   return dup;
 }
 
@@ -802,12 +816,12 @@ GNUNET_DNSPARSER_duplicate_soa_record (
  * @return the newly allocated record
  */
 struct GNUNET_DNSPARSER_CertRecord *
-GNUNET_DNSPARSER_duplicate_cert_record (
+GNUNET_DNSPARSER_duplicate_cert_record(
   const struct GNUNET_DNSPARSER_CertRecord *r)
 {
-  struct GNUNET_DNSPARSER_CertRecord *dup = GNUNET_memdup (r, sizeof (*r));
+  struct GNUNET_DNSPARSER_CertRecord *dup = GNUNET_memdup(r, sizeof(*r));
 
-  dup->certificate_data = GNUNET_strdup (r->certificate_data);
+  dup->certificate_data = GNUNET_strdup(r->certificate_data);
   return dup;
 }
 
@@ -819,11 +833,11 @@ GNUNET_DNSPARSER_duplicate_cert_record (
  * @return the newly allocated record
  */
 struct GNUNET_DNSPARSER_MxRecord *
-GNUNET_DNSPARSER_duplicate_mx_record (const struct GNUNET_DNSPARSER_MxRecord *r)
+GNUNET_DNSPARSER_duplicate_mx_record(const struct GNUNET_DNSPARSER_MxRecord *r)
 {
-  struct GNUNET_DNSPARSER_MxRecord *dup = GNUNET_memdup (r, sizeof (*r));
+  struct GNUNET_DNSPARSER_MxRecord *dup = GNUNET_memdup(r, sizeof(*r));
 
-  dup->mxhost = GNUNET_strdup (r->mxhost);
+  dup->mxhost = GNUNET_strdup(r->mxhost);
   return dup;
 }
 
@@ -835,12 +849,12 @@ GNUNET_DNSPARSER_duplicate_mx_record (const struct GNUNET_DNSPARSER_MxRecord *r)
  * @return the newly allocated record
  */
 struct GNUNET_DNSPARSER_SrvRecord *
-GNUNET_DNSPARSER_duplicate_srv_record (
+GNUNET_DNSPARSER_duplicate_srv_record(
   const struct GNUNET_DNSPARSER_SrvRecord *r)
 {
-  struct GNUNET_DNSPARSER_SrvRecord *dup = GNUNET_memdup (r, sizeof (*r));
+  struct GNUNET_DNSPARSER_SrvRecord *dup = GNUNET_memdup(r, sizeof(*r));
 
-  dup->target = GNUNET_strdup (r->target);
+  dup->target = GNUNET_strdup(r->target);
   return dup;
 }
 
@@ -851,21 +865,21 @@ GNUNET_DNSPARSER_duplicate_srv_record (
  * @param p packet to free
  */
 void
-GNUNET_DNSPARSER_free_packet (struct GNUNET_DNSPARSER_Packet *p)
+GNUNET_DNSPARSER_free_packet(struct GNUNET_DNSPARSER_Packet *p)
 {
   for (unsigned int i = 0; i < p->num_queries; i++)
-    GNUNET_free_non_null (p->queries[i].name);
-  GNUNET_free_non_null (p->queries);
+    GNUNET_free_non_null(p->queries[i].name);
+  GNUNET_free_non_null(p->queries);
   for (unsigned int i = 0; i < p->num_answers; i++)
-    GNUNET_DNSPARSER_free_record (&p->answers[i]);
-  GNUNET_free_non_null (p->answers);
+    GNUNET_DNSPARSER_free_record(&p->answers[i]);
+  GNUNET_free_non_null(p->answers);
   for (unsigned int i = 0; i < p->num_authority_records; i++)
-    GNUNET_DNSPARSER_free_record (&p->authority_records[i]);
-  GNUNET_free_non_null (p->authority_records);
+    GNUNET_DNSPARSER_free_record(&p->authority_records[i]);
+  GNUNET_free_non_null(p->authority_records);
   for (unsigned int i = 0; i < p->num_additional_records; i++)
-    GNUNET_DNSPARSER_free_record (&p->additional_records[i]);
-  GNUNET_free_non_null (p->additional_records);
-  GNUNET_free (p);
+    GNUNET_DNSPARSER_free_record(&p->additional_records[i]);
+  GNUNET_free_non_null(p->additional_records);
+  GNUNET_free(p);
 }
 
 
@@ -886,10 +900,10 @@ GNUNET_DNSPARSER_free_packet (struct GNUNET_DNSPARSER_Packet *p)
  *         #GNUNET_OK if @a name was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_name (char *dst,
-                                   size_t dst_len,
-                                   size_t *off,
-                                   const char *name)
+GNUNET_DNSPARSER_builder_add_name(char *dst,
+                                  size_t dst_len,
+                                  size_t *off,
+                                  const char *name)
 {
   const char *dot;
   const char *idna_name;
@@ -903,53 +917,54 @@ GNUNET_DNSPARSER_builder_add_name (char *dst,
     return GNUNET_SYSERR;
 
   if (IDNA_SUCCESS !=
-      (rc = idna_to_ascii_8z (name, &idna_start, IDNA_ALLOW_UNASSIGNED)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ (
-                  "Failed to convert UTF-8 name `%s' to DNS IDNA format: %s\n"),
-                name,
-                idna_strerror (rc));
-    return GNUNET_NO;
-  }
+      (rc = idna_to_ascii_8z(name, &idna_start, IDNA_ALLOW_UNASSIGNED)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _(
+                   "Failed to convert UTF-8 name `%s' to DNS IDNA format: %s\n"),
+                 name,
+                 idna_strerror(rc));
+      return GNUNET_NO;
+    }
   idna_name = idna_start;
   start = *off;
-  if (start + strlen (idna_name) + 2 > dst_len)
+  if (start + strlen(idna_name) + 2 > dst_len)
     goto fail;
   pos = start;
   do
-  {
-    dot = strchr (idna_name, '.');
-    if (NULL == dot)
-      len = strlen (idna_name);
-    else
-      len = dot - idna_name;
-    if ((len >= 64) || (0 == len))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Invalid DNS name `%s': label with %u characters encountered\n",
-                  name,
-                  (unsigned int) len);
-      goto fail; /* label too long or empty */
+      dot = strchr(idna_name, '.');
+      if (NULL == dot)
+        len = strlen(idna_name);
+      else
+        len = dot - idna_name;
+      if ((len >= 64) || (0 == len))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Invalid DNS name `%s': label with %u characters encountered\n",
+                     name,
+                     (unsigned int)len);
+          goto fail; /* label too long or empty */
+        }
+      dst[pos++] = (char)(uint8_t)len;
+      GNUNET_memcpy(&dst[pos], idna_name, len);
+      pos += len;
+      idna_name += len + 1; /* also skip dot */
     }
-    dst[pos++] = (char) (uint8_t) len;
-    GNUNET_memcpy (&dst[pos], idna_name, len);
-    pos += len;
-    idna_name += len + 1; /* also skip dot */
-  } while (NULL != dot);
+  while (NULL != dot);
   dst[pos++] = '\0'; /* terminator */
   *off = pos;
 #if WINDOWS
-  idn_free (idna_start);
+  idn_free(idna_start);
 #else
-  free (idna_start);
+  free(idna_start);
 #endif
   return GNUNET_OK;
 fail:
 #if WINDOWS
-  idn_free (idna_start);
+  idn_free(idna_start);
 #else
-  free (idna_start);
+  free(idna_start);
 #endif
   return GNUNET_NO;
 }
@@ -968,26 +983,26 @@ fail:
  *         #GNUNET_OK if @a query was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_query (char *dst,
-                                    size_t dst_len,
-                                    size_t *off,
-                                    const struct GNUNET_DNSPARSER_Query *query)
+GNUNET_DNSPARSER_builder_add_query(char *dst,
+                                   size_t dst_len,
+                                   size_t *off,
+                                   const struct GNUNET_DNSPARSER_Query *query)
 {
   int ret;
   struct GNUNET_TUN_DnsQueryLine ql;
 
-  ret = GNUNET_DNSPARSER_builder_add_name (dst,
-                                           dst_len -
-                                             sizeof (
-                                               struct GNUNET_TUN_DnsQueryLine),
-                                           off,
-                                           query->name);
+  ret = GNUNET_DNSPARSER_builder_add_name(dst,
+                                          dst_len -
+                                          sizeof(
+                                            struct GNUNET_TUN_DnsQueryLine),
+                                          off,
+                                          query->name);
   if (ret != GNUNET_OK)
     return ret;
-  ql.type = htons (query->type);
-  ql.dns_traffic_class = htons (query->dns_traffic_class);
-  GNUNET_memcpy (&dst[*off], &ql, sizeof (ql));
-  (*off) += sizeof (ql);
+  ql.type = htons(query->type);
+  ql.dns_traffic_class = htons(query->dns_traffic_class);
+  GNUNET_memcpy(&dst[*off], &ql, sizeof(ql));
+  (*off) += sizeof(ql);
   return GNUNET_OK;
 }
 
@@ -1005,19 +1020,19 @@ GNUNET_DNSPARSER_builder_add_query (char *dst,
  *         #GNUNET_OK if @a mx was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_mx (char *dst,
-                                 size_t dst_len,
-                                 size_t *off,
-                                 const struct GNUNET_DNSPARSER_MxRecord *mx)
+GNUNET_DNSPARSER_builder_add_mx(char *dst,
+                                size_t dst_len,
+                                size_t *off,
+                                const struct GNUNET_DNSPARSER_MxRecord *mx)
 {
   uint16_t mxpref;
 
-  if (*off + sizeof (uint16_t) > dst_len)
+  if (*off + sizeof(uint16_t) > dst_len)
     return GNUNET_NO;
-  mxpref = htons (mx->preference);
-  GNUNET_memcpy (&dst[*off], &mxpref, sizeof (mxpref));
-  (*off) += sizeof (mxpref);
-  return GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, mx->mxhost);
+  mxpref = htons(mx->preference);
+  GNUNET_memcpy(&dst[*off], &mxpref, sizeof(mxpref));
+  (*off) += sizeof(mxpref);
+  return GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, mx->mxhost);
 }
 
 
@@ -1034,7 +1049,7 @@ GNUNET_DNSPARSER_builder_add_mx (char *dst,
  *         #GNUNET_OK if @a cert was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_cert (
+GNUNET_DNSPARSER_builder_add_cert(
   char *dst,
   size_t dst_len,
   size_t *off,
@@ -1047,22 +1062,22 @@ GNUNET_DNSPARSER_builder_add_cert (
 #pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
 #endif
   if ((cert->cert_type > UINT16_MAX) || (cert->algorithm > UINT8_MAX))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
-  if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) + cert->certificate_size >
+  if (*off + sizeof(struct GNUNET_TUN_DnsCertRecord) + cert->certificate_size >
       dst_len)
     return GNUNET_NO;
-  dcert.cert_type = htons ((uint16_t) cert->cert_type);
-  dcert.cert_tag = htons ((uint16_t) cert->cert_tag);
-  dcert.algorithm = (uint8_t) cert->algorithm;
-  GNUNET_memcpy (&dst[*off], &dcert, sizeof (dcert));
-  (*off) += sizeof (dcert);
-  GNUNET_memcpy (&dst[*off], cert->certificate_data, cert->certificate_size);
+  dcert.cert_type = htons((uint16_t)cert->cert_type);
+  dcert.cert_tag = htons((uint16_t)cert->cert_tag);
+  dcert.algorithm = (uint8_t)cert->algorithm;
+  GNUNET_memcpy(&dst[*off], &dcert, sizeof(dcert));
+  (*off) += sizeof(dcert);
+  GNUNET_memcpy(&dst[*off], cert->certificate_data, cert->certificate_size);
   (*off) += cert->certificate_size;
   return GNUNET_OK;
 }
@@ -1081,30 +1096,30 @@ GNUNET_DNSPARSER_builder_add_cert (
  *         #GNUNET_OK if @a soa was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_soa (char *dst,
-                                  size_t dst_len,
-                                  size_t *off,
-                                  const struct GNUNET_DNSPARSER_SoaRecord *soa)
+GNUNET_DNSPARSER_builder_add_soa(char *dst,
+                                 size_t dst_len,
+                                 size_t *off,
+                                 const struct GNUNET_DNSPARSER_SoaRecord *soa)
 {
   struct GNUNET_TUN_DnsSoaRecord sd;
   int ret;
 
   if ((GNUNET_OK !=
        (ret =
-          GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, soa->mname))) ||
+          GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, soa->mname))) ||
       (GNUNET_OK !=
        (ret =
-          GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, soa->rname))))
+          GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, soa->rname))))
     return ret;
-  if (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > dst_len)
+  if (*off + sizeof(struct GNUNET_TUN_DnsSoaRecord) > dst_len)
     return GNUNET_NO;
-  sd.serial = htonl (soa->serial);
-  sd.refresh = htonl (soa->refresh);
-  sd.retry = htonl (soa->retry);
-  sd.expire = htonl (soa->expire);
-  sd.minimum = htonl (soa->minimum_ttl);
-  GNUNET_memcpy (&dst[*off], &sd, sizeof (sd));
-  (*off) += sizeof (sd);
+  sd.serial = htonl(soa->serial);
+  sd.refresh = htonl(soa->refresh);
+  sd.retry = htonl(soa->retry);
+  sd.expire = htonl(soa->expire);
+  sd.minimum = htonl(soa->minimum_ttl);
+  GNUNET_memcpy(&dst[*off], &sd, sizeof(sd));
+  (*off) += sizeof(sd);
   return GNUNET_OK;
 }
 
@@ -1122,24 +1137,24 @@ GNUNET_DNSPARSER_builder_add_soa (char *dst,
  *         #GNUNET_OK if @a srv was added to @a dst
  */
 int
-GNUNET_DNSPARSER_builder_add_srv (char *dst,
-                                  size_t dst_len,
-                                  size_t *off,
-                                  const struct GNUNET_DNSPARSER_SrvRecord *srv)
+GNUNET_DNSPARSER_builder_add_srv(char *dst,
+                                 size_t dst_len,
+                                 size_t *off,
+                                 const struct GNUNET_DNSPARSER_SrvRecord *srv)
 {
   struct GNUNET_TUN_DnsSrvRecord sd;
   int ret;
 
-  if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > dst_len)
+  if (*off + sizeof(struct GNUNET_TUN_DnsSrvRecord) > dst_len)
     return GNUNET_NO;
-  sd.prio = htons (srv->priority);
-  sd.weight = htons (srv->weight);
-  sd.port = htons (srv->port);
-  GNUNET_memcpy (&dst[*off], &sd, sizeof (sd));
-  (*off) += sizeof (sd);
+  sd.prio = htons(srv->priority);
+  sd.weight = htons(srv->weight);
+  sd.port = htons(srv->port);
+  GNUNET_memcpy(&dst[*off], &sd, sizeof(sd));
+  (*off) += sizeof(sd);
   if (GNUNET_OK !=
       (ret =
-         GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, srv->target)))
+         GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, srv->target)))
     return ret;
   return GNUNET_OK;
 }
@@ -1158,10 +1173,10 @@ GNUNET_DNSPARSER_builder_add_srv (char *dst,
  *         #GNUNET_OK if @a record was added to @a dst
  */
 static int
-add_record (char *dst,
-            size_t dst_len,
-            size_t *off,
-            const struct GNUNET_DNSPARSER_Record *record)
+add_record(char *dst,
+           size_t dst_len,
+           size_t *off,
+           const struct GNUNET_DNSPARSER_Record *record)
 {
   int ret;
   size_t start;
@@ -1169,73 +1184,78 @@ add_record (char *dst,
   struct GNUNET_TUN_DnsRecordLine rl;
 
   start = *off;
-  ret = GNUNET_DNSPARSER_builder_add_name (dst,
-                                           dst_len -
-                                             sizeof (
-                                               struct GNUNET_TUN_DnsRecordLine),
-                                           off,
-                                           record->name);
+  ret = GNUNET_DNSPARSER_builder_add_name(dst,
+                                          dst_len -
+                                          sizeof(
+                                            struct GNUNET_TUN_DnsRecordLine),
+                                          off,
+                                          record->name);
   if (GNUNET_OK != ret)
     return ret;
   /* '*off' is now the position where we will need to write the record line */
 
-  pos = *off + sizeof (struct GNUNET_TUN_DnsRecordLine);
+  pos = *off + sizeof(struct GNUNET_TUN_DnsRecordLine);
   switch (record->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_MX:
-    ret = GNUNET_DNSPARSER_builder_add_mx (dst, dst_len, &pos, record->data.mx);
-    break;
-  case GNUNET_DNSPARSER_TYPE_CERT:
-    ret =
-      GNUNET_DNSPARSER_builder_add_cert (dst, dst_len, &pos, record->data.cert);
-    break;
-  case GNUNET_DNSPARSER_TYPE_SOA:
-    ret =
-      GNUNET_DNSPARSER_builder_add_soa (dst, dst_len, &pos, record->data.soa);
-    break;
-  case GNUNET_DNSPARSER_TYPE_NS:
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-  case GNUNET_DNSPARSER_TYPE_PTR:
-    ret = GNUNET_DNSPARSER_builder_add_name (dst,
-                                             dst_len,
-                                             &pos,
-                                             record->data.hostname);
-    break;
-  case GNUNET_DNSPARSER_TYPE_SRV:
-    ret =
-      GNUNET_DNSPARSER_builder_add_srv (dst, dst_len, &pos, record->data.srv);
-    break;
-  default:
-    if (pos + record->data.raw.data_len > dst_len)
     {
-      ret = GNUNET_NO;
+    case GNUNET_DNSPARSER_TYPE_MX:
+      ret = GNUNET_DNSPARSER_builder_add_mx(dst, dst_len, &pos, record->data.mx);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_CERT:
+      ret =
+        GNUNET_DNSPARSER_builder_add_cert(dst, dst_len, &pos, record->data.cert);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SOA:
+      ret =
+        GNUNET_DNSPARSER_builder_add_soa(dst, dst_len, &pos, record->data.soa);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_NS:
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+    case GNUNET_DNSPARSER_TYPE_PTR:
+      ret = GNUNET_DNSPARSER_builder_add_name(dst,
+                                              dst_len,
+                                              &pos,
+                                              record->data.hostname);
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_SRV:
+      ret =
+        GNUNET_DNSPARSER_builder_add_srv(dst, dst_len, &pos, record->data.srv);
+      break;
+
+    default:
+      if (pos + record->data.raw.data_len > dst_len)
+        {
+          ret = GNUNET_NO;
+          break;
+        }
+      GNUNET_memcpy(&dst[pos], record->data.raw.data, record->data.raw.data_len);
+      pos += record->data.raw.data_len;
+      ret = GNUNET_OK;
       break;
     }
-    GNUNET_memcpy (&dst[pos], record->data.raw.data, record->data.raw.data_len);
-    pos += record->data.raw.data_len;
-    ret = GNUNET_OK;
-    break;
-  }
   if (GNUNET_OK != ret)
-  {
-    *off = start;
-    return GNUNET_NO;
-  }
+    {
+      *off = start;
+      return GNUNET_NO;
+    }
 
-  if (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine)) > UINT16_MAX)
-  {
-    /* record data too long */
-    *off = start;
-    return GNUNET_NO;
-  }
-  rl.type = htons (record->type);
-  rl.dns_traffic_class = htons (record->dns_traffic_class);
-  rl.ttl = htonl (
-    GNUNET_TIME_absolute_get_remaining (record->expiration_time).rel_value_us /
+  if (pos - (*off + sizeof(struct GNUNET_TUN_DnsRecordLine)) > UINT16_MAX)
+    {
+      /* record data too long */
+      *off = start;
+      return GNUNET_NO;
+    }
+  rl.type = htons(record->type);
+  rl.dns_traffic_class = htons(record->dns_traffic_class);
+  rl.ttl = htonl(
+    GNUNET_TIME_absolute_get_remaining(record->expiration_time).rel_value_us /
     1000LL / 1000LL); /* in seconds */
-  rl.data_len = htons (
-    (uint16_t) (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine))));
-  GNUNET_memcpy (&dst[*off], &rl, sizeof (struct GNUNET_TUN_DnsRecordLine));
+  rl.data_len = htons(
+    (uint16_t)(pos - (*off + sizeof(struct GNUNET_TUN_DnsRecordLine))));
+  GNUNET_memcpy(&dst[*off], &rl, sizeof(struct GNUNET_TUN_DnsRecordLine));
   *off = pos;
   return GNUNET_OK;
 }
@@ -1256,10 +1276,10 @@ add_record (char *dst,
  *         #GNUNET_OK if @a p was packed completely into @a buf
  */
 int
-GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p,
-                       uint16_t max,
-                       char **buf,
-                       size_t *buf_length)
+GNUNET_DNSPARSER_pack(const struct GNUNET_DNSPARSER_Packet *p,
+                      uint16_t max,
+                      char **buf,
+                      size_t *buf_length)
 {
   struct GNUNET_TUN_DnsHeader dns;
   size_t off;
@@ -1273,72 +1293,72 @@ GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p,
     return GNUNET_SYSERR;
   dns.id = p->id;
   dns.flags = p->flags;
-  dns.query_count = htons (p->num_queries);
-  dns.answer_rcount = htons (p->num_answers);
-  dns.authority_rcount = htons (p->num_authority_records);
-  dns.additional_rcount = htons (p->num_additional_records);
+  dns.query_count = htons(p->num_queries);
+  dns.answer_rcount = htons(p->num_answers);
+  dns.authority_rcount = htons(p->num_authority_records);
+  dns.additional_rcount = htons(p->num_additional_records);
 
-  off = sizeof (struct GNUNET_TUN_DnsHeader);
+  off = sizeof(struct GNUNET_TUN_DnsHeader);
   trc = GNUNET_NO;
   for (unsigned int i = 0; i < p->num_queries; i++)
-  {
-    ret = GNUNET_DNSPARSER_builder_add_query (tmp,
-                                              sizeof (tmp),
-                                              &off,
-                                              &p->queries[i]);
-    if (GNUNET_SYSERR == ret)
-      return GNUNET_SYSERR;
-    if (GNUNET_NO == ret)
     {
-      dns.query_count = htons ((uint16_t) (i - 1));
-      trc = GNUNET_YES;
-      break;
+      ret = GNUNET_DNSPARSER_builder_add_query(tmp,
+                                               sizeof(tmp),
+                                               &off,
+                                               &p->queries[i]);
+      if (GNUNET_SYSERR == ret)
+        return GNUNET_SYSERR;
+      if (GNUNET_NO == ret)
+        {
+          dns.query_count = htons((uint16_t)(i - 1));
+          trc = GNUNET_YES;
+          break;
+        }
     }
-  }
   for (unsigned int i = 0; i < p->num_answers; i++)
-  {
-    ret = add_record (tmp, sizeof (tmp), &off, &p->answers[i]);
-    if (GNUNET_SYSERR == ret)
-      return GNUNET_SYSERR;
-    if (GNUNET_NO == ret)
     {
-      dns.answer_rcount = htons ((uint16_t) (i - 1));
-      trc = GNUNET_YES;
-      break;
+      ret = add_record(tmp, sizeof(tmp), &off, &p->answers[i]);
+      if (GNUNET_SYSERR == ret)
+        return GNUNET_SYSERR;
+      if (GNUNET_NO == ret)
+        {
+          dns.answer_rcount = htons((uint16_t)(i - 1));
+          trc = GNUNET_YES;
+          break;
+        }
     }
-  }
   for (unsigned int i = 0; i < p->num_authority_records; i++)
-  {
-    ret = add_record (tmp, sizeof (tmp), &off, &p->authority_records[i]);
-    if (GNUNET_SYSERR == ret)
-      return GNUNET_SYSERR;
-    if (GNUNET_NO == ret)
     {
-      dns.authority_rcount = htons ((uint16_t) (i - 1));
-      trc = GNUNET_YES;
-      break;
+      ret = add_record(tmp, sizeof(tmp), &off, &p->authority_records[i]);
+      if (GNUNET_SYSERR == ret)
+        return GNUNET_SYSERR;
+      if (GNUNET_NO == ret)
+        {
+          dns.authority_rcount = htons((uint16_t)(i - 1));
+          trc = GNUNET_YES;
+          break;
+        }
     }
-  }
   for (unsigned int i = 0; i < p->num_additional_records; i++)
-  {
-    ret = add_record (tmp, sizeof (tmp), &off, &p->additional_records[i]);
-    if (GNUNET_SYSERR == ret)
-      return GNUNET_SYSERR;
-    if (GNUNET_NO == ret)
     {
-      dns.additional_rcount = htons (i - 1);
-      trc = GNUNET_YES;
-      break;
+      ret = add_record(tmp, sizeof(tmp), &off, &p->additional_records[i]);
+      if (GNUNET_SYSERR == ret)
+        return GNUNET_SYSERR;
+      if (GNUNET_NO == ret)
+        {
+          dns.additional_rcount = htons(i - 1);
+          trc = GNUNET_YES;
+          break;
+        }
     }
-  }
 
   if (GNUNET_YES == trc)
     dns.flags.message_truncated = 1;
-  GNUNET_memcpy (tmp, &dns, sizeof (struct GNUNET_TUN_DnsHeader));
+  GNUNET_memcpy(tmp, &dns, sizeof(struct GNUNET_TUN_DnsHeader));
 
-  *buf = GNUNET_malloc (off);
+  *buf = GNUNET_malloc(off);
   *buf_length = off;
-  GNUNET_memcpy (*buf, tmp, off);
+  GNUNET_memcpy(*buf, tmp, off);
   if (GNUNET_YES == trc)
     return GNUNET_NO;
   return GNUNET_OK;
@@ -1353,16 +1373,16 @@ GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p,
  * @return HEX string (lower case)
  */
 char *
-GNUNET_DNSPARSER_bin_to_hex (const void *data, size_t data_size)
+GNUNET_DNSPARSER_bin_to_hex(const void *data, size_t data_size)
 {
   char *ret;
   size_t off;
   const uint8_t *idata;
 
   idata = data;
-  ret = GNUNET_malloc (data_size * 2 + 1);
+  ret = GNUNET_malloc(data_size * 2 + 1);
   for (off = 0; off < data_size; off++)
-    sprintf (&ret[off * 2], "%02x", idata[off]);
+    sprintf(&ret[off * 2], "%02x", idata[off]);
   return ret;
 }
 
@@ -1376,7 +1396,7 @@ GNUNET_DNSPARSER_bin_to_hex (const void *data, size_t data_size)
  * @return number of bytes written to data
  */
 size_t
-GNUNET_DNSPARSER_hex_to_bin (const char *hex, void *data)
+GNUNET_DNSPARSER_hex_to_bin(const char *hex, void *data)
 {
   size_t data_size;
   size_t off;
@@ -1384,17 +1404,17 @@ GNUNET_DNSPARSER_hex_to_bin (const char *hex, void *data)
   unsigned int h;
   char in[3];
 
-  data_size = strlen (hex) / 2;
+  data_size = strlen(hex) / 2;
   idata = data;
   in[2] = '\0';
   for (off = 0; off < data_size; off++)
-  {
-    in[0] = tolower ((unsigned char) hex[off * 2]);
-    in[1] = tolower ((unsigned char) hex[off * 2 + 1]);
-    if (1 != sscanf (in, "%x", &h))
-      return off;
-    idata[off] = (uint8_t) h;
-  }
+    {
+      in[0] = tolower((unsigned char)hex[off * 2]);
+      in[1] = tolower((unsigned char)hex[off * 2 + 1]);
+      if (1 != sscanf(in, "%x", &h))
+        return off;
+      idata[off] = (uint8_t)h;
+    }
   return off;
 }
 
diff --git a/src/util/dnsstub.c b/src/util/dnsstub.c
index aa0c2191a..ab7a08318 100644
--- a/src/util/dnsstub.c
+++ b/src/util/dnsstub.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 dns/dnsstub.c
  * @brief DNS stub resolver which sends DNS requests to an actual resolver
@@ -29,7 +29,7 @@
  * Timeout for retrying DNS queries.
  */
 #define DNS_RETRANSMIT_DELAY \
-  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
 
 
 /**
@@ -41,9 +41,7 @@ struct DnsServer;
 /**
  * UDP socket we are using for sending DNS requests to the Internet.
  */
-struct GNUNET_DNSSTUB_RequestSocket
-{
-
+struct GNUNET_DNSSTUB_RequestSocket {
   /**
    * UDP socket we use for this request for IPv4
    */
@@ -99,9 +97,7 @@ struct GNUNET_DNSSTUB_RequestSocket
 /**
  * DNS Server used for resolution.
  */
-struct DnsServer
-{
-
+struct DnsServer {
   /**
    * Kept in a DLL.
    */
@@ -122,9 +118,7 @@ struct DnsServer
 /**
  * Handle to the stub resolver.
  */
-struct GNUNET_DNSSTUB_Context
-{
-
+struct GNUNET_DNSSTUB_Context {
   /**
    * Array of all open sockets for DNS requests.
    */
@@ -158,33 +152,33 @@ struct GNUNET_DNSSTUB_Context
  * @param rs request socket to clean up
  */
 static void
-cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
+cleanup_rs(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   if (NULL != rs->dnsout4)
-  {
-    GNUNET_NETWORK_socket_close (rs->dnsout4);
-    rs->dnsout4 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(rs->dnsout4);
+      rs->dnsout4 = NULL;
+    }
   if (NULL != rs->dnsout6)
-  {
-    GNUNET_NETWORK_socket_close (rs->dnsout6);
-    rs->dnsout6 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(rs->dnsout6);
+      rs->dnsout6 = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->read_task);
+      rs->read_task = NULL;
+    }
   if (NULL != rs->retry_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->retry_task);
-    rs->retry_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->request)
-  {
-    GNUNET_free (rs->request);
-    rs->request = NULL;
-  }
+    {
+      GNUNET_free(rs->request);
+      rs->request = NULL;
+    }
 }
 
 
@@ -195,7 +189,7 @@ cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @return #GNUNET_OK on success
  */
 static struct GNUNET_NETWORK_Handle *
-open_socket (int af)
+open_socket(int af)
 {
   struct sockaddr_in a4;
   struct sockaddr_in6 a6;
@@ -203,33 +197,35 @@ open_socket (int af)
   socklen_t alen;
   struct GNUNET_NETWORK_Handle *ret;
 
-  ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
+  ret = GNUNET_NETWORK_socket_create(af, SOCK_DGRAM, 0);
   if (NULL == ret)
     return NULL;
   switch (af)
-  {
-  case AF_INET:
-    memset (&a4, 0, alen = sizeof (struct sockaddr_in));
-    sa = (struct sockaddr *) &a4;
-    break;
-  case AF_INET6:
-    memset (&a6, 0, alen = sizeof (struct sockaddr_in6));
-    sa = (struct sockaddr *) &a6;
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_NETWORK_socket_close (ret);
-    return NULL;
-  }
+    {
+    case AF_INET:
+      memset(&a4, 0, alen = sizeof(struct sockaddr_in));
+      sa = (struct sockaddr *)&a4;
+      break;
+
+    case AF_INET6:
+      memset(&a6, 0, alen = sizeof(struct sockaddr_in6));
+      sa = (struct sockaddr *)&a6;
+      break;
+
+    default:
+      GNUNET_break(0);
+      GNUNET_NETWORK_socket_close(ret);
+      return NULL;
+    }
   sa->sa_family = af;
-  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not bind to any port: %s\n"),
-                strerror (errno));
-    GNUNET_NETWORK_socket_close (ret);
-    return NULL;
-  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_bind(ret, sa, alen))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not bind to any port: %s\n"),
+                 strerror(errno));
+      GNUNET_NETWORK_socket_close(ret);
+      return NULL;
+    }
   return ret;
 }
 
@@ -242,38 +238,38 @@ open_socket (int af)
  * @return NULL on error
  */
 static struct GNUNET_DNSSTUB_RequestSocket *
-get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
+get_request_socket(struct GNUNET_DNSSTUB_Context *ctx)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs;
 
   for (unsigned int i = 0; i < 256; i++)
-  {
-    rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                                 ctx->num_sockets)];
-    if (NULL == rs->rc)
-      break;
-  }
+    {
+      rs = &ctx->sockets[GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
+                                                  ctx->num_sockets)];
+      if (NULL == rs->rc)
+        break;
+    }
   if (NULL != rs->rc)
-  {
-    /* signal "failure" */
-    rs->rc (rs->rc_cls, NULL, 0);
-    rs->rc = NULL;
-  }
+    {
+      /* signal "failure" */
+      rs->rc(rs->rc_cls, NULL, 0);
+      rs->rc = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->read_task);
+      rs->read_task = NULL;
+    }
   if (NULL != rs->retry_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->retry_task);
-    rs->retry_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->request)
-  {
-    GNUNET_free (rs->request);
-    rs->request = NULL;
-  }
+    {
+      GNUNET_free(rs->request);
+      rs->request = NULL;
+    }
   rs->ctx = ctx;
   return rs;
 }
@@ -288,24 +284,24 @@ get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
  * @return #GNUNET_OK on success, #GNUNET_NO on drop, #GNUNET_SYSERR on IO-errors (closed socket)
  */
 static int
-do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
-             struct GNUNET_NETWORK_Handle *dnsout)
+do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs,
+            struct GNUNET_NETWORK_Handle *dnsout)
 {
   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
   ssize_t r;
   int len;
 
 #ifndef MINGW
-  if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
-  {
-    /* conservative choice: */
-    len = UINT16_MAX;
-  }
+  if (0 != ioctl(GNUNET_NETWORK_get_fd(dnsout), FIONREAD, &len))
+    {
+      /* conservative choice: */
+      len = UINT16_MAX;
+    }
 #else
   /* port the code above? */
   len = UINT16_MAX;
 #endif
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
   {
     unsigned char buf[len] GNUNET_ALIGN;
     int found;
@@ -313,51 +309,51 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
     socklen_t addrlen;
     struct GNUNET_TUN_DnsHeader *dns;
 
-    addrlen = sizeof (addr);
-    memset (&addr, 0, sizeof (addr));
-    r = GNUNET_NETWORK_socket_recvfrom (dnsout,
-                                        buf,
-                                        sizeof (buf),
-                                        (struct sockaddr *) &addr,
-                                        &addrlen);
+    addrlen = sizeof(addr);
+    memset(&addr, 0, sizeof(addr));
+    r = GNUNET_NETWORK_socket_recvfrom(dnsout,
+                                       buf,
+                                       sizeof(buf),
+                                       (struct sockaddr *)&addr,
+                                       &addrlen);
     if (-1 == r)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
-      GNUNET_NETWORK_socket_close (dnsout);
-      return GNUNET_SYSERR;
-    }
+      {
+        GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "recvfrom");
+        GNUNET_NETWORK_socket_close(dnsout);
+        return GNUNET_SYSERR;
+      }
     found = GNUNET_NO;
     for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
-    {
-      if (0 == memcmp (&addr,
-                       &ds->ss,
-                       GNUNET_MIN (sizeof (struct sockaddr_storage), addrlen)))
       {
-        found = GNUNET_YES;
-        break;
+        if (0 == memcmp(&addr,
+                        &ds->ss,
+                        GNUNET_MIN(sizeof(struct sockaddr_storage), addrlen)))
+          {
+            found = GNUNET_YES;
+            break;
+          }
       }
-    }
     if (GNUNET_NO == found)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received DNS response from server we never asked (ignored)");
-      return GNUNET_NO;
-    }
-    if (sizeof (struct GNUNET_TUN_DnsHeader) > (size_t) r)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Received DNS response that is too small (%u bytes)"),
-                  (unsigned int) r);
-      return GNUNET_NO;
-    }
-    dns = (struct GNUNET_TUN_DnsHeader *) buf;
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Received DNS response from server we never asked (ignored)");
+        return GNUNET_NO;
+      }
+    if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t)r)
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   _("Received DNS response that is too small (%u bytes)"),
+                   (unsigned int)r);
+        return GNUNET_NO;
+      }
+    dns = (struct GNUNET_TUN_DnsHeader *)buf;
     if (NULL == rs->rc)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Request timeout or cancelled; ignoring reply\n");
-      return GNUNET_NO;
-    }
-    rs->rc (rs->rc_cls, dns, r);
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Request timeout or cancelled; ignoring reply\n");
+        return GNUNET_NO;
+      }
+    rs->rc(rs->rc_cls, dns, r);
   }
   return GNUNET_OK;
 }
@@ -369,7 +365,7 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
  * @param cls socket to read from
  */
 static void
-read_response (void *cls);
+read_response(void *cls);
 
 
 /**
@@ -378,25 +374,25 @@ read_response (void *cls);
  * @param rs request to schedule read operation for
  */
 static void
-schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
+schedule_read(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   struct GNUNET_NETWORK_FDSet *rset;
 
   if (NULL != rs->read_task)
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-  rset = GNUNET_NETWORK_fdset_create ();
+    GNUNET_SCHEDULER_cancel(rs->read_task);
+  rset = GNUNET_NETWORK_fdset_create();
   if (NULL != rs->dnsout4)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
+    GNUNET_NETWORK_fdset_set(rset, rs->dnsout4);
   if (NULL != rs->dnsout6)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
+    GNUNET_NETWORK_fdset_set(rset, rs->dnsout6);
   rs->read_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                 rset,
-                                 NULL,
-                                 &read_response,
-                                 rs);
-  GNUNET_NETWORK_fdset_destroy (rset);
+    GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                rset,
+                                NULL,
+                                &read_response,
+                                rs);
+  GNUNET_NETWORK_fdset_destroy(rset);
 }
 
 
@@ -406,24 +402,24 @@ schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @param cls `struct GNUNET_DNSSTUB_RequestSocket` to read from
  */
 static void
-read_response (void *cls)
+read_response(void *cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   rs->read_task = NULL;
-  tc = GNUNET_SCHEDULER_get_task_context ();
+  tc = GNUNET_SCHEDULER_get_task_context();
   /* read and process ready sockets */
   if ((NULL != rs->dnsout4) &&
-      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) &&
-      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4)))
+      (GNUNET_NETWORK_fdset_isset(tc->read_ready, rs->dnsout4)) &&
+      (GNUNET_SYSERR == do_dns_read(rs, rs->dnsout4)))
     rs->dnsout4 = NULL;
   if ((NULL != rs->dnsout6) &&
-      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) &&
-      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6)))
+      (GNUNET_NETWORK_fdset_isset(tc->read_ready, rs->dnsout6)) &&
+      (GNUNET_SYSERR == do_dns_read(rs, rs->dnsout6)))
     rs->dnsout6 = NULL;
   /* re-schedule read task */
-  schedule_read (rs);
+  schedule_read(rs);
 }
 
 
@@ -434,7 +430,7 @@ read_response (void *cls)
  * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *`
  */
 static void
-transmit_query (void *cls)
+transmit_query(void *cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
@@ -444,52 +440,54 @@ transmit_query (void *cls)
   struct GNUNET_NETWORK_Handle *dnsout;
 
   rs->retry_task =
-    GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs);
+    GNUNET_SCHEDULER_add_delayed(ctx->retry_freq, &transmit_query, rs);
   ds = rs->ds_pos;
   rs->ds_pos = ds->next;
   if (NULL == rs->ds_pos)
     rs->ds_pos = ctx->dns_head;
-  GNUNET_assert (NULL != ds);
+  GNUNET_assert(NULL != ds);
   dnsout = NULL;
   switch (ds->ss.ss_family)
-  {
-  case AF_INET:
-    if (NULL == rs->dnsout4)
-      rs->dnsout4 = open_socket (AF_INET);
-    dnsout = rs->dnsout4;
-    sa = (const struct sockaddr *) &ds->ss;
-    salen = sizeof (struct sockaddr_in);
-    break;
-  case AF_INET6:
-    if (NULL == rs->dnsout6)
-      rs->dnsout6 = open_socket (AF_INET6);
-    dnsout = rs->dnsout6;
-    sa = (const struct sockaddr *) &ds->ss;
-    salen = sizeof (struct sockaddr_in6);
-    break;
-  default:
-    return;
-  }
+    {
+    case AF_INET:
+      if (NULL == rs->dnsout4)
+        rs->dnsout4 = open_socket(AF_INET);
+      dnsout = rs->dnsout4;
+      sa = (const struct sockaddr *)&ds->ss;
+      salen = sizeof(struct sockaddr_in);
+      break;
+
+    case AF_INET6:
+      if (NULL == rs->dnsout6)
+        rs->dnsout6 = open_socket(AF_INET6);
+      dnsout = rs->dnsout6;
+      sa = (const struct sockaddr *)&ds->ss;
+      salen = sizeof(struct sockaddr_in6);
+      break;
+
+    default:
+      return;
+    }
   if (NULL == dnsout)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to use configure DNS server, skipping\n");
-    return;
-  }
-  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout,
-                                                     rs->request,
-                                                     rs->request_len,
-                                                     sa,
-                                                     salen))
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Failed to send DNS request to %s: %s\n"),
-                GNUNET_a2s (sa, salen),
-                strerror (errno));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to use configure DNS server, skipping\n");
+      return;
+    }
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto(dnsout,
+                                                    rs->request,
+                                                    rs->request_len,
+                                                    sa,
+                                                    salen))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("Failed to send DNS request to %s: %s\n"),
+               GNUNET_a2s(sa, salen),
+               strerror(errno));
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _ ("Sent DNS request to %s\n"),
-                GNUNET_a2s (sa, salen));
-  schedule_read (rs);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               _("Sent DNS request to %s\n"),
+               GNUNET_a2s(sa, salen));
+  schedule_read(rs);
 }
 
 
@@ -504,32 +502,32 @@ transmit_query (void *cls)
  * @return socket used for the request, NULL on error
  */
 struct GNUNET_DNSSTUB_RequestSocket *
-GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
-                        const void *request,
-                        size_t request_len,
-                        GNUNET_DNSSTUB_ResultCallback rc,
-                        void *rc_cls)
+GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx,
+                       const void *request,
+                       size_t request_len,
+                       GNUNET_DNSSTUB_ResultCallback rc,
+                       void *rc_cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs;
 
   if (NULL == ctx->dns_head)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "No DNS server configured for resolution\n");
-    return NULL;
-  }
-  if (NULL == (rs = get_request_socket (ctx)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "No request socket available for DNS resolution\n");
-    return NULL;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "No DNS server configured for resolution\n");
+      return NULL;
+    }
+  if (NULL == (rs = get_request_socket(ctx)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "No request socket available for DNS resolution\n");
+      return NULL;
+    }
   rs->ds_pos = ctx->dns_head;
   rs->rc = rc;
   rs->rc_cls = rc_cls;
-  rs->request = GNUNET_memdup (request, request_len);
+  rs->request = GNUNET_memdup(request, request_len);
   rs->request_len = request_len;
-  rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query, rs);
+  rs->retry_task = GNUNET_SCHEDULER_add_now(&transmit_query, rs);
   return rs;
 }
 
@@ -540,19 +538,19 @@ GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
  * @param rs resolution to cancel
  */
 void
-GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
+GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   rs->rc = NULL;
   if (NULL != rs->retry_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->retry_task);
-    rs->retry_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->read_task);
+      rs->read_task = NULL;
+    }
 }
 
 
@@ -564,19 +562,19 @@ GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @return NULL on error
  */
 struct GNUNET_DNSSTUB_Context *
-GNUNET_DNSSTUB_start (unsigned int num_sockets)
+GNUNET_DNSSTUB_start(unsigned int num_sockets)
 {
   struct GNUNET_DNSSTUB_Context *ctx;
 
   if (0 == num_sockets)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  ctx = GNUNET_new (struct GNUNET_DNSSTUB_Context);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  ctx = GNUNET_new(struct GNUNET_DNSSTUB_Context);
   ctx->num_sockets = num_sockets;
   ctx->sockets =
-    GNUNET_new_array (num_sockets, struct GNUNET_DNSSTUB_RequestSocket);
+    GNUNET_new_array(num_sockets, struct GNUNET_DNSSTUB_RequestSocket);
   ctx->retry_freq = DNS_RETRANSMIT_DELAY;
   return ctx;
 }
@@ -591,45 +589,45 @@ GNUNET_DNSSTUB_start (unsigned int num_sockets)
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
-                           const char *dns_ip)
+GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx,
+                          const char *dns_ip)
 {
   struct DnsServer *ds;
   struct in_addr i4;
   struct in6_addr i6;
 
-  ds = GNUNET_new (struct DnsServer);
-  if (1 == inet_pton (AF_INET, dns_ip, &i4))
-  {
-    struct sockaddr_in *s4 = (struct sockaddr_in *) &ds->ss;
+  ds = GNUNET_new(struct DnsServer);
+  if (1 == inet_pton(AF_INET, dns_ip, &i4))
+    {
+      struct sockaddr_in *s4 = (struct sockaddr_in *)&ds->ss;
 
-    s4->sin_family = AF_INET;
-    s4->sin_port = htons (53);
-    s4->sin_addr = i4;
+      s4->sin_family = AF_INET;
+      s4->sin_port = htons(53);
+      s4->sin_addr = i4;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    s4->sin_len = (u_char) sizeof (struct sockaddr_in);
+      s4->sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-  }
-  else if (1 == inet_pton (AF_INET6, dns_ip, &i6))
-  {
-    struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &ds->ss;
+    }
+  else if (1 == inet_pton(AF_INET6, dns_ip, &i6))
+    {
+      struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&ds->ss;
 
-    s6->sin6_family = AF_INET6;
-    s6->sin6_port = htons (53);
-    s6->sin6_addr = i6;
+      s6->sin6_family = AF_INET6;
+      s6->sin6_port = htons(53);
+      s6->sin6_addr = i6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    s6->sin6_len = (u_char) sizeof (struct sockaddr_in6);
+      s6->sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-  }
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Malformed IP address `%s' for DNS server\n",
-                dns_ip);
-    GNUNET_free (ds);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Malformed IP address `%s' for DNS server\n",
+                 dns_ip);
+      GNUNET_free(ds);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds);
   return GNUNET_OK;
 }
 
@@ -643,26 +641,28 @@ GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
-                           const struct sockaddr *sa)
+GNUNET_DNSSTUB_add_dns_sa(struct GNUNET_DNSSTUB_Context *ctx,
+                          const struct sockaddr *sa)
 {
   struct DnsServer *ds;
 
-  ds = GNUNET_new (struct DnsServer);
+  ds = GNUNET_new(struct DnsServer);
   switch (sa->sa_family)
-  {
-  case AF_INET:
-    GNUNET_memcpy (&ds->ss, sa, sizeof (struct sockaddr_in));
-    break;
-  case AF_INET6:
-    GNUNET_memcpy (&ds->ss, sa, sizeof (struct sockaddr_in6));
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_free (ds);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
+    {
+    case AF_INET:
+      GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in));
+      break;
+
+    case AF_INET6:
+      GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in6));
+      break;
+
+    default:
+      GNUNET_break(0);
+      GNUNET_free(ds);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds);
   return GNUNET_OK;
 }
 
@@ -675,8 +675,8 @@ GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
  * @param retry_freq how long to wait between retries
  */
 void
-GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
-                          struct GNUNET_TIME_Relative retry_freq)
+GNUNET_DNSSTUB_set_retry(struct GNUNET_DNSSTUB_Context *ctx,
+                         struct GNUNET_TIME_Relative retry_freq)
 {
   ctx->retry_freq = retry_freq;
 }
@@ -688,19 +688,19 @@ GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
  * @param ctx stub resolver to clean up
  */
 void
-GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
+GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx)
 {
   struct DnsServer *ds;
 
   while (NULL != (ds = ctx->dns_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (ctx->dns_head, ctx->dns_tail, ds);
-    GNUNET_free (ds);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(ctx->dns_head, ctx->dns_tail, ds);
+      GNUNET_free(ds);
+    }
   for (unsigned int i = 0; i < ctx->num_sockets; i++)
-    cleanup_rs (&ctx->sockets[i]);
-  GNUNET_free (ctx->sockets);
-  GNUNET_free (ctx);
+    cleanup_rs(&ctx->sockets[i]);
+  GNUNET_free(ctx->sockets);
+  GNUNET_free(ctx);
 }
 
 
diff --git a/src/util/getopt.c b/src/util/getopt.c
index 678e2a61f..19b160cc9 100644
--- a/src/util/getopt.c
+++ b/src/util/getopt.c
@@ -6,28 +6,28 @@
    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
      Free Software Foundation, Inc.
 
-NOTE: The canonical source of this file is maintained with the GNU C Library.
-Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+   NOTE: The canonical source of this file is maintained with the GNU C Library.
+   Bugs can be reported to bug-glibc@prep.ai.mit.edu.
 
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 3, or (at your option) any
-later version.
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 3, or (at your option) any
+   later version.
 
-This program 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 General Public License for more details.
+   This program 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 General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-USA.
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+   USA.
 
 
-This code was heavily modified for GNUnet.
-Copyright (C) 2006, 2017 Christian Grothoff
-*/
+   This code was heavily modified for GNUnet.
+   Copyright (C) 2006, 2017 Christian Grothoff
+ */
 
 /**
  * @file util/getopt.c
@@ -47,15 +47,15 @@ Copyright (C) 2006, 2017 Christian Grothoff
 #endif
 #endif
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-getopt", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-getopt", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-getopt", syscall)
+  GNUNET_log_from_strerror(kind, "util-getopt", syscall)
 
-#if defined(WIN32) && ! defined(__CYGWIN32__)
+#if defined(WIN32) && !defined(__CYGWIN32__)
 /* It's not Unix, really.  See?  Capital letters.  */
 #include <windows.h>
-#define getpid() GetCurrentProcessId ()
+#define getpid() GetCurrentProcessId()
 #endif
 
 #ifndef _
@@ -63,7 +63,7 @@ Copyright (C) 2006, 2017 Christian Grothoff
    When compiling libc, the _ macro is predefined.  */
 #ifdef HAVE_LIBINTL_H
 #include <libintl.h>
-#define _(msgid) gettext (msgid)
+#define _(msgid) gettext(msgid)
 #else
 #define _(msgid) (msgid)
 #endif
@@ -75,7 +75,7 @@ Copyright (C) 2006, 2017 Christian Grothoff
    zero.
 
    The field `has_arg' is:
-   no_argument          (or 0) if the option does not take an argument,
+   no_argument          (or 0) if the option does not take an argument,
    required_argument  (or 1) if the option requires an argument,
    optional_argument   (or 2) if the option takes an optional argument.
 
@@ -90,8 +90,7 @@ Copyright (C) 2006, 2017 Christian Grothoff
    one).  For long options that have a zero `flag' field, `getopt'
    returns the contents of the `val' field.  */
 
-struct GNoption
-{
+struct GNoption {
   const char *name;
   /* has_arg can't be an enum because some compilers complain about
    * type mismatches in all the code that assumes it is an int.  */
@@ -195,17 +194,17 @@ static char *posixly_correct;
    whose names are inconsistent.  */
 
 char *
-getenv ();
+getenv();
 
 static char *
-my_index (const char *str, int chr)
+my_index(const char *str, int chr)
 {
   while (*str)
-  {
-    if (*str == chr)
-      return (char *) str;
-    str++;
-  }
+    {
+      if (*str == chr)
+        return (char *)str;
+      str++;
+    }
   return 0;
 }
 
@@ -214,11 +213,11 @@ my_index (const char *str, int chr)
 #ifdef __GNUC__
 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
    That was relevant to code that was here before.  */
-#if ! defined(__STDC__) || ! __STDC__
+#if !defined(__STDC__) || !__STDC__
 /* gcc with -traditional declares the built-in strlen to return int,
    and has done so at least since version 2.4.5. -- rms.  */
 extern int
-strlen (const char *);
+strlen(const char *);
 #endif /* not __STDC__ */
 #endif /* __GNUC__ */
 
@@ -246,11 +245,11 @@ static int last_nonopt;
 
 #if defined(__STDC__) && __STDC__
 static void
-exchange (char **);
+exchange(char **);
 #endif
 
 static void
-exchange (char **argv)
+exchange(char **argv)
 {
   int bottom = first_nonopt;
   int middle = last_nonopt;
@@ -263,42 +262,42 @@ exchange (char **argv)
    * but it consists of two parts that need to be swapped next.  */
 
   while (top > middle && middle > bottom)
-  {
-    if (top - middle > middle - bottom)
     {
-      /* Bottom segment is the short one.  */
-      int len = middle - bottom;
-      register int i;
+      if (top - middle > middle - bottom)
+        {
+          /* Bottom segment is the short one.  */
+          int len = middle - bottom;
+          register int i;
 
-      /* Swap it with the top part of the top segment.  */
-      for (i = 0; i < len; i++)
-      {
-        tem = argv[bottom + i];
-        argv[bottom + i] = argv[top - (middle - bottom) + i];
-        argv[top - (middle - bottom) + i] = tem;
-        SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
-      }
-      /* Exclude the moved bottom segment from further swapping.  */
-      top -= len;
-    }
-    else
-    {
-      /* Top segment is the short one.  */
-      int len = top - middle;
-      register int i;
+          /* Swap it with the top part of the top segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[top - (middle - bottom) + i];
+              argv[top - (middle - bottom) + i] = tem;
+              SWAP_FLAGS(bottom + i, top - (middle - bottom) + i);
+            }
+          /* Exclude the moved bottom segment from further swapping.  */
+          top -= len;
+        }
+      else
+        {
+          /* Top segment is the short one.  */
+          int len = top - middle;
+          register int i;
 
-      /* Swap it with the bottom part of the bottom segment.  */
-      for (i = 0; i < len; i++)
-      {
-        tem = argv[bottom + i];
-        argv[bottom + i] = argv[middle + i];
-        argv[middle + i] = tem;
-        SWAP_FLAGS (bottom + i, middle + i);
-      }
-      /* Exclude the moved top segment from further swapping.  */
-      bottom += len;
+          /* Swap it with the bottom part of the bottom segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[middle + i];
+              argv[middle + i] = tem;
+              SWAP_FLAGS(bottom + i, middle + i);
+            }
+          /* Exclude the moved top segment from further swapping.  */
+          bottom += len;
+        }
     }
-  }
 
   /* Update records for the slots the non-options now occupy.  */
 
@@ -310,10 +309,10 @@ exchange (char **argv)
 
 #if defined(__STDC__) && __STDC__
 static const char *
-_getopt_initialize (int, char *const *, const char *);
+_getopt_initialize(int, char *const *, const char *);
 #endif
 static const char *
-_getopt_initialize (int argc, char *const *argv, const char *optstring)
+_getopt_initialize(int argc, char *const *argv, const char *optstring)
 {
   /* Start processing options with ARGV-element 1 (since ARGV-element 0
    * is the program name); the sequence of previously skipped
@@ -323,20 +322,20 @@ _getopt_initialize (int argc, char *const *argv, const char *optstring)
 
   nextchar = NULL;
 
-  posixly_correct = getenv ("POSIXLY_CORRECT");
+  posixly_correct = getenv("POSIXLY_CORRECT");
 
   /* Determine how to handle the ordering of options and nonoptions.  */
 
   if (optstring[0] == '-')
-  {
-    ordering = RETURN_IN_ORDER;
-    ++optstring;
-  }
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
   else if (optstring[0] == '+')
-  {
-    ordering = REQUIRE_ORDER;
-    ++optstring;
-  }
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
   else if (posixly_correct != NULL)
     ordering = REQUIRE_ORDER;
   else
@@ -402,25 +401,25 @@ _getopt_initialize (int argc, char *const *argv, const char *optstring)
    long-named options.  */
 
 static int
-GN_getopt_internal (int argc,
-                    char *const *argv,
-                    const char *optstring,
-                    const struct GNoption *longopts,
-                    int *longind,
-                    int long_only)
+GN_getopt_internal(int argc,
+                   char *const *argv,
+                   const char *optstring,
+                   const struct GNoption *longopts,
+                   int *longind,
+                   int long_only)
 {
   static int __getopt_initialized = 0;
   static int GNopterr = 1;
 
   GNoptarg = NULL;
 
-  if (GNoptind == 0 || ! __getopt_initialized)
-  {
-    if (GNoptind == 0)
-      GNoptind = 1; /* Don't scan ARGV[0], the program name.  */
-    optstring = _getopt_initialize (argc, argv, optstring);
-    __getopt_initialized = 1;
-  }
+  if (GNoptind == 0 || !__getopt_initialized)
+    {
+      if (GNoptind == 0)
+        GNoptind = 1; /* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize(argc, argv, optstring);
+      __getopt_initialized = 1;
+    }
 
   /* Test whether ARGV[GNoptind] points to a non-option argument.
    * Either it does not have option syntax, or there is an environment flag
@@ -429,80 +428,80 @@ GN_getopt_internal (int argc,
 #define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')
 
   if (nextchar == NULL || *nextchar == '\0')
-  {
-    /* Advance to the next ARGV-element.  */
-
-    /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
-     * moved back by the user (who may also have changed the arguments).  */
-    if (last_nonopt > GNoptind)
-      last_nonopt = GNoptind;
-    if (first_nonopt > GNoptind)
-      first_nonopt = GNoptind;
-
-    if (ordering == PERMUTE)
     {
-      /* If we have just processed some options following some non-options,
-       * exchange them so that the options come first.  */
+      /* Advance to the next ARGV-element.  */
 
-      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
-        exchange ((char **) argv);
-      else if (last_nonopt != GNoptind)
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
+      * moved back by the user (who may also have changed the arguments).  */
+      if (last_nonopt > GNoptind)
+        last_nonopt = GNoptind;
+      if (first_nonopt > GNoptind)
         first_nonopt = GNoptind;
 
-      /* Skip any additional non-options
-       * and extend the range of non-options previously skipped.  */
+      if (ordering == PERMUTE)
+        {
+          /* If we have just processed some options following some non-options,
+           * exchange them so that the options come first.  */
 
-      while (GNoptind < argc && NONOPTION_P)
-        GNoptind++;
-      last_nonopt = GNoptind;
-    }
+          if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+            exchange((char **)argv);
+          else if (last_nonopt != GNoptind)
+            first_nonopt = GNoptind;
 
-    /* The special ARGV-element `--' means premature end of options.
-     * Skip it like a null option,
-     * then exchange with previous non-options as if it were an option,
-     * then skip everything else like a non-option.  */
-    if (GNoptind != argc && ! strcmp (argv[GNoptind], "--"))
-    {
-      GNoptind++;
+          /* Skip any additional non-options
+           * and extend the range of non-options previously skipped.  */
 
-      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
-        exchange ((char **) argv);
-      else if (first_nonopt == last_nonopt)
-        first_nonopt = GNoptind;
-      last_nonopt = argc;
+          while (GNoptind < argc && NONOPTION_P)
+            GNoptind++;
+          last_nonopt = GNoptind;
+        }
 
-      GNoptind = argc;
-    }
+      /* The special ARGV-element `--' means premature end of options.
+       * Skip it like a null option,
+       * then exchange with previous non-options as if it were an option,
+       * then skip everything else like a non-option.  */
+      if (GNoptind != argc && !strcmp(argv[GNoptind], "--"))
+        {
+          GNoptind++;
 
-    /* If we have done all the ARGV-elements, stop the scan
-     * and back over any non-options that we skipped and permuted.  */
+          if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+            exchange((char **)argv);
+          else if (first_nonopt == last_nonopt)
+            first_nonopt = GNoptind;
+          last_nonopt = argc;
 
-    if (GNoptind == argc)
-    {
-      /* Set the next-arg-index to point at the non-options
-       * that we previously skipped, so the caller will digest them.  */
-      if (first_nonopt != last_nonopt)
-        GNoptind = first_nonopt;
-      return -1;
-    }
+          GNoptind = argc;
+        }
 
-    /* If we have come to a non-option and did not permute it,
-     * either stop the scan or describe it to the caller and pass it by.  */
+      /* If we have done all the ARGV-elements, stop the scan
+       * and back over any non-options that we skipped and permuted.  */
 
-    if (NONOPTION_P)
-    {
-      if (ordering == REQUIRE_ORDER)
-        return -1;
-      GNoptarg = argv[GNoptind++];
-      return 1;
-    }
+      if (GNoptind == argc)
+        {
+          /* Set the next-arg-index to point at the non-options
+           * that we previously skipped, so the caller will digest them.  */
+          if (first_nonopt != last_nonopt)
+            GNoptind = first_nonopt;
+          return -1;
+        }
 
-    /* We have found another option-ARGV-element.
-     * Skip the initial punctuation.  */
+      /* If we have come to a non-option and did not permute it,
+       * either stop the scan or describe it to the caller and pass it by.  */
 
-    nextchar =
-      (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
-  }
+      if (NONOPTION_P)
+        {
+          if (ordering == REQUIRE_ORDER)
+            return -1;
+          GNoptarg = argv[GNoptind++];
+          return 1;
+        }
+
+      /* We have found another option-ARGV-element.
+       * Skip the initial punctuation.  */
+
+      nextchar =
+        (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
+    }
 
   /* Decode the current option-ARGV-element.  */
 
@@ -522,359 +521,359 @@ GN_getopt_internal (int argc,
   if (longopts != NULL &&
       (argv[GNoptind][1] == '-' ||
        (long_only &&
-        (argv[GNoptind][2] || ! my_index (optstring, argv[GNoptind][1])))))
-  {
-    char *nameend;
-    const struct GNoption *p;
-    const struct GNoption *pfound = NULL;
-    int exact = 0;
-    int ambig = 0;
-    int indfound = -1;
-    int option_index;
-
-    for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-      /* Do nothing.  */;
-
-    /* Test all long options for either exact match
-     * or abbreviated matches.  */
-    for (p = longopts, option_index = 0; p->name; p++, option_index++)
-      if (! strncmp (p->name, nextchar, nameend - nextchar))
-      {
-        if ((unsigned int) (nameend - nextchar) ==
-            (unsigned int) strlen (p->name))
-        {
-          /* Exact match found.  */
-          pfound = p;
-          indfound = option_index;
-          exact = 1;
-          break;
-        }
-        else if (pfound == NULL)
-        {
-          /* First nonexact match found.  */
-          pfound = p;
-          indfound = option_index;
-        }
-        else
-          /* Second or later nonexact match found.  */
-          ambig = 1;
-      }
-
-    if (ambig && ! exact)
+        (argv[GNoptind][2] || !my_index(optstring, argv[GNoptind][1])))))
     {
-      if (GNopterr)
-        fprintf (stderr,
-                 _ ("%s: option `%s' is ambiguous\n"),
-                 argv[0],
-                 argv[GNoptind]);
-      nextchar += strlen (nextchar);
-      GNoptind++;
-      return '?';
-    }
+      char *nameend;
+      const struct GNoption *p;
+      const struct GNoption *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = -1;
+      int option_index;
 
-    if (pfound != NULL)
-    {
-      option_index = indfound;
-      GNoptind++;
-      if (*nameend)
-      {
-        /* Don't test has_arg with >, because some C compilers don't
-         * allow it to be used on enums.  */
-        if (pfound->has_arg)
-          GNoptarg = nameend + 1;
-        else
-        {
-          if (GNopterr)
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+        /* Do nothing.  */;
+
+      /* Test all long options for either exact match
+       * or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+        if (!strncmp(p->name, nextchar, nameend - nextchar))
           {
-            if (argv[GNoptind - 1][1] == '-')
-              /* --option */
-              fprintf (stderr,
-                       _ ("%s: option `--%s' does not allow an argument\n"),
-                       argv[0],
-                       pfound->name);
+            if ((unsigned int)(nameend - nextchar) ==
+                (unsigned int)strlen(p->name))
+              {
+                /* Exact match found.  */
+                pfound = p;
+                indfound = option_index;
+                exact = 1;
+                break;
+              }
+            else if (pfound == NULL)
+              {
+                /* First nonexact match found.  */
+                pfound = p;
+                indfound = option_index;
+              }
             else
-              /* +option or -option */
-              fprintf (stderr,
-                       _ ("%s: option `%c%s' does not allow an argument\n"),
-                       argv[0],
-                       argv[GNoptind - 1][0],
-                       pfound->name);
+              /* Second or later nonexact match found.  */
+              ambig = 1;
           }
-          nextchar += strlen (nextchar);
+
+      if (ambig && !exact)
+        {
+          if (GNopterr)
+            fprintf(stderr,
+                    _("%s: option `%s' is ambiguous\n"),
+                    argv[0],
+                    argv[GNoptind]);
+          nextchar += strlen(nextchar);
+          GNoptind++;
           return '?';
         }
-      }
-      else if (pfound->has_arg == 1)
-      {
-        if (GNoptind < argc)
+
+      if (pfound != NULL)
         {
-          GNoptarg = argv[GNoptind++];
+          option_index = indfound;
+          GNoptind++;
+          if (*nameend)
+            {
+              /* Don't test has_arg with >, because some C compilers don't
+               * allow it to be used on enums.  */
+              if (pfound->has_arg)
+                GNoptarg = nameend + 1;
+              else
+                {
+                  if (GNopterr)
+                    {
+                      if (argv[GNoptind - 1][1] == '-')
+                        /* --option */
+                        fprintf(stderr,
+                                _("%s: option `--%s' does not allow an argument\n"),
+                                argv[0],
+                                pfound->name);
+                      else
+                        /* +option or -option */
+                        fprintf(stderr,
+                                _("%s: option `%c%s' does not allow an argument\n"),
+                                argv[0],
+                                argv[GNoptind - 1][0],
+                                pfound->name);
+                    }
+                  nextchar += strlen(nextchar);
+                  return '?';
+                }
+            }
+          else if (pfound->has_arg == 1)
+            {
+              if (GNoptind < argc)
+                {
+                  GNoptarg = argv[GNoptind++];
+                }
+              else
+                {
+                  if (GNopterr)
+                    {
+                      fprintf(stderr,
+                              _("%s: option `%s' requires an argument\n"),
+                              argv[0],
+                              argv[GNoptind - 1]);
+                    }
+                  nextchar += strlen(nextchar);
+                  return (optstring[0] == ':') ? ':' : '?';
+                }
+            }
+          nextchar += strlen(nextchar);
+          if (longind != NULL)
+            *longind = option_index;
+          if (pfound->flag)
+            {
+              *(pfound->flag) = pfound->val;
+              return 0;
+            }
+          return pfound->val;
         }
-        else
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+       * or the option starts with '--' or is not a valid short
+       * option, then it's an error.
+       * Otherwise interpret it as a short option.  */
+      if (!long_only || argv[GNoptind][1] == '-' ||
+          my_index(optstring, *nextchar) == NULL)
         {
           if (GNopterr)
-          {
-            fprintf (stderr,
-                     _ ("%s: option `%s' requires an argument\n"),
-                     argv[0],
-                     argv[GNoptind - 1]);
-          }
-          nextchar += strlen (nextchar);
-          return (optstring[0] == ':') ? ':' : '?';
+            {
+              if (argv[GNoptind][1] == '-')
+                /* --option */
+                fprintf(stderr,
+                        _("%s: unrecognized option `--%s'\n"),
+                        argv[0],
+                        nextchar);
+              else
+                /* +option or -option */
+                fprintf(stderr,
+                        _("%s: unrecognized option `%c%s'\n"),
+                        argv[0],
+                        argv[GNoptind][0],
+                        nextchar);
+            }
+          nextchar = (char *)"";
+          GNoptind++;
+          return '?';
         }
-      }
-      nextchar += strlen (nextchar);
-      if (longind != NULL)
-        *longind = option_index;
-      if (pfound->flag)
-      {
-        *(pfound->flag) = pfound->val;
-        return 0;
-      }
-      return pfound->val;
     }
 
-    /* Can't find it as a long option.  If this is not getopt_long_only,
-     * or the option starts with '--' or is not a valid short
-     * option, then it's an error.
-     * Otherwise interpret it as a short option.  */
-    if (! long_only || argv[GNoptind][1] == '-' ||
-        my_index (optstring, *nextchar) == NULL)
-    {
-      if (GNopterr)
-      {
-        if (argv[GNoptind][1] == '-')
-          /* --option */
-          fprintf (stderr,
-                   _ ("%s: unrecognized option `--%s'\n"),
-                   argv[0],
-                   nextchar);
-        else
-          /* +option or -option */
-          fprintf (stderr,
-                   _ ("%s: unrecognized option `%c%s'\n"),
-                   argv[0],
-                   argv[GNoptind][0],
-                   nextchar);
-      }
-      nextchar = (char *) "";
-      GNoptind++;
-      return '?';
-    }
-  }
-
   /* Look at and handle the next short option-character.  */
 
   {
     char c = *nextchar++;
-    char *temp = my_index (optstring, c);
+    char *temp = my_index(optstring, c);
 
     /* Increment `GNoptind' when we start to process its last character.  */
     if (*nextchar == '\0')
       ++GNoptind;
 
     if (temp == NULL || c == ':')
-    {
-      if (GNopterr)
-      {
-        if (posixly_correct)
-          /* 1003.2 specifies the format of this message.  */
-          fprintf (stderr, _ ("%s: illegal option -- %c\n"), argv[0], c);
-        else
-          fprintf (stderr, _ ("%s: invalid option -- %c\n"), argv[0], c);
-      }
-      return '?';
-    }
-    /* Convenience. Treat POSIX -W foo same as long option --foo */
-    if (temp[0] == 'W' && temp[1] == ';')
-    {
-      char *nameend;
-      const struct GNoption *p;
-      const struct GNoption *pfound = NULL;
-      int exact = 0;
-      int ambig = 0;
-      int indfound = 0;
-      int option_index;
-
-      /* This is an option that requires an argument.  */
-      if (*nextchar != '\0')
-      {
-        GNoptarg = nextchar;
-        /* If we end this ARGV-element by taking the rest as an arg,
-         * we must advance to the next element now.  */
-        GNoptind++;
-      }
-      else if (GNoptind == argc)
       {
         if (GNopterr)
-        {
-          /* 1003.2 specifies the format of this message.  */
-          fprintf (stderr,
-                   _ ("%s: option requires an argument -- %c\n"),
-                   argv[0],
-                   c);
-        }
-        if (optstring[0] == ':')
-          c = ':';
-        else
-          c = '?';
-        return c;
-      }
-      else
-        /* We already incremented `GNoptind' once;
-         * increment it again when taking next ARGV-elt as argument.  */
-        GNoptarg = argv[GNoptind++];
-
-      /* GNoptarg is now the argument, see if it's in the
-       * table of longopts.  */
-
-      for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
-           nameend++)
-        /* Do nothing.  */;
-
-      /* Test all long options for either exact match
-       * or abbreviated matches.  */
-      if (longopts != NULL)
-        for (p = longopts, option_index = 0; p->name; p++, option_index++)
-          if (! strncmp (p->name, nextchar, nameend - nextchar))
           {
-            if ((unsigned int) (nameend - nextchar) == strlen (p->name))
-            {
-              /* Exact match found.  */
-              pfound = p;
-              indfound = option_index;
-              exact = 1;
-              break;
-            }
-            else if (pfound == NULL)
-            {
-              /* First nonexact match found.  */
-              pfound = p;
-              indfound = option_index;
-            }
+            if (posixly_correct)
+              /* 1003.2 specifies the format of this message.  */
+              fprintf(stderr, _("%s: illegal option -- %c\n"), argv[0], c);
             else
-              /* Second or later nonexact match found.  */
-              ambig = 1;
+              fprintf(stderr, _("%s: invalid option -- %c\n"), argv[0], c);
           }
-      if (ambig && ! exact)
-      {
-        if (GNopterr)
-          fprintf (stderr,
-                   _ ("%s: option `-W %s' is ambiguous\n"),
-                   argv[0],
-                   argv[GNoptind]);
-        nextchar += strlen (nextchar);
-        GNoptind++;
         return '?';
       }
-      if (pfound != NULL)
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
       {
-        option_index = indfound;
-        if (*nameend)
-        {
-          /* Don't test has_arg with >, because some C compilers don't
-           * allow it to be used on enums.  */
-          if (pfound->has_arg)
-            GNoptarg = nameend + 1;
-          else
+        char *nameend;
+        const struct GNoption *p;
+        const struct GNoption *pfound = NULL;
+        int exact = 0;
+        int ambig = 0;
+        int indfound = 0;
+        int option_index;
+
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+          {
+            GNoptarg = nextchar;
+            /* If we end this ARGV-element by taking the rest as an arg,
+             * we must advance to the next element now.  */
+            GNoptind++;
+          }
+        else if (GNoptind == argc)
           {
             if (GNopterr)
-              fprintf (stderr,
-                       _ ("%s: option `-W %s' does not allow an argument\n"),
-                       argv[0],
-                       pfound->name);
+              {
+                /* 1003.2 specifies the format of this message.  */
+                fprintf(stderr,
+                        _("%s: option requires an argument -- %c\n"),
+                        argv[0],
+                        c);
+              }
+            if (optstring[0] == ':')
+              c = ':';
+            else
+              c = '?';
+            return c;
+          }
+        else
+          /* We already incremented `GNoptind' once;
+           * increment it again when taking next ARGV-elt as argument.  */
+          GNoptarg = argv[GNoptind++];
 
-            nextchar += strlen (nextchar);
+        /* GNoptarg is now the argument, see if it's in the
+         * table of longopts.  */
+
+        for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
+             nameend++)
+          /* Do nothing.  */;
+
+        /* Test all long options for either exact match
+         * or abbreviated matches.  */
+        if (longopts != NULL)
+          for (p = longopts, option_index = 0; p->name; p++, option_index++)
+            if (!strncmp(p->name, nextchar, nameend - nextchar))
+              {
+                if ((unsigned int)(nameend - nextchar) == strlen(p->name))
+                  {
+                    /* Exact match found.  */
+                    pfound = p;
+                    indfound = option_index;
+                    exact = 1;
+                    break;
+                  }
+                else if (pfound == NULL)
+                  {
+                    /* First nonexact match found.  */
+                    pfound = p;
+                    indfound = option_index;
+                  }
+                else
+                  /* Second or later nonexact match found.  */
+                  ambig = 1;
+              }
+        if (ambig && !exact)
+          {
+            if (GNopterr)
+              fprintf(stderr,
+                      _("%s: option `-W %s' is ambiguous\n"),
+                      argv[0],
+                      argv[GNoptind]);
+            nextchar += strlen(nextchar);
+            GNoptind++;
             return '?';
           }
-        }
-        else if (pfound->has_arg == 1)
-        {
-          if (GNoptind < argc)
-            GNoptarg = argv[GNoptind++];
-          else
+        if (pfound != NULL)
           {
-            if (GNopterr)
-              fprintf (stderr,
-                       _ ("%s: option `%s' requires an argument\n"),
-                       argv[0],
-                       argv[GNoptind - 1]);
-            nextchar += strlen (nextchar);
-            return optstring[0] == ':' ? ':' : '?';
+            option_index = indfound;
+            if (*nameend)
+              {
+                /* Don't test has_arg with >, because some C compilers don't
+                 * allow it to be used on enums.  */
+                if (pfound->has_arg)
+                  GNoptarg = nameend + 1;
+                else
+                  {
+                    if (GNopterr)
+                      fprintf(stderr,
+                              _("%s: option `-W %s' does not allow an argument\n"),
+                              argv[0],
+                              pfound->name);
+
+                    nextchar += strlen(nextchar);
+                    return '?';
+                  }
+              }
+            else if (pfound->has_arg == 1)
+              {
+                if (GNoptind < argc)
+                  GNoptarg = argv[GNoptind++];
+                else
+                  {
+                    if (GNopterr)
+                      fprintf(stderr,
+                              _("%s: option `%s' requires an argument\n"),
+                              argv[0],
+                              argv[GNoptind - 1]);
+                    nextchar += strlen(nextchar);
+                    return optstring[0] == ':' ? ':' : '?';
+                  }
+              }
+            nextchar += strlen(nextchar);
+            if (longind != NULL)
+              *longind = option_index;
+            if (pfound->flag)
+              {
+                *(pfound->flag) = pfound->val;
+                return 0;
+              }
+            return pfound->val;
           }
-        }
-        nextchar += strlen (nextchar);
-        if (longind != NULL)
-          *longind = option_index;
-        if (pfound->flag)
-        {
-          *(pfound->flag) = pfound->val;
-          return 0;
-        }
-        return pfound->val;
-      }
-      nextchar = NULL;
-      return 'W'; /* Let the application handle it.   */
-    }
-    if (temp[1] == ':')
-    {
-      if (temp[2] == ':')
-      {
-        /* This is an option that accepts an argument optionally.  */
-        if (*nextchar != '\0')
-        {
-          GNoptarg = nextchar;
-          GNoptind++;
-        }
-        else
-          GNoptarg = NULL;
         nextchar = NULL;
+        return 'W'; /* Let the application handle it.   */
       }
-      else
+    if (temp[1] == ':')
       {
-        /* This is an option that requires an argument.  */
-        if (*nextchar != '\0')
-        {
-          GNoptarg = nextchar;
-          /* If we end this ARGV-element by taking the rest as an arg,
-           * we must advance to the next element now.  */
-          GNoptind++;
-        }
-        else if (GNoptind == argc)
-        {
-          if (GNopterr)
+        if (temp[2] == ':')
           {
-            /* 1003.2 specifies the format of this message.  */
-            fprintf (stderr,
-                     _ ("%s: option requires an argument -- %c\n"),
-                     argv[0],
-                     c);
+            /* This is an option that accepts an argument optionally.  */
+            if (*nextchar != '\0')
+              {
+                GNoptarg = nextchar;
+                GNoptind++;
+              }
+            else
+              GNoptarg = NULL;
+            nextchar = NULL;
           }
-          if (optstring[0] == ':')
-            c = ':';
-          else
-            c = '?';
-        }
         else
-          /* We already incremented `GNoptind' once;
-           * increment it again when taking next ARGV-elt as argument.  */
-          GNoptarg = argv[GNoptind++];
-        nextchar = NULL;
+          {
+            /* This is an option that requires an argument.  */
+            if (*nextchar != '\0')
+              {
+                GNoptarg = nextchar;
+                /* If we end this ARGV-element by taking the rest as an arg,
+                 * we must advance to the next element now.  */
+                GNoptind++;
+              }
+            else if (GNoptind == argc)
+              {
+                if (GNopterr)
+                  {
+                    /* 1003.2 specifies the format of this message.  */
+                    fprintf(stderr,
+                            _("%s: option requires an argument -- %c\n"),
+                            argv[0],
+                            c);
+                  }
+                if (optstring[0] == ':')
+                  c = ':';
+                else
+                  c = '?';
+              }
+            else
+              /* We already incremented `GNoptind' once;
+               * increment it again when taking next ARGV-elt as argument.  */
+              GNoptarg = argv[GNoptind++];
+            nextchar = NULL;
+          }
       }
-    }
     return c;
   }
 }
 
 
 static int
-GNgetopt_long (int argc,
-               char *const *argv,
-               const char *options,
-               const struct GNoption *long_options,
-               int *opt_index)
+GNgetopt_long(int argc,
+              char *const *argv,
+              const char *options,
+              const struct GNoption *long_options,
+              int *opt_index)
 {
-  return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
+  return GN_getopt_internal(argc, argv, options, long_options, opt_index, 0);
 }
 
 /* ******************** now the GNUnet specific modifications... ********************* */
@@ -890,10 +889,10 @@ GNgetopt_long (int argc,
  *   argument, or #GNUNET_SYSERR on error
  */
 int
-GNUNET_GETOPT_run (const char *binaryOptions,
-                   const struct GNUNET_GETOPT_CommandLineOption *allOptions,
-                   unsigned int argc,
-                   char *const *argv)
+GNUNET_GETOPT_run(const char *binaryOptions,
+                  const struct GNUNET_GETOPT_CommandLineOption *allOptions,
+                  unsigned int argc,
+                  char *const *argv)
 {
   struct GNoption *long_options;
   struct GNUNET_GETOPT_CommandLineProcessorContext clpc;
@@ -905,7 +904,7 @@ GNUNET_GETOPT_run (const char *binaryOptions,
   unsigned int optmatch = 0;
   const char *have_exclusive = NULL;
 
-  GNUNET_assert (argc > 0);
+  GNUNET_assert(argc > 0);
   GNoptind = 0;
   clpc.binaryName = argv[0];
   clpc.binaryOptions = binaryOptions;
@@ -917,20 +916,20 @@ GNUNET_GETOPT_run (const char *binaryOptions,
 
   /* transform our option representation into the format
      used by the GNU getopt copylib */
-  long_options = GNUNET_new_array (count + 1, struct GNoption);
-  seen = GNUNET_new_array (count, uint8_t);
-  shorts = GNUNET_malloc (count * 2 + 1);
+  long_options = GNUNET_new_array(count + 1, struct GNoption);
+  seen = GNUNET_new_array(count, uint8_t);
+  shorts = GNUNET_malloc(count * 2 + 1);
   spos = 0;
   for (unsigned i = 0; i < count; i++)
-  {
-    long_options[i].name = allOptions[i].name;
-    long_options[i].has_arg = allOptions[i].require_argument;
-    long_options[i].flag = NULL;
-    long_options[i].val = allOptions[i].shortName;
-    shorts[spos++] = allOptions[i].shortName;
-    if (allOptions[i].require_argument != 0)
-      shorts[spos++] = ':';
-  }
+    {
+      long_options[i].name = allOptions[i].name;
+      long_options[i].has_arg = allOptions[i].require_argument;
+      long_options[i].flag = NULL;
+      long_options[i].val = allOptions[i].shortName;
+      shorts[spos++] = allOptions[i].shortName;
+      if (allOptions[i].require_argument != 0)
+        shorts[spos++] = ':';
+    }
   long_options[count].name = NULL;
   long_options[count].has_arg = 0;
   long_options[count].flag = NULL;
@@ -940,74 +939,74 @@ GNUNET_GETOPT_run (const char *binaryOptions,
 
   /* main getopt loop */
   while (1)
-  {
-    int option_index = 0;
-    unsigned int i;
-    int c;
+    {
+      int option_index = 0;
+      unsigned int i;
+      int c;
 
-    c = GNgetopt_long (argc, argv, shorts, long_options, &option_index);
-    if (c == GNUNET_SYSERR)
-      break; /* No more flags to process */
+      c = GNgetopt_long(argc, argv, shorts, long_options, &option_index);
+      if (c == GNUNET_SYSERR)
+        break; /* No more flags to process */
 
-    /* Check which of our program's options was given by the user */
-    for (i = 0; i < count; i++)
-    {
-      clpc.currentArgument = GNoptind - 1;
-      if ((char) c == allOptions[i].shortName)
-      {
-        optmatch++;
-        if (allOptions[i].option_exclusive)
-          have_exclusive = allOptions[i].name;
-        if (GNUNET_OK == cont)
+      /* Check which of our program's options was given by the user */
+      for (i = 0; i < count; i++)
         {
-          /* parse the option using the option-specific processor */
-          cont = allOptions[i].processor (&clpc,
-                                          allOptions[i].scls,
-                                          allOptions[i].name,
-                                          GNoptarg);
+          clpc.currentArgument = GNoptind - 1;
+          if ((char)c == allOptions[i].shortName)
+            {
+              optmatch++;
+              if (allOptions[i].option_exclusive)
+                have_exclusive = allOptions[i].name;
+              if (GNUNET_OK == cont)
+                {
+                  /* parse the option using the option-specific processor */
+                  cont = allOptions[i].processor(&clpc,
+                                                 allOptions[i].scls,
+                                                 allOptions[i].name,
+                                                 GNoptarg);
+                }
+              seen[i] = 1;
+              break;
+            }
+        }
+      if (i == count)
+        {
+          fprintf(stderr, _("Use %s to get a list of options.\n"), "--help");
+          cont = GNUNET_SYSERR;
         }
-        seen[i] = 1;
-        break;
-      }
-    }
-    if (i == count)
-    {
-      fprintf (stderr, _ ("Use %s to get a list of options.\n"), "--help");
-      cont = GNUNET_SYSERR;
     }
-  }
-  GNUNET_free (shorts);
-  GNUNET_free (long_options);
+  GNUNET_free(shorts);
+  GNUNET_free(long_options);
 
   /* check that if any option that was marked as exclusive
      is the only option that was provided */
   if ((NULL != have_exclusive) && (optmatch > 1))
-  {
-    fprintf (stderr,
-             _ ("Option `%s' can't be used with other options.\n"),
-             have_exclusive);
-    cont = GNUNET_SYSERR;
-  }
+    {
+      fprintf(stderr,
+              _("Option `%s' can't be used with other options.\n"),
+              have_exclusive);
+      cont = GNUNET_SYSERR;
+    }
   if (GNUNET_YES == cont)
-  {
-    /* check that all mandatory options are present */
-    for (count = 0; NULL != allOptions[count].name; count++)
     {
-      if ((0 == seen[count]) && (allOptions[count].option_mandatory))
-      {
-        fprintf (stderr,
-                 _ ("Missing mandatory option `%s'.\n"),
-                 allOptions[count].name);
-        cont = GNUNET_SYSERR;
-      }
+      /* check that all mandatory options are present */
+      for (count = 0; NULL != allOptions[count].name; count++)
+        {
+          if ((0 == seen[count]) && (allOptions[count].option_mandatory))
+            {
+              fprintf(stderr,
+                      _("Missing mandatory option `%s'.\n"),
+                      allOptions[count].name);
+              cont = GNUNET_SYSERR;
+            }
+        }
     }
-  }
-  GNUNET_free (seen);
+  GNUNET_free(seen);
 
   /* call cleaners, if available */
   for (unsigned int i = 0; NULL != allOptions[i].name; i++)
     if (NULL != allOptions[i].cleaner)
-      allOptions[i].cleaner (allOptions[i].scls);
+      allOptions[i].cleaner(allOptions[i].scls);
 
   if (GNUNET_OK != cont)
     return cont;
diff --git a/src/util/getopt_helpers.c b/src/util/getopt_helpers.c
index f53441508..a5e752546 100644
--- a/src/util/getopt_helpers.c
+++ b/src/util/getopt_helpers.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file src/util/getopt_helpers.c
@@ -26,7 +26,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-getopt", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-getopt", __VA_ARGS__)
 
 
 /**
@@ -39,16 +39,16 @@
  * @return #GNUNET_NO (do not continue, not an error)
  */
 static int
-print_version (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-               void *scls,
-               const char *option,
-               const char *value)
+print_version(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+              void *scls,
+              const char *option,
+              const char *value)
 {
   const char *version = scls;
 
-  (void) option;
-  (void) value;
-  printf ("%s v%s\n", ctx->binaryName, version);
+  (void)option;
+  (void)value;
+  printf("%s v%s\n", ctx->binaryName, version);
   return GNUNET_NO;
 }
 
@@ -60,15 +60,16 @@ print_version (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param version string with the version number
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_version (const char *version)
+GNUNET_GETOPT_option_version(const char *version)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = 'v',
-                                                .name = "version",
-                                                .description = gettext_noop (
-                                                  "print the version number"),
-                                                .option_exclusive = 1,
-                                                .processor = &print_version,
-                                                .scls = (void *) version};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = 'v',
+                                                 .name = "version",
+                                                 .description = gettext_noop(
+                                                   "print the version number"),
+                                                 .option_exclusive = 1,
+                                                 .processor = &print_version,
+                                                 .scls = (void *)version };
+
   return clo;
 }
 
@@ -88,10 +89,10 @@ GNUNET_GETOPT_option_version (const char *version)
  * @return #GNUNET_NO (do not continue, not an error)
  */
 static int
-format_help (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-             void *scls,
-             const char *option,
-             const char *value)
+format_help(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+            void *scls,
+            const char *option,
+            const char *value)
 {
   const char *about = scls;
   size_t slen;
@@ -104,86 +105,86 @@ format_help (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
   const struct GNUNET_GETOPT_CommandLineOption *opt;
   const struct GNUNET_OS_ProjectData *pd;
 
-  (void) option;
-  (void) value;
+  (void)option;
+  (void)value;
   if (NULL != about)
-  {
-    printf ("%s\n%s\n", ctx->binaryOptions, gettext (about));
-    printf (_ (
-      "Arguments mandatory for long options are also mandatory for short options.\n"));
-  }
+    {
+      printf("%s\n%s\n", ctx->binaryOptions, gettext(about));
+      printf(_(
+               "Arguments mandatory for long options are also mandatory for short options.\n"));
+    }
   i = 0;
   opt = ctx->allOptions;
   while (NULL != opt[i].description)
-  {
-    if (opt[i].shortName == '\0')
-      printf ("      ");
-    else
-      printf ("  -%c, ", opt[i].shortName);
-    printf ("--%s", opt[i].name);
-    slen = 8 + strlen (opt[i].name);
-    if (NULL != opt[i].argumentHelp)
     {
-      printf ("=%s", opt[i].argumentHelp);
-      slen += 1 + strlen (opt[i].argumentHelp);
-    }
-    if (slen > BORDER)
-    {
-      printf ("\n%*s", BORDER, "");
-      slen = BORDER;
-    }
-    if (slen < BORDER)
-    {
-      printf ("%*s", (int) (BORDER - slen), "");
-      slen = BORDER;
-    }
-    if (0 < strlen (opt[i].description))
-      trans = gettext (opt[i].description);
-    else
-      trans = "";
-    ml = strlen (trans);
-    p = 0;
-  OUTER:
-    while (ml - p > 78 - slen)
-    {
-      for (j = p + 78 - slen; j > (int) p; j--)
-      {
-        if (isspace ((unsigned char) trans[j]))
+      if (opt[i].shortName == '\0')
+        printf("      ");
+      else
+        printf("  -%c, ", opt[i].shortName);
+      printf("--%s", opt[i].name);
+      slen = 8 + strlen(opt[i].name);
+      if (NULL != opt[i].argumentHelp)
+        {
+          printf("=%s", opt[i].argumentHelp);
+          slen += 1 + strlen(opt[i].argumentHelp);
+        }
+      if (slen > BORDER)
+        {
+          printf("\n%*s", BORDER, "");
+          slen = BORDER;
+        }
+      if (slen < BORDER)
         {
-          scp = GNUNET_malloc (j - p + 1);
-          GNUNET_memcpy (scp, &trans[p], j - p);
-          scp[j - p] = '\0';
-          printf ("%s\n%*s", scp, BORDER + 2, "");
-          GNUNET_free (scp);
-          p = j + 1;
+          printf("%*s", (int)(BORDER - slen), "");
+          slen = BORDER;
+        }
+      if (0 < strlen(opt[i].description))
+        trans = gettext(opt[i].description);
+      else
+        trans = "";
+      ml = strlen(trans);
+      p = 0;
+OUTER:
+      while (ml - p > 78 - slen)
+        {
+          for (j = p + 78 - slen; j > (int)p; j--)
+            {
+              if (isspace((unsigned char)trans[j]))
+                {
+                  scp = GNUNET_malloc(j - p + 1);
+                  GNUNET_memcpy(scp, &trans[p], j - p);
+                  scp[j - p] = '\0';
+                  printf("%s\n%*s", scp, BORDER + 2, "");
+                  GNUNET_free(scp);
+                  p = j + 1;
+                  slen = BORDER + 2;
+                  goto OUTER;
+                }
+            }
+          /* could not find space to break line */
+          scp = GNUNET_malloc(78 - slen + 1);
+          GNUNET_memcpy(scp, &trans[p], 78 - slen);
+          scp[78 - slen] = '\0';
+          printf("%s\n%*s", scp, BORDER + 2, "");
+          GNUNET_free(scp);
           slen = BORDER + 2;
-          goto OUTER;
+          p = p + 78 - slen;
         }
-      }
-      /* could not find space to break line */
-      scp = GNUNET_malloc (78 - slen + 1);
-      GNUNET_memcpy (scp, &trans[p], 78 - slen);
-      scp[78 - slen] = '\0';
-      printf ("%s\n%*s", scp, BORDER + 2, "");
-      GNUNET_free (scp);
-      slen = BORDER + 2;
-      p = p + 78 - slen;
+      /* print rest */
+      if (p < ml)
+        printf("%s\n", &trans[p]);
+      if (strlen(trans) == 0)
+        printf("\n");
+      i++;
     }
-    /* print rest */
-    if (p < ml)
-      printf ("%s\n", &trans[p]);
-    if (strlen (trans) == 0)
-      printf ("\n");
-    i++;
-  }
-  pd = GNUNET_OS_project_data_get ();
-  printf ("Report bugs to %s.\n"
-          "Home page: %s\n",
-          pd->bug_email,
-          pd->homepage);
+  pd = GNUNET_OS_project_data_get();
+  printf("Report bugs to %s.\n"
+         "Home page: %s\n",
+         pd->bug_email,
+         pd->homepage);
 
   if (0 != pd->is_gnu)
-    printf ("General help using GNU software: http://www.gnu.org/gethelp/\n");
+    printf("General help using GNU software: http://www.gnu.org/gethelp/\n");
 
   return GNUNET_NO;
 }
@@ -196,15 +197,15 @@ format_help (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param about string with brief description of the application
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_help (const char *about)
+GNUNET_GETOPT_option_help(const char *about)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = 'h',
-                                                .name = "help",
-                                                .description = gettext_noop (
-                                                  "print this help"),
-                                                .option_exclusive = 1,
-                                                .processor = format_help,
-                                                .scls = (void *) about};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = 'h',
+                                                 .name = "help",
+                                                 .description = gettext_noop(
+                                                   "print this help"),
+                                                 .option_exclusive = 1,
+                                                 .processor = format_help,
+                                                 .scls = (void *)about };
 
   return clo;
 }
@@ -225,16 +226,16 @@ GNUNET_GETOPT_option_help (const char *about)
  * @return #GNUNET_OK
  */
 static int
-increment_value (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                 void *scls,
-                 const char *option,
-                 const char *value)
+increment_value(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                void *scls,
+                const char *option,
+                const char *value)
 {
   unsigned int *val = scls;
 
-  (void) ctx;
-  (void) option;
-  (void) value;
+  (void)ctx;
+  (void)option;
+  (void)value;
   (*val)++;
   return GNUNET_OK;
 }
@@ -250,16 +251,16 @@ increment_value (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val increment by 1 each time the option is present
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_increment_uint (char shortName,
-                                     const char *name,
-                                     const char *description,
-                                     unsigned int *val)
+GNUNET_GETOPT_option_increment_uint(char shortName,
+                                    const char *name,
+                                    const char *description,
+                                    unsigned int *val)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .description = description,
-                                                .processor = &increment_value,
-                                                .scls = (void *) val};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .description = description,
+                                                 .processor = &increment_value,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -272,14 +273,14 @@ GNUNET_GETOPT_option_increment_uint (char shortName,
  * @param[out] level set to the verbosity level
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_verbose (unsigned int *level)
+GNUNET_GETOPT_option_verbose(unsigned int *level)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = 'V',
-                                                .name = "verbose",
-                                                .description =
-                                                  gettext_noop ("be verbose"),
-                                                .processor = &increment_value,
-                                                .scls = (void *) level};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = 'V',
+                                                 .name = "verbose",
+                                                 .description =
+                                                   gettext_noop("be verbose"),
+                                                 .processor = &increment_value,
+                                                 .scls = (void *)level };
 
   return clo;
 }
@@ -300,16 +301,16 @@ GNUNET_GETOPT_option_verbose (unsigned int *level)
  * @return #GNUNET_OK
  */
 static int
-set_one (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-         void *scls,
-         const char *option,
-         const char *value)
+set_one(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+        void *scls,
+        const char *option,
+        const char *value)
 {
   int *val = scls;
 
-  (void) ctx;
-  (void) option;
-  (void) value;
+  (void)ctx;
+  (void)option;
+  (void)value;
   *val = 1;
   return GNUNET_OK;
 }
@@ -326,16 +327,16 @@ set_one (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to 1 if the option is present
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_flag (char shortName,
-                           const char *name,
-                           const char *description,
-                           int *val)
+GNUNET_GETOPT_option_flag(char shortName,
+                          const char *name,
+                          const char *description,
+                          int *val)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .description = description,
-                                                .processor = &set_one,
-                                                .scls = (void *) val};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .description = description,
+                                                 .processor = &set_one,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -356,18 +357,18 @@ GNUNET_GETOPT_option_flag (char shortName,
  * @return #GNUNET_OK
  */
 static int
-set_string (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-            void *scls,
-            const char *option,
-            const char *value)
+set_string(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+           void *scls,
+           const char *option,
+           const char *value)
 {
   char **val = scls;
 
-  (void) ctx;
-  (void) option;
-  GNUNET_assert (NULL != value);
-  GNUNET_free_non_null (*val);
-  *val = GNUNET_strdup (value);
+  (void)ctx;
+  (void)option;
+  GNUNET_assert(NULL != value);
+  GNUNET_free_non_null(*val);
+  *val = GNUNET_strdup(value);
   return GNUNET_OK;
 }
 
@@ -382,19 +383,19 @@ set_string (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] str set to the string
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_string (char shortName,
-                             const char *name,
-                             const char *argumentHelp,
-                             const char *description,
-                             char **str)
+GNUNET_GETOPT_option_string(char shortName,
+                            const char *name,
+                            const char *argumentHelp,
+                            const char *description,
+                            char **str)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_string,
-                                                .scls = (void *) str};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_string,
+                                                 .scls = (void *)str };
 
   return clo;
 }
@@ -407,16 +408,16 @@ GNUNET_GETOPT_option_string (char shortName,
  * @param[out] level set to the log level
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_loglevel (char **level)
+GNUNET_GETOPT_option_loglevel(char **level)
 {
   struct GNUNET_GETOPT_CommandLineOption clo =
-    {.shortName = 'L',
-     .name = "log",
-     .argumentHelp = "LOGLEVEL",
-     .description = gettext_noop ("configure logging to use LOGLEVEL"),
-     .require_argument = 1,
-     .processor = &set_string,
-     .scls = (void *) level};
+  { .shortName = 'L',
+    .name = "log",
+    .argumentHelp = "LOGLEVEL",
+    .description = gettext_noop("configure logging to use LOGLEVEL"),
+    .require_argument = 1,
+    .processor = &set_string,
+    .scls = (void *)level };
 
   return clo;
 }
@@ -434,18 +435,18 @@ GNUNET_GETOPT_option_loglevel (char **level)
  * @return #GNUNET_OK
  */
 static int
-set_filename (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-              void *scls,
-              const char *option,
-              const char *value)
+set_filename(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+             void *scls,
+             const char *option,
+             const char *value)
 {
   char **val = scls;
 
-  (void) ctx;
-  (void) option;
-  GNUNET_assert (NULL != value);
-  GNUNET_free_non_null (*val);
-  *val = GNUNET_STRINGS_filename_expand (value);
+  (void)ctx;
+  (void)option;
+  GNUNET_assert(NULL != value);
+  GNUNET_free_non_null(*val);
+  *val = GNUNET_STRINGS_filename_expand(value);
   return GNUNET_OK;
 }
 
@@ -460,19 +461,19 @@ set_filename (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] str set to the string
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_filename (char shortName,
-                               const char *name,
-                               const char *argumentHelp,
-                               const char *description,
-                               char **str)
-{
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_filename,
-                                                .scls = (void *) str};
+GNUNET_GETOPT_option_filename(char shortName,
+                              const char *name,
+                              const char *argumentHelp,
+                              const char *description,
+                              char **str)
+{
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_filename,
+                                                 .scls = (void *)str };
 
   return clo;
 }
@@ -484,17 +485,17 @@ GNUNET_GETOPT_option_filename (char shortName,
  * @param[out] logfn set to the name of the logfile
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_logfile (char **logfn)
+GNUNET_GETOPT_option_logfile(char **logfn)
 {
   struct GNUNET_GETOPT_CommandLineOption clo =
-    {.shortName = 'l',
-     .name = "logfile",
-     .argumentHelp = "FILENAME",
-     .description =
-       gettext_noop ("configure logging to write logs to FILENAME"),
-     .require_argument = 1,
-     .processor = &set_filename,
-     .scls = (void *) logfn};
+  { .shortName = 'l',
+    .name = "logfile",
+    .argumentHelp = "FILENAME",
+    .description =
+      gettext_noop("configure logging to write logs to FILENAME"),
+    .require_argument = 1,
+    .processor = &set_filename,
+    .scls = (void *)logfn };
 
   return clo;
 }
@@ -506,16 +507,16 @@ GNUNET_GETOPT_option_logfile (char **logfn)
  * @param[out] fn set to the name of the configuration file
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_cfgfile (char **fn)
+GNUNET_GETOPT_option_cfgfile(char **fn)
 {
   struct GNUNET_GETOPT_CommandLineOption clo =
-    {.shortName = 'c',
-     .name = "config",
-     .argumentHelp = "FILENAME",
-     .description = gettext_noop ("use configuration file FILENAME"),
-     .require_argument = 1,
-     .processor = &set_filename,
-     .scls = (void *) fn};
+  { .shortName = 'c',
+    .name = "config",
+    .argumentHelp = "FILENAME",
+    .description = gettext_noop("use configuration file FILENAME"),
+    .require_argument = 1,
+    .processor = &set_filename,
+    .scls = (void *)fn };
 
   return clo;
 }
@@ -535,22 +536,22 @@ GNUNET_GETOPT_option_cfgfile (char **fn)
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_ulong (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-           void *scls,
-           const char *option,
-           const char *value)
+set_ulong(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+          void *scls,
+          const char *option,
+          const char *value)
 {
   unsigned long long *val = scls;
   char dummy[2];
 
-  (void) ctx;
-  if (1 != sscanf (value, "%llu%1s", val, dummy))
-  {
-    fprintf (stderr,
-             _ ("You must pass a number to the `%s' option.\n"),
-             option);
-    return GNUNET_SYSERR;
-  }
+  (void)ctx;
+  if (1 != sscanf(value, "%llu%1s", val, dummy))
+    {
+      fprintf(stderr,
+              _("You must pass a number to the `%s' option.\n"),
+              option);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -565,19 +566,19 @@ set_ulong (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to the value specified at the command line
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_ulong (char shortName,
-                            const char *name,
-                            const char *argumentHelp,
-                            const char *description,
-                            unsigned long long *val)
+GNUNET_GETOPT_option_ulong(char shortName,
+                           const char *name,
+                           const char *argumentHelp,
+                           const char *description,
+                           unsigned long long *val)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_ulong,
-                                                .scls = (void *) val};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_ulong,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -597,21 +598,21 @@ GNUNET_GETOPT_option_ulong (char shortName,
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_relative_time (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                   void *scls,
-                   const char *option,
-                   const char *value)
+set_relative_time(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                  void *scls,
+                  const char *option,
+                  const char *value)
 {
   struct GNUNET_TIME_Relative *val = scls;
 
-  (void) ctx;
-  if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative (value, val))
-  {
-    fprintf (stderr,
-             _ ("You must pass relative time to the `%s' option.\n"),
-             option);
-    return GNUNET_SYSERR;
-  }
+  (void)ctx;
+  if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative(value, val))
+    {
+      fprintf(stderr,
+              _("You must pass relative time to the `%s' option.\n"),
+              option);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -627,19 +628,19 @@ set_relative_time (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to the time specified at the command line
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_relative_time (char shortName,
-                                    const char *name,
-                                    const char *argumentHelp,
-                                    const char *description,
-                                    struct GNUNET_TIME_Relative *val)
-{
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_relative_time,
-                                                .scls = (void *) val};
+GNUNET_GETOPT_option_relative_time(char shortName,
+                                   const char *name,
+                                   const char *argumentHelp,
+                                   const char *description,
+                                   struct GNUNET_TIME_Relative *val)
+{
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_relative_time,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -659,21 +660,21 @@ GNUNET_GETOPT_option_relative_time (char shortName,
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_absolute_time (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                   void *scls,
-                   const char *option,
-                   const char *value)
+set_absolute_time(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                  void *scls,
+                  const char *option,
+                  const char *value)
 {
   struct GNUNET_TIME_Absolute *val = scls;
 
-  (void) ctx;
-  if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_absolute (value, val))
-  {
-    fprintf (stderr,
-             _ ("You must pass absolute time to the `%s' option.\n"),
-             option);
-    return GNUNET_SYSERR;
-  }
+  (void)ctx;
+  if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_absolute(value, val))
+    {
+      fprintf(stderr,
+              _("You must pass absolute time to the `%s' option.\n"),
+              option);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -689,19 +690,19 @@ set_absolute_time (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to the time specified at the command line
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_absolute_time (char shortName,
-                                    const char *name,
-                                    const char *argumentHelp,
-                                    const char *description,
-                                    struct GNUNET_TIME_Absolute *val)
-{
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_absolute_time,
-                                                .scls = (void *) val};
+GNUNET_GETOPT_option_absolute_time(char shortName,
+                                   const char *name,
+                                   const char *argumentHelp,
+                                   const char *description,
+                                   struct GNUNET_TIME_Absolute *val)
+{
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_absolute_time,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -721,30 +722,30 @@ GNUNET_GETOPT_option_absolute_time (char shortName,
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_uint (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-          void *scls,
-          const char *option,
-          const char *value)
+set_uint(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+         void *scls,
+         const char *option,
+         const char *value)
 {
   unsigned int *val = scls;
   char dummy[2];
 
-  (void) ctx;
+  (void)ctx;
   if ('-' == *value)
-  {
-    fprintf (stderr,
-             _ (
-               "Your input for the '%s' option has to be a non negative number \n"),
-             option);
-    return GNUNET_SYSERR;
-  }
-  if (1 != sscanf (value, "%u%1s", val, dummy))
-  {
-    fprintf (stderr,
-             _ ("You must pass a number to the `%s' option.\n"),
-             option);
-    return GNUNET_SYSERR;
-  }
+    {
+      fprintf(stderr,
+              _(
+                "Your input for the '%s' option has to be a non negative number \n"),
+              option);
+      return GNUNET_SYSERR;
+    }
+  if (1 != sscanf(value, "%u%1s", val, dummy))
+    {
+      fprintf(stderr,
+              _("You must pass a number to the `%s' option.\n"),
+              option);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -759,19 +760,19 @@ set_uint (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to the value specified at the command line
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_uint (char shortName,
-                           const char *name,
-                           const char *argumentHelp,
-                           const char *description,
-                           unsigned int *val)
-{
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_uint,
-                                                .scls = (void *) val};
+GNUNET_GETOPT_option_uint(char shortName,
+                          const char *name,
+                          const char *argumentHelp,
+                          const char *description,
+                          unsigned int *val)
+{
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_uint,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -791,32 +792,32 @@ GNUNET_GETOPT_option_uint (char shortName,
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_uint16 (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-            void *scls,
-            const char *option,
-            const char *value)
+set_uint16(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+           void *scls,
+           const char *option,
+           const char *value)
 {
   uint16_t *val = scls;
   unsigned int v;
   char dummy[2];
 
-  (void) ctx;
-  if (1 != sscanf (value, "%u%1s", &v, dummy))
-  {
-    fprintf (stderr,
-             _ ("You must pass a number to the `%s' option.\n"),
-             option);
-    return GNUNET_SYSERR;
-  }
+  (void)ctx;
+  if (1 != sscanf(value, "%u%1s", &v, dummy))
+    {
+      fprintf(stderr,
+              _("You must pass a number to the `%s' option.\n"),
+              option);
+      return GNUNET_SYSERR;
+    }
   if (v > UINT16_MAX)
-  {
-    fprintf (stderr,
-             _ ("You must pass a number below %u to the `%s' option.\n"),
-             (unsigned int) UINT16_MAX,
-             option);
-    return GNUNET_SYSERR;
-  }
-  *val = (uint16_t) v;
+    {
+      fprintf(stderr,
+              _("You must pass a number below %u to the `%s' option.\n"),
+              (unsigned int)UINT16_MAX,
+              option);
+      return GNUNET_SYSERR;
+    }
+  *val = (uint16_t)v;
   return GNUNET_OK;
 }
 
@@ -831,19 +832,19 @@ set_uint16 (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] val set to the value specified at the command line
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_uint16 (char shortName,
-                             const char *name,
-                             const char *argumentHelp,
-                             const char *description,
-                             uint16_t *val)
+GNUNET_GETOPT_option_uint16(char shortName,
+                            const char *name,
+                            const char *argumentHelp,
+                            const char *description,
+                            uint16_t *val)
 {
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_uint16,
-                                                .scls = (void *) val};
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_uint16,
+                                                 .scls = (void *)val };
 
   return clo;
 }
@@ -852,8 +853,7 @@ GNUNET_GETOPT_option_uint16 (char shortName,
 /**
  * Closure for #set_base32().
  */
-struct Base32Context
-{
+struct Base32Context {
   /**
    * Value to initialize (already allocated)
    */
@@ -880,26 +880,26 @@ struct Base32Context
  * @return #GNUNET_OK if parsing the value worked
  */
 static int
-set_base32 (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-            void *scls,
-            const char *option,
-            const char *value)
+set_base32(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+           void *scls,
+           const char *option,
+           const char *value)
 {
   struct Base32Context *bc = scls;
 
-  (void) ctx;
-  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (value,
-                                                  strlen (value),
-                                                  bc->val,
-                                                  bc->val_size))
-  {
-    fprintf (
-      stderr,
-      _ (
-        "Argument `%s' malformed. Expected base32 (Crockford) encoded value.\n"),
-      option);
-    return GNUNET_SYSERR;
-  }
+  (void)ctx;
+  if (GNUNET_OK != GNUNET_STRINGS_string_to_data(value,
+                                                 strlen(value),
+                                                 bc->val,
+                                                 bc->val_size))
+    {
+      fprintf(
+        stderr,
+        _(
+          "Argument `%s' malformed. Expected base32 (Crockford) encoded value.\n"),
+        option);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -911,9 +911,9 @@ set_base32 (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param cls value to GNUNET_free()
  */
 static void
-free_bc (void *cls)
+free_bc(void *cls)
 {
-  GNUNET_free (cls);
+  GNUNET_free(cls);
 }
 
 
@@ -929,22 +929,22 @@ free_bc (void *cls)
  * @param val_size size of @a val in bytes
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_base32_fixed_size (char shortName,
-                                        const char *name,
-                                        const char *argumentHelp,
-                                        const char *description,
-                                        void *val,
-                                        size_t val_size)
-{
-  struct Base32Context *bc = GNUNET_new (struct Base32Context);
-  struct GNUNET_GETOPT_CommandLineOption clo = {.shortName = shortName,
-                                                .name = name,
-                                                .argumentHelp = argumentHelp,
-                                                .description = description,
-                                                .require_argument = 1,
-                                                .processor = &set_base32,
-                                                .cleaner = &free_bc,
-                                                .scls = (void *) bc};
+GNUNET_GETOPT_option_base32_fixed_size(char shortName,
+                                       const char *name,
+                                       const char *argumentHelp,
+                                       const char *description,
+                                       void *val,
+                                       size_t val_size)
+{
+  struct Base32Context *bc = GNUNET_new(struct Base32Context);
+  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
+                                                 .name = name,
+                                                 .argumentHelp = argumentHelp,
+                                                 .description = description,
+                                                 .require_argument = 1,
+                                                 .processor = &set_base32,
+                                                 .cleaner = &free_bc,
+                                                 .scls = (void *)bc };
 
   bc->val = val;
   bc->val_size = val_size;
@@ -959,7 +959,7 @@ GNUNET_GETOPT_option_base32_fixed_size (char shortName,
  * @return @a opt with the mandatory flag set.
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_mandatory (struct GNUNET_GETOPT_CommandLineOption opt)
+GNUNET_GETOPT_option_mandatory(struct GNUNET_GETOPT_CommandLineOption opt)
 {
   opt.option_mandatory = 1;
   return opt;
@@ -973,7 +973,7 @@ GNUNET_GETOPT_option_mandatory (struct GNUNET_GETOPT_CommandLineOption opt)
  * @return @a opt with the exclusive flag set.
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_GETOPT_option_exclusive (struct GNUNET_GETOPT_CommandLineOption opt)
+GNUNET_GETOPT_option_exclusive(struct GNUNET_GETOPT_CommandLineOption opt)
 {
   opt.option_exclusive = 1;
   return opt;
diff --git a/src/util/gnunet-config-diff.c b/src/util/gnunet-config-diff.c
index 207b9518a..214d6d73f 100644
--- a/src/util/gnunet-config-diff.c
+++ b/src/util/gnunet-config-diff.c
@@ -2,22 +2,22 @@
 #include <gnunet_util_lib.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   struct GNUNET_CONFIGURATION_Handle *i1;
   struct GNUNET_CONFIGURATION_Handle *i2;
 
   if (argc != 3)
-  {
-    fprintf (stderr, "Invoke using `%s DEFAULTS-IN DIFFS'\n", argv[0]);
+    {
+      fprintf(stderr, "Invoke using `%s DEFAULTS-IN DIFFS'\n", argv[0]);
+      return 1;
+    }
+  i1 = GNUNET_CONFIGURATION_create();
+  i2 = GNUNET_CONFIGURATION_create();
+  if ((GNUNET_OK != GNUNET_CONFIGURATION_load(i1, argv[1])) ||
+      (GNUNET_OK != GNUNET_CONFIGURATION_load(i2, argv[2])))
     return 1;
-  }
-  i1 = GNUNET_CONFIGURATION_create ();
-  i2 = GNUNET_CONFIGURATION_create ();
-  if ((GNUNET_OK != GNUNET_CONFIGURATION_load (i1, argv[1])) ||
-      (GNUNET_OK != GNUNET_CONFIGURATION_load (i2, argv[2])))
-    return 1;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_write_diffs (i1, i2, argv[2]))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_write_diffs(i1, i2, argv[2]))
     return 2;
   return 0;
 }
diff --git a/src/util/gnunet-config.c b/src/util/gnunet-config.c
index 3b9b64d4e..c67237a27 100644
--- a/src/util/gnunet-config.c
+++ b/src/util/gnunet-config.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 util/gnunet-config.c
@@ -80,36 +80,36 @@ static int rewrite;
  * @param value value of the option
  */
 static void
-print_option (void *cls,
-              const char *section,
-              const char *option,
-              const char *value)
+print_option(void *cls,
+             const char *section,
+             const char *option,
+             const char *value)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
-  (void) section;
+  (void)section;
   if (is_filename)
-  {
-    char *value_fn;
-    char *fn;
+    {
+      char *value_fn;
+      char *fn;
 
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONFIGURATION_get_value_filename (cfg,
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CONFIGURATION_get_value_filename(cfg,
                                                             section,
                                                             option,
                                                             &value_fn));
-    fn = GNUNET_STRINGS_filename_expand (value_fn);
-    if (NULL == fn)
-      fn = value_fn;
-    else
-      GNUNET_free (value_fn);
-    fprintf (stdout, "%s = %s\n", option, fn);
-    GNUNET_free (fn);
-  }
+      fn = GNUNET_STRINGS_filename_expand(value_fn);
+      if (NULL == fn)
+        fn = value_fn;
+      else
+        GNUNET_free(value_fn);
+      fprintf(stdout, "%s = %s\n", option, fn);
+      GNUNET_free(fn);
+    }
   else
-  {
-    fprintf (stdout, "%s = %s\n", option, value);
-  }
+    {
+      fprintf(stdout, "%s = %s\n", option, value);
+    }
 }
 
 
@@ -120,10 +120,10 @@ print_option (void *cls,
  * @param section a section in the configuration file
  */
 static void
-print_section_name (void *cls, const char *section)
+print_section_name(void *cls, const char *section)
 {
-  (void) cls;
-  fprintf (stdout, "%s\n", section);
+  (void)cls;
+  fprintf(stdout, "%s\n", section);
 }
 
 
@@ -137,133 +137,133 @@ print_section_name (void *cls, const char *section)
  * @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)
 {
   struct GNUNET_CONFIGURATION_Handle *out = NULL;
   struct GNUNET_CONFIGURATION_Handle *diff = NULL;
   char *cfg_fn;
 
-  (void) cls;
-  (void) args;
+  (void)cls;
+  (void)args;
   if (NULL != backend_check)
-  {
-    char *name;
-
-    GNUNET_asprintf (&name, "libgnunet_plugin_%s", backend_check);
-    global_ret = (GNUNET_OK == GNUNET_PLUGIN_test (name)) ? 0 : 77;
-    GNUNET_free (name);
-    return;
-  }
-  if (rewrite)
-  {
-    struct GNUNET_CONFIGURATION_Handle *def;
-
-    def = GNUNET_CONFIGURATION_create ();
-    if (GNUNET_OK != GNUNET_CONFIGURATION_load (def, NULL))
     {
-      fprintf (stderr, _ ("failed to load configuration defaults"));
-      global_ret = 1;
+      char *name;
+
+      GNUNET_asprintf(&name, "libgnunet_plugin_%s", backend_check);
+      global_ret = (GNUNET_OK == GNUNET_PLUGIN_test(name)) ? 0 : 77;
+      GNUNET_free(name);
       return;
     }
-    diff = GNUNET_CONFIGURATION_get_diff (def, cfg);
-    cfg = diff;
-  }
-  if (((! rewrite) && (NULL == section)) || list_sections)
-  {
-    if (! list_sections)
+  if (rewrite)
     {
-      fprintf (stderr,
-               _ ("%s or %s argument is required\n"),
-               "--section",
-               "--list-sections");
-      global_ret = 1;
+      struct GNUNET_CONFIGURATION_Handle *def;
+
+      def = GNUNET_CONFIGURATION_create();
+      if (GNUNET_OK != GNUNET_CONFIGURATION_load(def, NULL))
+        {
+          fprintf(stderr, _("failed to load configuration defaults"));
+          global_ret = 1;
+          return;
+        }
+      diff = GNUNET_CONFIGURATION_get_diff(def, cfg);
+      cfg = diff;
     }
-    else
+  if (((!rewrite) && (NULL == section)) || list_sections)
     {
-      fprintf (stderr, _ ("The following sections are available:\n"));
-      GNUNET_CONFIGURATION_iterate_sections (cfg, &print_section_name, NULL);
+      if (!list_sections)
+        {
+          fprintf(stderr,
+                  _("%s or %s argument is required\n"),
+                  "--section",
+                  "--list-sections");
+          global_ret = 1;
+        }
+      else
+        {
+          fprintf(stderr, _("The following sections are available:\n"));
+          GNUNET_CONFIGURATION_iterate_sections(cfg, &print_section_name, NULL);
+        }
+      goto cleanup;
     }
-    goto cleanup;
-  }
 
   if ((NULL != section) && (NULL == value))
-  {
-    if (NULL == option)
-    {
-      GNUNET_CONFIGURATION_iterate_section_values (cfg,
-                                                   section,
-                                                   &print_option,
-                                                   (void *) cfg);
-    }
-    else
     {
-      if (is_filename)
-      {
-        if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                                  section,
-                                                                  option,
-                                                                  &value))
+      if (NULL == option)
         {
-          GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, section, option);
-          global_ret = 3;
-          goto cleanup;
+          GNUNET_CONFIGURATION_iterate_section_values(cfg,
+                                                      section,
+                                                      &print_option,
+                                                      (void *)cfg);
         }
-      }
       else
-      {
-        if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                                section,
-                                                                option,
-                                                                &value))
         {
-          GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, section, option);
-          global_ret = 3;
-          goto cleanup;
+          if (is_filename)
+            {
+              if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                                       section,
+                                                                       option,
+                                                                       &value))
+                {
+                  GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, section, option);
+                  global_ret = 3;
+                  goto cleanup;
+                }
+            }
+          else
+            {
+              if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                                     section,
+                                                                     option,
+                                                                     &value))
+                {
+                  GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, section, option);
+                  global_ret = 3;
+                  goto cleanup;
+                }
+            }
+          fprintf(stdout, "%s\n", value);
         }
-      }
-      fprintf (stdout, "%s\n", value);
     }
-  }
   else if (NULL != section)
-  {
-    if (NULL == option)
     {
-      fprintf (stderr, _ ("--option argument required to set value\n"));
-      global_ret = 1;
-      goto cleanup;
+      if (NULL == option)
+        {
+          fprintf(stderr, _("--option argument required to set value\n"));
+          global_ret = 1;
+          goto cleanup;
+        }
+      out = GNUNET_CONFIGURATION_dup(cfg);
+      GNUNET_CONFIGURATION_set_value_string(out, section, option, value);
     }
-    out = GNUNET_CONFIGURATION_dup (cfg);
-    GNUNET_CONFIGURATION_set_value_string (out, section, option, value);
-  }
   cfg_fn = NULL;
   if (NULL == cfgfile)
-  {
-    const char *xdg = getenv ("XDG_CONFIG_HOME");
-    if (NULL != xdg)
-      GNUNET_asprintf (&cfg_fn,
-                       "%s%s%s",
-                       xdg,
-                       DIR_SEPARATOR_STR,
-                       GNUNET_OS_project_data_get ()->config_file);
-    else
-      cfg_fn = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
-    cfgfile = cfg_fn;
-  }
+    {
+      const char *xdg = getenv("XDG_CONFIG_HOME");
+      if (NULL != xdg)
+        GNUNET_asprintf(&cfg_fn,
+                        "%s%s%s",
+                        xdg,
+                        DIR_SEPARATOR_STR,
+                        GNUNET_OS_project_data_get()->config_file);
+      else
+        cfg_fn = GNUNET_strdup(GNUNET_OS_project_data_get()->user_config_file);
+      cfgfile = cfg_fn;
+    }
   if ((NULL != diff) || (NULL != out))
-  {
-    if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_write ((NULL == out) ? diff : out, cfgfile))
-      global_ret = 2;
-  }
-  GNUNET_free_non_null (cfg_fn);
+    {
+      if (GNUNET_OK !=
+          GNUNET_CONFIGURATION_write((NULL == out) ? diff : out, cfgfile))
+        global_ret = 2;
+    }
+  GNUNET_free_non_null(cfg_fn);
   if (NULL != out)
-    GNUNET_CONFIGURATION_destroy (out);
+    GNUNET_CONFIGURATION_destroy(out);
 cleanup:
   if (NULL != diff)
-    GNUNET_CONFIGURATION_destroy (diff);
+    GNUNET_CONFIGURATION_destroy(diff);
 }
 
 
@@ -275,63 +275,63 @@ cleanup:
  * @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 (
-       'f',
-       "filename",
-       gettext_noop ("interpret option value as a filename (with $-expansion)"),
-       &is_filename),
-     GNUNET_GETOPT_option_exclusive (GNUNET_GETOPT_option_string (
-       'b',
-       "supported-backend",
-       "BACKEND",
-       gettext_noop (
-         "test if the current installation supports the specified BACKEND"),
-       &backend_check)),
-     GNUNET_GETOPT_option_string ('s',
-                                  "section",
-                                  "SECTION",
-                                  gettext_noop (
-                                    "name of the section to access"),
-                                  &section),
-     GNUNET_GETOPT_option_string ('o',
-                                  "option",
-                                  "OPTION",
-                                  gettext_noop ("name of the option to access"),
-                                  &option),
-     GNUNET_GETOPT_option_string ('V',
-                                  "value",
-                                  "VALUE",
-                                  gettext_noop ("value to set"),
-                                  &value),
-     GNUNET_GETOPT_option_flag ('S',
-                                "list-sections",
-                                gettext_noop (
-                                  "print available configuration sections"),
-                                &list_sections),
-     GNUNET_GETOPT_option_flag (
-       'w',
-       "rewrite",
-       gettext_noop (
-         "write configuration file that only contains delta to defaults"),
-       &rewrite),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_flag(
+      'f',
+      "filename",
+      gettext_noop("interpret option value as a filename (with $-expansion)"),
+      &is_filename),
+    GNUNET_GETOPT_option_exclusive(GNUNET_GETOPT_option_string(
+                                     'b',
+                                     "supported-backend",
+                                     "BACKEND",
+                                     gettext_noop(
+                                       "test if the current installation supports the specified BACKEND"),
+                                     &backend_check)),
+    GNUNET_GETOPT_option_string('s',
+                                "section",
+                                "SECTION",
+                                gettext_noop(
+                                  "name of the section to access"),
+                                &section),
+    GNUNET_GETOPT_option_string('o',
+                                "option",
+                                "OPTION",
+                                gettext_noop("name of the option to access"),
+                                &option),
+    GNUNET_GETOPT_option_string('V',
+                                "value",
+                                "VALUE",
+                                gettext_noop("value to set"),
+                                &value),
+    GNUNET_GETOPT_option_flag('S',
+                              "list-sections",
+                              gettext_noop(
+                                "print available configuration sections"),
+                              &list_sections),
+    GNUNET_GETOPT_option_flag(
+      'w',
+      "rewrite",
+      gettext_noop(
+        "write configuration file that only contains delta to defaults"),
+      &rewrite),
+    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;
 
   ret =
-    GNUNET_PROGRAM_run (argc,
-                        argv,
-                        "gnunet-config [OPTIONS]",
-                        gettext_noop ("Manipulate GNUnet configuration files"),
-                        options,
-                        &run,
-                        NULL);
-  GNUNET_free ((void *) argv);
+    GNUNET_PROGRAM_run(argc,
+                       argv,
+                       "gnunet-config [OPTIONS]",
+                       gettext_noop("Manipulate GNUnet configuration files"),
+                       options,
+                       &run,
+                       NULL);
+  GNUNET_free((void *)argv);
   if (GNUNET_OK == ret)
     return global_ret;
   return ret;
diff --git a/src/util/gnunet-ecc.c b/src/util/gnunet-ecc.c
index e7a170b81..7fb8150f6 100644
--- a/src/util/gnunet-ecc.c
+++ b/src/util/gnunet-ecc.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 util/gnunet-ecc.c
@@ -31,7 +31,7 @@
 /**
  * Number of characters a Base32-encoded public key requires.
  */
-#define KEY_STR_LEN sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) * 8 / 5 + 1
+#define KEY_STR_LEN sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) * 8 / 5 + 1
 
 /**
  * Flag for listing public key.
@@ -76,7 +76,7 @@ static unsigned int make_keys;
  * @param prefix Desired prefix for the public keys, NULL if any key is OK.
  */
 static void
-create_keys (const char *fn, const char *prefix)
+create_keys(const char *fn, const char *prefix)
 {
   FILE *f;
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
@@ -89,120 +89,120 @@ create_keys (const char *fn, const char *prefix)
   unsigned target_byte;
   char *s;
 
-  if (NULL == (f = fopen (fn, "w+")))
-  {
-    fprintf (stderr, _ ("Failed to open `%s': %s\n"), fn, strerror (errno));
-    return;
-  }
+  if (NULL == (f = fopen(fn, "w+")))
+    {
+      fprintf(stderr, _("Failed to open `%s': %s\n"), fn, strerror(errno));
+      return;
+    }
   if (NULL != prefix)
-  {
-    len = GNUNET_strlcpy (vanity, prefix, sizeof (vanity));
-    n = len * 5 / 8;
-    rest = len * 5 % 8;
-
-    memset (&vanity[len], '0', KEY_STR_LEN - len);
-    vanity[KEY_STR_LEN] = '\0';
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_eddsa_public_key_from_string (vanity,
+    {
+      len = GNUNET_strlcpy(vanity, prefix, sizeof(vanity));
+      n = len * 5 / 8;
+      rest = len * 5 % 8;
+
+      memset(&vanity[len], '0', KEY_STR_LEN - len);
+      vanity[KEY_STR_LEN] = '\0';
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CRYPTO_eddsa_public_key_from_string(vanity,
                                                                KEY_STR_LEN,
                                                                &target_pub));
-    if (0 != rest)
-    {
-      /**
-       * Documentation by example:
-       * vanity = "A"
-       * len = 1
-       * n = 5/8 = 0 (bytes)
-       * rest = 5%8 = 5 (bits)
-       * mask = ~(2**(8 - 5) - 1) = ~(2**3 - 1) = ~(8 - 1) = ~b111 = b11111000
-       */
-      mask = ~((int) pow (2, 8 - rest) - 1);
-      target_byte = ((unsigned char *) &target_pub)[n] & mask;
+      if (0 != rest)
+        {
+          /**
+           * Documentation by example:
+           * vanity = "A"
+           * len = 1
+           * n = 5/8 = 0 (bytes)
+           * rest = 5%8 = 5 (bits)
+           * mask = ~(2**(8 - 5) - 1) = ~(2**3 - 1) = ~(8 - 1) = ~b111 = b11111000
+           */
+          mask = ~((int)pow(2, 8 - rest) - 1);
+          target_byte = ((unsigned char *)&target_pub)[n] & mask;
+        }
+      else
+        {
+          /* Just so old (debian) versions of GCC calm down with the warnings. */
+          mask = target_byte = 0;
+        }
+      s = GNUNET_CRYPTO_eddsa_public_key_to_string(&target_pub);
+      fprintf(stderr,
+              _("Generating %u keys like %s, please wait"),
+              make_keys,
+              s);
+      GNUNET_free(s);
+      fprintf(stderr, "\nattempt %s [%u, %X]\n", vanity, (unsigned int)n, mask);
     }
-    else
+  else
     {
+      fprintf(stderr, _("Generating %u keys, please wait"), make_keys);
       /* Just so old (debian) versions of GCC calm down with the warnings. */
-      mask = target_byte = 0;
+      n = rest = target_byte = mask = 0;
     }
-    s = GNUNET_CRYPTO_eddsa_public_key_to_string (&target_pub);
-    fprintf (stderr,
-             _ ("Generating %u keys like %s, please wait"),
-             make_keys,
-             s);
-    GNUNET_free (s);
-    fprintf (stderr, "\nattempt %s [%u, %X]\n", vanity, (unsigned int) n, mask);
-  }
-  else
-  {
-    fprintf (stderr, _ ("Generating %u keys, please wait"), make_keys);
-    /* Just so old (debian) versions of GCC calm down with the warnings. */
-    n = rest = target_byte = mask = 0;
-  }
 
   while (0 < make_keys--)
-  {
-    fprintf (stderr, ".");
-    if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create ()))
-    {
-      GNUNET_break (0);
-      break;
-    }
-    if (NULL != prefix)
     {
-      struct GNUNET_CRYPTO_EddsaPublicKey newkey;
-
-      GNUNET_CRYPTO_eddsa_key_get_public (pk, &newkey);
-      if (0 != memcmp (&target_pub, &newkey, n))
-      {
-        make_keys++;
-        continue;
-      }
-      if (0 != rest)
-      {
-        unsigned char new_byte;
-
-        new_byte = ((unsigned char *) &newkey)[n] & mask;
-        if (target_byte != new_byte)
+      fprintf(stderr, ".");
+      if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create()))
         {
-          make_keys++;
-          continue;
+          GNUNET_break(0);
+          break;
         }
-      }
-    }
-    if (GNUNET_TESTING_HOSTKEYFILESIZE !=
-        fwrite (pk, 1, GNUNET_TESTING_HOSTKEYFILESIZE, f))
-    {
-      fprintf (stderr,
-               _ ("\nFailed to write to `%s': %s\n"),
-               fn,
-               strerror (errno));
-      GNUNET_free (pk);
-      break;
+      if (NULL != prefix)
+        {
+          struct GNUNET_CRYPTO_EddsaPublicKey newkey;
+
+          GNUNET_CRYPTO_eddsa_key_get_public(pk, &newkey);
+          if (0 != memcmp(&target_pub, &newkey, n))
+            {
+              make_keys++;
+              continue;
+            }
+          if (0 != rest)
+            {
+              unsigned char new_byte;
+
+              new_byte = ((unsigned char *)&newkey)[n] & mask;
+              if (target_byte != new_byte)
+                {
+                  make_keys++;
+                  continue;
+                }
+            }
+        }
+      if (GNUNET_TESTING_HOSTKEYFILESIZE !=
+          fwrite(pk, 1, GNUNET_TESTING_HOSTKEYFILESIZE, f))
+        {
+          fprintf(stderr,
+                  _("\nFailed to write to `%s': %s\n"),
+                  fn,
+                  strerror(errno));
+          GNUNET_free(pk);
+          break;
+        }
+      GNUNET_free(pk);
     }
-    GNUNET_free (pk);
-  }
   if (UINT_MAX == make_keys)
-    fprintf (stderr, _ ("\nFinished!\n"));
+    fprintf(stderr, _("\nFinished!\n"));
   else
-    fprintf (stderr, _ ("\nError, %u keys not generated\n"), make_keys);
-  fclose (f);
+    fprintf(stderr, _("\nError, %u keys not generated\n"), make_keys);
+  fclose(f);
 }
 
 
 static void
-print_hex (const char *msg, const void *buf, size_t size)
+print_hex(const char *msg, const void *buf, size_t size)
 {
-  printf ("%s: ", msg);
+  printf("%s: ", msg);
   for (size_t i = 0; i < size; i++)
-  {
-    printf ("%02hhx", ((const uint8_t *) buf)[i]);
-  }
-  printf ("\n");
+    {
+      printf("%02hhx", ((const uint8_t *)buf)[i]);
+    }
+  printf("\n");
 }
 
 
 static void
-print_examples_ecdh ()
+print_examples_ecdh()
 {
   struct GNUNET_CRYPTO_EcdhePrivateKey *dh_priv1;
   struct GNUNET_CRYPTO_EcdhePublicKey *dh_pub1;
@@ -211,40 +211,40 @@ print_examples_ecdh ()
   struct GNUNET_HashCode hash;
   char buf[128];
 
-  dh_pub1 = GNUNET_new (struct GNUNET_CRYPTO_EcdhePublicKey);
-  dh_priv1 = GNUNET_CRYPTO_ecdhe_key_create ();
-  dh_pub2 = GNUNET_new (struct GNUNET_CRYPTO_EcdhePublicKey);
-  dh_priv2 = GNUNET_CRYPTO_ecdhe_key_create ();
-  GNUNET_CRYPTO_ecdhe_key_get_public (dh_priv1, dh_pub1);
-  GNUNET_CRYPTO_ecdhe_key_get_public (dh_priv2, dh_pub2);
-
-  GNUNET_assert (NULL !=
-                 GNUNET_STRINGS_data_to_string (dh_priv1, 32, buf, 128));
-  printf ("ECDHE key 1:\n");
-  printf ("private: %s\n", buf);
-  print_hex ("private(hex)", dh_priv1, sizeof *dh_priv1);
-  GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_pub1, 32, buf, 128));
-  printf ("public: %s\n", buf);
-  print_hex ("public(hex)", dh_pub1, sizeof *dh_pub1);
-
-  GNUNET_assert (NULL !=
-                 GNUNET_STRINGS_data_to_string (dh_priv2, 32, buf, 128));
-  printf ("ECDHE key 2:\n");
-  printf ("private: %s\n", buf);
-  print_hex ("private(hex)", dh_priv2, sizeof *dh_priv2);
-  GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (dh_pub2, 32, buf, 128));
-  printf ("public: %s\n", buf);
-  print_hex ("public(hex)", dh_pub2, sizeof *dh_pub2);
-
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_ecc_ecdh (dh_priv1, dh_pub2, &hash));
-  GNUNET_assert (NULL != GNUNET_STRINGS_data_to_string (&hash, 64, buf, 128));
-  printf ("ECDH shared secret: %s\n", buf);
-
-  GNUNET_free (dh_priv1);
-  GNUNET_free (dh_priv2);
-  GNUNET_free (dh_pub1);
-  GNUNET_free (dh_pub2);
+  dh_pub1 = GNUNET_new(struct GNUNET_CRYPTO_EcdhePublicKey);
+  dh_priv1 = GNUNET_CRYPTO_ecdhe_key_create();
+  dh_pub2 = GNUNET_new(struct GNUNET_CRYPTO_EcdhePublicKey);
+  dh_priv2 = GNUNET_CRYPTO_ecdhe_key_create();
+  GNUNET_CRYPTO_ecdhe_key_get_public(dh_priv1, dh_pub1);
+  GNUNET_CRYPTO_ecdhe_key_get_public(dh_priv2, dh_pub2);
+
+  GNUNET_assert(NULL !=
+                GNUNET_STRINGS_data_to_string(dh_priv1, 32, buf, 128));
+  printf("ECDHE key 1:\n");
+  printf("private: %s\n", buf);
+  print_hex("private(hex)", dh_priv1, sizeof *dh_priv1);
+  GNUNET_assert(NULL != GNUNET_STRINGS_data_to_string(dh_pub1, 32, buf, 128));
+  printf("public: %s\n", buf);
+  print_hex("public(hex)", dh_pub1, sizeof *dh_pub1);
+
+  GNUNET_assert(NULL !=
+                GNUNET_STRINGS_data_to_string(dh_priv2, 32, buf, 128));
+  printf("ECDHE key 2:\n");
+  printf("private: %s\n", buf);
+  print_hex("private(hex)", dh_priv2, sizeof *dh_priv2);
+  GNUNET_assert(NULL != GNUNET_STRINGS_data_to_string(dh_pub2, 32, buf, 128));
+  printf("public: %s\n", buf);
+  print_hex("public(hex)", dh_pub2, sizeof *dh_pub2);
+
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CRYPTO_ecc_ecdh(dh_priv1, dh_pub2, &hash));
+  GNUNET_assert(NULL != GNUNET_STRINGS_data_to_string(&hash, 64, buf, 128));
+  printf("ECDH shared secret: %s\n", buf);
+
+  GNUNET_free(dh_priv1);
+  GNUNET_free(dh_priv2);
+  GNUNET_free(dh_pub1);
+  GNUNET_free(dh_pub2);
 }
 
 
@@ -252,16 +252,16 @@ print_examples_ecdh ()
  * Print some random example operations to stdout.
  */
 static void
-print_examples ()
+print_examples()
 {
-  print_examples_ecdh ();
+  print_examples_ecdh();
   // print_examples_ecdsa ();
   // print_examples_eddsa ();
 }
 
 
 static void
-print_key (const char *filename)
+print_key(const char *filename)
 {
   struct GNUNET_DISK_FileHandle *fd;
   struct GNUNET_CRYPTO_EddsaPrivateKey private_key;
@@ -273,64 +273,64 @@ print_key (const char *filename)
   unsigned int c;
   ssize_t sret;
 
-  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-  {
-    fprintf (stderr, _ ("Hostkeys file `%s' not found\n"), filename);
-    return;
-  }
+  if (GNUNET_YES != GNUNET_DISK_file_test(filename))
+    {
+      fprintf(stderr, _("Hostkeys file `%s' not found\n"), filename);
+      return;
+    }
 
   /* Check hostkey file size, read entire thing into memory */
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
+      GNUNET_DISK_file_size(filename, &fs, GNUNET_YES, GNUNET_YES))
     fs = 0;
   if (0 == fs)
-  {
-    fprintf (stderr, _ ("Hostkeys file `%s' is empty\n"), filename);
-    return; /* File is empty */
-  }
+    {
+      fprintf(stderr, _("Hostkeys file `%s' is empty\n"), filename);
+      return; /* File is empty */
+    }
   if (0 != (fs % GNUNET_TESTING_HOSTKEYFILESIZE))
-  {
-    fprintf (stderr, _ ("Incorrect hostkey file format: %s\n"), filename);
-    return;
-  }
-  fd = GNUNET_DISK_file_open (filename,
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
+    {
+      fprintf(stderr, _("Incorrect hostkey file format: %s\n"), filename);
+      return;
+    }
+  fd = GNUNET_DISK_file_open(filename,
+                             GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (NULL == fd)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-    return;
-  }
-  hostkeys_data = GNUNET_malloc (fs);
-  sret = GNUNET_DISK_file_read (fd, hostkeys_data, fs);
-  if ((sret < 0) || (fs != (size_t) sret))
-  {
-    fprintf (stderr, _ ("Could not read hostkey file: %s\n"), filename);
-    GNUNET_free (hostkeys_data);
-    GNUNET_DISK_file_close (fd);
-    return;
-  }
-  GNUNET_DISK_file_close (fd);
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", filename);
+      return;
+    }
+  hostkeys_data = GNUNET_malloc(fs);
+  sret = GNUNET_DISK_file_read(fd, hostkeys_data, fs);
+  if ((sret < 0) || (fs != (size_t)sret))
+    {
+      fprintf(stderr, _("Could not read hostkey file: %s\n"), filename);
+      GNUNET_free(hostkeys_data);
+      GNUNET_DISK_file_close(fd);
+      return;
+    }
+  GNUNET_DISK_file_close(fd);
 
   if (NULL == hostkeys_data)
     return;
   total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE;
   for (c = 0; (c < total_hostkeys) && (c < list_keys_count); c++)
-  {
-    GNUNET_memcpy (&private_key,
-                   hostkeys_data + (c * GNUNET_TESTING_HOSTKEYFILESIZE),
-                   GNUNET_TESTING_HOSTKEYFILESIZE);
-    GNUNET_CRYPTO_eddsa_key_get_public (&private_key, &public_key);
-    hostkey_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&public_key);
-    if (NULL != hostkey_str)
     {
-      fprintf (stderr, "%4u: %s\n", c, hostkey_str);
-      GNUNET_free (hostkey_str);
+      GNUNET_memcpy(&private_key,
+                    hostkeys_data + (c * GNUNET_TESTING_HOSTKEYFILESIZE),
+                    GNUNET_TESTING_HOSTKEYFILESIZE);
+      GNUNET_CRYPTO_eddsa_key_get_public(&private_key, &public_key);
+      hostkey_str = GNUNET_CRYPTO_eddsa_public_key_to_string(&public_key);
+      if (NULL != hostkey_str)
+        {
+          fprintf(stderr, "%4u: %s\n", c, hostkey_str);
+          GNUNET_free(hostkey_str);
+        }
+      else
+        fprintf(stderr, "%4u: %s\n", c, "invalid");
     }
-    else
-      fprintf (stderr, "%4u: %s\n", c, "invalid");
-  }
-  GNUNET_free (hostkeys_data);
+  GNUNET_free(hostkeys_data);
 }
 
 
@@ -343,69 +343,69 @@ print_key (const char *filename)
  * @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) cfgfile;
-  (void) cfg;
+  (void)cls;
+  (void)cfgfile;
+  (void)cfg;
 
   if (print_examples_flag)
-  {
-    print_examples ();
-    return;
-  }
+    {
+      print_examples();
+      return;
+    }
   if (NULL == args[0])
-  {
-    fprintf (stderr, "%s", _ ("No hostkey file specified on command line\n"));
-    return;
-  }
+    {
+      fprintf(stderr, "%s", _("No hostkey file specified on command line\n"));
+      return;
+    }
   if (list_keys)
-  {
-    print_key (args[0]);
-    return;
-  }
+    {
+      print_key(args[0]);
+      return;
+    }
   if (make_keys > 0)
-  {
-    create_keys (args[0], args[1]);
-    return;
-  }
-  if (print_public_key || print_public_key_hex || print_private_key)
-  {
-    char *str;
-    struct GNUNET_DISK_FileHandle *keyfile;
-    struct GNUNET_CRYPTO_EddsaPrivateKey pk;
-    struct GNUNET_CRYPTO_EddsaPublicKey pub;
-
-    keyfile = GNUNET_DISK_file_open (args[0],
-                                     GNUNET_DISK_OPEN_READ,
-                                     GNUNET_DISK_PERM_NONE);
-    if (NULL == keyfile)
+    {
+      create_keys(args[0], args[1]);
       return;
-    while (sizeof (pk) == GNUNET_DISK_file_read (keyfile, &pk, sizeof (pk)))
+    }
+  if (print_public_key || print_public_key_hex || print_private_key)
     {
-      GNUNET_CRYPTO_eddsa_key_get_public (&pk, &pub);
-      if (print_public_key_hex)
-      {
-        print_hex ("HEX:", &pub, sizeof (pub));
-      }
-      else if (print_public_key)
-      {
-        str = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
-        fprintf (stdout, "%s\n", str);
-        GNUNET_free (str);
-      }
-      else if (print_private_key)
-      {
-        str = GNUNET_CRYPTO_eddsa_private_key_to_string (&pk);
-        fprintf (stdout, "%s\n", str);
-        GNUNET_free (str);
-      }
+      char *str;
+      struct GNUNET_DISK_FileHandle *keyfile;
+      struct GNUNET_CRYPTO_EddsaPrivateKey pk;
+      struct GNUNET_CRYPTO_EddsaPublicKey pub;
+
+      keyfile = GNUNET_DISK_file_open(args[0],
+                                      GNUNET_DISK_OPEN_READ,
+                                      GNUNET_DISK_PERM_NONE);
+      if (NULL == keyfile)
+        return;
+      while (sizeof(pk) == GNUNET_DISK_file_read(keyfile, &pk, sizeof(pk)))
+        {
+          GNUNET_CRYPTO_eddsa_key_get_public(&pk, &pub);
+          if (print_public_key_hex)
+            {
+              print_hex("HEX:", &pub, sizeof(pub));
+            }
+          else if (print_public_key)
+            {
+              str = GNUNET_CRYPTO_eddsa_public_key_to_string(&pub);
+              fprintf(stdout, "%s\n", str);
+              GNUNET_free(str);
+            }
+          else if (print_private_key)
+            {
+              str = GNUNET_CRYPTO_eddsa_private_key_to_string(&pk);
+              fprintf(stdout, "%s\n", str);
+              GNUNET_free(str);
+            }
+        }
+      GNUNET_DISK_file_close(keyfile);
     }
-    GNUNET_DISK_file_close (keyfile);
-  }
 }
 
 
@@ -417,66 +417,66 @@ 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_flag ('i',
-                                "iterate",
-                                gettext_noop (
-                                  "list keys included in a file (for testing)"),
-                                &list_keys),
-     GNUNET_GETOPT_option_uint (
-       'e',
-       "end=",
-       "COUNT",
-       gettext_noop ("number of keys to list included in a file (for testing)"),
-       &list_keys_count),
-     GNUNET_GETOPT_option_uint (
-       'g',
-       "generate-keys",
-       "COUNT",
-       gettext_noop ("create COUNT public-private key pairs (for testing)"),
-       &make_keys),
-     GNUNET_GETOPT_option_flag ('p',
-                                "print-public-key",
-                                gettext_noop (
-                                  "print the public key in ASCII format"),
-                                &print_public_key),
-     GNUNET_GETOPT_option_flag ('P',
-                                "print-private-key",
-                                gettext_noop (
-                                  "print the private key in ASCII format"),
-                                &print_private_key),
-     GNUNET_GETOPT_option_flag ('x',
-                                "print-hex",
-                                gettext_noop (
-                                  "print the public key in HEX format"),
-                                &print_public_key_hex),
-     GNUNET_GETOPT_option_flag (
-       'E',
-       "examples",
-       gettext_noop (
-         "print examples of ECC operations (used for compatibility testing)"),
-       &print_examples_flag),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_flag('i',
+                              "iterate",
+                              gettext_noop(
+                                "list keys included in a file (for testing)"),
+                              &list_keys),
+    GNUNET_GETOPT_option_uint(
+      'e',
+      "end=",
+      "COUNT",
+      gettext_noop("number of keys to list included in a file (for testing)"),
+      &list_keys_count),
+    GNUNET_GETOPT_option_uint(
+      'g',
+      "generate-keys",
+      "COUNT",
+      gettext_noop("create COUNT public-private key pairs (for testing)"),
+      &make_keys),
+    GNUNET_GETOPT_option_flag('p',
+                              "print-public-key",
+                              gettext_noop(
+                                "print the public key in ASCII format"),
+                              &print_public_key),
+    GNUNET_GETOPT_option_flag('P',
+                              "print-private-key",
+                              gettext_noop(
+                                "print the private key in ASCII format"),
+                              &print_private_key),
+    GNUNET_GETOPT_option_flag('x',
+                              "print-hex",
+                              gettext_noop(
+                                "print the public key in HEX format"),
+                              &print_public_key_hex),
+    GNUNET_GETOPT_option_flag(
+      'E',
+      "examples",
+      gettext_noop(
+        "print examples of ECC operations (used for compatibility testing)"),
+      &print_examples_flag),
+    GNUNET_GETOPT_OPTION_END };
   int ret;
 
   list_keys_count = UINT32_MAX;
-  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;
 
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run (argc,
-                             argv,
-                             "gnunet-ecc [OPTIONS] keyfile [VANITY_PREFIX]",
-                             gettext_noop (
-                               "Manipulate GNUnet private ECC key files"),
-                             options,
-                             &run,
-                             NULL))
-          ? 0
-          : 1;
-  GNUNET_free ((void *) argv);
+         GNUNET_PROGRAM_run(argc,
+                            argv,
+                            "gnunet-ecc [OPTIONS] keyfile [VANITY_PREFIX]",
+                            gettext_noop(
+                              "Manipulate GNUnet private ECC key files"),
+                            options,
+                            &run,
+                            NULL))
+        ? 0
+        : 1;
+  GNUNET_free((void *)argv);
   return ret;
 }
 
diff --git a/src/util/gnunet-helper-w32-console.c b/src/util/gnunet-helper-w32-console.c
index fdebd9a49..b773e27d7 100644
--- a/src/util/gnunet-helper-w32-console.c
+++ b/src/util/gnunet-helper-w32-console.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file src/util/gnunet-helper-w32-console.c
@@ -45,9 +45,9 @@ static HANDLE parent_handle;
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-write_all (int output, 
-           const void *buf,
-           size_t size)
+write_all(int output,
+          const void *buf,
+          size_t size)
 {
   const char *cbuf = buf;
   size_t total;
@@ -55,17 +55,18 @@ write_all (int output,
 
   total = 0;
   do
-  {
-    wr = write (output,
-                &cbuf[total],
-                size - total);
-    if (wr > 0)
-      total += wr;
-  } while ( (wr > 0) && (total < size) );
+    {
+      wr = write(output,
+                 &cbuf[total],
+                 size - total);
+      if (wr > 0)
+        total += wr;
+    }
+  while ((wr > 0) && (total < size));
   if (wr <= 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Failed to write to stdout: %s\n",
-                strerror (errno));
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Failed to write to stdout: %s\n",
+               strerror(errno));
   return (total == size) ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -80,24 +81,24 @@ write_all (int output,
  * @return #GNUNET_SYSERR to stop scanning (the pipe was broken somehow)
  */
 static int
-write_message (int output,
-               uint16_t message_type,
-               const char *data,
-               size_t data_length)
+write_message(int output,
+              uint16_t message_type,
+              const char *data,
+              size_t data_length)
 {
   struct GNUNET_MessageHeader hdr;
 
 #if 0
-  fprintf (stderr,
-           "Helper sends %u-byte message of type %u\n",
-           (unsigned int) (sizeof (struct GNUNET_MessageHeader) + data_length),
-           (unsigned int) message_type);
+  fprintf(stderr,
+          "Helper sends %u-byte message of type %u\n",
+          (unsigned int)(sizeof(struct GNUNET_MessageHeader) + data_length),
+          (unsigned int)message_type);
 #endif
-  hdr.type = htons (message_type);
-  hdr.size = htons (sizeof (struct GNUNET_MessageHeader) + data_length);
-  if (GNUNET_OK != write_all (output, &hdr, sizeof (hdr)))
+  hdr.type = htons(message_type);
+  hdr.size = htons(sizeof(struct GNUNET_MessageHeader) + data_length);
+  if (GNUNET_OK != write_all(output, &hdr, sizeof(hdr)))
     return GNUNET_SYSERR;
-  if (GNUNET_OK != write_all (output, data, data_length))
+  if (GNUNET_OK != write_all(output, data, data_length))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -112,7 +113,7 @@ write_message (int output,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-read_events (HANDLE console, int output_stream)
+read_events(HANDLE console, int output_stream)
 {
   DWORD rr;
   BOOL b;
@@ -121,30 +122,30 @@ read_events (HANDLE console, int output_stream)
   int result;
 
   result = GNUNET_SYSERR;
-  buf = malloc (sizeof (INPUT_RECORD) * buffer_size);
+  buf = malloc(sizeof(INPUT_RECORD) * buffer_size);
   if (NULL == buf)
     return result;
   b = TRUE;
   rr = 1;
   while (TRUE == b && 0 < rr)
-  {
-    rr = 0;
-    b = ReadConsoleInput (console, buf, buffer_size, &rr);
-    if (FALSE == b && ERROR_SUCCESS != GetLastError ())
-      break;
-    for (i = 0; i < rr; i++)
     {
-      int r;
-      r = write_message (output_stream,
-                         GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_INPUT,
-                         (const char *) &buf[i],
-                         sizeof (INPUT_RECORD));
-      if (GNUNET_OK != r)
+      rr = 0;
+      b = ReadConsoleInput(console, buf, buffer_size, &rr);
+      if (FALSE == b && ERROR_SUCCESS != GetLastError())
+        break;
+      for (i = 0; i < rr; i++)
+        {
+          int r;
+          r = write_message(output_stream,
+                            GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_INPUT,
+                            (const char *)&buf[i],
+                            sizeof(INPUT_RECORD));
+          if (GNUNET_OK != r)
+            break;
+        }
+      if (rr + 1 != i)
         break;
     }
-    if (rr + 1 != i)
-      break;
-  }
   return result;
 }
 
@@ -158,7 +159,7 @@ read_events (HANDLE console, int output_stream)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-read_chars (HANDLE console, int output_stream)
+read_chars(HANDLE console, int output_stream)
 {
   DWORD rr;
   BOOL b;
@@ -171,78 +172,78 @@ read_chars (HANDLE console, int output_stream)
   int result;
 
   result = GNUNET_SYSERR;
-  buf = malloc (sizeof (wchar_t) * buffer_size);
+  buf = malloc(sizeof(wchar_t) * buffer_size);
   if (NULL == buf)
     return result;
-  small_ubuf = malloc (sizeof (char) * buffer_size * 2);
+  small_ubuf = malloc(sizeof(char) * buffer_size * 2);
   if (NULL == small_ubuf)
-  {
-    free (buf);
-    return result;
-  }
+    {
+      free(buf);
+      return result;
+    }
   b = TRUE;
   rr = 1;
   while (TRUE == b)
-  {
-    large_ubuf = NULL;
-    rr = 0;
-    b = ReadConsoleW (console, buf, buffer_size, &rr, NULL);
-    if (FALSE == b && ERROR_SUCCESS != GetLastError ())
-      break;
-    if (0 == rr)
-      continue;
-    /* Caveat: if the UTF-16-encoded string is longer than BUFFER_SIZE,
-     * there's a possibility that we will read up to a word that constitutes
-     * a part of a multi-byte UTF-16 codepoint. Converting that to UTF-8
-     * will either drop invalid word (flags == 0) or bail out because of it
-     * (flags == WC_ERR_INVALID_CHARS).
-     */
-    conv = WideCharToMultiByte (CP_UTF8, 0, buf, rr, small_ubuf, 0, NULL, FALSE);
-    if (0 == conv || 0xFFFD == conv)
-      continue;
-    if (conv <= buffer_size * 2 - 1)
-    {
-      memset (small_ubuf, 0, buffer_size * 2);
-      conv = WideCharToMultiByte (CP_UTF8, 0, buf, rr, small_ubuf, buffer_size * 2 - 1, NULL, FALSE);
-      if (0 == conv || 0xFFFD == conv)
-        continue;
-      ubuf = small_ubuf;
-    }
-    else
     {
-      large_ubuf = malloc (conv + 1);
-      if (NULL == large_ubuf)
+      large_ubuf = NULL;
+      rr = 0;
+      b = ReadConsoleW(console, buf, buffer_size, &rr, NULL);
+      if (FALSE == b && ERROR_SUCCESS != GetLastError())
+        break;
+      if (0 == rr)
         continue;
-      memset (large_ubuf, 0, conv + 1);
-      conv = WideCharToMultiByte (CP_UTF8, 0, buf, rr, large_ubuf, conv, NULL, FALSE);
+      /* Caveat: if the UTF-16-encoded string is longer than BUFFER_SIZE,
+       * there's a possibility that we will read up to a word that constitutes
+       * a part of a multi-byte UTF-16 codepoint. Converting that to UTF-8
+       * will either drop invalid word (flags == 0) or bail out because of it
+       * (flags == WC_ERR_INVALID_CHARS).
+       */
+      conv = WideCharToMultiByte(CP_UTF8, 0, buf, rr, small_ubuf, 0, NULL, FALSE);
       if (0 == conv || 0xFFFD == conv)
-      {
-        free (large_ubuf);
-        large_ubuf = NULL;
         continue;
-      }
-      ubuf = large_ubuf;
+      if (conv <= buffer_size * 2 - 1)
+        {
+          memset(small_ubuf, 0, buffer_size * 2);
+          conv = WideCharToMultiByte(CP_UTF8, 0, buf, rr, small_ubuf, buffer_size * 2 - 1, NULL, FALSE);
+          if (0 == conv || 0xFFFD == conv)
+            continue;
+          ubuf = small_ubuf;
+        }
+      else
+        {
+          large_ubuf = malloc(conv + 1);
+          if (NULL == large_ubuf)
+            continue;
+          memset(large_ubuf, 0, conv + 1);
+          conv = WideCharToMultiByte(CP_UTF8, 0, buf, rr, large_ubuf, conv, NULL, FALSE);
+          if (0 == conv || 0xFFFD == conv)
+            {
+              free(large_ubuf);
+              large_ubuf = NULL;
+              continue;
+            }
+          ubuf = large_ubuf;
+        }
+      r = write_message(output_stream,
+                        GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_CHARS,
+                        ubuf,
+                        conv + 1);
+      if (large_ubuf)
+        free(large_ubuf);
+      if (GNUNET_OK != r)
+        break;
     }
-    r = write_message (output_stream,
-                       GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_CHARS,
-                       ubuf,
-                       conv + 1);
-    if (large_ubuf)
-      free (large_ubuf);
-    if (GNUNET_OK != r)
-      break;
-  }
-  free (small_ubuf);
-  free (buf);
+  free(small_ubuf);
+  free(buf);
   return result;
 }
 
 
 DWORD WINAPI
-watch_parent (LPVOID param)
+watch_parent(LPVOID param)
 {
-  WaitForSingleObject (parent_handle, INFINITE);
-  ExitProcess (1);
+  WaitForSingleObject(parent_handle, INFINITE);
+  ExitProcess(1);
   return 0;
 }
 
@@ -257,62 +258,62 @@ watch_parent (LPVOID param)
  * @return 0 on success
  */
 int
-main (int argc,
-      char *const *argv)
+main(int argc,
+     char *const *argv)
 {
   HANDLE os_stdin;
   DWORD parent_pid;
+
   /* We're using stdout to communicate binary data back to the parent; use
    * binary mode.
    */
-  _setmode (1, _O_BINARY);
+  _setmode(1, _O_BINARY);
 
   if (argc != 4)
-  {
-    fprintf (stderr,
-        "Usage: gnunet-helper-w32-console <chars|events> <buffer size> <parent pid>\n");
-    return 2;
-  }
+    {
+      fprintf(stderr,
+              "Usage: gnunet-helper-w32-console <chars|events> <buffer size> <parent pid>\n");
+      return 2;
+    }
 
-  if (0 == strcmp (argv[1], "chars"))
+  if (0 == strcmp(argv[1], "chars"))
     chars = GNUNET_YES;
-  else if (0 == strcmp (argv[1], "events"))
+  else if (0 == strcmp(argv[1], "events"))
     chars = GNUNET_NO;
   else
     return 3;
 
-  buffer_size = strtoul (argv[2], NULL, 10);
+  buffer_size = strtoul(argv[2], NULL, 10);
   if (buffer_size <= 0)
     return 4;
 
-  parent_pid = (DWORD) strtoul (argv[3], NULL, 10);
+  parent_pid = (DWORD)strtoul(argv[3], NULL, 10);
   if (parent_pid == 0)
     return 5;
-  parent_handle = OpenProcess (SYNCHRONIZE, FALSE, parent_pid);
+  parent_handle = OpenProcess(SYNCHRONIZE, FALSE, parent_pid);
   if (NULL == parent_handle)
     return 6;
 
-  CreateThread (NULL, 0, watch_parent, NULL, 0, NULL);
+  CreateThread(NULL, 0, watch_parent, NULL, 0, NULL);
 
-  if (0 == AttachConsole (ATTACH_PARENT_PROCESS))
-  {
-    if (ERROR_ACCESS_DENIED != GetLastError ())
-      return 5;
-  }
+  if (0 == AttachConsole(ATTACH_PARENT_PROCESS))
+    {
+      if (ERROR_ACCESS_DENIED != GetLastError())
+        return 5;
+    }
 
   /* Helper API overrides stdin, so we just attach to the console that we
    * inherited. If we did.
    */
-  os_stdin = CreateFile ("CONIN$", GENERIC_READ | GENERIC_WRITE,
-      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
+  os_stdin = CreateFile("CONIN$", GENERIC_READ | GENERIC_WRITE,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
   if (INVALID_HANDLE_VALUE == os_stdin)
     return 1;
 
   if (GNUNET_NO == chars)
-    return read_events (os_stdin, 1);
+    return read_events(os_stdin, 1);
   else
-    return read_chars (os_stdin, 1);
-
+    return read_chars(os_stdin, 1);
 }
 
 /* end of gnunet-helper-w32-console.c */
diff --git a/src/util/gnunet-helper-w32-console.h b/src/util/gnunet-helper-w32-console.h
index eaa9019a5..6af357cb7 100644
--- a/src/util/gnunet-helper-w32-console.h
+++ b/src/util/gnunet-helper-w32-console.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @author LRN
@@ -44,8 +44,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * This is just a dump of the INPUT_RECORD structure.
  */
-struct GNUNET_W32_CONSOLE_input
-{
+struct GNUNET_W32_CONSOLE_input {
   /**
    * Type:  GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_INPUT
    */
@@ -57,8 +56,7 @@ struct GNUNET_W32_CONSOLE_input
 /**
  * A header, followed by UTF8-encoded, 0-terminated string
  */
-struct GNUNET_W32_CONSOLE_chars
-{
+struct GNUNET_W32_CONSOLE_chars {
   /**
    * Type:  GNUNET_MESSAGE_TYPE_W32_CONSOLE_HELPER_CHARS
    */
diff --git a/src/util/gnunet-qr.c b/src/util/gnunet-qr.c
index ff781f726..91c36dbdf 100644
--- a/src/util/gnunet-qr.c
+++ b/src/util/gnunet-qr.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 util/gnunet-qr.c
  * @author Hartmut Goebel (original implementation)
@@ -31,7 +31,7 @@
 
 #define LOG(fmt, ...)  \
   if (verbose == true) \
-  printf (fmt, ##__VA_ARGS__)
+  printf (fmt, ## __VA_ARGS__)
 
 /**
  * Video device to capture from. Sane default for GNU/Linux systems.
@@ -72,14 +72,14 @@ static struct GNUNET_DISK_PipeHandle *sigpipe;
  * @param cls closure, NULL
  */
 static void
-maint_child_death (void *cls)
+maint_child_death(void *cls)
 {
   enum GNUNET_OS_ProcessStatusType type;
 
-  if ((GNUNET_OK != GNUNET_OS_process_status (p, &type, &exit_code)) ||
+  if ((GNUNET_OK != GNUNET_OS_process_status(p, &type, &exit_code)) ||
       (type != GNUNET_OS_PROCESS_EXITED))
-    GNUNET_break (0 == GNUNET_OS_process_kill (p, GNUNET_TERM_SIG));
-  GNUNET_OS_process_destroy (p);
+    GNUNET_break(0 == GNUNET_OS_process_kill(p, GNUNET_TERM_SIG));
+  GNUNET_OS_process_destroy(p);
 }
 
 
@@ -92,10 +92,10 @@ maint_child_death (void *cls)
  * @param cfg configuration
  */
 static void
-gnunet_uri (void *cls,
-            const char *uri,
-            const char *cfgfile,
-            const struct GNUNET_CONFIGURATION_Handle *cfg)
+gnunet_uri(void *cls,
+           const char *uri,
+           const char *cfgfile,
+           const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *orig_uri;
   const char *slash;
@@ -104,45 +104,45 @@ gnunet_uri (void *cls,
   struct GNUNET_SCHEDULER_Task *rt;
 
   orig_uri = uri;
-  if (0 != strncasecmp ("gnunet://", uri, strlen ("gnunet://")))
-  {
-    fprintf (stderr,
-             _ ("Invalid URI: does not start with `%s'\n"),
-             "gnunet://");
-    return;
-  }
-  uri += strlen ("gnunet://");
-  if (NULL == (slash = strchr (uri, '/')))
-  {
-    fprintf (stderr, _ ("Invalid URI: fails to specify subsystem\n"));
-    return;
-  }
-  subsystem = GNUNET_strndup (uri, slash - uri);
+  if (0 != strncasecmp("gnunet://", uri, strlen("gnunet://")))
+    {
+      fprintf(stderr,
+              _("Invalid URI: does not start with `%s'\n"),
+              "gnunet://");
+      return;
+    }
+  uri += strlen("gnunet://");
+  if (NULL == (slash = strchr(uri, '/')))
+    {
+      fprintf(stderr, _("Invalid URI: fails to specify subsystem\n"));
+      return;
+    }
+  subsystem = GNUNET_strndup(uri, slash - uri);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, "uri", subsystem, &program))
-  {
-    fprintf (stderr, _ ("No handler known for subsystem `%s'\n"), subsystem);
-    GNUNET_free (subsystem);
-    return;
-  }
-  GNUNET_free (subsystem);
-  rt = GNUNET_SCHEDULER_add_read_file (
+      GNUNET_CONFIGURATION_get_value_string(cfg, "uri", subsystem, &program))
+    {
+      fprintf(stderr, _("No handler known for subsystem `%s'\n"), subsystem);
+      GNUNET_free(subsystem);
+      return;
+    }
+  GNUNET_free(subsystem);
+  rt = GNUNET_SCHEDULER_add_read_file(
     GNUNET_TIME_UNIT_FOREVER_REL,
-    GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ),
+    GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ),
     &maint_child_death,
     NULL);
-  p = GNUNET_OS_start_process (GNUNET_NO,
-                               0,
-                               NULL,
-                               NULL,
-                               NULL,
-                               program,
-                               program,
-                               orig_uri,
-                               NULL);
-  GNUNET_free (program);
+  p = GNUNET_OS_start_process(GNUNET_NO,
+                              0,
+                              NULL,
+                              NULL,
+                              NULL,
+                              program,
+                              program,
+                              orig_uri,
+                              NULL);
+  GNUNET_free(program);
   if (NULL == p)
-    GNUNET_SCHEDULER_cancel (rt);
+    GNUNET_SCHEDULER_cancel(rt);
 }
 
 
@@ -153,54 +153,54 @@ gnunet_uri (void *cls,
  * @return NULL on error
  */
 static const zbar_symbol_t *
-get_symbol (zbar_processor_t *proc)
+get_symbol(zbar_processor_t *proc)
 {
   const zbar_symbol_set_t *symbols;
   int rc;
   int n;
 
-  if (0 != zbar_processor_parse_config (proc, "enable"))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+  if (0 != zbar_processor_parse_config(proc, "enable"))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
 
   /* initialize the Processor */
-  if (0 != (rc = zbar_processor_init (proc, device, 1)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to open device `%s': %d\n",
-                device,
-                rc);
-    return NULL;
-  }
+  if (0 != (rc = zbar_processor_init(proc, device, 1)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to open device `%s': %d\n",
+                 device,
+                 rc);
+      return NULL;
+    }
 
   /* enable the preview window */
-  if ((0 != (rc = zbar_processor_set_visible (proc, 1))) ||
-      (0 != (rc = zbar_processor_set_active (proc, 1))))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+  if ((0 != (rc = zbar_processor_set_visible(proc, 1))) ||
+      (0 != (rc = zbar_processor_set_active(proc, 1))))
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
 
   /* read at least one barcode (or until window closed) */
-  LOG ("Capturing\n");
-  n = zbar_process_one (proc, -1);
+  LOG("Capturing\n");
+  n = zbar_process_one(proc, -1);
 
   /* hide the preview window */
-  (void) zbar_processor_set_active (proc, 0);
-  (void) zbar_processor_set_visible (proc, 0);
+  (void)zbar_processor_set_active(proc, 0);
+  (void)zbar_processor_set_visible(proc, 0);
   if (-1 == n)
     return NULL; /* likely user closed the window */
-  LOG ("Got %i images\n", n);
+  LOG("Got %i images\n", n);
   /* extract results */
-  symbols = zbar_processor_get_results (proc);
+  symbols = zbar_processor_get_results(proc);
   if (NULL == symbols)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  return zbar_symbol_set_first_symbol (symbols);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  return zbar_symbol_set_first_symbol(symbols);
 }
 
 
@@ -210,7 +210,7 @@ get_symbol (zbar_processor_t *proc)
  * @return NULL on error, otherwise the URI that we found
  */
 static char *
-run_zbar ()
+run_zbar()
 {
   zbar_processor_t *proc;
   const char *data;
@@ -218,32 +218,32 @@ run_zbar ()
   const zbar_symbol_t *symbol;
 
   /* configure the Processor */
-  proc = zbar_processor_create (1);
+  proc = zbar_processor_create(1);
   if (NULL == proc)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
 
-  symbol = get_symbol (proc);
+  symbol = get_symbol(proc);
   if (NULL == symbol)
-  {
-    zbar_processor_destroy (proc);
-    return NULL;
-  }
-  data = zbar_symbol_get_data (symbol);
+    {
+      zbar_processor_destroy(proc);
+      return NULL;
+    }
+  data = zbar_symbol_get_data(symbol);
   if (NULL == data)
-  {
-    GNUNET_break (0);
-    zbar_processor_destroy (proc);
-    return NULL;
-  }
-  LOG ("Found %s \"%s\"\n",
-       zbar_get_symbol_name (zbar_symbol_get_type (symbol)),
-       data);
-  ret = GNUNET_strdup (data);
+    {
+      GNUNET_break(0);
+      zbar_processor_destroy(proc);
+      return NULL;
+    }
+  LOG("Found %s \"%s\"\n",
+      zbar_get_symbol_name(zbar_symbol_get_type(symbol)),
+      data);
+  ret = GNUNET_strdup(data);
   /* clean up */
-  zbar_processor_destroy (proc);
+  zbar_processor_destroy(proc);
   return ret;
 }
 
@@ -257,55 +257,55 @@ run_zbar ()
  * @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)
 {
   char *data;
 
-  data = run_zbar ();
+  data = run_zbar();
   if (NULL == data)
     return;
-  gnunet_uri (cls, data, cfgfile, cfg);
+  gnunet_uri(cls, data, cfgfile, cfg);
   if (exit_code != 0)
-  {
-    printf ("Failed to add URI %s\n", data);
-  }
+    {
+      printf("Failed to add URI %s\n", data);
+    }
   else
-  {
-    printf ("Added URI %s\n", data);
-  }
-  GNUNET_free (data);
+    {
+      printf("Added URI %s\n", data);
+    }
+  GNUNET_free(data);
 };
 
 
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   int ret;
   struct GNUNET_GETOPT_CommandLineOption options[] =
-    {GNUNET_GETOPT_option_string (
-       'd',
-       "device",
-       "DEVICE",
-       gettext_noop ("use video-device DEVICE (default: /dev/video0"),
-       &device),
-     GNUNET_GETOPT_option_flag ('\0',
-                                "verbose",
-                                gettext_noop ("be verbose"),
-                                &verbose),
-     GNUNET_GETOPT_option_flag ('s',
-                                "silent",
-                                gettext_noop ("do not show preview windows"),
-                                &silent),
-     GNUNET_GETOPT_OPTION_END};
-
-  ret = GNUNET_PROGRAM_run (
+  { GNUNET_GETOPT_option_string(
+      'd',
+      "device",
+      "DEVICE",
+      gettext_noop("use video-device DEVICE (default: /dev/video0"),
+      &device),
+    GNUNET_GETOPT_option_flag('\0',
+                              "verbose",
+                              gettext_noop("be verbose"),
+                              &verbose),
+    GNUNET_GETOPT_option_flag('s',
+                              "silent",
+                              gettext_noop("do not show preview windows"),
+                              &silent),
+    GNUNET_GETOPT_OPTION_END };
+
+  ret = GNUNET_PROGRAM_run(
     argc,
     argv,
     "gnunet-qr",
-    gettext_noop (
+    gettext_noop(
       "Scan a QR code using a video device and import the uri read"),
     options,
     &run,
diff --git a/src/util/gnunet-resolver.c b/src/util/gnunet-resolver.c
index 3aba5fb1e..dd1e8f5e0 100644
--- a/src/util/gnunet-resolver.c
+++ b/src/util/gnunet-resolver.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 util/gnunet-resolver.c
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_resolver_service.h"
 
-#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
 
 /**
  * Flag for reverse lookup.
@@ -43,15 +43,15 @@ static int reverse;
  *        on the last call to the callback
  */
 static void
-print_hostname (void *cls,
-                const char *hostname)
+print_hostname(void *cls,
+               const char *hostname)
 {
-  (void) cls;
+  (void)cls;
   if (NULL == hostname)
     return;
-  fprintf (stdout,
-           "%s\n",
-           hostname);
+  fprintf(stdout,
+          "%s\n",
+          hostname);
 }
 
 
@@ -63,17 +63,17 @@ print_hostname (void *cls,
  * @param addrlen length of the address
  */
 static void
-print_sockaddr (void *cls,
-                const struct sockaddr *addr,
-                socklen_t addrlen)
+print_sockaddr(void *cls,
+               const struct sockaddr *addr,
+               socklen_t addrlen)
 {
-  (void) cls;
+  (void)cls;
   if (NULL == addr)
     return;
-  fprintf (stdout,
-           "%s\n",
-           GNUNET_a2s (addr,
-                       addrlen));
+  fprintf(stdout,
+          "%s\n",
+          GNUNET_a2s(addr,
+                     addrlen));
 }
 
 
@@ -86,69 +86,69 @@ print_sockaddr (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 struct sockaddr *sa;
   socklen_t salen;
   struct sockaddr_in v4;
   struct sockaddr_in6 v6;
 
-  (void) cls;
-  (void) cfgfile;
-  (void) cfg;
+  (void)cls;
+  (void)cfgfile;
+  (void)cfg;
   if (NULL == args[0])
     return;
-  if (! reverse)
-  {
-    GNUNET_RESOLVER_ip_get (args[0],
-                            AF_UNSPEC,
-                            GET_TIMEOUT,
-                            &print_sockaddr,
-                            NULL);
-    return;
-  }
+  if (!reverse)
+    {
+      GNUNET_RESOLVER_ip_get(args[0],
+                             AF_UNSPEC,
+                             GET_TIMEOUT,
+                             &print_sockaddr,
+                             NULL);
+      return;
+    }
 
   sa = NULL;
-  memset (&v4, 0, sizeof (v4));
+  memset(&v4, 0, sizeof(v4));
   v4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v4.sin_len = sizeof (v4);
+  v4.sin_len = sizeof(v4);
 #endif
-  if (1 == inet_pton (AF_INET,
-                      args[0],
-                      &v4.sin_addr))
-  {
-    sa = (struct sockaddr *) &v4;
-    salen = sizeof (v4);
-  }
-  memset (&v6, 0, sizeof (v6));
+  if (1 == inet_pton(AF_INET,
+                     args[0],
+                     &v4.sin_addr))
+    {
+      sa = (struct sockaddr *)&v4;
+      salen = sizeof(v4);
+    }
+  memset(&v6, 0, sizeof(v6));
   v6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v6.sin6_len = sizeof (v6);
+  v6.sin6_len = sizeof(v6);
 #endif
-  if (1 == inet_pton (AF_INET6,
-                      args[0],
-                      &v6.sin6_addr))
-  {
-    sa = (struct sockaddr *) &v6;
-    salen = sizeof (v6);
-  }
+  if (1 == inet_pton(AF_INET6,
+                     args[0],
+                     &v6.sin6_addr))
+    {
+      sa = (struct sockaddr *)&v6;
+      salen = sizeof(v6);
+    }
   if (NULL == sa)
-  {
-    fprintf (stderr,
-             "`%s' is not a valid IP: %s\n",
-             args[0],
-             strerror (errno));
-    return;
-  }
-  GNUNET_RESOLVER_hostname_get (sa, salen,
-                                GNUNET_YES,
-                                GET_TIMEOUT,
-                                &print_hostname,
-                                NULL);
+    {
+      fprintf(stderr,
+              "`%s' is not a valid IP: %s\n",
+              args[0],
+              strerror(errno));
+      return;
+    }
+  GNUNET_RESOLVER_hostname_get(sa, salen,
+                               GNUNET_YES,
+                               GET_TIMEOUT,
+                               &print_hostname,
+                               NULL);
 }
 
 
@@ -160,25 +160,25 @@ 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_flag ('r',
-                                  "reverse",
-                                  gettext_noop ("perform a reverse lookup"),
-                                  &reverse),
+    GNUNET_GETOPT_option_flag('r',
+                              "reverse",
+                              gettext_noop("perform a reverse lookup"),
+                              &reverse),
     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;
 
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run (argc, argv, "gnunet-resolver [hostname]",
-                             gettext_noop ("Use build-in GNUnet stub resolver"),
-                             options, &run, NULL)) ? 0 : 1;
-  GNUNET_free ((void*) argv);
+         GNUNET_PROGRAM_run(argc, argv, "gnunet-resolver [hostname]",
+                            gettext_noop("Use build-in GNUnet stub resolver"),
+                            options, &run, NULL)) ? 0 : 1;
+  GNUNET_free((void*)argv);
   return ret;
 }
 
diff --git a/src/util/gnunet-scrypt.c b/src/util/gnunet-scrypt.c
index 6f9690c99..182ab346e 100644
--- a/src/util/gnunet-scrypt.c
+++ b/src/util/gnunet-scrypt.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 util/gnunet-scrypt.c
  * @brief tool to manipulate SCRYPT proofs of work.
@@ -55,15 +55,15 @@ static char *pwfn;
  * @param cls closure
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) cls;
-  if (sizeof (proof) != GNUNET_DISK_fn_write (pwfn,
-                                              &proof,
-                                              sizeof (proof),
-                                              GNUNET_DISK_PERM_USER_READ |
-                                                GNUNET_DISK_PERM_USER_WRITE))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", pwfn);
+  (void)cls;
+  if (sizeof(proof) != GNUNET_DISK_fn_write(pwfn,
+                                            &proof,
+                                            sizeof(proof),
+                                            GNUNET_DISK_PERM_USER_READ |
+                                            GNUNET_DISK_PERM_USER_WRITE))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "write", pwfn);
 }
 
 
@@ -75,18 +75,18 @@ shutdown_task (void *cls)
  * @param result where to write the resulting hash
  */
 static void
-pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
+pow_hash(const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
 {
-  GNUNET_break (
-    0 == gcry_kdf_derive (buf,
-                          buf_len,
-                          GCRY_KDF_SCRYPT,
-                          1 /* subalgo */,
-                          "gnunet-proof-of-work",
-                          strlen ("gnunet-proof-of-work"),
-                          2 /* iterations; keep cost of individual op small */,
-                          sizeof (struct GNUNET_HashCode),
-                          result));
+  GNUNET_break(
+    0 == gcry_kdf_derive(buf,
+                         buf_len,
+                         GCRY_KDF_SCRYPT,
+                         1 /* subalgo */,
+                         "gnunet-proof-of-work",
+                         strlen("gnunet-proof-of-work"),
+                         2 /* iterations; keep cost of individual op small */,
+                         sizeof(struct GNUNET_HashCode),
+                         result));
 }
 
 
@@ -97,12 +97,12 @@ pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
  * @return the number of leading zero bits.
  */
 static unsigned int
-count_leading_zeroes (const struct GNUNET_HashCode *hash)
+count_leading_zeroes(const struct GNUNET_HashCode *hash)
 {
   unsigned int hash_count;
 
   hash_count = 0;
-  while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count))
+  while (0 == GNUNET_CRYPTO_hash_get_bit(hash, hash_count))
     hash_count++;
   return hash_count;
 }
@@ -115,68 +115,68 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
  * @param tc task context
  */
 static void
-find_proof (void *cls)
+find_proof(void *cls)
 {
 #define ROUND_SIZE 10
   uint64_t counter;
-  char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
-           sizeof (uint64_t)] GNUNET_ALIGN;
+  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
+           sizeof(uint64_t)] GNUNET_ALIGN;
   struct GNUNET_HashCode result;
   unsigned int i;
   struct GNUNET_TIME_Absolute timestamp;
   struct GNUNET_TIME_Relative elapsed;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got Proof of Work %llu\n",
-              (unsigned long long) proof);
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got Proof of Work %llu\n",
+             (unsigned long long)proof);
   proof_task = NULL;
-  GNUNET_memcpy (&buf[sizeof (uint64_t)],
-                 &pub,
-                 sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+  GNUNET_memcpy(&buf[sizeof(uint64_t)],
+                &pub,
+                sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
   i = 0;
   counter = proof;
-  timestamp = GNUNET_TIME_absolute_get ();
+  timestamp = GNUNET_TIME_absolute_get();
   while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
-  {
-    GNUNET_memcpy (buf, &counter, sizeof (uint64_t));
-    pow_hash (buf, sizeof (buf), &result);
-    if (nse_work_required <= count_leading_zeroes (&result))
     {
-      proof = counter;
-      fprintf (stdout,
-               "Proof of work found: %llu!\n",
-               (unsigned long long) proof);
-      GNUNET_SCHEDULER_shutdown ();
-      return;
+      GNUNET_memcpy(buf, &counter, sizeof(uint64_t));
+      pow_hash(buf, sizeof(buf), &result);
+      if (nse_work_required <= count_leading_zeroes(&result))
+        {
+          proof = counter;
+          fprintf(stdout,
+                  "Proof of work found: %llu!\n",
+                  (unsigned long long)proof);
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      counter++;
+      i++;
     }
-    counter++;
-    i++;
-  }
-  elapsed = GNUNET_TIME_absolute_get_duration (timestamp);
-  elapsed = GNUNET_TIME_relative_divide (elapsed, ROUND_SIZE);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Current: %llu [%s/proof]\n",
-              (unsigned long long) counter,
-              GNUNET_STRINGS_relative_time_to_string (elapsed, 0));
+  elapsed = GNUNET_TIME_absolute_get_duration(timestamp);
+  elapsed = GNUNET_TIME_relative_divide(elapsed, ROUND_SIZE);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Current: %llu [%s/proof]\n",
+             (unsigned long long)counter,
+             GNUNET_STRINGS_relative_time_to_string(elapsed, 0));
   if (proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Testing proofs currently at %llu\n",
-                (unsigned long long) counter);
-    /* remember progress every 100 rounds */
-    proof = counter;
-    shutdown_task (NULL);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Testing proofs currently at %llu\n",
+                 (unsigned long long)counter);
+      /* remember progress every 100 rounds */
+      proof = counter;
+      shutdown_task(NULL);
+    }
   else
-  {
-    proof = counter;
-  }
+    {
+      proof = counter;
+    }
   proof_task =
-    GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
-                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                &find_proof,
-                                                NULL);
+    GNUNET_SCHEDULER_add_delayed_with_priority(proof_find_delay,
+                                               GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                               &find_proof,
+                                               NULL);
 }
 
 
@@ -189,101 +189,101 @@ find_proof (void *cls)
  * @param cfg configuration
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *config)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *config)
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
   char *pids;
 
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
   cfg = config;
   /* load proof of work */
   if (NULL == pwfn)
-  {
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                              "NSE",
-                                                              "PROOFFILE",
-                                                              &pwfn))
     {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
-      GNUNET_SCHEDULER_shutdown ();
-      return;
+      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                               "NSE",
+                                                               "PROOFFILE",
+                                                               &pwfn))
+        {
+          GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
     }
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Proof of Work file: %s\n", pwfn);
-  if ((GNUNET_YES != GNUNET_DISK_file_test (pwfn)) ||
-      (sizeof (proof) != GNUNET_DISK_fn_read (pwfn, &proof, sizeof (proof))))
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Proof of Work file: %s\n", pwfn);
+  if ((GNUNET_YES != GNUNET_DISK_file_test(pwfn)) ||
+      (sizeof(proof) != GNUNET_DISK_fn_read(pwfn, &proof, sizeof(proof))))
     proof = 0;
 
   /* load private key */
   if (NULL == pkfn)
-  {
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                              "PEER",
-                                                              "PRIVATE_KEY",
-                                                              &pkfn))
     {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                                 "PEER",
-                                 "PRIVATE_KEY");
+      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                               "PEER",
+                                                               "PRIVATE_KEY",
+                                                               &pkfn))
+        {
+          GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
+                                    "PEER",
+                                    "PRIVATE_KEY");
+          return;
+        }
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Private Key file: %s\n", pkfn);
+  if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create_from_file(pkfn)))
+    {
+      fprintf(stderr, _("Loading hostkey from `%s' failed.\n"), pkfn);
+      GNUNET_free(pkfn);
       return;
     }
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Private Key file: %s\n", pkfn);
-  if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create_from_file (pkfn)))
-  {
-    fprintf (stderr, _ ("Loading hostkey from `%s' failed.\n"), pkfn);
-    GNUNET_free (pkfn);
-    return;
-  }
-  GNUNET_free (pkfn);
-  GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
-  GNUNET_free (pk);
-  pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer ID: %s\n", pids);
-  GNUNET_free (pids);
+  GNUNET_free(pkfn);
+  GNUNET_CRYPTO_eddsa_key_get_public(pk, &pub);
+  GNUNET_free(pk);
+  pids = GNUNET_CRYPTO_eddsa_public_key_to_string(&pub);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Peer ID: %s\n", pids);
+  GNUNET_free(pids);
 
   /* get target bit amount */
   if (0 == nse_work_required)
-  {
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                            "NSE",
-                                                            "WORKBITS",
-                                                            &nse_work_required))
-    {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-    if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
     {
-      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                                 "NSE",
-                                 "WORKBITS",
-                                 _ ("Value is too large.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-    else if (0 == nse_work_required)
-    {
-      GNUNET_SCHEDULER_shutdown ();
-      return;
+      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
+                                                             "NSE",
+                                                             "WORKBITS",
+                                                             &nse_work_required))
+        {
+          GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
+        {
+          GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
+                                    "NSE",
+                                    "WORKBITS",
+                                    _("Value is too large.\n"));
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
+      else if (0 == nse_work_required)
+        {
+          GNUNET_SCHEDULER_shutdown();
+          return;
+        }
     }
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Bits: %llu\n", nse_work_required);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Bits: %llu\n", nse_work_required);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Delay between tries: %s\n",
-              GNUNET_STRINGS_relative_time_to_string (proof_find_delay, 1));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Delay between tries: %s\n",
+             GNUNET_STRINGS_relative_time_to_string(proof_find_delay, 1));
   proof_task =
-    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                        &find_proof,
-                                        NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                       &find_proof,
+                                       NULL);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
 }
 
 
@@ -295,52 +295,52 @@ 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_ulong (
-       'b',
-       "bits",
-       "BITS",
-       gettext_noop ("number of bits to require for the proof of work"),
-       &nse_work_required),
-     GNUNET_GETOPT_option_filename (
-       'k',
-       "keyfile",
-       "FILE",
-       gettext_noop ("file with private key, otherwise default is used"),
-       &pkfn),
-     GNUNET_GETOPT_option_filename (
-       'o',
-       "outfile",
-       "FILE",
-       gettext_noop ("file with proof of work, otherwise default is used"),
-       &pwfn),
-     GNUNET_GETOPT_option_relative_time ('t',
-                                         "timeout",
-                                         "TIME",
-                                         gettext_noop (
-                                           "time to wait between calculations"),
-                                         &proof_find_delay),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_ulong(
+      'b',
+      "bits",
+      "BITS",
+      gettext_noop("number of bits to require for the proof of work"),
+      &nse_work_required),
+    GNUNET_GETOPT_option_filename(
+      'k',
+      "keyfile",
+      "FILE",
+      gettext_noop("file with private key, otherwise default is used"),
+      &pkfn),
+    GNUNET_GETOPT_option_filename(
+      'o',
+      "outfile",
+      "FILE",
+      gettext_noop("file with proof of work, otherwise default is used"),
+      &pwfn),
+    GNUNET_GETOPT_option_relative_time('t',
+                                       "timeout",
+                                       "TIME",
+                                       gettext_noop(
+                                         "time to wait between calculations"),
+                                       &proof_find_delay),
+    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;
 
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run (argc,
-                         argv,
-                         "gnunet-scrypt [OPTIONS] prooffile",
-                         gettext_noop ("Manipulate GNUnet proof of work files"),
-                         options,
-                         &run,
-                         NULL))
-      ? 0
-      : 1;
-  GNUNET_free ((void *) argv);
-  GNUNET_free_non_null (pwfn);
+     GNUNET_PROGRAM_run(argc,
+                        argv,
+                        "gnunet-scrypt [OPTIONS] prooffile",
+                        gettext_noop("Manipulate GNUnet proof of work files"),
+                        options,
+                        &run,
+                        NULL))
+    ? 0
+    : 1;
+  GNUNET_free((void *)argv);
+  GNUNET_free_non_null(pwfn);
   return ret;
 }
 
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c
index 2cabe553b..a69a7bd66 100644
--- a/src/util/gnunet-service-resolver.c
+++ b/src/util/gnunet-service-resolver.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file util/gnunet-service-resolver.c
@@ -33,7 +33,7 @@
 /**
  * How long do we wait for DNS answers?
  */
-#define DNS_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+#define DNS_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
 
 /**
  * Maximum number of hostnames we cache results for.
@@ -43,8 +43,7 @@
 /**
  * Entry in list of cached DNS records for a hostname.
  */
-struct RecordListEntry
-{
+struct RecordListEntry {
   /**
    * This is a doubly linked list.
    */
@@ -65,8 +64,7 @@ struct RecordListEntry
 /**
  * A cached DNS lookup result.
  */
-struct ResolveCache
-{
+struct ResolveCache {
   /**
    * This is a doubly linked list.
    */
@@ -97,8 +95,7 @@ struct ResolveCache
 /**
  * Information about pending lookups.
  */
-struct ActiveLookup
-{
+struct ActiveLookup {
   /**
    * Stored in a DLL.
    */
@@ -206,21 +203,21 @@ static unsigned int cache_size;
  * @param rc entry to free
  */
 static void
-free_cache_entry (struct ResolveCache *rc)
+free_cache_entry(struct ResolveCache *rc)
 {
   struct RecordListEntry *pos;
 
   while (NULL != (pos = rc->records_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
-    GNUNET_DNSPARSER_free_record (pos->record);
-    GNUNET_free (pos->record);
-    GNUNET_free (pos);
-  }
-  GNUNET_free_non_null (rc->hostname);
-  GNUNET_CONTAINER_DLL_remove (cache_head, cache_tail, rc);
+    {
+      GNUNET_CONTAINER_DLL_remove(rc->records_head, rc->records_tail, pos);
+      GNUNET_DNSPARSER_free_record(pos->record);
+      GNUNET_free(pos->record);
+      GNUNET_free(pos);
+    }
+  GNUNET_free_non_null(rc->hostname);
+  GNUNET_CONTAINER_DLL_remove(cache_head, cache_tail, rc);
   cache_size--;
-  GNUNET_free (rc);
+  GNUNET_free(rc);
 }
 
 
@@ -230,21 +227,21 @@ free_cache_entry (struct ResolveCache *rc)
  * @param rc entry to free
  */
 static void
-free_hosts_entry (struct ResolveCache *rc)
+free_hosts_entry(struct ResolveCache *rc)
 {
   struct RecordListEntry *pos;
 
   while (NULL != (pos = rc->records_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
-    GNUNET_DNSPARSER_free_record (pos->record);
-    GNUNET_free (pos->record);
-    GNUNET_free (pos);
-  }
-  GNUNET_free_non_null (rc->hostname);
-  GNUNET_CONTAINER_DLL_remove (hosts_head, hosts_tail, rc);
+    {
+      GNUNET_CONTAINER_DLL_remove(rc->records_head, rc->records_tail, pos);
+      GNUNET_DNSPARSER_free_record(pos->record);
+      GNUNET_free(pos->record);
+      GNUNET_free(pos);
+    }
+  GNUNET_free_non_null(rc->hostname);
+  GNUNET_CONTAINER_DLL_remove(hosts_head, hosts_tail, rc);
   cache_size--;
-  GNUNET_free (rc);
+  GNUNET_free(rc);
 }
 
 
@@ -254,21 +251,21 @@ free_hosts_entry (struct ResolveCache *rc)
  * @param al an active lookup
  */
 static void
-free_active_lookup (struct ActiveLookup *al)
+free_active_lookup(struct ActiveLookup *al)
 {
-  GNUNET_CONTAINER_DLL_remove (lookup_head, lookup_tail, al);
+  GNUNET_CONTAINER_DLL_remove(lookup_head, lookup_tail, al);
   if (NULL != al->resolve_handle)
-  {
-    GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
-    al->resolve_handle = NULL;
-  }
+    {
+      GNUNET_DNSSTUB_resolve_cancel(al->resolve_handle);
+      al->resolve_handle = NULL;
+    }
   if (NULL != al->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (al->timeout_task);
-    al->timeout_task = NULL;
-  }
-  GNUNET_free_non_null (al->hostname);
-  GNUNET_free (al);
+    {
+      GNUNET_SCHEDULER_cancel(al->timeout_task);
+      al->timeout_task = NULL;
+    }
+  GNUNET_free_non_null(al->hostname);
+  GNUNET_free(al);
 }
 
 
@@ -282,11 +279,11 @@ free_active_lookup (struct ActiveLookup *al)
  * @return NULL if no nameserver is configured in this @a line
  */
 static char *
-extract_dns_server (const char *line, size_t line_len)
+extract_dns_server(const char *line, size_t line_len)
 {
-  if (0 == strncmp (line, "nameserver ", strlen ("nameserver ")))
-    return GNUNET_strndup (line + strlen ("nameserver "),
-                           line_len - strlen ("nameserver "));
+  if (0 == strncmp(line, "nameserver ", strlen("nameserver ")))
+    return GNUNET_strndup(line + strlen("nameserver "),
+                          line_len - strlen("nameserver "));
   return NULL;
 }
 
@@ -301,11 +298,11 @@ extract_dns_server (const char *line, size_t line_len)
  * @return NULL if no nameserver is configured in this @a line
  */
 static char *
-extract_search_domain (const char *line, size_t line_len)
+extract_search_domain(const char *line, size_t line_len)
 {
-  if (0 == strncmp (line, "search ", strlen ("search ")))
-    return GNUNET_strndup (line + strlen ("search "),
-                           line_len - strlen ("search "));
+  if (0 == strncmp(line, "search ", strlen("search ")))
+    return GNUNET_strndup(line + strlen("search "),
+                          line_len - strlen("search "));
   return NULL;
 }
 
@@ -317,7 +314,7 @@ extract_search_domain (const char *line, size_t line_len)
  * @return the number of server addresses in @server_addrs, -1 on error
  */
 static int
-lookup_dns_servers (char ***server_addrs)
+lookup_dns_servers(char ***server_addrs)
 {
   struct GNUNET_DISK_FileHandle *fh;
   struct GNUNET_DISK_MapHandle *mh;
@@ -326,63 +323,63 @@ lookup_dns_servers (char ***server_addrs)
   size_t read_offset;
   unsigned int num_dns_servers;
 
-  fh = GNUNET_DISK_file_open ("/etc/resolv.conf",
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
+  fh = GNUNET_DISK_file_open("/etc/resolv.conf",
+                             GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (NULL == fh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Could not open /etc/resolv.conf. "
-                "DNS resolution will not be possible.\n");
-    return -1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Could not determine size of /etc/resolv.conf. "
-                "DNS resolution will not be possible.\n");
-    GNUNET_DISK_file_close (fh);
-    return -1;
-  }
-  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "/etc/resolv.conf file too large to mmap. "
-                "DNS resolution will not be possible.\n");
-    GNUNET_DISK_file_close (fh);
-    return -1;
-  }
-  buf = GNUNET_DISK_file_map (fh,
-                              &mh,
-                              GNUNET_DISK_MAP_TYPE_READ,
-                              (size_t) bytes_read);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Could not open /etc/resolv.conf. "
+                 "DNS resolution will not be possible.\n");
+      return -1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_file_handle_size(fh, &bytes_read))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Could not determine size of /etc/resolv.conf. "
+                 "DNS resolution will not be possible.\n");
+      GNUNET_DISK_file_close(fh);
+      return -1;
+    }
+  if (((unsigned long long)bytes_read) > (unsigned long long)SIZE_MAX)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "/etc/resolv.conf file too large to mmap. "
+                 "DNS resolution will not be possible.\n");
+      GNUNET_DISK_file_close(fh);
+      return -1;
+    }
+  buf = GNUNET_DISK_file_map(fh,
+                             &mh,
+                             GNUNET_DISK_MAP_TYPE_READ,
+                             (size_t)bytes_read);
   *server_addrs = NULL;
   read_offset = 0;
   num_dns_servers = 0;
-  while (read_offset < (size_t) bytes_read)
-  {
-    const char *newline;
-    size_t line_len;
-    char *dns_server;
-
-    newline = strchr (buf + read_offset, '\n');
-    if (NULL == newline)
-      break;
-    line_len = newline - buf - read_offset;
-    dns_server = extract_dns_server (buf + read_offset, line_len);
-    if (NULL != dns_server)
+  while (read_offset < (size_t)bytes_read)
     {
-      GNUNET_array_append (*server_addrs, num_dns_servers, dns_server);
-    }
-    else if (NULL == my_domain)
-    {
-      my_domain = extract_search_domain (buf + read_offset, line_len);
+      const char *newline;
+      size_t line_len;
+      char *dns_server;
+
+      newline = strchr(buf + read_offset, '\n');
+      if (NULL == newline)
+        break;
+      line_len = newline - buf - read_offset;
+      dns_server = extract_dns_server(buf + read_offset, line_len);
+      if (NULL != dns_server)
+        {
+          GNUNET_array_append(*server_addrs, num_dns_servers, dns_server);
+        }
+      else if (NULL == my_domain)
+        {
+          my_domain = extract_search_domain(buf + read_offset, line_len);
+        }
+      read_offset += line_len + 1;
     }
-    read_offset += line_len + 1;
-  }
-  GNUNET_DISK_file_unmap (mh);
-  GNUNET_DISK_file_close (fh);
-  return (int) num_dns_servers;
+  GNUNET_DISK_file_unmap(mh);
+  GNUNET_DISK_file_close(fh);
+  return (int)num_dns_servers;
 }
 
 
@@ -393,52 +390,52 @@ lookup_dns_servers (char ***server_addrs)
  * @param af address family of @a ip, AF_INET or AF_INET6
  */
 static char *
-make_reverse_hostname (const void *ip, int af)
+make_reverse_hostname(const void *ip, int af)
 {
-  char *buf = GNUNET_new_array (80, char);
+  char *buf = GNUNET_new_array(80, char);
   int pos = 0;
 
   if (AF_INET == af)
-  {
-    struct in_addr *addr = (struct in_addr *) ip;
-    uint32_t ip_int = addr->s_addr;
-
-    for (int i = 3; i >= 0; i--)
     {
-      int n =
-        GNUNET_snprintf (buf + pos, 80 - pos, "%u.", ((uint8_t *) &ip_int)[i]);
-      if (n < 0)
-      {
-        GNUNET_free (buf);
-        return NULL;
-      }
-      pos += n;
+      struct in_addr *addr = (struct in_addr *)ip;
+      uint32_t ip_int = addr->s_addr;
+
+      for (int i = 3; i >= 0; i--)
+        {
+          int n =
+            GNUNET_snprintf(buf + pos, 80 - pos, "%u.", ((uint8_t *)&ip_int)[i]);
+          if (n < 0)
+            {
+              GNUNET_free(buf);
+              return NULL;
+            }
+          pos += n;
+        }
+      pos += GNUNET_snprintf(buf + pos, 80 - pos, "in-addr.arpa");
     }
-    pos += GNUNET_snprintf (buf + pos, 80 - pos, "in-addr.arpa");
-  }
   else if (AF_INET6 == af)
-  {
-    struct in6_addr *addr = (struct in6_addr *) ip;
-    for (int i = 15; i >= 0; i--)
     {
-      int n =
-        GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] & 0xf);
-      if (n < 0)
-      {
-        GNUNET_free (buf);
-        return NULL;
-      }
-      pos += n;
-      n = GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] >> 4);
-      if (n < 0)
-      {
-        GNUNET_free (buf);
-        return NULL;
-      }
-      pos += n;
+      struct in6_addr *addr = (struct in6_addr *)ip;
+      for (int i = 15; i >= 0; i--)
+        {
+          int n =
+            GNUNET_snprintf(buf + pos, 80 - pos, "%x.", addr->s6_addr[i] & 0xf);
+          if (n < 0)
+            {
+              GNUNET_free(buf);
+              return NULL;
+            }
+          pos += n;
+          n = GNUNET_snprintf(buf + pos, 80 - pos, "%x.", addr->s6_addr[i] >> 4);
+          if (n < 0)
+            {
+              GNUNET_free(buf);
+              return NULL;
+            }
+          pos += n;
+        }
+      pos += GNUNET_snprintf(buf + pos, 80 - pos, "ip6.arpa");
     }
-    pos += GNUNET_snprintf (buf + pos, 80 - pos, "ip6.arpa");
-  }
   buf[pos] = '\0';
   return buf;
 }
@@ -456,10 +453,10 @@ make_reverse_hostname (const void *ip, int af)
  *         does not match @a record_type
  */
 static int
-send_reply (struct GNUNET_DNSPARSER_Record *record,
-            uint16_t record_type,
-            uint32_t client_request_id,
-            struct GNUNET_SERVICE_Client *client)
+send_reply(struct GNUNET_DNSPARSER_Record *record,
+           uint16_t record_type,
+           uint32_t client_request_id,
+           struct GNUNET_SERVICE_Client *client)
 {
   struct GNUNET_RESOLVER_ResponseMessage *msg;
   struct GNUNET_MQ_Envelope *env;
@@ -467,45 +464,49 @@ send_reply (struct GNUNET_DNSPARSER_Record *record,
   size_t payload_len;
 
   switch (record->type)
-  {
-  case GNUNET_DNSPARSER_TYPE_CNAME:
-    if (GNUNET_DNSPARSER_TYPE_CNAME != record_type)
-      return GNUNET_NO;
-    payload = record->data.hostname;
-    payload_len = strlen (record->data.hostname) + 1;
-    break;
-  case GNUNET_DNSPARSER_TYPE_PTR:
-    if (GNUNET_DNSPARSER_TYPE_PTR != record_type)
-      return GNUNET_NO;
-    payload = record->data.hostname;
-    payload_len = strlen (record->data.hostname) + 1;
-    break;
-  case GNUNET_DNSPARSER_TYPE_A:
-    if ((GNUNET_DNSPARSER_TYPE_A != record_type) &&
-        (GNUNET_DNSPARSER_TYPE_ALL != record_type))
-      return GNUNET_NO;
-    payload = record->data.raw.data;
-    payload_len = record->data.raw.data_len;
-    break;
-  case GNUNET_DNSPARSER_TYPE_AAAA:
-    if ((GNUNET_DNSPARSER_TYPE_AAAA != record_type) &&
-        (GNUNET_DNSPARSER_TYPE_ALL != record_type))
+    {
+    case GNUNET_DNSPARSER_TYPE_CNAME:
+      if (GNUNET_DNSPARSER_TYPE_CNAME != record_type)
+        return GNUNET_NO;
+      payload = record->data.hostname;
+      payload_len = strlen(record->data.hostname) + 1;
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_PTR:
+      if (GNUNET_DNSPARSER_TYPE_PTR != record_type)
+        return GNUNET_NO;
+      payload = record->data.hostname;
+      payload_len = strlen(record->data.hostname) + 1;
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_A:
+      if ((GNUNET_DNSPARSER_TYPE_A != record_type) &&
+          (GNUNET_DNSPARSER_TYPE_ALL != record_type))
+        return GNUNET_NO;
+      payload = record->data.raw.data;
+      payload_len = record->data.raw.data_len;
+      break;
+
+    case GNUNET_DNSPARSER_TYPE_AAAA:
+      if ((GNUNET_DNSPARSER_TYPE_AAAA != record_type) &&
+          (GNUNET_DNSPARSER_TYPE_ALL != record_type))
+        return GNUNET_NO;
+      payload = record->data.raw.data;
+      payload_len = record->data.raw.data_len;
+      break;
+
+    default:
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Cannot handle DNS response type %u: not supported here\n",
+                 record->type);
       return GNUNET_NO;
-    payload = record->data.raw.data;
-    payload_len = record->data.raw.data_len;
-    break;
-  default:
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Cannot handle DNS response type %u: not supported here\n",
-                record->type);
-    return GNUNET_NO;
-  }
-  env = GNUNET_MQ_msg_extra (msg,
-                             payload_len,
-                             GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
+    }
+  env = GNUNET_MQ_msg_extra(msg,
+                            payload_len,
+                            GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   msg->client_id = client_request_id;
-  GNUNET_memcpy (&msg[1], payload, payload_len);
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
+  GNUNET_memcpy(&msg[1], payload, payload_len);
+  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env);
   return GNUNET_YES;
 }
 
@@ -518,15 +519,15 @@ send_reply (struct GNUNET_DNSPARSER_Record *record,
  * @param client where to send @a record
  */
 static void
-send_end_msg (uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
+send_end_msg(uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
 {
   struct GNUNET_RESOLVER_ResponseMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending END message\n");
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending END message\n");
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
   msg->client_id = client_request_id;
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
+  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env);
 }
 
 
@@ -538,27 +539,27 @@ send_end_msg (uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
  *         #GNUNET_NO if some entries are left
  */
 static int
-remove_expired (struct ResolveCache *rc)
+remove_expired(struct ResolveCache *rc)
 {
-  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
   struct RecordListEntry *n;
 
   for (struct RecordListEntry *pos = rc->records_head; NULL != pos; pos = n)
-  {
-    n = pos->next;
-    if (now.abs_value_us > pos->record->expiration_time.abs_value_us)
     {
-      GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
-      GNUNET_DNSPARSER_free_record (pos->record);
-      GNUNET_free (pos->record);
-      GNUNET_free (pos);
+      n = pos->next;
+      if (now.abs_value_us > pos->record->expiration_time.abs_value_us)
+        {
+          GNUNET_CONTAINER_DLL_remove(rc->records_head, rc->records_tail, pos);
+          GNUNET_DNSPARSER_free_record(pos->record);
+          GNUNET_free(pos->record);
+          GNUNET_free(pos);
+        }
     }
-  }
   if (NULL == rc->records_head)
-  {
-    free_cache_entry (rc);
-    return GNUNET_YES;
-  }
+    {
+      free_cache_entry(rc);
+      return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -573,10 +574,10 @@ remove_expired (struct ResolveCache *rc)
  * @param client who should get the result?
  */
 static void
-process_get (const char *hostname,
-             uint16_t record_type,
-             uint32_t client_request_id,
-             struct GNUNET_SERVICE_Client *client);
+process_get(const char *hostname,
+            uint16_t record_type,
+            uint32_t client_request_id,
+            struct GNUNET_SERVICE_Client *client);
 
 
 /**
@@ -591,10 +592,10 @@ process_get (const char *hostname,
  * @param client handle to the client making the request (for sending the reply)
  */
 static int
-try_cache (const char *hostname,
-           uint16_t record_type,
-           uint32_t client_request_id,
-           struct GNUNET_SERVICE_Client *client)
+try_cache(const char *hostname,
+          uint16_t record_type,
+          uint32_t client_request_id,
+          struct GNUNET_SERVICE_Client *client)
 {
   struct ResolveCache *pos;
   struct ResolveCache *next;
@@ -603,57 +604,57 @@ try_cache (const char *hostname,
 
   in_hosts = GNUNET_NO;
   for (pos = hosts_head; NULL != pos; pos = pos->next)
-    if (0 == strcmp (pos->hostname, hostname))
+    if (0 == strcmp(pos->hostname, hostname))
+      {
+        in_hosts = GNUNET_YES;
+        break;
+      }
+  if (NULL == pos)
     {
-      in_hosts = GNUNET_YES;
-      break;
+      next = cache_head;
+      for (pos = next; NULL != pos; pos = next)
+        {
+          next = pos->next;
+          if (GNUNET_YES == remove_expired(pos))
+            continue;
+          if (0 == strcmp(pos->hostname, hostname))
+            break;
+        }
     }
   if (NULL == pos)
-  {
-    next = cache_head;
-    for (pos = next; NULL != pos; pos = next)
     {
-      next = pos->next;
-      if (GNUNET_YES == remove_expired (pos))
-        continue;
-      if (0 == strcmp (pos->hostname, hostname))
-        break;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "No cache entry for '%s'\n", hostname);
+      return GNUNET_NO;
     }
-  }
-  if (NULL == pos)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No cache entry for '%s'\n", hostname);
-    return GNUNET_NO;
-  }
   if ((GNUNET_NO == in_hosts) && (cache_head != pos))
-  {
-    /* move result to head to achieve LRU for cache eviction */
-    GNUNET_CONTAINER_DLL_remove (cache_head, cache_tail, pos);
-    GNUNET_CONTAINER_DLL_insert (cache_head, cache_tail, pos);
-  }
+    {
+      /* move result to head to achieve LRU for cache eviction */
+      GNUNET_CONTAINER_DLL_remove(cache_head, cache_tail, pos);
+      GNUNET_CONTAINER_DLL_insert(cache_head, cache_tail, pos);
+    }
   found = GNUNET_NO;
   for (struct RecordListEntry *rle = pos->records_head; NULL != rle;
        rle = rle->next)
-  {
-    const struct GNUNET_DNSPARSER_Record *record = rle->record;
-
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Found cache entry for '%s', record type '%u'\n",
-                hostname,
-                record_type);
-    if ((GNUNET_DNSPARSER_TYPE_CNAME == record->type) &&
-        (GNUNET_DNSPARSER_TYPE_CNAME != record_type) && (GNUNET_NO == found))
     {
-      const char *hostname = record->data.hostname;
-
-      process_get (hostname, record_type, client_request_id, client);
-      return GNUNET_YES; /* counts as a cache "hit" */
+      const struct GNUNET_DNSPARSER_Record *record = rle->record;
+
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Found cache entry for '%s', record type '%u'\n",
+                 hostname,
+                 record_type);
+      if ((GNUNET_DNSPARSER_TYPE_CNAME == record->type) &&
+          (GNUNET_DNSPARSER_TYPE_CNAME != record_type) && (GNUNET_NO == found))
+        {
+          const char *hostname = record->data.hostname;
+
+          process_get(hostname, record_type, client_request_id, client);
+          return GNUNET_YES; /* counts as a cache "hit" */
+        }
+      found |= send_reply(rle->record, record_type, client_request_id, client);
     }
-    found |= send_reply (rle->record, record_type, client_request_id, client);
-  }
   if (GNUNET_NO == found)
     return GNUNET_NO; /* had records, but none matched! */
-  send_end_msg (client_request_id, client);
+  send_end_msg(client_request_id, client);
   return GNUNET_YES;
 }
 
@@ -670,64 +671,64 @@ try_cache (const char *hostname,
  * @return #GNUNET_OK on success
  */
 static int
-pack (const char *hostname,
-      uint16_t type,
-      uint16_t dns_id,
-      char **packet_buf,
-      size_t *packet_size)
+pack(const char *hostname,
+     uint16_t type,
+     uint16_t dns_id,
+     char **packet_buf,
+     size_t *packet_size)
 {
   struct GNUNET_DNSPARSER_Query query;
   struct GNUNET_DNSPARSER_Packet packet;
 
-  query.name = (char *) hostname;
+  query.name = (char *)hostname;
   query.type = type;
   query.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-  memset (&packet, 0, sizeof (packet));
+  memset(&packet, 0, sizeof(packet));
   packet.num_queries = 1;
   packet.queries = &query;
-  packet.id = htons (dns_id);
+  packet.id = htons(dns_id);
   packet.flags.recursion_desired = 1;
   if (GNUNET_OK !=
-      GNUNET_DNSPARSER_pack (&packet, UINT16_MAX, packet_buf, packet_size))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to pack query for hostname `%s'\n",
-                hostname);
-    packet_buf = NULL;
-    return GNUNET_SYSERR;
-  }
+      GNUNET_DNSPARSER_pack(&packet, UINT16_MAX, packet_buf, packet_size))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to pack query for hostname `%s'\n",
+                 hostname);
+      packet_buf = NULL;
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
 static void
-cache_answers (const char *name,
-               struct GNUNET_DNSPARSER_Record *records,
-               unsigned int num_records)
+cache_answers(const char *name,
+              struct GNUNET_DNSPARSER_Record *records,
+              unsigned int num_records)
 {
   struct ResolveCache *rc;
   struct GNUNET_DNSPARSER_Record *record;
   struct RecordListEntry *rle;
 
   for (unsigned int i = 0; i != num_records; i++)
-  {
-    record = &records[i];
-
-    for (rc = cache_head; NULL != rc; rc = rc->next)
-      if (0 == strcasecmp (rc->hostname, name))
-        break;
-    if (NULL == rc)
     {
-      rc = GNUNET_new (struct ResolveCache);
-      rc->hostname = GNUNET_strdup (name);
-      GNUNET_CONTAINER_DLL_insert (cache_head, cache_tail, rc);
-      cache_size++;
+      record = &records[i];
+
+      for (rc = cache_head; NULL != rc; rc = rc->next)
+        if (0 == strcasecmp(rc->hostname, name))
+          break;
+      if (NULL == rc)
+        {
+          rc = GNUNET_new(struct ResolveCache);
+          rc->hostname = GNUNET_strdup(name);
+          GNUNET_CONTAINER_DLL_insert(cache_head, cache_tail, rc);
+          cache_size++;
+        }
+      /* TODO: ought to check first if we have this exact record
+         already in the cache! */
+      rle = GNUNET_new(struct RecordListEntry);
+      rle->record = GNUNET_DNSPARSER_duplicate_record(record);
+      GNUNET_CONTAINER_DLL_insert(rc->records_head, rc->records_tail, rle);
     }
-    /* TODO: ought to check first if we have this exact record
-       already in the cache! */
-    rle = GNUNET_new (struct RecordListEntry);
-    rle->record = GNUNET_DNSPARSER_duplicate_record (record);
-    GNUNET_CONTAINER_DLL_insert (rc->records_head, rc->records_tail, rle);
-  }
 }
 
 /**
@@ -739,107 +740,107 @@ cache_answers (const char *name,
  * @param dns_len number of bytes in @a dns
  */
 static void
-handle_resolve_result (void *cls,
-                       const struct GNUNET_TUN_DnsHeader *dns,
-                       size_t dns_len)
+handle_resolve_result(void *cls,
+                      const struct GNUNET_TUN_DnsHeader *dns,
+                      size_t dns_len)
 {
   struct ActiveLookup *al = cls;
   struct GNUNET_DNSPARSER_Packet *parsed;
 
-  parsed = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len);
+  parsed = GNUNET_DNSPARSER_parse((const char *)dns, dns_len);
   if (NULL == parsed)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to parse DNS reply (hostname %s, request ID %u)\n",
-                al->hostname,
-                al->dns_id);
-    return;
-  }
-  if (al->dns_id != ntohs (parsed->id))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Request ID in DNS reply does not match\n");
-    GNUNET_DNSPARSER_free_packet (parsed);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to parse DNS reply (hostname %s, request ID %u)\n",
+                 al->hostname,
+                 al->dns_id);
+      return;
+    }
+  if (al->dns_id != ntohs(parsed->id))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Request ID in DNS reply does not match\n");
+      GNUNET_DNSPARSER_free_packet(parsed);
+      return;
+    }
   if (0 == parsed->num_answers + parsed->num_authority_records +
-             parsed->num_additional_records)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "DNS reply (hostname %s, request ID %u) contains no answers\n",
-                al->hostname,
-                (unsigned int) al->client_request_id);
-    /* resume by trying again from cache */
-    if (GNUNET_NO == try_cache (al->hostname,
-                                al->record_type,
-                                al->client_request_id,
-                                al->client))
-    /* cache failed, tell client we could not get an answer */
+      parsed->num_additional_records)
     {
-      send_end_msg (al->client_request_id, al->client);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "DNS reply (hostname %s, request ID %u) contains no answers\n",
+                 al->hostname,
+                 (unsigned int)al->client_request_id);
+      /* resume by trying again from cache */
+      if (GNUNET_NO == try_cache(al->hostname,
+                                 al->record_type,
+                                 al->client_request_id,
+                                 al->client))
+      /* cache failed, tell client we could not get an answer */
+        {
+          send_end_msg(al->client_request_id, al->client);
+        }
+      GNUNET_DNSPARSER_free_packet(parsed);
+      free_active_lookup(al);
+      return;
     }
-    GNUNET_DNSPARSER_free_packet (parsed);
-    free_active_lookup (al);
-    return;
-  }
   /* LRU-based cache eviction: we remove from tail */
   while (cache_size > MAX_CACHE)
-    free_cache_entry (cache_tail);
+    free_cache_entry(cache_tail);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got reply for hostname %s and request ID %u\n",
-              al->hostname,
-              (unsigned int) al->client_request_id);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got reply for hostname %s and request ID %u\n",
+             al->hostname,
+             (unsigned int)al->client_request_id);
   /* add to cache */
-  cache_answers (al->hostname, parsed->answers, parsed->num_answers);
-  cache_answers (al->hostname,
-                 parsed->authority_records,
-                 parsed->num_authority_records);
-  cache_answers (al->hostname,
-                 parsed->additional_records,
-                 parsed->num_additional_records);
+  cache_answers(al->hostname, parsed->answers, parsed->num_answers);
+  cache_answers(al->hostname,
+                parsed->authority_records,
+                parsed->num_authority_records);
+  cache_answers(al->hostname,
+                parsed->additional_records,
+                parsed->num_additional_records);
 
   /* see if we need to do the 2nd request for AAAA records */
   if ((GNUNET_DNSPARSER_TYPE_ALL == al->record_type) &&
       (GNUNET_NO == al->did_aaaa))
-  {
-    char *packet_buf;
-    size_t packet_size;
-    uint16_t dns_id;
+    {
+      char *packet_buf;
+      size_t packet_size;
+      uint16_t dns_id;
 
-    dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
+      dns_id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
                                                   UINT16_MAX);
-    if (GNUNET_OK == pack (al->hostname,
-                           GNUNET_DNSPARSER_TYPE_AAAA,
-                           dns_id,
-                           &packet_buf,
-                           &packet_size))
-    {
-      al->did_aaaa = GNUNET_YES;
-      al->dns_id = dns_id;
-      GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
-      al->resolve_handle = GNUNET_DNSSTUB_resolve (dnsstub_ctx,
-                                                   packet_buf,
-                                                   packet_size,
-                                                   &handle_resolve_result,
-                                                   al);
-      GNUNET_free (packet_buf);
-      GNUNET_DNSPARSER_free_packet (parsed);
-      return;
+      if (GNUNET_OK == pack(al->hostname,
+                            GNUNET_DNSPARSER_TYPE_AAAA,
+                            dns_id,
+                            &packet_buf,
+                            &packet_size))
+        {
+          al->did_aaaa = GNUNET_YES;
+          al->dns_id = dns_id;
+          GNUNET_DNSSTUB_resolve_cancel(al->resolve_handle);
+          al->resolve_handle = GNUNET_DNSSTUB_resolve(dnsstub_ctx,
+                                                      packet_buf,
+                                                      packet_size,
+                                                      &handle_resolve_result,
+                                                      al);
+          GNUNET_free(packet_buf);
+          GNUNET_DNSPARSER_free_packet(parsed);
+          return;
+        }
     }
-  }
 
   /* resume by trying again from cache */
-  if (GNUNET_NO == try_cache (al->hostname,
-                              al->record_type,
-                              al->client_request_id,
-                              al->client))
+  if (GNUNET_NO == try_cache(al->hostname,
+                             al->record_type,
+                             al->client_request_id,
+                             al->client))
   /* cache failed, tell client we could not get an answer */
-  {
-    send_end_msg (al->client_request_id, al->client);
-  }
-  free_active_lookup (al);
-  GNUNET_DNSPARSER_free_packet (parsed);
+    {
+      send_end_msg(al->client_request_id, al->client);
+    }
+  free_active_lookup(al);
+  GNUNET_DNSPARSER_free_packet(parsed);
 }
 
 
@@ -850,14 +851,14 @@ handle_resolve_result (void *cls,
  * @param cls a `struct ActiveLookup`
  */
 static void
-handle_resolve_timeout (void *cls)
+handle_resolve_timeout(void *cls)
 {
   struct ActiveLookup *al = cls;
 
   al->timeout_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DNS lookup timeout!\n");
-  send_end_msg (al->client_request_id, al->client);
-  free_active_lookup (al);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DNS lookup timeout!\n");
+  send_end_msg(al->client_request_id, al->client);
+  free_active_lookup(al);
 }
 
 
@@ -872,10 +873,10 @@ handle_resolve_timeout (void *cls)
  * @return #GNUNET_OK if the DNS query is now pending
  */
 static int
-resolve_and_cache (const char *hostname,
-                   uint16_t record_type,
-                   uint32_t client_request_id,
-                   struct GNUNET_SERVICE_Client *client)
+resolve_and_cache(const char *hostname,
+                  uint16_t record_type,
+                  uint32_t client_request_id,
+                  struct GNUNET_SERVICE_Client *client)
 {
   char *packet_buf;
   size_t packet_size;
@@ -883,42 +884,42 @@ resolve_and_cache (const char *hostname,
   uint16_t dns_id;
   uint16_t type;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "resolve_and_cache `%s'\n", hostname);
-  dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                                UINT16_MAX);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "resolve_and_cache `%s'\n", hostname);
+  dns_id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
+                                              UINT16_MAX);
 
   if (GNUNET_DNSPARSER_TYPE_ALL == record_type)
     type = GNUNET_DNSPARSER_TYPE_A;
   else
     type = record_type;
-  if (GNUNET_OK != pack (hostname, type, dns_id, &packet_buf, &packet_size))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to pack query for hostname `%s'\n",
-                hostname);
-    return GNUNET_SYSERR;
-  }
-
-  al = GNUNET_new (struct ActiveLookup);
-  al->hostname = GNUNET_strdup (hostname);
+  if (GNUNET_OK != pack(hostname, type, dns_id, &packet_buf, &packet_size))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to pack query for hostname `%s'\n",
+                 hostname);
+      return GNUNET_SYSERR;
+    }
+
+  al = GNUNET_new(struct ActiveLookup);
+  al->hostname = GNUNET_strdup(hostname);
   al->record_type = record_type;
   al->client_request_id = client_request_id;
   al->dns_id = dns_id;
   al->client = client;
   al->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (DNS_TIMEOUT, &handle_resolve_timeout, al);
-  al->resolve_handle = GNUNET_DNSSTUB_resolve (dnsstub_ctx,
-                                               packet_buf,
-                                               packet_size,
-                                               &handle_resolve_result,
-                                               al);
-  GNUNET_free (packet_buf);
-  GNUNET_CONTAINER_DLL_insert (lookup_head, lookup_tail, al);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Resolving %s, client_request_id = %u, dns_id = %u\n",
-              hostname,
-              (unsigned int) client_request_id,
-              (unsigned int) dns_id);
+    GNUNET_SCHEDULER_add_delayed(DNS_TIMEOUT, &handle_resolve_timeout, al);
+  al->resolve_handle = GNUNET_DNSSTUB_resolve(dnsstub_ctx,
+                                              packet_buf,
+                                              packet_size,
+                                              &handle_resolve_result,
+                                              al);
+  GNUNET_free(packet_buf);
+  GNUNET_CONTAINER_DLL_insert(lookup_head, lookup_tail, al);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Resolving %s, client_request_id = %u, dns_id = %u\n",
+             hostname,
+             (unsigned int)client_request_id,
+             (unsigned int)dns_id);
   return GNUNET_OK;
 }
 
@@ -933,38 +934,38 @@ resolve_and_cache (const char *hostname,
  * @param client who should get the result?
  */
 static void
-process_get (const char *hostname,
-             uint16_t record_type,
-             uint32_t client_request_id,
-             struct GNUNET_SERVICE_Client *client)
+process_get(const char *hostname,
+            uint16_t record_type,
+            uint32_t client_request_id,
+            struct GNUNET_SERVICE_Client *client)
 {
   char fqdn[255];
 
-  if (GNUNET_NO != try_cache (hostname, record_type, client_request_id, client))
+  if (GNUNET_NO != try_cache(hostname, record_type, client_request_id, client))
     return;
-  if ((NULL != my_domain) && (NULL == strchr (hostname, (unsigned char) '.')) &&
-      (strlen (hostname) + strlen (my_domain) <= 253))
-  {
-    GNUNET_snprintf (fqdn, sizeof (fqdn), "%s.%s", hostname, my_domain);
-  }
-  else if (strlen (hostname) < 255)
-  {
-    GNUNET_snprintf (fqdn, sizeof (fqdn), "%s", hostname);
-  }
+  if ((NULL != my_domain) && (NULL == strchr(hostname, (unsigned char)'.')) &&
+      (strlen(hostname) + strlen(my_domain) <= 253))
+    {
+      GNUNET_snprintf(fqdn, sizeof(fqdn), "%s.%s", hostname, my_domain);
+    }
+  else if (strlen(hostname) < 255)
+    {
+      GNUNET_snprintf(fqdn, sizeof(fqdn), "%s", hostname);
+    }
   else
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (client);
-    return;
-  }
-  if (GNUNET_NO == try_cache (fqdn, record_type, client_request_id, client))
-  {
-    if (GNUNET_OK !=
-        resolve_and_cache (fqdn, record_type, client_request_id, client))
     {
-      send_end_msg (client_request_id, client);
+      GNUNET_break(0);
+      GNUNET_SERVICE_client_drop(client);
+      return;
+    }
+  if (GNUNET_NO == try_cache(fqdn, record_type, client_request_id, client))
+    {
+      if (GNUNET_OK !=
+          resolve_and_cache(fqdn, record_type, client_request_id, client))
+        {
+          send_end_msg(client_request_id, client);
+        }
     }
-  }
 }
 
 
@@ -976,41 +977,43 @@ process_get (const char *hostname,
  * @return #GNUNET_OK if @a get is well-formed
  */
 static int
-check_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
+check_get(void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
 {
   uint16_t size;
   int direction;
   int af;
 
-  (void) cls;
-  size = ntohs (get->header.size) - sizeof (*get);
-  direction = ntohl (get->direction);
+  (void)cls;
+  size = ntohs(get->header.size) - sizeof(*get);
+  direction = ntohl(get->direction);
   if (GNUNET_NO == direction)
-  {
-    GNUNET_MQ_check_zero_termination (get);
-    return GNUNET_OK;
-  }
-  af = ntohl (get->af);
-  switch (af)
-  {
-  case AF_INET:
-    if (size != sizeof (struct in_addr))
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      GNUNET_MQ_check_zero_termination(get);
+      return GNUNET_OK;
     }
-    break;
-  case AF_INET6:
-    if (size != sizeof (struct in6_addr))
+  af = ntohl(get->af);
+  switch (af)
     {
-      GNUNET_break (0);
+    case AF_INET:
+      if (size != sizeof(struct in_addr))
+        {
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      break;
+
+    case AF_INET6:
+      if (size != sizeof(struct in6_addr))
+        {
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      break;
+
+    default:
+      GNUNET_break(0);
       return GNUNET_SYSERR;
     }
-    break;
-  default:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
   return GNUNET_OK;
 }
 
@@ -1022,7 +1025,7 @@ check_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
  * @param msg the actual message
  */
 static void
-handle_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
+handle_get(void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   int direction;
@@ -1030,56 +1033,59 @@ handle_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
   uint32_t client_request_id;
   char *hostname;
 
-  direction = ntohl (msg->direction);
-  af = ntohl (msg->af);
+  direction = ntohl(msg->direction);
+  af = ntohl(msg->af);
   client_request_id = msg->client_id;
-  GNUNET_SERVICE_client_continue (client);
+  GNUNET_SERVICE_client_continue(client);
   if (GNUNET_NO == direction)
-  {
-    /* IP from hostname */
-    hostname = GNUNET_strdup ((const char *) &msg[1]);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Client asks to resolve `%s'\n",
-                hostname);
-    switch (af)
     {
-    case AF_UNSPEC: {
-      process_get (hostname,
-                   GNUNET_DNSPARSER_TYPE_ALL,
-                   client_request_id,
-                   client);
-      break;
-    }
-    case AF_INET: {
-      process_get (hostname,
-                   GNUNET_DNSPARSER_TYPE_A,
-                   client_request_id,
-                   client);
-      break;
-    }
-    case AF_INET6: {
-      process_get (hostname,
-                   GNUNET_DNSPARSER_TYPE_AAAA,
-                   client_request_id,
-                   client);
-      break;
-    }
-    default: {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got invalid af: %d\n", af);
-      GNUNET_assert (0);
+      /* IP from hostname */
+      hostname = GNUNET_strdup((const char *)&msg[1]);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Client asks to resolve `%s'\n",
+                 hostname);
+      switch (af)
+        {
+        case AF_UNSPEC: {
+          process_get(hostname,
+                      GNUNET_DNSPARSER_TYPE_ALL,
+                      client_request_id,
+                      client);
+          break;
+        }
+
+        case AF_INET: {
+          process_get(hostname,
+                      GNUNET_DNSPARSER_TYPE_A,
+                      client_request_id,
+                      client);
+          break;
+        }
+
+        case AF_INET6: {
+          process_get(hostname,
+                      GNUNET_DNSPARSER_TYPE_AAAA,
+                      client_request_id,
+                      client);
+          break;
+        }
+
+        default: {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "got invalid af: %d\n", af);
+          GNUNET_assert(0);
+        }
+        }
     }
-    }
-  }
   else
-  {
-    /* hostname from IP */
-    hostname = make_reverse_hostname (&msg[1], af);
-    process_get (hostname,
-                 GNUNET_DNSPARSER_TYPE_PTR,
-                 client_request_id,
-                 client);
-  }
-  GNUNET_free_non_null (hostname);
+    {
+      /* hostname from IP */
+      hostname = make_reverse_hostname(&msg[1], af);
+      process_get(hostname,
+                  GNUNET_DNSPARSER_TYPE_PTR,
+                  client_request_id,
+                  client);
+    }
+  GNUNET_free_non_null(hostname);
 }
 
 
@@ -1089,18 +1095,18 @@ handle_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
  * @param cls NULL, unused
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) cls;
+  (void)cls;
 
   while (NULL != lookup_head)
-    free_active_lookup (lookup_head);
+    free_active_lookup(lookup_head);
   while (NULL != cache_head)
-    free_cache_entry (cache_head);
+    free_cache_entry(cache_head);
   while (NULL != hosts_head)
-    free_hosts_entry (hosts_head);
-  GNUNET_DNSSTUB_stop (dnsstub_ctx);
-  GNUNET_free_non_null (my_domain);
+    free_hosts_entry(hosts_head);
+  GNUNET_DNSSTUB_stop(dnsstub_ctx);
+  GNUNET_free_non_null(my_domain);
 }
 
 
@@ -1114,28 +1120,28 @@ shutdown_task (void *cls)
  * @param data_size number of bytes in @a data
  */
 static void
-add_host (const char *hostname,
-          uint16_t rec_type,
-          const void *data,
-          size_t data_size)
+add_host(const char *hostname,
+         uint16_t rec_type,
+         const void *data,
+         size_t data_size)
 {
   struct ResolveCache *rc;
   struct RecordListEntry *rle;
   struct GNUNET_DNSPARSER_Record *rec;
 
-  rec = GNUNET_malloc (sizeof (struct GNUNET_DNSPARSER_Record));
+  rec = GNUNET_malloc(sizeof(struct GNUNET_DNSPARSER_Record));
   rec->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS;
   rec->type = rec_type;
   rec->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
-  rec->name = GNUNET_strdup (hostname);
-  rec->data.raw.data = GNUNET_memdup (data, data_size);
+  rec->name = GNUNET_strdup(hostname);
+  rec->data.raw.data = GNUNET_memdup(data, data_size);
   rec->data.raw.data_len = data_size;
-  rle = GNUNET_new (struct RecordListEntry);
+  rle = GNUNET_new(struct RecordListEntry);
   rle->record = rec;
-  rc = GNUNET_new (struct ResolveCache);
-  rc->hostname = GNUNET_strdup (hostname);
-  GNUNET_CONTAINER_DLL_insert (rc->records_head, rc->records_tail, rle);
-  GNUNET_CONTAINER_DLL_insert (hosts_head, hosts_tail, rc);
+  rc = GNUNET_new(struct ResolveCache);
+  rc->hostname = GNUNET_strdup(hostname);
+  GNUNET_CONTAINER_DLL_insert(rc->records_head, rc->records_tail, rle);
+  GNUNET_CONTAINER_DLL_insert(hosts_head, hosts_tail, rc);
 }
 
 
@@ -1146,7 +1152,7 @@ add_host (const char *hostname,
  * @param line_len number of bytes in @a line
  */
 static void
-extract_hosts (const char *line, size_t line_len)
+extract_hosts(const char *line, size_t line_len)
 {
   const char *c;
   struct in_addr v4;
@@ -1155,33 +1161,33 @@ extract_hosts (const char *line, size_t line_len)
   char *tok;
 
   /* ignore everything after '#' */
-  c = memrchr (line, (unsigned char) '#', line_len);
+  c = memrchr(line, (unsigned char)'#', line_len);
   if (NULL != c)
     line_len = c - line;
   /* ignore leading whitespace */
-  while ((0 < line_len) && isspace ((unsigned char) *line))
-  {
-    line++;
-    line_len--;
-  }
-  tbuf = GNUNET_strndup (line, line_len);
-  tok = strtok (tbuf, " \t");
+  while ((0 < line_len) && isspace((unsigned char)*line))
+    {
+      line++;
+      line_len--;
+    }
+  tbuf = GNUNET_strndup(line, line_len);
+  tok = strtok(tbuf, " \t");
   if (NULL == tok)
-  {
-    GNUNET_free (tbuf);
-    return;
-  }
-  if (1 == inet_pton (AF_INET, tok, &v4))
-  {
-    while (NULL != (tok = strtok (NULL, " \t")))
-      add_host (tok, GNUNET_DNSPARSER_TYPE_A, &v4, sizeof (struct in_addr));
-  }
-  else if (1 == inet_pton (AF_INET6, tok, &v6))
-  {
-    while (NULL != (tok = strtok (NULL, " \t")))
-      add_host (tok, GNUNET_DNSPARSER_TYPE_AAAA, &v6, sizeof (struct in6_addr));
-  }
-  GNUNET_free (tbuf);
+    {
+      GNUNET_free(tbuf);
+      return;
+    }
+  if (1 == inet_pton(AF_INET, tok, &v4))
+    {
+      while (NULL != (tok = strtok(NULL, " \t")))
+        add_host(tok, GNUNET_DNSPARSER_TYPE_A, &v4, sizeof(struct in_addr));
+    }
+  else if (1 == inet_pton(AF_INET6, tok, &v6))
+    {
+      while (NULL != (tok = strtok(NULL, " \t")))
+        add_host(tok, GNUNET_DNSPARSER_TYPE_AAAA, &v6, sizeof(struct in6_addr));
+    }
+  GNUNET_free(tbuf);
 }
 
 
@@ -1189,7 +1195,7 @@ extract_hosts (const char *line, size_t line_len)
  * Reads the list of hosts from /etc/hosts.
  */
 static void
-load_etc_hosts (void)
+load_etc_hosts(void)
 {
   struct GNUNET_DISK_FileHandle *fh;
   struct GNUNET_DISK_MapHandle *mh;
@@ -1197,49 +1203,49 @@ load_etc_hosts (void)
   const char *buf;
   size_t read_offset;
 
-  fh = GNUNET_DISK_file_open ("/etc/hosts",
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
+  fh = GNUNET_DISK_file_open("/etc/hosts",
+                             GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
   if (NULL == fh)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Failed to open /etc/hosts");
-    return;
-  }
-  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Could not determin size of /etc/hosts. "
-                "DNS resolution will not be possible.\n");
-    GNUNET_DISK_file_close (fh);
-    return;
-  }
-  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "/etc/hosts file too large to mmap. "
-                "DNS resolution will not be possible.\n");
-    GNUNET_DISK_file_close (fh);
-    return;
-  }
-  buf = GNUNET_DISK_file_map (fh,
-                              &mh,
-                              GNUNET_DISK_MAP_TYPE_READ,
-                              (size_t) bytes_read);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Failed to open /etc/hosts");
+      return;
+    }
+  if (GNUNET_OK != GNUNET_DISK_file_handle_size(fh, &bytes_read))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Could not determin size of /etc/hosts. "
+                 "DNS resolution will not be possible.\n");
+      GNUNET_DISK_file_close(fh);
+      return;
+    }
+  if (((unsigned long long)bytes_read) > (unsigned long long)SIZE_MAX)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "/etc/hosts file too large to mmap. "
+                 "DNS resolution will not be possible.\n");
+      GNUNET_DISK_file_close(fh);
+      return;
+    }
+  buf = GNUNET_DISK_file_map(fh,
+                             &mh,
+                             GNUNET_DISK_MAP_TYPE_READ,
+                             (size_t)bytes_read);
   read_offset = 0;
-  while (read_offset < (size_t) bytes_read)
-  {
-    const char *newline;
-    size_t line_len;
+  while (read_offset < (size_t)bytes_read)
+    {
+      const char *newline;
+      size_t line_len;
 
-    newline = strchr (buf + read_offset, '\n');
-    if (NULL == newline)
-      break;
-    line_len = newline - buf - read_offset;
-    extract_hosts (buf + read_offset, line_len);
-    read_offset += line_len + 1;
-  }
-  GNUNET_DISK_file_unmap (mh);
-  GNUNET_DISK_file_close (fh);
+      newline = strchr(buf + read_offset, '\n');
+      if (NULL == newline)
+        break;
+      line_len = newline - buf - read_offset;
+      extract_hosts(buf + read_offset, line_len);
+      read_offset += line_len + 1;
+    }
+  GNUNET_DISK_file_unmap(mh);
+  GNUNET_DISK_file_close(fh);
 }
 
 
@@ -1251,37 +1257,37 @@ load_etc_hosts (void)
  * @param sh service handle
  */
 static void
-init_cb (void *cls,
-         const struct GNUNET_CONFIGURATION_Handle *cfg,
-         struct GNUNET_SERVICE_Handle *sh)
+init_cb(void *cls,
+        const struct GNUNET_CONFIGURATION_Handle *cfg,
+        struct GNUNET_SERVICE_Handle *sh)
 {
   char **dns_servers;
   int num_dns_servers;
 
-  (void) cfg;
-  (void) sh;
-  load_etc_hosts ();
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, cls);
-  dnsstub_ctx = GNUNET_DNSSTUB_start (128);
+  (void)cfg;
+  (void)sh;
+  load_etc_hosts();
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, cls);
+  dnsstub_ctx = GNUNET_DNSSTUB_start(128);
   dns_servers = NULL;
-  num_dns_servers = lookup_dns_servers (&dns_servers);
+  num_dns_servers = lookup_dns_servers(&dns_servers);
   if (0 >= num_dns_servers)
-  {
-    GNUNET_log (
-      GNUNET_ERROR_TYPE_ERROR,
-      _ ("No DNS server available. DNS resolution will not be possible.\n"));
-    return;
-  }
+    {
+      GNUNET_log(
+        GNUNET_ERROR_TYPE_ERROR,
+        _("No DNS server available. DNS resolution will not be possible.\n"));
+      return;
+    }
   for (int i = 0; i < num_dns_servers; i++)
-  {
-    int result = GNUNET_DNSSTUB_add_dns_ip (dnsstub_ctx, dns_servers[i]);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Adding DNS server '%s': %s\n",
-                dns_servers[i],
-                GNUNET_OK == result ? "success" : "failure");
-    GNUNET_free (dns_servers[i]);
-  }
-  GNUNET_free_non_null (dns_servers);
+    {
+      int result = GNUNET_DNSSTUB_add_dns_ip(dnsstub_ctx, dns_servers[i]);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Adding DNS server '%s': %s\n",
+                 dns_servers[i],
+                 GNUNET_OK == result ? "success" : "failure");
+      GNUNET_free(dns_servers[i]);
+    }
+  GNUNET_free_non_null(dns_servers);
 }
 
 
@@ -1294,12 +1300,12 @@ init_cb (void *cls,
  * @return @a c
  */
 static void *
-connect_cb (void *cls,
-            struct GNUNET_SERVICE_Client *c,
-            struct GNUNET_MQ_Handle *mq)
+connect_cb(void *cls,
+           struct GNUNET_SERVICE_Client *c,
+           struct GNUNET_MQ_Handle *mq)
 {
-  (void) cls;
-  (void) mq;
+  (void)cls;
+  (void)mq;
 
   return c;
 }
@@ -1313,37 +1319,38 @@ connect_cb (void *cls,
  * @param internal_cls should be equal to @a c
  */
 static void
-disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
+disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
 {
   struct ActiveLookup *n;
-  (void) cls;
 
-  GNUNET_assert (c == internal_cls);
+  (void)cls;
+
+  GNUNET_assert(c == internal_cls);
   n = lookup_head;
   for (struct ActiveLookup *al = n; NULL != al; al = n)
-  {
-    n = al->next;
-    if (al->client == c)
-      free_active_lookup (al);
-  }
+    {
+      n = al->next;
+      if (al->client == c)
+        free_active_lookup(al);
+    }
 }
 
 
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN (
+GNUNET_SERVICE_MAIN(
   "resolver",
   GNUNET_SERVICE_OPTION_NONE,
   &init_cb,
   &connect_cb,
   &disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size (get,
-                         GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST,
-                         struct GNUNET_RESOLVER_GetMessage,
-                         NULL),
-  GNUNET_MQ_handler_end ());
+  GNUNET_MQ_hd_var_size(get,
+                        GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST,
+                        struct GNUNET_RESOLVER_GetMessage,
+                        NULL),
+  GNUNET_MQ_handler_end());
 
 
 #if defined(LINUX) && defined(__GLIBC__)
@@ -1352,11 +1359,11 @@ GNUNET_SERVICE_MAIN (
 /**
  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
  */
-void __attribute__ ((constructor)) GNUNET_RESOLVER_memory_init ()
+void __attribute__ ((constructor)) GNUNET_RESOLVER_memory_init()
 {
-  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
-  mallopt (M_TOP_PAD, 1 * 1024);
-  malloc_trim (0);
+  mallopt(M_TRIM_THRESHOLD, 4 * 1024);
+  mallopt(M_TOP_PAD, 1 * 1024);
+  malloc_trim(0);
 }
 #endif
 
diff --git a/src/util/gnunet-timeout-w32.c b/src/util/gnunet-timeout-w32.c
index 6f92b172f..3e579714c 100644
--- a/src/util/gnunet-timeout-w32.c
+++ b/src/util/gnunet-timeout-w32.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/util/gnunet-timeout-w32.c
@@ -29,7 +29,7 @@
 #include <stdio.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int i;
   DWORD wait_result;
@@ -56,138 +56,138 @@ main (int argc, char *argv[])
   if (argc < 3)
     {
       printf
-        ("arg 1: timeout in sec., arg 2: executable, arg<n> arguments\n");
-      exit (1);
+        ("arg 1: timeout in sec., arg 2: executable, arg<n> arguments\n");
+      exit(1);
     }
 
-  timeout = atoi (argv[1]);
+  timeout = atoi(argv[1]);
 
   if (timeout == 0)
     timeout = 600;
 
-  commandline =  GetCommandLineW ();
+  commandline = GetCommandLineW();
   if (commandline == NULL)
-  {
-    printf ("Failed to get commandline: %lu\n", GetLastError ());
-    exit (2);
-  }
+    {
+      printf("Failed to get commandline: %lu\n", GetLastError());
+      exit(2);
+    }
 
-  wargv = CommandLineToArgvW (commandline, &wargc);
+  wargv = CommandLineToArgvW(commandline, &wargc);
   if (wargv == NULL || wargc <= 1)
-  {
-    printf ("Failed to get parse commandline: %lu\n", GetLastError ());
-    exit (3);
-  }
+    {
+      printf("Failed to get parse commandline: %lu\n", GetLastError());
+      exit(3);
+    }
 
-  job = CreateJobObject (NULL, NULL);
+  job = CreateJobObject(NULL, NULL);
   if (job == NULL)
-  {
-    printf ("Failed to create a job: %lu\n", GetLastError ());
-    exit (4);
-  }
+    {
+      printf("Failed to create a job: %lu\n", GetLastError());
+      exit(4);
+    }
 
-  pathbuf_len = GetEnvironmentVariableW (L"PATH", (wchar_t *) &pathbuf, 0);
+  pathbuf_len = GetEnvironmentVariableW(L"PATH", (wchar_t *)&pathbuf, 0);
 
   alloc_len = pathbuf_len + 1;
 
-  pathbuf = malloc (alloc_len * sizeof (wchar_t));
+  pathbuf = malloc(alloc_len * sizeof(wchar_t));
 
   ptr = pathbuf;
 
-  alloc_len = GetEnvironmentVariableW (L"PATH", ptr, pathbuf_len);
+  alloc_len = GetEnvironmentVariableW(L"PATH", ptr, pathbuf_len);
 
-  cmdlen = wcslen (wargv[2]);
-  if (cmdlen < 5 || wcscmp (&wargv[2][cmdlen - 4], L".exe") != 0)
-  {
-    non_const_filename = malloc (sizeof (wchar_t) * (cmdlen + 5));
-    swprintf (non_const_filename, cmdlen + 5, L"%S.exe", wargv[2]);
-  }
+  cmdlen = wcslen(wargv[2]);
+  if (cmdlen < 5 || wcscmp(&wargv[2][cmdlen - 4], L".exe") != 0)
+    {
+      non_const_filename = malloc(sizeof(wchar_t) * (cmdlen + 5));
+      swprintf(non_const_filename, cmdlen + 5, L"%S.exe", wargv[2]);
+    }
   else
-  {
-    non_const_filename = wcsdup (wargv[2]);
-  }
+    {
+      non_const_filename = wcsdup(wargv[2]);
+    }
 
   /* Check that this is the full path. If it isn't, search. */
   if (non_const_filename[1] == L':')
-    swprintf (wpath, sizeof (wpath) / sizeof (wchar_t), L"%S", non_const_filename);
+    swprintf(wpath, sizeof(wpath) / sizeof(wchar_t), L"%S", non_const_filename);
   else if (!SearchPathW
-           (pathbuf, non_const_filename, NULL, sizeof (wpath) / sizeof (wchar_t),
-            wpath, NULL))
-  {
-    printf ("Failed to get find executable: %lu\n", GetLastError ());
-    exit (5);
-  }
-  free (pathbuf);
-  free (non_const_filename);
-
-  cmdlen = wcslen (wpath) + 4;
+             (pathbuf, non_const_filename, NULL, sizeof(wpath) / sizeof(wchar_t),
+             wpath, NULL))
+    {
+      printf("Failed to get find executable: %lu\n", GetLastError());
+      exit(5);
+    }
+  free(pathbuf);
+  free(non_const_filename);
+
+  cmdlen = wcslen(wpath) + 4;
   i = 3;
   while (NULL != (arg = wargv[i++]))
-    cmdlen += wcslen (arg) + 4;
+    cmdlen += wcslen(arg) + 4;
 
-  wcmd = malloc (sizeof (wchar_t) * (cmdlen + 1));
+  wcmd = malloc(sizeof(wchar_t) * (cmdlen + 1));
   wrote = 0;
   i = 2;
   while (NULL != (arg = wargv[i++]))
-  {
-    /* This is to escape trailing slash */
-    wchar_t arg_lastchar = arg[wcslen (arg) - 1];
-    if (wrote == 0)
     {
-      wrote += swprintf (&wcmd[wrote], cmdlen + 1 - wrote, L"\"%S%S\" ", wpath,
-          arg_lastchar == L'\\' ? L"\\" : L"");
-    }
-    else
-    {
-      if (wcschr (arg, L' ') != NULL)
-        wrote += swprintf (&wcmd[wrote], cmdlen + 1 - wrote, L"\"%S%S\"%S", arg,
-            arg_lastchar == L'\\' ? L"\\" : L"", i == wargc ? L"" : L" ");
+      /* This is to escape trailing slash */
+      wchar_t arg_lastchar = arg[wcslen(arg) - 1];
+      if (wrote == 0)
+        {
+          wrote += swprintf(&wcmd[wrote], cmdlen + 1 - wrote, L"\"%S%S\" ", wpath,
+                            arg_lastchar == L'\\' ? L"\\" : L"");
+        }
       else
-        wrote += swprintf (&wcmd[wrote], cmdlen + 1 - wrote, L"%S%S%S", arg,
-            arg_lastchar == L'\\' ? L"\\" : L"", i == wargc ? L"" : L" ");
+        {
+          if (wcschr(arg, L' ') != NULL)
+            wrote += swprintf(&wcmd[wrote], cmdlen + 1 - wrote, L"\"%S%S\"%S", arg,
+                              arg_lastchar == L'\\' ? L"\\" : L"", i == wargc ? L"" : L" ");
+          else
+            wrote += swprintf(&wcmd[wrote], cmdlen + 1 - wrote, L"%S%S%S", arg,
+                              arg_lastchar == L'\\' ? L"\\" : L"", i == wargc ? L"" : L" ");
+        }
     }
-  }
 
-  LocalFree (wargv);
+  LocalFree(wargv);
 
-  memset (&start, 0, sizeof (start));
-  start.cb = sizeof (start);
+  memset(&start, 0, sizeof(start));
+  start.cb = sizeof(start);
 
-  if (!CreateProcessW (wpath, wcmd, NULL, NULL, TRUE, CREATE_SUSPENDED,
-       NULL, NULL, &start, &proc))
-  {
-    wprintf (L"Failed to get spawn process `%S' with arguments `%S': %lu\n", wpath, wcmd, GetLastError ());
-    exit (6);
-  }
+  if (!CreateProcessW(wpath, wcmd, NULL, NULL, TRUE, CREATE_SUSPENDED,
+                      NULL, NULL, &start, &proc))
+    {
+      wprintf(L"Failed to get spawn process `%S' with arguments `%S': %lu\n", wpath, wcmd, GetLastError());
+      exit(6);
+    }
 
-  AssignProcessToJobObject (job, proc.hProcess);
+  AssignProcessToJobObject(job, proc.hProcess);
 
-  ResumeThread (proc.hThread);
-  CloseHandle (proc.hThread);
+  ResumeThread(proc.hThread);
+  CloseHandle(proc.hThread);
 
-  free (wcmd);
+  free(wcmd);
 
-  wait_result = WaitForSingleObject (proc.hProcess, timeout * 1000);
+  wait_result = WaitForSingleObject(proc.hProcess, timeout * 1000);
   if (wait_result == WAIT_OBJECT_0)
-  {
-    DWORD status;
-    wait_result = GetExitCodeProcess (proc.hProcess, &status);
-    CloseHandle (proc.hProcess);
-    if (wait_result != 0)
     {
-      printf ("Test process exited with result %lu\n", status);
-      TerminateJobObject (job, status);
-      exit (status);
+      DWORD status;
+      wait_result = GetExitCodeProcess(proc.hProcess, &status);
+      CloseHandle(proc.hProcess);
+      if (wait_result != 0)
+        {
+          printf("Test process exited with result %lu\n", status);
+          TerminateJobObject(job, status);
+          exit(status);
+        }
+      printf("Test process exited (failed to obtain exit status)\n");
+      TerminateJobObject(job, 0);
+      exit(0);
     }
-    printf ("Test process exited (failed to obtain exit status)\n");
-    TerminateJobObject (job, 0);
-    exit (0);
-  }
-  printf ("Child processes were killed after timeout of %u seconds\n",
-          timeout);
-  TerminateJobObject (job, 1);
-  CloseHandle (proc.hProcess);
-  exit (1);
+  printf("Child processes were killed after timeout of %u seconds\n",
+         timeout);
+  TerminateJobObject(job, 1);
+  CloseHandle(proc.hProcess);
+  exit(1);
 }
 
 /* end of timeout_watchdog_w32.c */
diff --git a/src/util/gnunet-timeout.c b/src/util/gnunet-timeout.c
index d71b66af4..2b1754a5e 100644
--- a/src/util/gnunet-timeout.c
+++ b/src/util/gnunet-timeout.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/util/gnunet-timeout.c
@@ -35,85 +35,85 @@ static pid_t child;
 
 
 static void
-sigchld_handler (int val)
+sigchld_handler(int val)
 {
   int status = 0;
   int ret = 0;
 
-  (void) val;
-  waitpid (child, &status, 0);
-  if (WIFEXITED (status) != 0)
-  {
-    ret = WEXITSTATUS (status);
-    fprintf (stderr, "Process exited with result %u\n", ret);
-    _exit (ret); /* return same status code */
-  }
-  if (WIFSIGNALED (status) != 0)
-  {
-    ret = WTERMSIG (status);
-    fprintf (stderr, "Process received signal %u\n", ret);
-    kill (getpid (), ret); /* kill self with the same signal */
-  }
-  _exit (-1);
+  (void)val;
+  waitpid(child, &status, 0);
+  if (WIFEXITED(status) != 0)
+    {
+      ret = WEXITSTATUS(status);
+      fprintf(stderr, "Process exited with result %u\n", ret);
+      _exit(ret); /* return same status code */
+    }
+  if (WIFSIGNALED(status) != 0)
+    {
+      ret = WTERMSIG(status);
+      fprintf(stderr, "Process received signal %u\n", ret);
+      kill(getpid(), ret); /* kill self with the same signal */
+    }
+  _exit(-1);
 }
 
 
 static void
-sigint_handler (int val)
+sigint_handler(int val)
 {
-  kill (0, val);
-  _exit (val);
+  kill(0, val);
+  _exit(val);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int timeout = 0;
   pid_t gpid = 0;
 
   if (argc < 3)
-  {
-    fprintf (stderr,
-             "arg 1: timeout in sec., arg 2: executable, arg<n> arguments\n");
-    exit (-1);
-  }
+    {
+      fprintf(stderr,
+              "arg 1: timeout in sec., arg 2: executable, arg<n> arguments\n");
+      exit(-1);
+    }
 
-  timeout = atoi (argv[1]);
+  timeout = atoi(argv[1]);
 
   if (timeout == 0)
     timeout = 600;
 
   /* with getpgid() it does not compile, but getpgrp is the BSD version and working */
-  gpid = getpgrp ();
+  gpid = getpgrp();
 
-  signal (SIGCHLD, sigchld_handler);
-  signal (SIGABRT, sigint_handler);
-  signal (SIGFPE, sigint_handler);
-  signal (SIGILL, sigint_handler);
-  signal (SIGINT, sigint_handler);
-  signal (SIGSEGV, sigint_handler);
-  signal (SIGTERM, sigint_handler);
+  signal(SIGCHLD, sigchld_handler);
+  signal(SIGABRT, sigint_handler);
+  signal(SIGFPE, sigint_handler);
+  signal(SIGILL, sigint_handler);
+  signal(SIGINT, sigint_handler);
+  signal(SIGSEGV, sigint_handler);
+  signal(SIGTERM, sigint_handler);
 
-  child = fork ();
+  child = fork();
   if (child == 0)
-  {
-    /*  int setpgrp(pid_t pid, pid_t pgid); is not working on this machine */
-    //setpgrp (0, pid_t gpid);
-    if (-1 != gpid)
-      setpgid (0, gpid);
-    execvp (argv[2], &argv[2]);
-    exit (-1);
-  }
+    {
+      /*  int setpgrp(pid_t pid, pid_t pgid); is not working on this machine */
+      //setpgrp (0, pid_t gpid);
+      if (-1 != gpid)
+        setpgid(0, gpid);
+      execvp(argv[2], &argv[2]);
+      exit(-1);
+    }
   if (child > 0)
-  {
-    sleep (timeout);
-    printf ("Child processes were killed after timeout of %u seconds\n",
-            timeout);
-    kill (0, SIGTERM);
-    exit (3);
-  }
-  exit (-1);
+    {
+      sleep(timeout);
+      printf("Child processes were killed after timeout of %u seconds\n",
+             timeout);
+      kill(0, SIGTERM);
+      exit(3);
+    }
+  exit(-1);
 }
 
 /* end of timeout_watchdog.c */
diff --git a/src/util/gnunet-uri.c b/src/util/gnunet-uri.c
index 33ff7b1e6..75667b30f 100644
--- a/src/util/gnunet-uri.c
+++ b/src/util/gnunet-uri.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 util/gnunet-uri.c
@@ -49,15 +49,15 @@ static struct GNUNET_DISK_PipeHandle *sigpipe;
  * @param cls closure, NULL
  */
 static void
-maint_child_death (void *cls)
+maint_child_death(void *cls)
 {
   enum GNUNET_OS_ProcessStatusType type;
 
-  (void) cls;
-  if ((GNUNET_OK != GNUNET_OS_process_status (p, &type, &exit_code)) ||
+  (void)cls;
+  if ((GNUNET_OK != GNUNET_OS_process_status(p, &type, &exit_code)) ||
       (type != GNUNET_OS_PROCESS_EXITED))
-    GNUNET_break (0 == GNUNET_OS_process_kill (p, GNUNET_TERM_SIG));
-  GNUNET_OS_process_destroy (p);
+    GNUNET_break(0 == GNUNET_OS_process_kill(p, GNUNET_TERM_SIG));
+  GNUNET_OS_process_destroy(p);
 }
 
 
@@ -70,10 +70,10 @@ maint_child_death (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 *uri;
   const char *slash;
@@ -81,52 +81,52 @@ run (void *cls,
   char *program;
   struct GNUNET_SCHEDULER_Task *rt;
 
-  (void) cls;
-  (void) cfgfile;
+  (void)cls;
+  (void)cfgfile;
   if (NULL == (uri = args[0]))
-  {
-    fprintf (stderr, _ ("No URI specified on command line\n"));
-    return;
-  }
-  if (0 != strncasecmp ("gnunet://", uri, strlen ("gnunet://")))
-  {
-    fprintf (stderr,
-             _ ("Invalid URI: does not start with `%s'\n"),
-             "gnunet://");
-    return;
-  }
-  uri += strlen ("gnunet://");
-  if (NULL == (slash = strchr (uri, '/')))
-  {
-    fprintf (stderr, _ ("Invalid URI: fails to specify subsystem\n"));
-    return;
-  }
-  subsystem = GNUNET_strndup (uri, slash - uri);
+    {
+      fprintf(stderr, _("No URI specified on command line\n"));
+      return;
+    }
+  if (0 != strncasecmp("gnunet://", uri, strlen("gnunet://")))
+    {
+      fprintf(stderr,
+              _("Invalid URI: does not start with `%s'\n"),
+              "gnunet://");
+      return;
+    }
+  uri += strlen("gnunet://");
+  if (NULL == (slash = strchr(uri, '/')))
+    {
+      fprintf(stderr, _("Invalid URI: fails to specify subsystem\n"));
+      return;
+    }
+  subsystem = GNUNET_strndup(uri, slash - uri);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, "uri", subsystem, &program))
-  {
-    fprintf (stderr, _ ("No handler known for subsystem `%s'\n"), subsystem);
-    GNUNET_free (subsystem);
-    return;
-  }
-  GNUNET_free (subsystem);
-  rt = GNUNET_SCHEDULER_add_read_file (
+      GNUNET_CONFIGURATION_get_value_string(cfg, "uri", subsystem, &program))
+    {
+      fprintf(stderr, _("No handler known for subsystem `%s'\n"), subsystem);
+      GNUNET_free(subsystem);
+      return;
+    }
+  GNUNET_free(subsystem);
+  rt = GNUNET_SCHEDULER_add_read_file(
     GNUNET_TIME_UNIT_FOREVER_REL,
-    GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ),
+    GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ),
     &maint_child_death,
     NULL);
-  p = GNUNET_OS_start_process (GNUNET_NO,
-                               0,
-                               NULL,
-                               NULL,
-                               NULL,
-                               program,
-                               program,
-                               args[0],
-                               NULL);
-  GNUNET_free (program);
+  p = GNUNET_OS_start_process(GNUNET_NO,
+                              0,
+                              NULL,
+                              NULL,
+                              NULL,
+                              program,
+                              program,
+                              args[0],
+                              NULL);
+  GNUNET_free(program);
   if (NULL == p)
-    GNUNET_SCHEDULER_cancel (rt);
+    GNUNET_SCHEDULER_cancel(rt);
 }
 
 
@@ -135,17 +135,17 @@ run (void *cls,
  * respective handler by writing to the trigger pipe.
  */
 static void
-sighandler_child_death ()
+sighandler_child_death()
 {
   static char c;
   int old_errno = errno; /* back-up errno */
 
-  GNUNET_break (
+  GNUNET_break(
     1 ==
-    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe,
-                                                     GNUNET_DISK_PIPE_END_WRITE),
-                            &c,
-                            sizeof (c)));
+    GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe,
+                                                   GNUNET_DISK_PIPE_END_WRITE),
+                           &c,
+                           sizeof(c)));
   errno = old_errno; /* restore errno */
 }
 
@@ -158,32 +158,33 @@ sighandler_child_death ()
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END};
+    GNUNET_GETOPT_OPTION_END
+  };
   struct GNUNET_SIGNAL_Context *shc_chld;
   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;
-  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
-  GNUNET_assert (sigpipe != NULL);
+  sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
+  GNUNET_assert(sigpipe != NULL);
   shc_chld =
-    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
-  ret = GNUNET_PROGRAM_run (argc,
-                            argv,
-                            "gnunet-uri URI",
-                            gettext_noop (
-                              "Perform default-actions for GNUnet URIs"),
-                            options,
-                            &run,
-                            NULL);
-  GNUNET_SIGNAL_handler_uninstall (shc_chld);
+    GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death);
+  ret = GNUNET_PROGRAM_run(argc,
+                           argv,
+                           "gnunet-uri URI",
+                           gettext_noop(
+                             "Perform default-actions for GNUnet URIs"),
+                           options,
+                           &run,
+                           NULL);
+  GNUNET_SIGNAL_handler_uninstall(shc_chld);
   shc_chld = NULL;
-  GNUNET_DISK_pipe_close (sigpipe);
+  GNUNET_DISK_pipe_close(sigpipe);
   sigpipe = NULL;
-  GNUNET_free ((void *) argv);
+  GNUNET_free((void *)argv);
   return ((GNUNET_OK == ret) && (0 == exit_code)) ? 0 : 1;
 }
 
diff --git a/src/util/helper.c b/src/util/helper.c
index aa452d22b..f0892a485 100644
--- a/src/util/helper.c
+++ b/src/util/helper.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 util/helper.c
@@ -33,9 +33,7 @@
 /**
  * Entry in the queue of messages we need to transmit to the helper.
  */
-struct GNUNET_HELPER_SendHandle
-{
-
+struct GNUNET_HELPER_SendHandle {
   /**
    * This is an entry in a DLL.
    */
@@ -76,9 +74,7 @@ struct GNUNET_HELPER_SendHandle
 /**
  * The handle to a helper process.
  */
-struct GNUNET_HELPER_Handle
-{
-
+struct GNUNET_HELPER_Handle {
   /**
    * PipeHandle to receive data from the helper
    */
@@ -176,40 +172,40 @@ struct GNUNET_HELPER_Handle
  * @return #GNUNET_OK on success; #GNUNET_SYSERR on error
  */
 int
-GNUNET_HELPER_kill (struct GNUNET_HELPER_Handle *h, int soft_kill)
+GNUNET_HELPER_kill(struct GNUNET_HELPER_Handle *h, int soft_kill)
 {
   struct GNUNET_HELPER_SendHandle *sh;
   int ret;
 
   while (NULL != (sh = h->sh_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
-    if (NULL != sh->cont)
-      sh->cont (sh->cont_cls, GNUNET_NO);
-    GNUNET_free (sh);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(h->sh_head, h->sh_tail, sh);
+      if (NULL != sh->cont)
+        sh->cont(sh->cont_cls, GNUNET_NO);
+      GNUNET_free(sh);
+    }
   if (NULL != h->restart_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->restart_task);
-    h->restart_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->restart_task);
+      h->restart_task = NULL;
+    }
   if (NULL != h->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->read_task);
-    h->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->read_task);
+      h->read_task = NULL;
+    }
   if (NULL == h->helper_proc)
     return GNUNET_SYSERR;
   if (GNUNET_YES == soft_kill)
-  {
-    /* soft-kill only possible with pipes */
-    GNUNET_assert (NULL != h->helper_in);
-    ret = GNUNET_DISK_pipe_close (h->helper_in);
-    h->helper_in = NULL;
-    h->fh_to_helper = NULL;
-    return ret;
-  }
-  if (0 != GNUNET_OS_process_kill (h->helper_proc, GNUNET_TERM_SIG))
+    {
+      /* soft-kill only possible with pipes */
+      GNUNET_assert(NULL != h->helper_in);
+      ret = GNUNET_DISK_pipe_close(h->helper_in);
+      h->helper_in = NULL;
+      h->fh_to_helper = NULL;
+      return ret;
+    }
+  if (0 != GNUNET_OS_process_kill(h->helper_proc, GNUNET_TERM_SIG))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -224,50 +220,50 @@ GNUNET_HELPER_kill (struct GNUNET_HELPER_Handle *h, int soft_kill)
  * @return #GNUNET_OK on success; #GNUNET_SYSERR on error
  */
 int
-GNUNET_HELPER_wait (struct GNUNET_HELPER_Handle *h)
+GNUNET_HELPER_wait(struct GNUNET_HELPER_Handle *h)
 {
   struct GNUNET_HELPER_SendHandle *sh;
   int ret;
 
   ret = GNUNET_SYSERR;
   if (NULL != h->helper_proc)
-  {
-    ret = GNUNET_OS_process_wait (h->helper_proc);
-    GNUNET_OS_process_destroy (h->helper_proc);
-    h->helper_proc = NULL;
-  }
+    {
+      ret = GNUNET_OS_process_wait(h->helper_proc);
+      GNUNET_OS_process_destroy(h->helper_proc);
+      h->helper_proc = NULL;
+    }
   if (NULL != h->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->read_task);
-    h->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->read_task);
+      h->read_task = NULL;
+    }
   if (NULL != h->write_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->write_task);
-    h->write_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->write_task);
+      h->write_task = NULL;
+    }
   if (NULL != h->helper_in)
-  {
-    GNUNET_DISK_pipe_close (h->helper_in);
-    h->helper_in = NULL;
-    h->fh_to_helper = NULL;
-  }
+    {
+      GNUNET_DISK_pipe_close(h->helper_in);
+      h->helper_in = NULL;
+      h->fh_to_helper = NULL;
+    }
   if (NULL != h->helper_out)
-  {
-    GNUNET_DISK_pipe_close (h->helper_out);
-    h->helper_out = NULL;
-    h->fh_from_helper = NULL;
-  }
+    {
+      GNUNET_DISK_pipe_close(h->helper_out);
+      h->helper_out = NULL;
+      h->fh_from_helper = NULL;
+    }
   while (NULL != (sh = h->sh_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
-    if (NULL != sh->cont)
-      sh->cont (sh->cont_cls, GNUNET_NO);
-    GNUNET_free (sh);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(h->sh_head, h->sh_tail, sh);
+      if (NULL != sh->cont)
+        sh->cont(sh->cont_cls, GNUNET_NO);
+      GNUNET_free(sh);
+    }
   /* purge MST buffer */
   if (NULL != h->mst)
-    (void) GNUNET_MST_from_buffer (h->mst, NULL, 0, GNUNET_YES, GNUNET_NO);
+    (void)GNUNET_MST_from_buffer(h->mst, NULL, 0, GNUNET_YES, GNUNET_NO);
   return ret;
 }
 
@@ -280,18 +276,18 @@ GNUNET_HELPER_wait (struct GNUNET_HELPER_Handle *h)
  *          stdin; #GNUNET_NO to signal termination by sending SIGTERM to helper
  */
 static void
-stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
+stop_helper(struct GNUNET_HELPER_Handle *h, int soft_kill)
 {
   if (NULL != h->restart_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->restart_task);
-    h->restart_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->restart_task);
+      h->restart_task = NULL;
+    }
   else
-  {
-    GNUNET_break (GNUNET_OK == GNUNET_HELPER_kill (h, soft_kill));
-    GNUNET_break (GNUNET_OK == GNUNET_HELPER_wait (h));
-  }
+    {
+      GNUNET_break(GNUNET_OK == GNUNET_HELPER_kill(h, soft_kill));
+      GNUNET_break(GNUNET_OK == GNUNET_HELPER_wait(h));
+    }
 }
 
 
@@ -301,7 +297,7 @@ stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
  * @param cls handle to the helper process
  */
 static void
-restart_task (void *cls);
+restart_task(void *cls);
 
 
 /**
@@ -310,87 +306,87 @@ restart_task (void *cls);
  * @param cls handle to the helper process
  */
 static void
-helper_read (void *cls)
+helper_read(void *cls)
 {
   struct GNUNET_HELPER_Handle *h = cls;
   char buf[GNUNET_MAX_MESSAGE_SIZE] GNUNET_ALIGN;
   ssize_t t;
 
   h->read_task = NULL;
-  t = GNUNET_DISK_file_read (h->fh_from_helper, &buf, sizeof (buf));
+  t = GNUNET_DISK_file_read(h->fh_from_helper, &buf, sizeof(buf));
   if (t < 0)
-  {
-    /* On read-error, restart the helper */
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Error reading from `%s': %s\n"),
-                h->binary_name,
-                strerror (errno));
-    if (NULL != h->exp_cb)
     {
-      h->exp_cb (h->cb_cls);
-      GNUNET_HELPER_stop (h, GNUNET_NO);
+      /* On read-error, restart the helper */
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Error reading from `%s': %s\n"),
+                 h->binary_name,
+                 strerror(errno));
+      if (NULL != h->exp_cb)
+        {
+          h->exp_cb(h->cb_cls);
+          GNUNET_HELPER_stop(h, GNUNET_NO);
+          return;
+        }
+      stop_helper(h, GNUNET_NO);
+      /* Restart the helper */
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
       return;
     }
-    stop_helper (h, GNUNET_NO);
-    /* Restart the helper */
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
   if (0 == t)
-  {
-    /* this happens if the helper is shut down via a
-       signal, so it is not a "hard" error */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Got 0 bytes from helper `%s' (EOF)\n",
-                h->binary_name);
-    if (NULL != h->exp_cb)
     {
-      h->exp_cb (h->cb_cls);
-      GNUNET_HELPER_stop (h, GNUNET_NO);
+      /* this happens if the helper is shut down via a
+         signal, so it is not a "hard" error */
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Got 0 bytes from helper `%s' (EOF)\n",
+                 h->binary_name);
+      if (NULL != h->exp_cb)
+        {
+          h->exp_cb(h->cb_cls);
+          GNUNET_HELPER_stop(h, GNUNET_NO);
+          return;
+        }
+      stop_helper(h, GNUNET_NO);
+      /* Restart the helper */
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
       return;
     }
-    stop_helper (h, GNUNET_NO);
-    /* Restart the helper */
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got %u bytes from helper `%s'\n",
-              (unsigned int) t,
-              h->binary_name);
-  h->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 h->fh_from_helper,
-                                                 &helper_read,
-                                                 h);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Got %u bytes from helper `%s'\n",
+             (unsigned int)t,
+             h->binary_name);
+  h->read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                h->fh_from_helper,
+                                                &helper_read,
+                                                h);
   if (GNUNET_SYSERR ==
-      GNUNET_MST_from_buffer (h->mst, buf, t, GNUNET_NO, GNUNET_NO))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Failed to parse inbound message from helper `%s'\n"),
-                h->binary_name);
-    if (NULL != h->exp_cb)
+      GNUNET_MST_from_buffer(h->mst, buf, t, GNUNET_NO, GNUNET_NO))
     {
-      h->exp_cb (h->cb_cls);
-      GNUNET_HELPER_stop (h, GNUNET_NO);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Failed to parse inbound message from helper `%s'\n"),
+                 h->binary_name);
+      if (NULL != h->exp_cb)
+        {
+          h->exp_cb(h->cb_cls);
+          GNUNET_HELPER_stop(h, GNUNET_NO);
+          return;
+        }
+      stop_helper(h, GNUNET_NO);
+      /* Restart the helper */
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
       return;
     }
-    stop_helper (h, GNUNET_NO);
-    /* Restart the helper */
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
 }
 
 
@@ -400,55 +396,55 @@ helper_read (void *cls)
  * @param h handle to the helper process
  */
 static void
-start_helper (struct GNUNET_HELPER_Handle *h)
+start_helper(struct GNUNET_HELPER_Handle *h)
 {
   h->helper_in =
-    GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
+    GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
   h->helper_out =
-    GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+    GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if ((h->helper_in == NULL) || (h->helper_out == NULL))
-  {
-    /* out of file descriptors? try again later... */
-    stop_helper (h, GNUNET_NO);
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting HELPER process `%s'\n",
-              h->binary_name);
+    {
+      /* out of file descriptors? try again later... */
+      stop_helper(h, GNUNET_NO);
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting HELPER process `%s'\n",
+             h->binary_name);
   h->fh_from_helper =
-    GNUNET_DISK_pipe_handle (h->helper_out, GNUNET_DISK_PIPE_END_READ);
+    GNUNET_DISK_pipe_handle(h->helper_out, GNUNET_DISK_PIPE_END_READ);
   h->fh_to_helper =
-    GNUNET_DISK_pipe_handle (h->helper_in, GNUNET_DISK_PIPE_END_WRITE);
-  h->helper_proc = GNUNET_OS_start_process_vap (h->with_control_pipe,
-                                                GNUNET_OS_INHERIT_STD_ERR,
-                                                h->helper_in,
-                                                h->helper_out,
-                                                NULL,
-                                                h->binary_name,
-                                                h->binary_argv);
+    GNUNET_DISK_pipe_handle(h->helper_in, GNUNET_DISK_PIPE_END_WRITE);
+  h->helper_proc = GNUNET_OS_start_process_vap(h->with_control_pipe,
+                                               GNUNET_OS_INHERIT_STD_ERR,
+                                               h->helper_in,
+                                               h->helper_out,
+                                               NULL,
+                                               h->binary_name,
+                                               h->binary_argv);
   if (NULL == h->helper_proc)
-  {
-    /* failed to start process? try again later... */
-    stop_helper (h, GNUNET_NO);
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
-  GNUNET_DISK_pipe_close_end (h->helper_out, GNUNET_DISK_PIPE_END_WRITE);
-  GNUNET_DISK_pipe_close_end (h->helper_in, GNUNET_DISK_PIPE_END_READ);
+    {
+      /* failed to start process? try again later... */
+      stop_helper(h, GNUNET_NO);
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
+      return;
+    }
+  GNUNET_DISK_pipe_close_end(h->helper_out, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_DISK_pipe_close_end(h->helper_in, GNUNET_DISK_PIPE_END_READ);
   if (NULL != h->mst)
-    h->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                   h->fh_from_helper,
-                                                   &helper_read,
-                                                   h);
+    h->read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  h->fh_from_helper,
+                                                  &helper_read,
+                                                  h);
 }
 
 
@@ -458,16 +454,16 @@ start_helper (struct GNUNET_HELPER_Handle *h)
  * @param cls handle to the helper process
  */
 static void
-restart_task (void *cls)
+restart_task(void *cls)
 {
   struct GNUNET_HELPER_Handle *h = cls;
 
   h->restart_task = NULL;
   h->retry_back_off++;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Restarting helper with back-off %u\n",
-              h->retry_back_off);
-  start_helper (h);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Restarting helper with back-off %u\n",
+             h->retry_back_off);
+  start_helper(h);
 }
 
 
@@ -488,35 +484,35 @@ restart_task (void *cls)
  * @return the new Handle, NULL on error
  */
 struct GNUNET_HELPER_Handle *
-GNUNET_HELPER_start (int with_control_pipe,
-                     const char *binary_name,
-                     char *const binary_argv[],
-                     GNUNET_MessageTokenizerCallback cb,
-                     GNUNET_HELPER_ExceptionCallback exp_cb,
-                     void *cb_cls)
+GNUNET_HELPER_start(int with_control_pipe,
+                    const char *binary_name,
+                    char *const binary_argv[],
+                    GNUNET_MessageTokenizerCallback cb,
+                    GNUNET_HELPER_ExceptionCallback exp_cb,
+                    void *cb_cls)
 {
   struct GNUNET_HELPER_Handle *h;
   unsigned int c;
 
-  h = GNUNET_new (struct GNUNET_HELPER_Handle);
+  h = GNUNET_new(struct GNUNET_HELPER_Handle);
   h->with_control_pipe = with_control_pipe;
   /* Lookup in libexec path only if we are starting gnunet helpers */
-  if (NULL != strstr (binary_name, "gnunet"))
-    h->binary_name = GNUNET_OS_get_libexec_binary_path (binary_name);
+  if (NULL != strstr(binary_name, "gnunet"))
+    h->binary_name = GNUNET_OS_get_libexec_binary_path(binary_name);
   else
-    h->binary_name = GNUNET_strdup (binary_name);
+    h->binary_name = GNUNET_strdup(binary_name);
   for (c = 0; NULL != binary_argv[c]; c++)
     ;
-  h->binary_argv = GNUNET_malloc (sizeof (char *) * (c + 1));
+  h->binary_argv = GNUNET_malloc(sizeof(char *) * (c + 1));
   for (c = 0; NULL != binary_argv[c]; c++)
-    h->binary_argv[c] = GNUNET_strdup (binary_argv[c]);
+    h->binary_argv[c] = GNUNET_strdup(binary_argv[c]);
   h->binary_argv[c] = NULL;
   h->cb_cls = cb_cls;
   if (NULL != cb)
-    h->mst = GNUNET_MST_create (cb, h->cb_cls);
+    h->mst = GNUNET_MST_create(cb, h->cb_cls);
   h->exp_cb = exp_cb;
   h->retry_back_off = 0;
-  start_helper (h);
+  start_helper(h);
   return h;
 }
 
@@ -527,32 +523,32 @@ GNUNET_HELPER_start (int with_control_pipe,
  * @param h the helper handle to free
  */
 void
-GNUNET_HELPER_destroy (struct GNUNET_HELPER_Handle *h)
+GNUNET_HELPER_destroy(struct GNUNET_HELPER_Handle *h)
 {
   unsigned int c;
   struct GNUNET_HELPER_SendHandle *sh;
 
   if (NULL != h->write_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->write_task);
-    h->write_task = NULL;
-  }
-  GNUNET_assert (NULL == h->read_task);
-  GNUNET_assert (NULL == h->restart_task);
+    {
+      GNUNET_SCHEDULER_cancel(h->write_task);
+      h->write_task = NULL;
+    }
+  GNUNET_assert(NULL == h->read_task);
+  GNUNET_assert(NULL == h->restart_task);
   while (NULL != (sh = h->sh_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
-    if (NULL != sh->cont)
-      sh->cont (sh->cont_cls, GNUNET_SYSERR);
-    GNUNET_free (sh);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(h->sh_head, h->sh_tail, sh);
+      if (NULL != sh->cont)
+        sh->cont(sh->cont_cls, GNUNET_SYSERR);
+      GNUNET_free(sh);
+    }
   if (NULL != h->mst)
-    GNUNET_MST_destroy (h->mst);
-  GNUNET_free (h->binary_name);
+    GNUNET_MST_destroy(h->mst);
+  GNUNET_free(h->binary_name);
   for (c = 0; h->binary_argv[c] != NULL; c++)
-    GNUNET_free (h->binary_argv[c]);
-  GNUNET_free (h->binary_argv);
-  GNUNET_free (h);
+    GNUNET_free(h->binary_argv[c]);
+  GNUNET_free(h->binary_argv);
+  GNUNET_free(h);
 }
 
 
@@ -564,11 +560,11 @@ GNUNET_HELPER_destroy (struct GNUNET_HELPER_Handle *h)
  *          stdin; #GNUNET_NO to signal termination by sending SIGTERM to helper
  */
 void
-GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h, int soft_kill)
+GNUNET_HELPER_stop(struct GNUNET_HELPER_Handle *h, int soft_kill)
 {
   h->exp_cb = NULL;
-  stop_helper (h, soft_kill);
-  GNUNET_HELPER_destroy (h);
+  stop_helper(h, soft_kill);
+  GNUNET_HELPER_destroy(h);
 }
 
 
@@ -578,7 +574,7 @@ GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h, int soft_kill)
  * @param cls handle to the helper process
  */
 static void
-helper_write (void *cls)
+helper_write(void *cls)
 {
   struct GNUNET_HELPER_Handle *h = cls;
   struct GNUNET_HELPER_SendHandle *sh;
@@ -587,56 +583,56 @@ helper_write (void *cls)
 
   h->write_task = NULL;
   if (NULL == (sh = h->sh_head))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Helper write had no work!\n");
-    return; /* how did this happen? */
-  }
-  buf = (const char *) sh->msg;
-  t = GNUNET_DISK_file_write (h->fh_to_helper,
-                              &buf[sh->wpos],
-                              ntohs (sh->msg->size) - sh->wpos);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Helper write had no work!\n");
+      return; /* how did this happen? */
+    }
+  buf = (const char *)sh->msg;
+  t = GNUNET_DISK_file_write(h->fh_to_helper,
+                             &buf[sh->wpos],
+                             ntohs(sh->msg->size) - sh->wpos);
   if (-1 == t)
-  {
-    /* On write-error, restart the helper */
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Error writing to `%s': %s\n"),
-                h->binary_name,
-                strerror (errno));
-    if (NULL != h->exp_cb)
     {
-      h->exp_cb (h->cb_cls);
-      GNUNET_HELPER_stop (h, GNUNET_NO);
+      /* On write-error, restart the helper */
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Error writing to `%s': %s\n"),
+                 h->binary_name,
+                 strerror(errno));
+      if (NULL != h->exp_cb)
+        {
+          h->exp_cb(h->cb_cls);
+          GNUNET_HELPER_stop(h, GNUNET_NO);
+          return;
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Stopping and restarting helper task!\n");
+      stop_helper(h, GNUNET_NO);
+      /* Restart the helper */
+      h->restart_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                      h->retry_back_off),
+        &restart_task,
+        h);
       return;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Stopping and restarting helper task!\n");
-    stop_helper (h, GNUNET_NO);
-    /* Restart the helper */
-    h->restart_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                     h->retry_back_off),
-      &restart_task,
-      h);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitted %u bytes to %s\n",
-              (unsigned int) t,
-              h->binary_name);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Transmitted %u bytes to %s\n",
+             (unsigned int)t,
+             h->binary_name);
   sh->wpos += t;
-  if (sh->wpos == ntohs (sh->msg->size))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
-    if (NULL != sh->cont)
-      sh->cont (sh->cont_cls, GNUNET_YES);
-    GNUNET_free (sh);
-  }
+  if (sh->wpos == ntohs(sh->msg->size))
+    {
+      GNUNET_CONTAINER_DLL_remove(h->sh_head, h->sh_tail, sh);
+      if (NULL != sh->cont)
+        sh->cont(sh->cont_cls, GNUNET_YES);
+      GNUNET_free(sh);
+    }
   if (NULL != h->sh_head)
     h->write_task =
-      GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                       h->fh_to_helper,
-                                       &helper_write,
-                                       h);
+      GNUNET_SCHEDULER_add_write_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                      h->fh_to_helper,
+                                      &helper_write,
+                                      h);
 }
 
 
@@ -654,11 +650,11 @@ helper_write (void *cls)
  *         not be abortable)
  */
 struct GNUNET_HELPER_SendHandle *
-GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h,
-                    const struct GNUNET_MessageHeader *msg,
-                    int can_drop,
-                    GNUNET_HELPER_Continuation cont,
-                    void *cont_cls)
+GNUNET_HELPER_send(struct GNUNET_HELPER_Handle *h,
+                   const struct GNUNET_MessageHeader *msg,
+                   int can_drop,
+                   GNUNET_HELPER_Continuation cont,
+                   void *cont_cls)
 {
   struct GNUNET_HELPER_SendHandle *sh;
   uint16_t mlen;
@@ -667,20 +663,20 @@ GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h,
     return NULL;
   if ((GNUNET_YES == can_drop) && (NULL != h->sh_head))
     return NULL;
-  mlen = ntohs (msg->size);
-  sh = GNUNET_malloc (sizeof (struct GNUNET_HELPER_SendHandle) + mlen);
-  sh->msg = (const struct GNUNET_MessageHeader *) &sh[1];
-  GNUNET_memcpy (&sh[1], msg, mlen);
+  mlen = ntohs(msg->size);
+  sh = GNUNET_malloc(sizeof(struct GNUNET_HELPER_SendHandle) + mlen);
+  sh->msg = (const struct GNUNET_MessageHeader *)&sh[1];
+  GNUNET_memcpy(&sh[1], msg, mlen);
   sh->h = h;
   sh->cont = cont;
   sh->cont_cls = cont_cls;
-  GNUNET_CONTAINER_DLL_insert_tail (h->sh_head, h->sh_tail, sh);
+  GNUNET_CONTAINER_DLL_insert_tail(h->sh_head, h->sh_tail, sh);
   if (NULL == h->write_task)
     h->write_task =
-      GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                       h->fh_to_helper,
-                                       &helper_write,
-                                       h);
+      GNUNET_SCHEDULER_add_write_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                      h->fh_to_helper,
+                                      &helper_write,
+                                      h);
 
   return sh;
 }
@@ -693,22 +689,22 @@ GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h,
  * @param sh operation to cancel
  */
 void
-GNUNET_HELPER_send_cancel (struct GNUNET_HELPER_SendHandle *sh)
+GNUNET_HELPER_send_cancel(struct GNUNET_HELPER_SendHandle *sh)
 {
   struct GNUNET_HELPER_Handle *h = sh->h;
 
   sh->cont = NULL;
   sh->cont_cls = NULL;
   if (0 == sh->wpos)
-  {
-    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
-    GNUNET_free (sh);
-    if (NULL == h->sh_head)
     {
-      GNUNET_SCHEDULER_cancel (h->write_task);
-      h->write_task = NULL;
+      GNUNET_CONTAINER_DLL_remove(h->sh_head, h->sh_tail, sh);
+      GNUNET_free(sh);
+      if (NULL == h->sh_head)
+        {
+          GNUNET_SCHEDULER_cancel(h->write_task);
+          h->write_task = NULL;
+        }
     }
-  }
 }
 
 
diff --git a/src/util/load.c b/src/util/load.c
index f5ea875bb..5c4d9d37b 100644
--- a/src/util/load.c
+++ b/src/util/load.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 util/load.c
@@ -27,14 +27,12 @@
 #include "gnunet_util_lib.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-load", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-load", __VA_ARGS__)
 
 /**
  * Values we track for load calculations.
  */
-struct GNUNET_LOAD_Value
-{
-
+struct GNUNET_LOAD_Value {
   /**
    * How fast should the load decline if no values are added?
    */
@@ -77,39 +75,38 @@ struct GNUNET_LOAD_Value
    * load is so high that we currently cannot calculate it.
    */
   double load;
-
 };
 
 
 static void
-internal_update (struct GNUNET_LOAD_Value *load)
+internal_update(struct GNUNET_LOAD_Value *load)
 {
   struct GNUNET_TIME_Relative delta;
   unsigned int n;
 
   if (load->autodecline.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     return;
-  delta = GNUNET_TIME_absolute_get_duration (load->last_update);
+  delta = GNUNET_TIME_absolute_get_duration(load->last_update);
   if (delta.rel_value_us < load->autodecline.rel_value_us)
     return;
   if (0 == load->autodecline.rel_value_us)
-  {
-    load->runavg_delay = 0.0;
-    load->load = 0;
-    return;
-  }
+    {
+      load->runavg_delay = 0.0;
+      load->load = 0;
+      return;
+    }
   n = delta.rel_value_us / load->autodecline.rel_value_us;
   if (n > 16)
-  {
-    load->runavg_delay = 0.0;
-    load->load = 0;
-    return;
-  }
+    {
+      load->runavg_delay = 0.0;
+      load->load = 0;
+      return;
+    }
   while (n > 0)
-  {
-    n--;
-    load->runavg_delay = (load->runavg_delay * 7.0) / 8.0;
-  }
+    {
+      n--;
+      load->runavg_delay = (load->runavg_delay * 7.0) / 8.0;
+    }
 }
 
 
@@ -122,13 +119,13 @@ internal_update (struct GNUNET_LOAD_Value *load)
  * @return the new load value
  */
 struct GNUNET_LOAD_Value *
-GNUNET_LOAD_value_init (struct GNUNET_TIME_Relative autodecline)
+GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
 {
   struct GNUNET_LOAD_Value *ret;
 
-  ret = GNUNET_new (struct GNUNET_LOAD_Value);
+  ret = GNUNET_new(struct GNUNET_LOAD_Value);
   ret->autodecline = autodecline;
-  ret->last_update = GNUNET_TIME_absolute_get ();
+  ret->last_update = GNUNET_TIME_absolute_get();
   return ret;
 }
 
@@ -140,10 +137,10 @@ GNUNET_LOAD_value_init (struct GNUNET_TIME_Relative autodecline)
  * @param autodecline frequency of load decline
  */
 void
-GNUNET_LOAD_value_set_decline (struct GNUNET_LOAD_Value *load,
-                               struct GNUNET_TIME_Relative autodecline)
+GNUNET_LOAD_value_set_decline(struct GNUNET_LOAD_Value *load,
+                              struct GNUNET_TIME_Relative autodecline)
 {
-  internal_update (load);
+  internal_update(load);
   load->autodecline = autodecline;
 }
 
@@ -154,7 +151,7 @@ GNUNET_LOAD_value_set_decline (struct GNUNET_LOAD_Value *load,
  * @param load load to update
  */
 static void
-calculate_load (struct GNUNET_LOAD_Value *load)
+calculate_load(struct GNUNET_LOAD_Value *load)
 {
   double stddev;
   double avgdel;
@@ -171,13 +168,13 @@ calculate_load (struct GNUNET_LOAD_Value *load)
    * = (sum (val_i^2 - 2 avg val_i + avg^2) / (n-1)
    * = (sum (val_i^2) - 2 avg sum (val_i) + n * avg^2) / (n-1)
    */
-  sum_val_i = (double) load->cummulative_delay;
-  n = ((double) load->cummulative_request_count);
+  sum_val_i = (double)load->cummulative_delay;
+  n = ((double)load->cummulative_request_count);
   nm1 = n - 1.0;
   avgdel = sum_val_i / n;
   stddev =
-      (((double) load->cummulative_squared_delay) - 2.0 * avgdel * sum_val_i +
-       n * avgdel * avgdel) / nm1;
+    (((double)load->cummulative_squared_delay) - 2.0 * avgdel * sum_val_i +
+     n * avgdel * avgdel) / nm1;
   if (stddev <= 0)
     stddev = 0.01;              /* must have been rounding error or zero; prevent division by zero */
   /* now calculate load based on how far out we are from
@@ -199,10 +196,10 @@ calculate_load (struct GNUNET_LOAD_Value *load)
  *         that we could not do proper calculations
  */
 double
-GNUNET_LOAD_get_load (struct GNUNET_LOAD_Value *load)
+GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
 {
-  internal_update (load);
-  calculate_load (load);
+  internal_update(load);
+  calculate_load(load);
   return load->load;
 }
 
@@ -214,16 +211,16 @@ GNUNET_LOAD_get_load (struct GNUNET_LOAD_Value *load)
  * @return zero if update was never called
  */
 double
-GNUNET_LOAD_get_average (struct GNUNET_LOAD_Value *load)
+GNUNET_LOAD_get_average(struct GNUNET_LOAD_Value *load)
 {
   double n;
   double sum_val_i;
 
-  internal_update (load);
+  internal_update(load);
   if (load->cummulative_request_count == 0)
     return 0.0;
-  n = ((double) load->cummulative_request_count);
-  sum_val_i = (double) load->cummulative_delay;
+  n = ((double)load->cummulative_request_count);
+  sum_val_i = (double)load->cummulative_delay;
   return sum_val_i / n;
 }
 
@@ -235,19 +232,19 @@ GNUNET_LOAD_get_average (struct GNUNET_LOAD_Value *load)
  * @param data latest measurement value (for example, delay)
  */
 void
-GNUNET_LOAD_update (struct GNUNET_LOAD_Value *load, uint64_t data)
+GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
 {
   uint32_t dv;
 
-  internal_update (load);
-  load->last_update = GNUNET_TIME_absolute_get ();
+  internal_update(load);
+  load->last_update = GNUNET_TIME_absolute_get();
   if (data > 64 * 1024)
-  {
-    /* very large */
-    load->load = 100.0;
-    return;
-  }
-  dv = (uint32_t) data;
+    {
+      /* very large */
+      load->load = 100.0;
+      return;
+    }
+  dv = (uint32_t)data;
   load->cummulative_delay += dv;
   load->cummulative_squared_delay += dv * dv;
   load->cummulative_request_count++;
diff --git a/src/util/mq.c b/src/util/mq.c
index 03b0f3a2a..188606fb4 100644
--- a/src/util/mq.c
+++ b/src/util/mq.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 Florian Dold
@@ -26,11 +26,10 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-mq", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-mq", __VA_ARGS__)
 
 
-struct GNUNET_MQ_Envelope
-{
+struct GNUNET_MQ_Envelope {
   /**
    * Messages are stored in a linked list.
    * Each queue has its own list of envelopes.
@@ -82,8 +81,7 @@ struct GNUNET_MQ_Envelope
 /**
  * Handle to a message queue.
  */
-struct GNUNET_MQ_Handle
-{
+struct GNUNET_MQ_Handle {
   /**
    * Handlers array, or NULL if the queue should not receive messages
    */
@@ -199,17 +197,17 @@ struct GNUNET_MQ_Handle
  * @param mh message to dispatch
  */
 void
-GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq,
-                          const struct GNUNET_MessageHeader *mh)
+GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq,
+                         const struct GNUNET_MessageHeader *mh)
 {
   int ret;
 
-  ret = GNUNET_MQ_handle_message (mq->handlers, mh);
+  ret = GNUNET_MQ_handle_message(mq->handlers, mh);
   if (GNUNET_SYSERR == ret)
-  {
-    GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_MALFORMED);
-    return;
-  }
+    {
+      GNUNET_MQ_inject_error(mq, GNUNET_MQ_ERROR_MALFORMED);
+      return;
+    }
 }
 
 
@@ -226,62 +224,62 @@ GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq,
  *         #GNUNET_SYSERR if message was rejected by check function
  */
 int
-GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers,
-                          const struct GNUNET_MessageHeader *mh)
+GNUNET_MQ_handle_message(const struct GNUNET_MQ_MessageHandler *handlers,
+                         const struct GNUNET_MessageHeader *mh)
 {
   const struct GNUNET_MQ_MessageHandler *handler;
   int handled = GNUNET_NO;
-  uint16_t msize = ntohs (mh->size);
-  uint16_t mtype = ntohs (mh->type);
+  uint16_t msize = ntohs(mh->size);
+  uint16_t mtype = ntohs(mh->type);
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received message of type %u and size %u\n",
-       mtype,
-       msize);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received message of type %u and size %u\n",
+      mtype,
+      msize);
 
   if (NULL == handlers)
     goto done;
   for (handler = handlers; NULL != handler->cb; handler++)
-  {
-    if (handler->type == mtype)
     {
-      handled = GNUNET_YES;
-      if ((handler->expected_size > msize) ||
-          ((handler->expected_size != msize) && (NULL == handler->mv)))
-      {
-        /* Too small, or not an exact size and
-           no 'mv' handler to check rest */
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             "Received malformed message of type %u\n",
-             (unsigned int) handler->type);
-        return GNUNET_SYSERR;
-      }
-      if ((NULL == handler->mv) ||
-          (GNUNET_OK == handler->mv (handler->cls, mh)))
-      {
-        /* message well-formed, pass to handler */
-        handler->cb (handler->cls, mh);
-      }
-      else
-      {
-        /* Message rejected by check routine */
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             "Received malformed message of type %u\n",
-             (unsigned int) handler->type);
-        return GNUNET_SYSERR;
-      }
-      break;
+      if (handler->type == mtype)
+        {
+          handled = GNUNET_YES;
+          if ((handler->expected_size > msize) ||
+              ((handler->expected_size != msize) && (NULL == handler->mv)))
+            {
+              /* Too small, or not an exact size and
+                 no 'mv' handler to check rest */
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  "Received malformed message of type %u\n",
+                  (unsigned int)handler->type);
+              return GNUNET_SYSERR;
+            }
+          if ((NULL == handler->mv) ||
+              (GNUNET_OK == handler->mv(handler->cls, mh)))
+            {
+              /* message well-formed, pass to handler */
+              handler->cb(handler->cls, mh);
+            }
+          else
+            {
+              /* Message rejected by check routine */
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  "Received malformed message of type %u\n",
+                  (unsigned int)handler->type);
+              return GNUNET_SYSERR;
+            }
+          break;
+        }
     }
-  }
 done:
   if (GNUNET_NO == handled)
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         "No handler for message of type %u and size %u\n",
-         mtype,
-         msize);
-    return GNUNET_NO;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          "No handler for message of type %u and size %u\n",
+          mtype,
+          msize);
+      return GNUNET_NO;
+    }
   return GNUNET_OK;
 }
 
@@ -297,16 +295,16 @@ done:
  * @param error the error type
  */
 void
-GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
+GNUNET_MQ_inject_error(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
 {
   if (NULL == mq->error_handler)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Got error %d, but no handler installed\n",
-         (int) error);
-    return;
-  }
-  mq->error_handler (mq->error_handler_cls, error);
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Got error %d, but no handler installed\n",
+          (int)error);
+      return;
+    }
+  mq->error_handler(mq->error_handler_cls, error);
 }
 
 
@@ -318,10 +316,10 @@ GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
  * @param mqm the message to discard
  */
 void
-GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *ev)
 {
-  GNUNET_assert (NULL == ev->parent_queue);
-  GNUNET_free (ev);
+  GNUNET_assert(NULL == ev->parent_queue);
+  GNUNET_free(ev);
 }
 
 
@@ -332,12 +330,12 @@ GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *ev)
  * @return number of queued, non-transmitted messages
  */
 unsigned int
-GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
 {
   if (GNUNET_YES != mq->in_flight)
-  {
-    return mq->queue_length;
-  }
+    {
+      return mq->queue_length;
+    }
   return mq->queue_length - 1;
 }
 
@@ -350,36 +348,36 @@ GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)
  * @param ev the envelope with the message to send.
  */
 void
-GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
 {
-  GNUNET_assert (NULL != mq);
-  GNUNET_assert (NULL == ev->parent_queue);
+  GNUNET_assert(NULL != mq);
+  GNUNET_assert(NULL == ev->parent_queue);
 
   mq->queue_length++;
   if (mq->queue_length >= 10000)
-  {
-    /* This would seem like a bug... */
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "MQ with %u entries extended by message of type %u (FC broken?)\n",
-                (unsigned int) mq->queue_length,
-                (unsigned int) ntohs (ev->mh->type));
-  }
+    {
+      /* This would seem like a bug... */
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "MQ with %u entries extended by message of type %u (FC broken?)\n",
+                 (unsigned int)mq->queue_length,
+                 (unsigned int)ntohs(ev->mh->type));
+    }
   ev->parent_queue = mq;
   /* is the implementation busy? queue it! */
   if ((NULL != mq->current_envelope) || (NULL != mq->send_task))
-  {
-    GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, mq->envelope_tail, ev);
-    return;
-  }
-  GNUNET_assert (NULL == mq->envelope_head);
+    {
+      GNUNET_CONTAINER_DLL_insert_tail(mq->envelope_head, mq->envelope_tail, ev);
+      return;
+    }
+  GNUNET_assert(NULL == mq->envelope_head);
   mq->current_envelope = ev;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "sending message of type %u, queue empty (MQ: %p)\n",
-       ntohs (ev->mh->type),
-       mq);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "sending message of type %u, queue empty (MQ: %p)\n",
+      ntohs(ev->mh->type),
+      mq);
 
-  mq->send_impl (mq, ev->mh, mq->impl_state);
+  mq->send_impl(mq, ev->mh, mq->impl_state);
 }
 
 
@@ -391,12 +389,12 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
  * @return NULL if queue is empty (or has no envelope that is not under transmission)
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_unsent_head(struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *env;
 
   env = mq->envelope_head;
-  GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, env);
+  GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, env);
   mq->queue_length--;
   env->parent_queue = NULL;
   return env;
@@ -411,13 +409,13 @@ GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq)
  * @return copy of @a env
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_env_copy (struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_copy(struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_assert (NULL == env->next);
-  GNUNET_assert (NULL == env->parent_queue);
-  GNUNET_assert (NULL == env->sent_cb);
-  GNUNET_assert (GNUNET_NO == env->have_custom_options);
-  return GNUNET_MQ_msg_copy (env->mh);
+  GNUNET_assert(NULL == env->next);
+  GNUNET_assert(NULL == env->parent_queue);
+  GNUNET_assert(NULL == env->sent_cb);
+  GNUNET_assert(GNUNET_NO == env->have_custom_options);
+  return GNUNET_MQ_msg_copy(env->mh);
 }
 
 
@@ -429,19 +427,19 @@ GNUNET_MQ_env_copy (struct GNUNET_MQ_Envelope *env)
  * @param ev the envelope with the message to send.
  */
 void
-GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq,
-                     const struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send_copy(struct GNUNET_MQ_Handle *mq,
+                    const struct GNUNET_MQ_Envelope *ev)
 {
   struct GNUNET_MQ_Envelope *env;
   uint16_t msize;
 
-  msize = ntohs (ev->mh->size);
-  env = GNUNET_malloc (sizeof (struct GNUNET_MQ_Envelope) + msize);
-  env->mh = (struct GNUNET_MessageHeader *) &env[1];
+  msize = ntohs(ev->mh->size);
+  env = GNUNET_malloc(sizeof(struct GNUNET_MQ_Envelope) + msize);
+  env->mh = (struct GNUNET_MessageHeader *)&env[1];
   env->sent_cb = ev->sent_cb;
   env->sent_cls = ev->sent_cls;
-  GNUNET_memcpy (&env[1], ev->mh, msize);
-  GNUNET_MQ_send (mq, env);
+  GNUNET_memcpy(&env[1], ev->mh, msize);
+  GNUNET_MQ_send(mq, env);
 }
 
 
@@ -453,7 +451,7 @@ GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq,
  * @param cls message queue to send the next message with
  */
 static void
-impl_send_continue (void *cls)
+impl_send_continue(void *cls)
 {
   struct GNUNET_MQ_Handle *mq = cls;
 
@@ -463,15 +461,15 @@ impl_send_continue (void *cls)
   if (NULL == mq->envelope_head)
     return;
   mq->current_envelope = mq->envelope_head;
-  GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
-                               mq->envelope_tail,
-                               mq->current_envelope);
+  GNUNET_CONTAINER_DLL_remove(mq->envelope_head,
+                              mq->envelope_tail,
+                              mq->current_envelope);
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "sending message of type %u from queue\n",
-       ntohs (mq->current_envelope->mh->type));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "sending message of type %u from queue\n",
+      ntohs(mq->current_envelope->mh->type));
 
-  mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
+  mq->send_impl(mq, mq->current_envelope->mh, mq->impl_state);
 }
 
 
@@ -483,25 +481,25 @@ impl_send_continue (void *cls)
  * @param mq message queue to send the next message with
  */
 void
-GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
 
-  GNUNET_assert (0 < mq->queue_length);
+  GNUNET_assert(0 < mq->queue_length);
   mq->queue_length--;
   mq->in_flight = GNUNET_NO;
   current_envelope = mq->current_envelope;
   current_envelope->parent_queue = NULL;
   mq->current_envelope = NULL;
-  GNUNET_assert (NULL == mq->send_task);
-  mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, mq);
+  GNUNET_assert(NULL == mq->send_task);
+  mq->send_task = GNUNET_SCHEDULER_add_now(&impl_send_continue, mq);
   if (NULL != (cb = current_envelope->sent_cb))
-  {
-    current_envelope->sent_cb = NULL;
-    cb (current_envelope->sent_cls);
-  }
-  GNUNET_free (current_envelope);
+    {
+      current_envelope->sent_cb = NULL;
+      cb(current_envelope->sent_cls);
+    }
+  GNUNET_free(current_envelope);
 }
 
 
@@ -516,7 +514,7 @@ GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
  * @param mq message queue to send the next message with
  */
 void
-GNUNET_MQ_impl_send_in_flight (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_send_in_flight(struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
@@ -525,14 +523,14 @@ GNUNET_MQ_impl_send_in_flight (struct GNUNET_MQ_Handle *mq)
   /* call is only valid if we're actually currently sending
    * a message */
   current_envelope = mq->current_envelope;
-  GNUNET_assert (NULL != current_envelope);
+  GNUNET_assert(NULL != current_envelope);
   /* can't call cancel from now on anymore */
   current_envelope->parent_queue = NULL;
   if (NULL != (cb = current_envelope->sent_cb))
-  {
-    current_envelope->sent_cb = NULL;
-    cb (current_envelope->sent_cls);
-  }
+    {
+      current_envelope->sent_cb = NULL;
+      cb(current_envelope->sent_cls);
+    }
 }
 
 
@@ -549,21 +547,21 @@ GNUNET_MQ_impl_send_in_flight (struct GNUNET_MQ_Handle *mq)
  * @return a new message queue
  */
 struct GNUNET_MQ_Handle *
-GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send,
-                               GNUNET_MQ_DestroyImpl destroy,
-                               GNUNET_MQ_CancelImpl cancel,
-                               void *impl_state,
-                               const struct GNUNET_MQ_MessageHandler *handlers,
-                               GNUNET_MQ_ErrorHandler error_handler,
-                               void *error_handler_cls)
+GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send,
+                              GNUNET_MQ_DestroyImpl destroy,
+                              GNUNET_MQ_CancelImpl cancel,
+                              void *impl_state,
+                              const struct GNUNET_MQ_MessageHandler *handlers,
+                              GNUNET_MQ_ErrorHandler error_handler,
+                              void *error_handler_cls)
 {
   struct GNUNET_MQ_Handle *mq;
 
-  mq = GNUNET_new (struct GNUNET_MQ_Handle);
+  mq = GNUNET_new(struct GNUNET_MQ_Handle);
   mq->send_impl = send;
   mq->destroy_impl = destroy;
   mq->cancel_impl = cancel;
-  mq->handlers = GNUNET_MQ_copy_handlers (handlers);
+  mq->handlers = GNUNET_MQ_copy_handlers(handlers);
   mq->error_handler = error_handler;
   mq->error_handler_cls = error_handler_cls;
   mq->impl_state = impl_state;
@@ -580,7 +578,7 @@ GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send,
  * @param handlers_cls new closure to use
  */
 void
-GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void *handlers_cls)
+GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
 {
   if (NULL == mq->handlers)
     return;
@@ -599,10 +597,10 @@ GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void *handlers_cls)
  * @return message to send, never NULL
  */
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_current(struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_assert (NULL != mq->current_envelope);
-  GNUNET_assert (NULL != mq->current_envelope->mh);
+  GNUNET_assert(NULL != mq->current_envelope);
+  GNUNET_assert(NULL != mq->current_envelope->mh);
   return mq->current_envelope->mh;
 }
 
@@ -622,21 +620,21 @@ GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq)
  * @return message to send, never NULL
  */
 void *
-GNUNET_MQ_impl_state (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_state(struct GNUNET_MQ_Handle *mq)
 {
   return mq->impl_state;
 }
 
 
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
+GNUNET_MQ_msg_(struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
 {
   struct GNUNET_MQ_Envelope *ev;
 
-  ev = GNUNET_malloc (size + sizeof (struct GNUNET_MQ_Envelope));
-  ev->mh = (struct GNUNET_MessageHeader *) &ev[1];
-  ev->mh->size = htons (size);
-  ev->mh->type = htons (type);
+  ev = GNUNET_malloc(size + sizeof(struct GNUNET_MQ_Envelope));
+  ev->mh = (struct GNUNET_MessageHeader *)&ev[1];
+  ev->mh->size = htons(size);
+  ev->mh->type = htons(type);
   if (NULL != mhp)
     *mhp = ev->mh;
   return ev;
@@ -650,14 +648,14 @@ GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
  * @return envelope containing @a hdr
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)
+GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
 {
   struct GNUNET_MQ_Envelope *mqm;
-  uint16_t size = ntohs (hdr->size);
+  uint16_t size = ntohs(hdr->size);
 
-  mqm = GNUNET_malloc (sizeof (*mqm) + size);
-  mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
-  GNUNET_memcpy (mqm->mh, hdr, size);
+  mqm = GNUNET_malloc(sizeof(*mqm) + size);
+  mqm->mh = (struct GNUNET_MessageHeader *)&mqm[1];
+  GNUNET_memcpy(mqm->mh, hdr, size);
   return mqm;
 }
 
@@ -672,27 +670,27 @@ GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)
  * @param nested_mh the message to append to the message after base_size
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp,
-                          uint16_t base_size,
-                          uint16_t type,
-                          const struct GNUNET_MessageHeader *nested_mh)
+GNUNET_MQ_msg_nested_mh_(struct GNUNET_MessageHeader **mhp,
+                         uint16_t base_size,
+                         uint16_t type,
+                         const struct GNUNET_MessageHeader *nested_mh)
 {
   struct GNUNET_MQ_Envelope *mqm;
   uint16_t size;
 
   if (NULL == nested_mh)
-    return GNUNET_MQ_msg_ (mhp, base_size, type);
+    return GNUNET_MQ_msg_(mhp, base_size, type);
 
-  size = base_size + ntohs (nested_mh->size);
+  size = base_size + ntohs(nested_mh->size);
 
   /* check for uint16_t overflow */
   if (size < base_size)
     return NULL;
 
-  mqm = GNUNET_MQ_msg_ (mhp, size, type);
-  GNUNET_memcpy ((char *) mqm->mh + base_size,
-                 nested_mh,
-                 ntohs (nested_mh->size));
+  mqm = GNUNET_MQ_msg_(mhp, size, type);
+  GNUNET_memcpy((char *)mqm->mh + base_size,
+                nested_mh,
+                ntohs(nested_mh->size));
 
   return mqm;
 }
@@ -705,22 +703,22 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp,
  * @param assoc_data to associate
  */
 uint32_t
-GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data)
+GNUNET_MQ_assoc_add(struct GNUNET_MQ_Handle *mq, void *assoc_data)
 {
   uint32_t id;
 
   if (NULL == mq->assoc_map)
-  {
-    mq->assoc_map = GNUNET_CONTAINER_multihashmap32_create (8);
-    mq->assoc_id = 1;
-  }
+    {
+      mq->assoc_map = GNUNET_CONTAINER_multihashmap32_create(8);
+      mq->assoc_id = 1;
+    }
   id = mq->assoc_id++;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap32_put (
-                   mq->assoc_map,
-                   id,
-                   assoc_data,
-                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap32_put(
+                  mq->assoc_map,
+                  id,
+                  assoc_data,
+                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return id;
 }
 
@@ -733,11 +731,11 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data)
  * @return the associated data
  */
 void *
-GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
+GNUNET_MQ_assoc_get(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
 {
   if (NULL == mq->assoc_map)
     return NULL;
-  return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
+  return GNUNET_CONTAINER_multihashmap32_get(mq->assoc_map, request_id);
 }
 
 
@@ -749,14 +747,14 @@ GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
  * @return the associated data
  */
 void *
-GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
+GNUNET_MQ_assoc_remove(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
 {
   void *val;
 
   if (NULL == mq->assoc_map)
     return NULL;
-  val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
-  GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, request_id);
+  val = GNUNET_CONTAINER_multihashmap32_get(mq->assoc_map, request_id);
+  GNUNET_CONTAINER_multihashmap32_remove_all(mq->assoc_map, request_id);
   return val;
 }
 
@@ -771,12 +769,12 @@ GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
  * @param cb_cls closure for the callback
  */
 void
-GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev,
-                       GNUNET_SCHEDULER_TaskCallback cb,
-                       void *cb_cls)
+GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev,
+                      GNUNET_SCHEDULER_TaskCallback cb,
+                      void *cb_cls)
 {
   /* allow setting *OR* clearing callback */
-  GNUNET_assert ((NULL == ev->sent_cb) || (NULL == cb));
+  GNUNET_assert((NULL == ev->sent_cb) || (NULL == cb));
   ev->sent_cb = cb;
   ev->sent_cls = cb_cls;
 }
@@ -786,8 +784,7 @@ GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev,
  * Handle we return for callbacks registered to be
  * notified when #GNUNET_MQ_destroy() is called on a queue.
  */
-struct GNUNET_MQ_DestroyNotificationHandle
-{
+struct GNUNET_MQ_DestroyNotificationHandle {
   /**
    * Kept in a DLL.
    */
@@ -821,86 +818,86 @@ struct GNUNET_MQ_DestroyNotificationHandle
  * @param mq message queue to destroy
  */
 void
-GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
   if (NULL != mq->destroy_impl)
-  {
-    mq->destroy_impl (mq, mq->impl_state);
-  }
+    {
+      mq->destroy_impl(mq, mq->impl_state);
+    }
   if (NULL != mq->send_task)
-  {
-    GNUNET_SCHEDULER_cancel (mq->send_task);
-    mq->send_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(mq->send_task);
+      mq->send_task = NULL;
+    }
   while (NULL != mq->envelope_head)
-  {
-    struct GNUNET_MQ_Envelope *ev;
-
-    ev = mq->envelope_head;
-    ev->parent_queue = NULL;
-    GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
-    GNUNET_assert (0 < mq->queue_length);
-    mq->queue_length--;
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "MQ destroy drops message of type %u\n",
-         ntohs (ev->mh->type));
-    GNUNET_MQ_discard (ev);
-  }
+    {
+      struct GNUNET_MQ_Envelope *ev;
+
+      ev = mq->envelope_head;
+      ev->parent_queue = NULL;
+      GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, ev);
+      GNUNET_assert(0 < mq->queue_length);
+      mq->queue_length--;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "MQ destroy drops message of type %u\n",
+          ntohs(ev->mh->type));
+      GNUNET_MQ_discard(ev);
+    }
   if (NULL != mq->current_envelope)
-  {
-    /* we can only discard envelopes that
-     * are not queued! */
-    mq->current_envelope->parent_queue = NULL;
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "MQ destroy drops current message of type %u\n",
-         ntohs (mq->current_envelope->mh->type));
-    GNUNET_MQ_discard (mq->current_envelope);
-    mq->current_envelope = NULL;
-    GNUNET_assert (0 < mq->queue_length);
-    mq->queue_length--;
-  }
-  GNUNET_assert (0 == mq->queue_length);
+    {
+      /* we can only discard envelopes that
+       * are not queued! */
+      mq->current_envelope->parent_queue = NULL;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "MQ destroy drops current message of type %u\n",
+          ntohs(mq->current_envelope->mh->type));
+      GNUNET_MQ_discard(mq->current_envelope);
+      mq->current_envelope = NULL;
+      GNUNET_assert(0 < mq->queue_length);
+      mq->queue_length--;
+    }
+  GNUNET_assert(0 == mq->queue_length);
   while (NULL != (dnh = mq->dnh_head))
-  {
-    dnh->cb (dnh->cb_cls);
-    GNUNET_MQ_destroy_notify_cancel (dnh);
-  }
+    {
+      dnh->cb(dnh->cb_cls);
+      GNUNET_MQ_destroy_notify_cancel(dnh);
+    }
   if (NULL != mq->assoc_map)
-  {
-    GNUNET_CONTAINER_multihashmap32_destroy (mq->assoc_map);
-    mq->assoc_map = NULL;
-  }
-  GNUNET_free_non_null (mq->handlers);
-  GNUNET_free (mq);
+    {
+      GNUNET_CONTAINER_multihashmap32_destroy(mq->assoc_map);
+      mq->assoc_map = NULL;
+    }
+  GNUNET_free_non_null(mq->handlers);
+  GNUNET_free(mq);
 }
 
 
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_extract_nested_mh_ (const struct GNUNET_MessageHeader *mh,
-                              uint16_t base_size)
+GNUNET_MQ_extract_nested_mh_(const struct GNUNET_MessageHeader *mh,
+                             uint16_t base_size)
 {
   uint16_t whole_size;
   uint16_t nested_size;
   const struct GNUNET_MessageHeader *nested_msg;
 
-  whole_size = ntohs (mh->size);
-  GNUNET_assert (whole_size >= base_size);
+  whole_size = ntohs(mh->size);
+  GNUNET_assert(whole_size >= base_size);
   nested_size = whole_size - base_size;
   if (0 == nested_size)
     return NULL;
-  if (nested_size < sizeof (struct GNUNET_MessageHeader))
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
-  nested_msg = (const struct GNUNET_MessageHeader *) ((char *) mh + base_size);
-  if (ntohs (nested_msg->size) != nested_size)
-  {
-    GNUNET_break_op (0);
-    return NULL;
-  }
+  if (nested_size < sizeof(struct GNUNET_MessageHeader))
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
+  nested_msg = (const struct GNUNET_MessageHeader *)((char *)mh + base_size);
+  if (ntohs(nested_msg->size) != nested_size)
+    {
+      GNUNET_break_op(0);
+      return NULL;
+    }
   return nested_msg;
 }
 
@@ -913,53 +910,53 @@ GNUNET_MQ_extract_nested_mh_ (const struct GNUNET_MessageHeader *mh,
  * @param ev queued envelope to cancel
  */
 void
-GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
 {
   struct GNUNET_MQ_Handle *mq = ev->parent_queue;
 
-  GNUNET_assert (NULL != mq);
-  GNUNET_assert (NULL != mq->cancel_impl);
+  GNUNET_assert(NULL != mq);
+  GNUNET_assert(NULL != mq->cancel_impl);
 
   mq->evacuate_called = GNUNET_NO;
 
   if (mq->current_envelope == ev)
-  {
-    /* complex case, we already started with transmitting
-       the message using the callbacks. */
-    GNUNET_assert (GNUNET_NO == mq->in_flight);
-    GNUNET_assert (0 < mq->queue_length);
-    mq->queue_length--;
-    mq->cancel_impl (mq, mq->impl_state);
-    /* continue sending the next message, if any */
-    mq->current_envelope = mq->envelope_head;
-    if (NULL != mq->current_envelope)
     {
-      GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
-                                   mq->envelope_tail,
-                                   mq->current_envelope);
-
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "sending canceled message of type %u queue\n",
-           ntohs (ev->mh->type));
-
-      mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
+      /* complex case, we already started with transmitting
+         the message using the callbacks. */
+      GNUNET_assert(GNUNET_NO == mq->in_flight);
+      GNUNET_assert(0 < mq->queue_length);
+      mq->queue_length--;
+      mq->cancel_impl(mq, mq->impl_state);
+      /* continue sending the next message, if any */
+      mq->current_envelope = mq->envelope_head;
+      if (NULL != mq->current_envelope)
+        {
+          GNUNET_CONTAINER_DLL_remove(mq->envelope_head,
+                                      mq->envelope_tail,
+                                      mq->current_envelope);
+
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "sending canceled message of type %u queue\n",
+              ntohs(ev->mh->type));
+
+          mq->send_impl(mq, mq->current_envelope->mh, mq->impl_state);
+        }
     }
-  }
   else
-  {
-    /* simple case, message is still waiting in the queue */
-    GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
-    GNUNET_assert (0 < mq->queue_length);
-    mq->queue_length--;
-  }
+    {
+      /* simple case, message is still waiting in the queue */
+      GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, ev);
+      GNUNET_assert(0 < mq->queue_length);
+      mq->queue_length--;
+    }
 
   if (GNUNET_YES != mq->evacuate_called)
-  {
-    ev->parent_queue = NULL;
-    ev->mh = NULL;
-    /* also frees ev */
-    GNUNET_free (ev);
-  }
+    {
+      ev->parent_queue = NULL;
+      ev->mh = NULL;
+      /* also frees ev */
+      GNUNET_free(ev);
+    }
 }
 
 
@@ -971,7 +968,7 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
  * @return the current envelope
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_get_current_envelope (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
 {
   return mq->current_envelope;
 }
@@ -984,7 +981,7 @@ GNUNET_MQ_get_current_envelope (struct GNUNET_MQ_Handle *mq)
  * @return the last envelope in the queue
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_last_envelope(struct GNUNET_MQ_Handle *mq)
 {
   if (NULL != mq->envelope_tail)
     return mq->envelope_tail;
@@ -1002,8 +999,8 @@ GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)
  * @param pp priorities and preferences to apply
  */
 void
-GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
-                           enum GNUNET_MQ_PriorityPreferences pp)
+GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env,
+                          enum GNUNET_MQ_PriorityPreferences pp)
 {
   env->priority = pp;
   env->have_custom_options = GNUNET_YES;
@@ -1017,7 +1014,7 @@ GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
  * @return priorities and preferences to apply for @a env
  */
 enum GNUNET_MQ_PriorityPreferences
-GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
 {
   struct GNUNET_MQ_Handle *mq = env->parent_queue;
 
@@ -1038,12 +1035,12 @@ GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env)
  * @return combined priority and preferences to use
  */
 enum GNUNET_MQ_PriorityPreferences
-GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1,
-                               enum GNUNET_MQ_PriorityPreferences p2)
+GNUNET_MQ_env_combine_options(enum GNUNET_MQ_PriorityPreferences p1,
+                              enum GNUNET_MQ_PriorityPreferences p2)
 {
   enum GNUNET_MQ_PriorityPreferences ret;
 
-  ret = GNUNET_MAX (p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK);
+  ret = GNUNET_MAX(p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK);
   ret |= ((p1 & GNUNET_MQ_PREF_UNRELIABLE) & (p2 & GNUNET_MQ_PREF_UNRELIABLE));
   ret |=
     ((p1 & GNUNET_MQ_PREF_LOW_LATENCY) | (p2 & GNUNET_MQ_PREF_LOW_LATENCY));
@@ -1063,8 +1060,8 @@ GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1,
  * @param pp priorities and preferences to apply
  */
 void
-GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
-                       enum GNUNET_MQ_PriorityPreferences pp)
+GNUNET_MQ_set_options(struct GNUNET_MQ_Handle *mq,
+                      enum GNUNET_MQ_PriorityPreferences pp)
 {
   mq->priority = pp;
 }
@@ -1077,7 +1074,7 @@ GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
  * @return message contained in the envelope
  */
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_env_get_msg (const struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
 {
   return env->mh;
 }
@@ -1090,7 +1087,7 @@ GNUNET_MQ_env_get_msg (const struct GNUNET_MQ_Envelope *env)
  * @return next one, or NULL
  */
 const struct GNUNET_MQ_Envelope *
-GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_next(const struct GNUNET_MQ_Envelope *env)
 {
   return env->next;
 }
@@ -1106,17 +1103,17 @@ GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env)
  * @return handle for #GNUNET_MQ_destroy_notify_cancel().
  */
 struct GNUNET_MQ_DestroyNotificationHandle *
-GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
-                          GNUNET_SCHEDULER_TaskCallback cb,
-                          void *cb_cls)
+GNUNET_MQ_destroy_notify(struct GNUNET_MQ_Handle *mq,
+                         GNUNET_SCHEDULER_TaskCallback cb,
+                         void *cb_cls)
 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
-  dnh = GNUNET_new (struct GNUNET_MQ_DestroyNotificationHandle);
+  dnh = GNUNET_new(struct GNUNET_MQ_DestroyNotificationHandle);
   dnh->mq = mq;
   dnh->cb = cb;
   dnh->cb_cls = cb_cls;
-  GNUNET_CONTAINER_DLL_insert (mq->dnh_head, mq->dnh_tail, dnh);
+  GNUNET_CONTAINER_DLL_insert(mq->dnh_head, mq->dnh_tail, dnh);
   return dnh;
 }
 
@@ -1127,13 +1124,13 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
  * @param dnh handle for registration to cancel
  */
 void
-GNUNET_MQ_destroy_notify_cancel (
+GNUNET_MQ_destroy_notify_cancel(
   struct GNUNET_MQ_DestroyNotificationHandle *dnh)
 {
   struct GNUNET_MQ_Handle *mq = dnh->mq;
 
-  GNUNET_CONTAINER_DLL_remove (mq->dnh_head, mq->dnh_tail, dnh);
-  GNUNET_free (dnh);
+  GNUNET_CONTAINER_DLL_remove(mq->dnh_head, mq->dnh_tail, dnh);
+  GNUNET_free(dnh);
 }
 
 
@@ -1150,12 +1147,11 @@ GNUNET_MQ_destroy_notify_cancel (
  * @param[in|out] env element to insert at the tail
  */
 void
-GNUNET_MQ_dll_insert_head (struct GNUNET_MQ_Envelope **env_head,
-                           struct GNUNET_MQ_Envelope **env_tail,
-                           struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_insert_head(struct GNUNET_MQ_Envelope **env_head,
+                          struct GNUNET_MQ_Envelope **env_tail,
+                          struct GNUNET_MQ_Envelope *env)
 {
-
-  GNUNET_CONTAINER_DLL_insert (*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_insert(*env_head, *env_tail, env);
 }
 
 
@@ -1172,11 +1168,11 @@ GNUNET_MQ_dll_insert_head (struct GNUNET_MQ_Envelope **env_head,
  * @param[in|out] env element to insert at the tail
  */
 void
-GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope **env_head,
-                           struct GNUNET_MQ_Envelope **env_tail,
-                           struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_insert_tail(struct GNUNET_MQ_Envelope **env_head,
+                          struct GNUNET_MQ_Envelope **env_tail,
+                          struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_CONTAINER_DLL_insert_tail (*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_insert_tail(*env_head, *env_tail, env);
 }
 
 
@@ -1193,11 +1189,11 @@ GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope **env_head,
  * @param[in|out] env element to remove from the DLL
  */
 void
-GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope **env_head,
-                      struct GNUNET_MQ_Envelope **env_tail,
-                      struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head,
+                     struct GNUNET_MQ_Envelope **env_tail,
+                     struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_CONTAINER_DLL_remove (*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_remove(*env_head, *env_tail, env);
 }
 
 
@@ -1212,7 +1208,7 @@ GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope **env_head,
  *         Needs to be freed with #GNUNET_free.
  */
 struct GNUNET_MQ_MessageHandler *
-GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
@@ -1220,11 +1216,11 @@ GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
   if (NULL == handlers)
     return NULL;
 
-  count = GNUNET_MQ_count_handlers (handlers);
-  copy = GNUNET_new_array (count + 1, struct GNUNET_MQ_MessageHandler);
-  GNUNET_memcpy (copy,
-                 handlers,
-                 count * sizeof (struct GNUNET_MQ_MessageHandler));
+  count = GNUNET_MQ_count_handlers(handlers);
+  copy = GNUNET_new_array(count + 1, struct GNUNET_MQ_MessageHandler);
+  GNUNET_memcpy(copy,
+                handlers,
+                count * sizeof(struct GNUNET_MQ_MessageHandler));
   return copy;
 }
 
@@ -1242,25 +1238,25 @@ GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
  *         Needs to be freed with #GNUNET_free.
  */
 struct GNUNET_MQ_MessageHandler *
-GNUNET_MQ_copy_handlers2 (const struct GNUNET_MQ_MessageHandler *handlers,
-                          GNUNET_MQ_MessageCallback agpl_handler,
-                          void *agpl_cls)
+GNUNET_MQ_copy_handlers2(const struct GNUNET_MQ_MessageHandler *handlers,
+                         GNUNET_MQ_MessageCallback agpl_handler,
+                         void *agpl_cls)
 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
 
   if (NULL == handlers)
     return NULL;
-  count = GNUNET_MQ_count_handlers (handlers);
-  copy = GNUNET_new_array (count + 2, struct GNUNET_MQ_MessageHandler);
-  GNUNET_memcpy (copy,
-                 handlers,
-                 count * sizeof (struct GNUNET_MQ_MessageHandler));
+  count = GNUNET_MQ_count_handlers(handlers);
+  copy = GNUNET_new_array(count + 2, struct GNUNET_MQ_MessageHandler);
+  GNUNET_memcpy(copy,
+                handlers,
+                count * sizeof(struct GNUNET_MQ_MessageHandler));
   copy[count].mv = NULL;
   copy[count].cb = agpl_handler;
   copy[count].cls = agpl_cls;
   copy[count].type = GNUNET_MESSAGE_TYPE_REQUEST_AGPL;
-  copy[count].expected_size = sizeof (struct GNUNET_MessageHeader);
+  copy[count].expected_size = sizeof(struct GNUNET_MessageHeader);
   return copy;
 }
 
@@ -1272,7 +1268,7 @@ GNUNET_MQ_copy_handlers2 (const struct GNUNET_MQ_MessageHandler *handlers,
  * @return The number of handlers in the array.
  */
 unsigned int
-GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_MQ_count_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
 {
   unsigned int i;
 
@@ -1293,19 +1289,23 @@ GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
  * @return a string or NULL if invalid
  */
 const char *
-GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type)
+GNUNET_MQ_preference_to_string(enum GNUNET_MQ_PreferenceKind type)
 {
   switch (type)
-  {
-  case GNUNET_MQ_PREFERENCE_NONE:
-    return "NONE";
-  case GNUNET_MQ_PREFERENCE_BANDWIDTH:
-    return "BANDWIDTH";
-  case GNUNET_MQ_PREFERENCE_LATENCY:
-    return "LATENCY";
-  case GNUNET_MQ_PREFERENCE_RELIABILITY:
-    return "RELIABILITY";
-  };
+    {
+    case GNUNET_MQ_PREFERENCE_NONE:
+      return "NONE";
+
+    case GNUNET_MQ_PREFERENCE_BANDWIDTH:
+      return "BANDWIDTH";
+
+    case GNUNET_MQ_PREFERENCE_LATENCY:
+      return "LATENCY";
+
+    case GNUNET_MQ_PREFERENCE_RELIABILITY:
+      return "RELIABILITY";
+    }
+  ;
   return NULL;
 }
 
diff --git a/src/util/mst.c b/src/util/mst.c
index bc52f2356..4ccf4988f 100644
--- a/src/util/mst.c
+++ b/src/util/mst.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 util/mst.c
@@ -34,15 +34,13 @@
 #define ALIGN_FACTOR 8
 #endif
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-mst", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-mst", __VA_ARGS__)
 
 
 /**
  * Handle to a message stream tokenizer.
  */
-struct GNUNET_MessageStreamTokenizer
-{
-
+struct GNUNET_MessageStreamTokenizer {
   /**
    * Function to call on completed messages.
    */
@@ -72,7 +70,6 @@ struct GNUNET_MessageStreamTokenizer
    * Beginning of the buffer.  Typed like this to force alignment.
    */
   struct GNUNET_MessageHeader *hdr;
-
 };
 
 
@@ -84,13 +81,13 @@ struct GNUNET_MessageStreamTokenizer
  * @return handle to tokenizer
  */
 struct GNUNET_MessageStreamTokenizer *
-GNUNET_MST_create (GNUNET_MessageTokenizerCallback cb,
-                   void *cb_cls)
+GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb,
+                  void *cb_cls)
 {
   struct GNUNET_MessageStreamTokenizer *ret;
 
-  ret = GNUNET_new (struct GNUNET_MessageStreamTokenizer);
-  ret->hdr = GNUNET_malloc (GNUNET_MIN_MESSAGE_SIZE);
+  ret = GNUNET_new(struct GNUNET_MessageStreamTokenizer);
+  ret->hdr = GNUNET_malloc(GNUNET_MIN_MESSAGE_SIZE);
   ret->curr_buf = GNUNET_MIN_MESSAGE_SIZE;
   ret->cb = cb;
   ret->cb_cls = cb_cls;
@@ -113,11 +110,11 @@ GNUNET_MST_create (GNUNET_MessageTokenizerCallback cb,
  *         #GNUNET_SYSERR if the data stream is corrupt
  */
 int
-GNUNET_MST_from_buffer (struct GNUNET_MessageStreamTokenizer *mst,
-                        const char *buf,
-                        size_t size,
-                        int purge,
-                        int one_shot)
+GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst,
+                       const char *buf,
+                       size_t size,
+                       int purge,
+                       int one_shot)
 {
   const struct GNUNET_MessageHeader *hdr;
   size_t delta;
@@ -128,203 +125,203 @@ GNUNET_MST_from_buffer (struct GNUNET_MessageStreamTokenizer *mst,
   int ret;
   int cbret;
 
-  GNUNET_assert (mst->off <= mst->pos);
-  GNUNET_assert (mst->pos <= mst->curr_buf);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "MST receives %u bytes with %u bytes already in private buffer\n",
-       (unsigned int) size,
-       (unsigned int) (mst->pos - mst->off));
+  GNUNET_assert(mst->off <= mst->pos);
+  GNUNET_assert(mst->pos <= mst->curr_buf);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "MST receives %u bytes with %u bytes already in private buffer\n",
+      (unsigned int)size,
+      (unsigned int)(mst->pos - mst->off));
   ret = GNUNET_OK;
-  ibuf = (char *) mst->hdr;
+  ibuf = (char *)mst->hdr;
   while (mst->pos > 0)
-  {
-do_align:
-    GNUNET_assert (mst->pos >= mst->off);
-    if ((mst->curr_buf - mst->off < sizeof (struct GNUNET_MessageHeader)) ||
-        (0 != (mst->off % ALIGN_FACTOR)))
-    {
-      /* need to align or need more space */
-      mst->pos -= mst->off;
-      memmove (ibuf,
-               &ibuf[mst->off],
-               mst->pos);
-      mst->off = 0;
-    }
-    if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
-    {
-      delta
-        = GNUNET_MIN (sizeof (struct GNUNET_MessageHeader)
-                      - (mst->pos - mst->off),
-                      size);
-      GNUNET_memcpy (&ibuf[mst->pos],
-                     buf,
-                     delta);
-      mst->pos += delta;
-      buf += delta;
-      size -= delta;
-    }
-    if (mst->pos - mst->off < sizeof (struct GNUNET_MessageHeader))
-    {
-      if (purge)
-      {
-        mst->off = 0;
-        mst->pos = 0;
-      }
-      return GNUNET_OK;
-    }
-    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
-    want = ntohs (hdr->size);
-    if (want < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
-    if ( (mst->curr_buf - mst->off < want) &&
-         (mst->off > 0) )
-    {
-      /* can get more space by moving */
-      mst->pos -= mst->off;
-      memmove (ibuf,
-               &ibuf[mst->off],
-               mst->pos);
-      mst->off = 0;
-    }
-    if (mst->curr_buf < want)
-    {
-      /* need to get more space by growing buffer */
-      GNUNET_assert (0 == mst->off);
-      mst->hdr = GNUNET_realloc (mst->hdr,
-                                 want);
-      ibuf = (char *) mst->hdr;
-      mst->curr_buf = want;
-    }
-    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
-    if (mst->pos - mst->off < want)
-    {
-      delta = GNUNET_MIN (want - (mst->pos - mst->off),
-                          size);
-      GNUNET_assert (mst->pos + delta <= mst->curr_buf);
-      GNUNET_memcpy (&ibuf[mst->pos],
-                     buf,
-                     delta);
-      mst->pos += delta;
-      buf += delta;
-      size -= delta;
-    }
-    if (mst->pos - mst->off < want)
-    {
-      if (purge)
-      {
-        mst->off = 0;
-        mst->pos = 0;
-      }
-      return GNUNET_OK;
-    }
-    if (one_shot == GNUNET_SYSERR)
     {
-      /* cannot call callback again, but return value saying that
-       * we have another full message in the buffer */
-      ret = GNUNET_NO;
-      goto copy;
-    }
-    if (one_shot == GNUNET_YES)
-      one_shot = GNUNET_SYSERR;
-    mst->off += want;
-    if (GNUNET_OK !=
-        (cbret = mst->cb (mst->cb_cls,
-                           hdr)))
-    {
-      if (GNUNET_SYSERR == cbret)
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    "Failure processing message of type %u and size %u\n",
-                    ntohs (hdr->type),
-                    ntohs (hdr->size));
-      return GNUNET_SYSERR;
-    }
-    if (mst->off == mst->pos)
-    {
-      /* reset to beginning of buffer, it's free right now! */
-      mst->off = 0;
-      mst->pos = 0;
-    }
-  }
-  GNUNET_assert (0 == mst->pos);
-  while (size > 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Server-mst has %u bytes left in inbound buffer\n",
-         (unsigned int) size);
-    if (size < sizeof (struct GNUNET_MessageHeader))
-      break;
-    offset = (unsigned long) buf;
-    need_align = (0 != (offset % ALIGN_FACTOR)) ? GNUNET_YES : GNUNET_NO;
-    if (GNUNET_NO == need_align)
-    {
-      /* can try to do zero-copy and process directly from original buffer */
-      hdr = (const struct GNUNET_MessageHeader *) buf;
-      want = ntohs (hdr->size);
-      if (want < sizeof (struct GNUNET_MessageHeader))
-      {
-        GNUNET_break_op (0);
-        mst->off = 0;
-        return GNUNET_SYSERR;
-      }
-      if (size < want)
-        break;                  /* or not: buffer incomplete, so copy to private buffer... */
+do_align:
+      GNUNET_assert(mst->pos >= mst->off);
+      if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) ||
+          (0 != (mst->off % ALIGN_FACTOR)))
+        {
+          /* need to align or need more space */
+          mst->pos -= mst->off;
+          memmove(ibuf,
+                  &ibuf[mst->off],
+                  mst->pos);
+          mst->off = 0;
+        }
+      if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
+        {
+          delta
+            = GNUNET_MIN(sizeof(struct GNUNET_MessageHeader)
+                         - (mst->pos - mst->off),
+                         size);
+          GNUNET_memcpy(&ibuf[mst->pos],
+                        buf,
+                        delta);
+          mst->pos += delta;
+          buf += delta;
+          size -= delta;
+        }
+      if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
+        {
+          if (purge)
+            {
+              mst->off = 0;
+              mst->pos = 0;
+            }
+          return GNUNET_OK;
+        }
+      hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off];
+      want = ntohs(hdr->size);
+      if (want < sizeof(struct GNUNET_MessageHeader))
+        {
+          GNUNET_break_op(0);
+          return GNUNET_SYSERR;
+        }
+      if ((mst->curr_buf - mst->off < want) &&
+          (mst->off > 0))
+        {
+          /* can get more space by moving */
+          mst->pos -= mst->off;
+          memmove(ibuf,
+                  &ibuf[mst->off],
+                  mst->pos);
+          mst->off = 0;
+        }
+      if (mst->curr_buf < want)
+        {
+          /* need to get more space by growing buffer */
+          GNUNET_assert(0 == mst->off);
+          mst->hdr = GNUNET_realloc(mst->hdr,
+                                    want);
+          ibuf = (char *)mst->hdr;
+          mst->curr_buf = want;
+        }
+      hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off];
+      if (mst->pos - mst->off < want)
+        {
+          delta = GNUNET_MIN(want - (mst->pos - mst->off),
+                             size);
+          GNUNET_assert(mst->pos + delta <= mst->curr_buf);
+          GNUNET_memcpy(&ibuf[mst->pos],
+                        buf,
+                        delta);
+          mst->pos += delta;
+          buf += delta;
+          size -= delta;
+        }
+      if (mst->pos - mst->off < want)
+        {
+          if (purge)
+            {
+              mst->off = 0;
+              mst->pos = 0;
+            }
+          return GNUNET_OK;
+        }
       if (one_shot == GNUNET_SYSERR)
-      {
-        /* cannot call callback again, but return value saying that
-         * we have another full message in the buffer */
-        ret = GNUNET_NO;
-        goto copy;
-      }
+        {
+          /* cannot call callback again, but return value saying that
+           * we have another full message in the buffer */
+          ret = GNUNET_NO;
+          goto copy;
+        }
       if (one_shot == GNUNET_YES)
         one_shot = GNUNET_SYSERR;
+      mst->off += want;
       if (GNUNET_OK !=
-          (cbret = mst->cb (mst->cb_cls,
-                            hdr)))
-      {
-        if (GNUNET_SYSERR == cbret)
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "Failure processing message of type %u and size %u\n",
-                      ntohs (hdr->type),
-                      ntohs (hdr->size));
-        return GNUNET_SYSERR;
-      }
-      buf += want;
-      size -= want;
+          (cbret = mst->cb(mst->cb_cls,
+                           hdr)))
+        {
+          if (GNUNET_SYSERR == cbret)
+            GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                       "Failure processing message of type %u and size %u\n",
+                       ntohs(hdr->type),
+                       ntohs(hdr->size));
+          return GNUNET_SYSERR;
+        }
+      if (mst->off == mst->pos)
+        {
+          /* reset to beginning of buffer, it's free right now! */
+          mst->off = 0;
+          mst->pos = 0;
+        }
     }
-    else
+  GNUNET_assert(0 == mst->pos);
+  while (size > 0)
     {
-      /* need to copy to private buffer to align;
-       * yes, we go a bit more spagetti than usual here */
-      goto do_align;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Server-mst has %u bytes left in inbound buffer\n",
+          (unsigned int)size);
+      if (size < sizeof(struct GNUNET_MessageHeader))
+        break;
+      offset = (unsigned long)buf;
+      need_align = (0 != (offset % ALIGN_FACTOR)) ? GNUNET_YES : GNUNET_NO;
+      if (GNUNET_NO == need_align)
+        {
+          /* can try to do zero-copy and process directly from original buffer */
+          hdr = (const struct GNUNET_MessageHeader *)buf;
+          want = ntohs(hdr->size);
+          if (want < sizeof(struct GNUNET_MessageHeader))
+            {
+              GNUNET_break_op(0);
+              mst->off = 0;
+              return GNUNET_SYSERR;
+            }
+          if (size < want)
+            break;              /* or not: buffer incomplete, so copy to private buffer... */
+          if (one_shot == GNUNET_SYSERR)
+            {
+              /* cannot call callback again, but return value saying that
+               * we have another full message in the buffer */
+              ret = GNUNET_NO;
+              goto copy;
+            }
+          if (one_shot == GNUNET_YES)
+            one_shot = GNUNET_SYSERR;
+          if (GNUNET_OK !=
+              (cbret = mst->cb(mst->cb_cls,
+                               hdr)))
+            {
+              if (GNUNET_SYSERR == cbret)
+                GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                           "Failure processing message of type %u and size %u\n",
+                           ntohs(hdr->type),
+                           ntohs(hdr->size));
+              return GNUNET_SYSERR;
+            }
+          buf += want;
+          size -= want;
+        }
+      else
+        {
+          /* need to copy to private buffer to align;
+           * yes, we go a bit more spagetti than usual here */
+          goto do_align;
+        }
     }
-  }
 copy:
   if ((size > 0) && (!purge))
-  {
-    if (size + mst->pos > mst->curr_buf)
     {
-      mst->hdr = GNUNET_realloc (mst->hdr,
-                                 size + mst->pos);
-      ibuf = (char *) mst->hdr;
-      mst->curr_buf = size + mst->pos;
+      if (size + mst->pos > mst->curr_buf)
+        {
+          mst->hdr = GNUNET_realloc(mst->hdr,
+                                    size + mst->pos);
+          ibuf = (char *)mst->hdr;
+          mst->curr_buf = size + mst->pos;
+        }
+      GNUNET_assert(size + mst->pos <= mst->curr_buf);
+      GNUNET_memcpy(&ibuf[mst->pos],
+                    buf,
+                    size);
+      mst->pos += size;
     }
-    GNUNET_assert (size + mst->pos <= mst->curr_buf);
-    GNUNET_memcpy (&ibuf[mst->pos],
-                   buf,
-                   size);
-    mst->pos += size;
-  }
   if (purge)
-  {
-    mst->off = 0;
-    mst->pos = 0;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Server-mst leaves %u bytes in private buffer\n",
-       (unsigned int) (mst->pos - mst->off));
+    {
+      mst->off = 0;
+      mst->pos = 0;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Server-mst leaves %u bytes in private buffer\n",
+      (unsigned int)(mst->pos - mst->off));
   return ret;
 }
 
@@ -344,40 +341,40 @@ copy:
  *         #GNUNET_SYSERR if the data stream is corrupt
  */
 int
-GNUNET_MST_read (struct GNUNET_MessageStreamTokenizer *mst,
-                 struct GNUNET_NETWORK_Handle *sock,
-                 int purge,
-                 int one_shot)
+GNUNET_MST_read(struct GNUNET_MessageStreamTokenizer *mst,
+                struct GNUNET_NETWORK_Handle *sock,
+                int purge,
+                int one_shot)
 {
   ssize_t ret;
   size_t left;
   char *buf;
 
   left = mst->curr_buf - mst->pos;
-  buf = (char *) mst->hdr;
-  ret = GNUNET_NETWORK_socket_recv (sock,
-                                    &buf[mst->pos],
-                                    left);
+  buf = (char *)mst->hdr;
+  ret = GNUNET_NETWORK_socket_recv(sock,
+                                   &buf[mst->pos],
+                                   left);
   if (-1 == ret)
-  {
-    if ( (EAGAIN == errno) ||
-         (EINTR == errno) )
-      return GNUNET_OK;
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO,
-                         "recv");
-    return GNUNET_SYSERR;
-  }
+    {
+      if ((EAGAIN == errno) ||
+          (EINTR == errno))
+        return GNUNET_OK;
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO,
+                          "recv");
+      return GNUNET_SYSERR;
+    }
   if (0 == ret)
-  {
-    /* other side closed connection, treat as error */
-    return GNUNET_SYSERR;
-  }
+    {
+      /* other side closed connection, treat as error */
+      return GNUNET_SYSERR;
+    }
   mst->pos += ret;
-  return GNUNET_MST_from_buffer (mst,
-                                 NULL,
-                                 0,
-                                 purge,
-                                 one_shot);
+  return GNUNET_MST_from_buffer(mst,
+                                NULL,
+                                0,
+                                purge,
+                                one_shot);
 }
 
 
@@ -393,14 +390,14 @@ GNUNET_MST_read (struct GNUNET_MessageStreamTokenizer *mst,
  *         #GNUNET_SYSERR if the data stream is corrupt
  */
 int
-GNUNET_MST_next (struct GNUNET_MessageStreamTokenizer *mst,
-                 int one_shot)
+GNUNET_MST_next(struct GNUNET_MessageStreamTokenizer *mst,
+                int one_shot)
 {
-  return GNUNET_MST_from_buffer (mst,
-                                 NULL,
-                                 0,
-                                 GNUNET_NO,
-                                 one_shot);
+  return GNUNET_MST_from_buffer(mst,
+                                NULL,
+                                0,
+                                GNUNET_NO,
+                                one_shot);
 }
 
 
@@ -410,10 +407,10 @@ GNUNET_MST_next (struct GNUNET_MessageStreamTokenizer *mst,
  * @param mst tokenizer to destroy
  */
 void
-GNUNET_MST_destroy (struct GNUNET_MessageStreamTokenizer *mst)
+GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
 {
-  GNUNET_free (mst->hdr);
-  GNUNET_free (mst);
+  GNUNET_free(mst->hdr);
+  GNUNET_free(mst);
 }
 
 
diff --git a/src/util/nc.c b/src/util/nc.c
index 7a3c5877e..ab7ef122d 100644
--- a/src/util/nc.c
+++ b/src/util/nc.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 util/nc.c
@@ -28,15 +28,13 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-nc", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-nc", __VA_ARGS__)
 
 
 /**
  * Lists of subscribers we manage for notifications.
  */
-struct SubscriberList
-{
-
+struct SubscriberList {
   /**
    * This is a doubly linked list.
    */
@@ -57,12 +55,11 @@ struct SubscriberList
    * the MQ's destruction.
    */
   struct GNUNET_MQ_DestroyNotificationHandle *mq_nh;
-  
+
   /**
    * Message queue for the subscriber.
    */
   struct GNUNET_MQ_Handle *mq;
-
 };
 
 
@@ -74,9 +71,7 @@ struct SubscriberList
  * (notification) messages are queued up until the subscriber is able to
  * read them.
  */
-struct GNUNET_NotificationContext
-{
-
+struct GNUNET_NotificationContext {
   /**
    * Head of list of subscribers receiving notifications.
    */
@@ -91,7 +86,6 @@ struct GNUNET_NotificationContext
    * Maximum number of optional messages to queue per subscriber.
    */
   unsigned int queue_length;
-
 };
 
 
@@ -101,15 +95,15 @@ struct GNUNET_NotificationContext
  * @param cls our `struct SubscriberList *`
  */
 static void
-handle_mq_destroy (void *cls)
+handle_mq_destroy(void *cls)
 {
-  struct SubscriberList *pos = cls; 
+  struct SubscriberList *pos = cls;
   struct GNUNET_NotificationContext *nc = pos->nc;
 
-  GNUNET_CONTAINER_DLL_remove (nc->subscribers_head,
-                               nc->subscribers_tail,
-                               pos);
-  GNUNET_free (pos);
+  GNUNET_CONTAINER_DLL_remove(nc->subscribers_head,
+                              nc->subscribers_tail,
+                              pos);
+  GNUNET_free(pos);
 }
 
 
@@ -122,11 +116,11 @@ handle_mq_destroy (void *cls)
  * @return handle to the notification context
  */
 struct GNUNET_NotificationContext *
-GNUNET_notification_context_create (unsigned int queue_length)
+GNUNET_notification_context_create(unsigned int queue_length)
 {
   struct GNUNET_NotificationContext *nc;
 
-  nc = GNUNET_new (struct GNUNET_NotificationContext);
+  nc = GNUNET_new(struct GNUNET_NotificationContext);
   nc->queue_length = queue_length;
   return nc;
 }
@@ -138,19 +132,19 @@ GNUNET_notification_context_create (unsigned int queue_length)
  * @param nc context to destroy.
  */
 void
-GNUNET_notification_context_destroy (struct GNUNET_NotificationContext *nc)
+GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
 {
   struct SubscriberList *pos;
 
   while (NULL != (pos = nc->subscribers_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (nc->subscribers_head,
-                                 nc->subscribers_tail,
-                                 pos);
-    GNUNET_MQ_destroy_notify_cancel (pos->mq_nh);
-    GNUNET_free (pos);
-  }
-  GNUNET_free (nc);
+    {
+      GNUNET_CONTAINER_DLL_remove(nc->subscribers_head,
+                                  nc->subscribers_tail,
+                                  pos);
+      GNUNET_MQ_destroy_notify_cancel(pos->mq_nh);
+      GNUNET_free(pos);
+    }
+  GNUNET_free(nc);
 }
 
 
@@ -161,23 +155,24 @@ GNUNET_notification_context_destroy (struct GNUNET_NotificationContext *nc)
  * @param mq message queue add
  */
 void
-GNUNET_notification_context_add (struct GNUNET_NotificationContext *nc,
-                                 struct GNUNET_MQ_Handle *mq)
+GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc,
+                                struct GNUNET_MQ_Handle *mq)
 {
   struct SubscriberList *cl;
 
   for (cl = nc->subscribers_head; NULL != cl; cl = cl->next)
     if (cl->mq == mq)
-      return; /* already present */
-  cl = GNUNET_new (struct SubscriberList);
-  GNUNET_CONTAINER_DLL_insert (nc->subscribers_head,
-                               nc->subscribers_tail,
-                               cl);
+      return;
+  /* already present */
+  cl = GNUNET_new(struct SubscriberList);
+  GNUNET_CONTAINER_DLL_insert(nc->subscribers_head,
+                              nc->subscribers_tail,
+                              cl);
   cl->nc = nc;
   cl->mq = mq;
-  cl->mq_nh = GNUNET_MQ_destroy_notify (cl->mq,
-                                        &handle_mq_destroy,
-                                        cl);
+  cl->mq_nh = GNUNET_MQ_destroy_notify(cl->mq,
+                                       &handle_mq_destroy,
+                                       cl);
 }
 
 
@@ -189,22 +184,22 @@ GNUNET_notification_context_add (struct GNUNET_NotificationContext *nc,
  * @param can_drop can this message be dropped due to queue length limitations
  */
 void
-GNUNET_notification_context_broadcast (struct GNUNET_NotificationContext *nc,
-                                       const struct GNUNET_MessageHeader *msg,
-                                       int can_drop)
+GNUNET_notification_context_broadcast(struct GNUNET_NotificationContext *nc,
+                                      const struct GNUNET_MessageHeader *msg,
+                                      int can_drop)
 {
   struct SubscriberList *pos;
   struct GNUNET_MQ_Envelope *env;
 
   for (pos = nc->subscribers_head; NULL != pos; pos = pos->next)
-  {
-    if ( (GNUNET_YES == can_drop) &&
-         (GNUNET_MQ_get_length (pos->mq) > nc->queue_length) )
-      continue;
-    env = GNUNET_MQ_msg_copy (msg);
-    GNUNET_MQ_send (pos->mq,
-                    env);
-  }
+    {
+      if ((GNUNET_YES == can_drop) &&
+          (GNUNET_MQ_get_length(pos->mq) > nc->queue_length))
+        continue;
+      env = GNUNET_MQ_msg_copy(msg);
+      GNUNET_MQ_send(pos->mq,
+                     env);
+    }
 }
 
 
@@ -215,7 +210,7 @@ GNUNET_notification_context_broadcast (struct GNUNET_NotificationContext *nc,
  * @return number of current subscribers
  */
 unsigned int
-GNUNET_notification_context_get_size (struct GNUNET_NotificationContext *nc)
+GNUNET_notification_context_get_size(struct GNUNET_NotificationContext *nc)
 {
   unsigned int num;
   struct SubscriberList *pos;
diff --git a/src/util/network.c b/src/util/network.c
index 2c16fe8c9..9eff6b96e 100644
--- a/src/util/network.c
+++ b/src/util/network.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 util/network.c
@@ -28,9 +28,9 @@
 #include "gnunet_util_lib.h"
 #include "disk.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-network", __VA_ARGS__)
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-network", syscall, filename)
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-network", syscall)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-network", __VA_ARGS__)
+#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util-network", syscall, filename)
+#define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror(kind, "util-network", syscall)
 
 #define DEBUG_NETWORK GNUNET_EXTRA_LOGGING
 
@@ -43,8 +43,7 @@
 /**
  * @brief handle to a socket
  */
-struct GNUNET_NETWORK_Handle
-{
+struct GNUNET_NETWORK_Handle {
 #ifndef MINGW
   int fd;
 #else
@@ -70,7 +69,6 @@ struct GNUNET_NETWORK_Handle
    * Address we were bound to, or NULL.
    */
   struct sockaddr *addr;
-
 };
 
 
@@ -81,7 +79,7 @@ struct GNUNET_NETWORK_Handle
  * @return #GNUNET_OK if the PF is supported
  */
 int
-GNUNET_NETWORK_test_pf (int pf)
+GNUNET_NETWORK_test_pf(int pf)
 {
   static int cache_v4 = -1;
   static int cache_v6 = -1;
@@ -90,56 +88,60 @@ GNUNET_NETWORK_test_pf (int pf)
   int ret;
 
   switch (pf)
-  {
-  case PF_INET:
-    if (-1 != cache_v4)
-      return cache_v4;
-    break;
-  case PF_INET6:
-    if (-1 != cache_v6)
-      return cache_v6;
-    break;
+    {
+    case PF_INET:
+      if (-1 != cache_v4)
+        return cache_v4;
+      break;
+
+    case PF_INET6:
+      if (-1 != cache_v6)
+        return cache_v6;
+      break;
+
 #ifdef PF_UNIX
-  case PF_UNIX:
-    if (-1 != cache_un)
-      return cache_un;
-    break;
+    case PF_UNIX:
+      if (-1 != cache_un)
+        return cache_un;
+      break;
 #endif
-  }
-  s = socket (pf, SOCK_STREAM, 0);
+    }
+  s = socket(pf, SOCK_STREAM, 0);
   if (-1 == s)
-  {
-    if (EAFNOSUPPORT != errno)
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                           "socket");
-      return GNUNET_SYSERR;
+      if (EAFNOSUPPORT != errno)
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
+                              "socket");
+          return GNUNET_SYSERR;
+        }
+      ret = GNUNET_NO;
     }
-    ret = GNUNET_NO;
-  }
   else
-  {
+    {
 #if WINDOWS
-    closesocket (s);
+      closesocket(s);
 #else
-    close (s);
+      close(s);
 #endif
-    ret = GNUNET_OK;
-  }
+      ret = GNUNET_OK;
+    }
   switch (pf)
-  {
-  case PF_INET:
-    cache_v4 = ret;
-    break;
-  case PF_INET6:
-    cache_v6 = ret;
-    break;
+    {
+    case PF_INET:
+      cache_v4 = ret;
+      break;
+
+    case PF_INET6:
+      cache_v6 = ret;
+      break;
+
 #ifdef PF_UNIX
-  case PF_UNIX:
-    cache_un = ret;
-    break;
+    case PF_UNIX:
+      cache_un = ret;
+      break;
 #endif
-  }
+    }
   return ret;
 }
 
@@ -154,7 +156,7 @@ GNUNET_NETWORK_test_pf (int pf)
  * @return shortened unixpath, NULL on error
  */
 char *
-GNUNET_NETWORK_shorten_unixpath (char *unixpath)
+GNUNET_NETWORK_shorten_unixpath(char *unixpath)
 {
   struct sockaddr_un dummy;
   size_t slen;
@@ -163,26 +165,26 @@ GNUNET_NETWORK_shorten_unixpath (char *unixpath)
   struct GNUNET_CRYPTO_HashAsciiEncoded ae;
   size_t upm;
 
-  upm = sizeof (dummy.sun_path);
-  slen = strlen (unixpath);
+  upm = sizeof(dummy.sun_path);
+  slen = strlen(unixpath);
   if (slen < upm)
     return unixpath; /* no shortening required */
-  GNUNET_CRYPTO_hash (unixpath, slen, &sh);
-  while (16 + strlen (unixpath) >= upm)
-  {
-    if (NULL == (end = strrchr (unixpath, '/')))
+  GNUNET_CRYPTO_hash(unixpath, slen, &sh);
+  while (16 + strlen(unixpath) >= upm)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Unable to shorten unix path `%s' while keeping name unique\n"),
-                  unixpath);
-      GNUNET_free (unixpath);
-      return NULL;
+      if (NULL == (end = strrchr(unixpath, '/')))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Unable to shorten unix path `%s' while keeping name unique\n"),
+                     unixpath);
+          GNUNET_free(unixpath);
+          return NULL;
+        }
+      *end = '\0';
     }
-    *end = '\0';
-  }
-  GNUNET_CRYPTO_hash_to_enc (&sh, &ae);
+  GNUNET_CRYPTO_hash_to_enc(&sh, &ae);
   ae.encoding[16] = '\0';
-  strcat (unixpath, (char *) ae.encoding);
+  strcat(unixpath, (char *)ae.encoding);
   return unixpath;
 }
 
@@ -198,50 +200,50 @@ GNUNET_NETWORK_shorten_unixpath (char *unixpath)
  * @param un unix domain socket address to check
  */
 void
-GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
+GNUNET_NETWORK_unix_precheck(const struct sockaddr_un *un)
 {
   int s;
   int eno;
   struct stat sbuf;
   int ret;
 
-  s = socket (AF_UNIX, SOCK_STREAM, 0);
+  s = socket(AF_UNIX, SOCK_STREAM, 0);
   if (-1 == s)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
-                         "Failed to open AF_UNIX socket");
-    return;
-  }
-  ret = connect (s,
-                 (struct sockaddr *) un,
-                 sizeof (struct sockaddr_un));
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
+                          "Failed to open AF_UNIX socket");
+      return;
+    }
+  ret = connect(s,
+                (struct sockaddr *)un,
+                sizeof(struct sockaddr_un));
   eno = errno;
-  GNUNET_break (0 == close (s));
+  GNUNET_break(0 == close(s));
   if (0 == ret)
     return; /* another process is listening, do not remove! */
   if (ECONNREFUSED != eno)
     return; /* some other error, likely "no such file or directory" -- all well */
   /* should unlink, but sanity checks first */
-  if (0 != stat (un->sun_path,
-                 &sbuf))
+  if (0 != stat(un->sun_path,
+                &sbuf))
     return; /* failed to 'stat', likely does not exist after all */
   if (S_IFSOCK != (S_IFMT & sbuf.st_mode))
     return; /* refuse to unlink anything except sockets */
   /* finally, really unlink */
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Removing left-over `%s' from previous exeuction\n",
-              un->sun_path);
-  if (0 != unlink (un->sun_path))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                              "unlink",
-                              un->sun_path);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Removing left-over `%s' from previous exeuction\n",
+             un->sun_path);
+  if (0 != unlink(un->sun_path))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
+                             "unlink",
+                             un->sun_path);
 }
 #endif
 
 
 
 #ifndef FD_COPY
-#define FD_COPY(s, d) do { GNUNET_memcpy ((d), (s), sizeof (fd_set)); } while (0)
+#define FD_COPY(s, d) do { GNUNET_memcpy((d), (s), sizeof(fd_set)); } while (0)
 #endif
 
 
@@ -253,51 +255,49 @@ GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,
-                                    int doBlock)
+GNUNET_NETWORK_socket_set_blocking(struct GNUNET_NETWORK_Handle *fd,
+                                   int doBlock)
 {
-
 #if MINGW
   u_long mode;
 
   mode = !doBlock;
   if (SOCKET_ERROR ==
-      ioctlsocket (fd->fd,
-                   FIONBIO,
-                   &mode))
+      ioctlsocket(fd->fd,
+                  FIONBIO,
+                  &mode))
 
-  {
-    SetErrnoFromWinsockError (WSAGetLastError ());
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "ioctlsocket");
-    return GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinsockError(WSAGetLastError());
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                   "ioctlsocket");
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
-
 #else
   /* not MINGW */
-  int flags = fcntl (fd->fd, F_GETFL);
+  int flags = fcntl(fd->fd, F_GETFL);
 
   if (flags == -1)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "fcntl");
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                   "fcntl");
+      return GNUNET_SYSERR;
+    }
   if (doBlock)
     flags &= ~O_NONBLOCK;
 
   else
     flags |= O_NONBLOCK;
-  if (0 != fcntl (fd->fd,
-                  F_SETFL,
-                  flags))
+  if (0 != fcntl(fd->fd,
+                 F_SETFL,
+                 flags))
 
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "fcntl");
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                   "fcntl");
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 #endif
 }
@@ -311,27 +311,27 @@ GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,
  * @warning Not implemented on Windows
  */
 static int
-socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h)
+socket_set_inheritable(const struct GNUNET_NETWORK_Handle *h)
 {
 #ifndef MINGW
   int i;
-  i = fcntl (h->fd, F_GETFD);
+  i = fcntl(h->fd, F_GETFD);
   if (i < 0)
     return GNUNET_SYSERR;
   if (i == (i | FD_CLOEXEC))
     return GNUNET_OK;
   i |= FD_CLOEXEC;
-  if (fcntl (h->fd, F_SETFD, i) < 0)
+  if (fcntl(h->fd, F_SETFD, i) < 0)
     return GNUNET_SYSERR;
 #else
   BOOL b;
-  SetLastError (0);
-  b = SetHandleInformation ((HANDLE) h->fd, HANDLE_FLAG_INHERIT, 0);
+  SetLastError(0);
+  b = SetHandleInformation((HANDLE)h->fd, HANDLE_FLAG_INHERIT, 0);
   if (!b)
-  {
-    SetErrnoFromWinsockError (WSAGetLastError ());
-    return GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinsockError(WSAGetLastError());
+      return GNUNET_SYSERR;
+    }
 #endif
   return GNUNET_OK;
 }
@@ -344,14 +344,14 @@ socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h)
  * @param h the socket to make non-delaying
  */
 static int
-socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
+socket_set_nosigpipe(const struct GNUNET_NETWORK_Handle *h)
 {
   int abs_value = 1;
 
   if (0 !=
-      setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE,
-                  (const void *) &abs_value,
-                  sizeof (abs_value)))
+      setsockopt(h->fd, SOL_SOCKET, SO_NOSIGPIPE,
+                 (const void *)&abs_value,
+                 sizeof(abs_value)))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -366,29 +366,29 @@ socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
  * @param h the socket to make non-delaying
  */
 static void
-socket_set_nodelay (const struct GNUNET_NETWORK_Handle *h)
+socket_set_nodelay(const struct GNUNET_NETWORK_Handle *h)
 {
 #ifndef WINDOWS
   int value = 1;
 
   if (0 !=
-      setsockopt (h->fd,
-                  IPPROTO_TCP,
-                  TCP_NODELAY,
-                  &value, sizeof (value)))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+      setsockopt(h->fd,
+                 IPPROTO_TCP,
+                 TCP_NODELAY,
+                 &value, sizeof(value)))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
 #else
   const char *abs_value = "1";
 
   if (0 !=
-      setsockopt (h->fd,
-                  IPPROTO_TCP,
-                  TCP_NODELAY,
-                  (const void *) abs_value,
-                  sizeof (abs_value)))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+      setsockopt(h->fd,
+                 IPPROTO_TCP,
+                 TCP_NODELAY,
+                 (const void *)abs_value,
+                 sizeof(abs_value)))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
 #endif
 }
 
@@ -406,60 +406,60 @@ socket_set_nodelay (const struct GNUNET_NETWORK_Handle *h)
  *         failed and the handle was destroyed
  */
 static int
-initialize_network_handle (struct GNUNET_NETWORK_Handle *h,
-                           int af,
-                           int type)
+initialize_network_handle(struct GNUNET_NETWORK_Handle *h,
+                          int af,
+                          int type)
 {
   int eno;
 
   h->af = af;
   h->type = type;
   if (h->fd == INVALID_SOCKET)
-  {
+    {
 #ifdef MINGW
-    SetErrnoFromWinsockError (WSAGetLastError ());
+      SetErrnoFromWinsockError(WSAGetLastError());
 #endif
-    eno = errno;
-    GNUNET_free (h);
-    errno = eno;
-    return GNUNET_SYSERR;
-  }
+      eno = errno;
+      GNUNET_free(h);
+      errno = eno;
+      return GNUNET_SYSERR;
+    }
 #ifndef MINGW
   if (h->fd >= FD_SETSIZE)
-  {
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (h));
-    errno = EMFILE;
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(h));
+      errno = EMFILE;
+      return GNUNET_SYSERR;
+    }
 #endif
-  if (GNUNET_OK != socket_set_inheritable (h))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "socket_set_inheritable");
+  if (GNUNET_OK != socket_set_inheritable(h))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                 "socket_set_inheritable");
 
-  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (h, GNUNET_NO))
-  {
-    eno = errno;
-    GNUNET_break (0);
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (h));
-    errno = eno;
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking(h, GNUNET_NO))
+    {
+      eno = errno;
+      GNUNET_break(0);
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(h));
+      errno = eno;
+      return GNUNET_SYSERR;
+    }
 #ifdef DARWIN
-  if (GNUNET_SYSERR == socket_set_nosigpipe (h))
-  {
-    eno = errno;
-    GNUNET_break (0);
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (h));
-    errno = eno;
-    return GNUNET_SYSERR;
-  }
+  if (GNUNET_SYSERR == socket_set_nosigpipe(h))
+    {
+      eno = errno;
+      GNUNET_break(0);
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(h));
+      errno = eno;
+      return GNUNET_SYSERR;
+    }
 #endif
-  if ( (type == SOCK_STREAM)
+  if ((type == SOCK_STREAM)
 #ifdef AF_UNIX
-       && (af != AF_UNIX)
+      && (af != AF_UNIX)
 #endif
       )
-    socket_set_nodelay (h);
+    socket_set_nodelay(h);
   return GNUNET_OK;
 }
 
@@ -473,47 +473,47 @@ initialize_network_handle (struct GNUNET_NETWORK_Handle *h,
  * @return client socket
  */
 struct GNUNET_NETWORK_Handle *
-GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
-                              struct sockaddr *address,
-                              socklen_t *address_len)
+GNUNET_NETWORK_socket_accept(const struct GNUNET_NETWORK_Handle *desc,
+                             struct sockaddr *address,
+                             socklen_t *address_len)
 {
   struct GNUNET_NETWORK_Handle *ret;
   int eno;
 
-  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
+  ret = GNUNET_new(struct GNUNET_NETWORK_Handle);
 #if DEBUG_NETWORK
   {
     struct sockaddr_storage name;
-    socklen_t namelen = sizeof (name);
+    socklen_t namelen = sizeof(name);
 
-    int gsn = getsockname (desc->fd,
-                           (struct sockaddr *) &name,
-                           &namelen);
+    int gsn = getsockname(desc->fd,
+                          (struct sockaddr *)&name,
+                          &namelen);
 
     if (0 == gsn)
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Accepting connection on `%s'\n",
-           GNUNET_a2s ((const struct sockaddr *) &name,
-                       namelen));
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Accepting connection on `%s'\n",
+          GNUNET_a2s((const struct sockaddr *)&name,
+                     namelen));
   }
 #endif
-  ret->fd = accept (desc->fd,
-                    address,
-                    address_len);
+  ret->fd = accept(desc->fd,
+                   address,
+                   address_len);
   if (-1 == ret->fd)
-  {
-    eno = errno;
-    GNUNET_free (ret);
-    errno = eno;
-    return NULL;
-  }
+    {
+      eno = errno;
+      GNUNET_free(ret);
+      errno = eno;
+      return NULL;
+    }
   if (GNUNET_OK !=
-      initialize_network_handle (ret,
-                                 (NULL != address) ? address->sa_family : desc->af,
-                                 SOCK_STREAM))
-  {
-    return NULL;
-  }
+      initialize_network_handle(ret,
+                                (NULL != address) ? address->sa_family : desc->af,
+                                SOCK_STREAM))
+    {
+      return NULL;
+    }
   return ret;
 }
 
@@ -527,9 +527,9 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
-                            const struct sockaddr *address,
-                            socklen_t address_len)
+GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc,
+                           const struct sockaddr *address,
+                           socklen_t address_len)
 {
   int ret;
 
@@ -539,63 +539,63 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
     const int on = 1;
 
     if (AF_INET6 == desc->af)
-      if (setsockopt (desc->fd,
-                      IPPROTO_IPV6,
-                      IPV6_V6ONLY,
-                      (const void *) &on,
-                      sizeof (on)))
-        LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG,
-                      "setsockopt");
+      if (setsockopt(desc->fd,
+                     IPPROTO_IPV6,
+                     IPV6_V6ONLY,
+                     (const void *)&on,
+                     sizeof(on)))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_DEBUG,
+                     "setsockopt");
   }
 #endif
 #endif
 #ifndef WINDOWS
   if (AF_UNIX == address->sa_family)
-    GNUNET_NETWORK_unix_precheck ((const struct sockaddr_un *) address);
+    GNUNET_NETWORK_unix_precheck((const struct sockaddr_un *)address);
   {
     const int on = 1;
 
     /* This is required here for TCP sockets, but only on UNIX */
-    if ( (SOCK_STREAM == desc->type) &&
-         (0 != setsockopt (desc->fd,
-                           SOL_SOCKET,
-                           SO_REUSEADDR,
-                           &on, sizeof (on))))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG,
-                    "setsockopt");
+    if ((SOCK_STREAM == desc->type) &&
+        (0 != setsockopt(desc->fd,
+                         SOL_SOCKET,
+                         SO_REUSEADDR,
+                         &on, sizeof(on))))
+      LOG_STRERROR(GNUNET_ERROR_TYPE_DEBUG,
+                   "setsockopt");
   }
   {
     /* set permissions of newly created non-abstract UNIX domain socket to
        "user-only"; applications can choose to relax this later */
     mode_t old_mask = 0; /* assigned to make compiler happy */
-    const struct sockaddr_un *un = (const struct sockaddr_un *) address;
+    const struct sockaddr_un *un = (const struct sockaddr_un *)address;
     int not_abstract = 0;
 
     if ((AF_UNIX == address->sa_family)
-        && ('\0' != un->sun_path[0]) ) /* Not an abstract socket */
+        && ('\0' != un->sun_path[0]))  /* Not an abstract socket */
       not_abstract = 1;
     if (not_abstract)
-      old_mask = umask (S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IROTH | S_IXOTH);
+      old_mask = umask(S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IROTH | S_IXOTH);
 #endif
 
-    ret = bind (desc->fd,
-                address,
-                address_len);
+  ret = bind(desc->fd,
+             address,
+             address_len);
 
 #ifndef WINDOWS
-    if (not_abstract)
-      (void) umask (old_mask);
-  }
+  if (not_abstract)
+    (void)umask(old_mask);
+}
 #endif
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   if (0 != ret)
     return GNUNET_SYSERR;
 #ifndef MINGW
-  desc->addr = GNUNET_malloc (address_len);
-  GNUNET_memcpy (desc->addr, address, address_len);
+  desc->addr = GNUNET_malloc(address_len);
+  GNUNET_memcpy(desc->addr, address, address_len);
   desc->addrlen = address_len;
 #endif
   return GNUNET_OK;
@@ -609,72 +609,73 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
 {
   int ret;
 
 #ifdef WINDOWS
   DWORD error = 0;
 
-  SetLastError (0);
-  ret = closesocket (desc->fd);
-  error = WSAGetLastError ();
-  SetErrnoFromWinsockError (error);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Closed 0x%x, closesocket() returned %d, GLE is %u\n",
-       desc->fd,
-       ret,
-       error);
+  SetLastError(0);
+  ret = closesocket(desc->fd);
+  error = WSAGetLastError();
+  SetErrnoFromWinsockError(error);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Closed 0x%x, closesocket() returned %d, GLE is %u\n",
+      desc->fd,
+      ret,
+      error);
 #else
-  ret = close (desc->fd);
+  ret = close(desc->fd);
 #endif
 #ifndef WINDOWS
-  const struct sockaddr_un *un = (const struct sockaddr_un *) desc->addr;
+  const struct sockaddr_un *un = (const struct sockaddr_un *)desc->addr;
 
   /* Cleanup the UNIX domain socket and its parent directories in case of non
      abstract sockets */
-  if ( (AF_UNIX == desc->af) &&
-       (NULL != desc->addr) &&
-       ('\0' != un->sun_path[0]) )
-  {
-    char *dirname = GNUNET_strndup (un->sun_path,
-                                    sizeof (un->sun_path));
-
-    if (0 != unlink (dirname))
-    {
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
-                         "unlink",
-                         dirname);
-    }
-    else
+  if ((AF_UNIX == desc->af) &&
+      (NULL != desc->addr) &&
+      ('\0' != un->sun_path[0]))
     {
-      size_t len;
-
-      len = strlen (dirname);
-      while ((len > 0) && (dirname[len] != DIR_SEPARATOR))
-        len--;
-      dirname[len] = '\0';
-      if ((0 != len) && (0 != rmdir (dirname)))
-      {
-        switch (errno)
+      char *dirname = GNUNET_strndup(un->sun_path,
+                                     sizeof(un->sun_path));
+
+      if (0 != unlink(dirname))
         {
-        case EACCES:
-        case ENOTEMPTY:
-        case EPERM:
-          /* these are normal and can just be ignored */
-          break;
-        default:
-          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                    "rmdir",
-                                    dirname);
-          break;
+          LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING,
+                            "unlink",
+                            dirname);
         }
-      }
+      else
+        {
+          size_t len;
+
+          len = strlen(dirname);
+          while ((len > 0) && (dirname[len] != DIR_SEPARATOR))
+            len--;
+          dirname[len] = '\0';
+          if ((0 != len) && (0 != rmdir(dirname)))
+            {
+              switch (errno)
+                {
+                case EACCES:
+                case ENOTEMPTY:
+                case EPERM:
+                  /* these are normal and can just be ignored */
+                  break;
+
+                default:
+                  GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
+                                           "rmdir",
+                                           dirname);
+                  break;
+                }
+            }
+        }
+      GNUNET_free(dirname);
     }
-    GNUNET_free (dirname);
-  }
 #endif
-  GNUNET_NETWORK_socket_free_memory_only_ (desc);
+  GNUNET_NETWORK_socket_free_memory_only_(desc);
   return (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -685,10 +686,10 @@ GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
  * @param desc socket
  */
 void
-GNUNET_NETWORK_socket_free_memory_only_ (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_socket_free_memory_only_(struct GNUNET_NETWORK_Handle *desc)
 {
-  GNUNET_free_non_null (desc->addr);
-  GNUNET_free (desc);
+  GNUNET_free_non_null(desc->addr);
+  GNUNET_free(desc);
 }
 
 
@@ -699,27 +700,28 @@ GNUNET_NETWORK_socket_free_memory_only_ (struct GNUNET_NETWORK_Handle *desc)
  * @return NULL on error (including not supported on target platform)
  */
 struct GNUNET_NETWORK_Handle *
-GNUNET_NETWORK_socket_box_native (SOCKTYPE fd)
+GNUNET_NETWORK_socket_box_native(SOCKTYPE fd)
 {
   struct GNUNET_NETWORK_Handle *ret;
+
 #if MINGW
   unsigned long i;
   DWORD d;
   /* FIXME: Find a better call to check that FD is valid */
   if (0 !=
-      WSAIoctl (fd, FIONBIO,
-                (void *) &i, sizeof (i),
-                NULL, 0, &d,
-                NULL, NULL))
+      WSAIoctl(fd, FIONBIO,
+               (void *)&i, sizeof(i),
+               NULL, 0, &d,
+               NULL, NULL))
     return NULL;                /* invalid FD */
-  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
+  ret = GNUNET_new(struct GNUNET_NETWORK_Handle);
   ret->fd = fd;
   ret->af = AF_UNSPEC;
   return ret;
 #else
-  if (fcntl (fd, F_GETFD) < 0)
+  if (fcntl(fd, F_GETFD) < 0)
     return NULL;                /* invalid FD */
-  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
+  ret = GNUNET_new(struct GNUNET_NETWORK_Handle);
   ret->fd = fd;
   ret->af = AF_UNSPEC;
   return ret;
@@ -736,22 +738,22 @@ GNUNET_NETWORK_socket_box_native (SOCKTYPE fd)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
-                               const struct sockaddr *address,
-                               socklen_t address_len)
+GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc,
+                              const struct sockaddr *address,
+                              socklen_t address_len)
 {
   int ret;
 
-  ret = connect (desc->fd,
-                 address,
-                 address_len);
+  ret = connect(desc->fd,
+                address,
+                address_len);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-  {
-    SetErrnoFromWinsockError (WSAGetLastError ());
-    if (errno == EWOULDBLOCK)
-      errno = EINPROGRESS;
-  }
+    {
+      SetErrnoFromWinsockError(WSAGetLastError());
+      if (errno == EWOULDBLOCK)
+        errno = EINPROGRESS;
+    }
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -768,26 +770,26 @@ GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
-                                  int level,
-                                  int optname,
-                                  void *optval,
-                                  socklen_t *optlen)
+GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc,
+                                 int level,
+                                 int optname,
+                                 void *optval,
+                                 socklen_t *optlen)
 {
   int ret;
 
-  ret = getsockopt (desc->fd,
-                    level,
-                    optname,
-                    optval, optlen);
+  ret = getsockopt(desc->fd,
+                   level,
+                   optname,
+                   optval, optlen);
 
 #ifdef MINGW
-  if ( (0 == ret) &&
-       (SOL_SOCKET == level) &&
-       (SO_ERROR == optname) )
-    *((int *) optval) = GetErrnoFromWinsockError (*((int *) optval));
+  if ((0 == ret) &&
+      (SOL_SOCKET == level) &&
+      (SO_ERROR == optname))
+    *((int *)optval) = GetErrnoFromWinsockError(*((int *)optval));
   else if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -801,16 +803,16 @@ GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
-                              int backlog)
+GNUNET_NETWORK_socket_listen(const struct GNUNET_NETWORK_Handle *desc,
+                             int backlog)
 {
   int ret;
 
-  ret = listen (desc->fd,
-                backlog);
+  ret = listen(desc->fd,
+               backlog);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -823,7 +825,7 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
  * @returns #GNUNET_SYSERR if no data is available, or on error!
  */
 ssize_t
-GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_socket_recvfrom_amount(const struct GNUNET_NETWORK_Handle *desc)
 {
   int error;
 
@@ -831,20 +833,20 @@ GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle *desc)
 #ifndef WINDOWS
   int pending;
 
-  error = ioctl (desc->fd,
-                 FIONREAD,
-                 &pending);
+  error = ioctl(desc->fd,
+                FIONREAD,
+                &pending);
   if (0 == error)
-    return (ssize_t) pending;
+    return (ssize_t)pending;
   return GNUNET_SYSERR;
 #else
   u_long pending;
 
-  error = ioctlsocket (desc->fd,
-                       FIONREAD,
-                       &pending);
+  error = ioctlsocket(desc->fd,
+                      FIONREAD,
+                      &pending);
   if (error != SOCKET_ERROR)
-    return (ssize_t) pending;
+    return (ssize_t)pending;
   return GNUNET_SYSERR;
 #endif
 }
@@ -861,11 +863,11 @@ GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle *desc)
  * @param addrlen length of the @a src_addr
  */
 ssize_t
-GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle *desc,
-                                void *buffer,
-                                size_t length,
-                                struct sockaddr *src_addr,
-                                socklen_t *addrlen)
+GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc,
+                               void *buffer,
+                               size_t length,
+                               struct sockaddr *src_addr,
+                               socklen_t *addrlen)
 {
   int ret;
   int flags;
@@ -874,17 +876,16 @@ GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle *desc,
 
 #ifdef MSG_DONTWAIT
   flags |= MSG_DONTWAIT;
-
 #endif
-  ret = recvfrom (desc->fd,
-                  buffer,
-                  length,
-                  flags,
-                  src_addr,
-                  addrlen);
+  ret = recvfrom(desc->fd,
+                 buffer,
+                 length,
+                 flags,
+                 src_addr,
+                 addrlen);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret;
 }
@@ -899,9 +900,9 @@ GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle *desc,
  * @return number of bytes received, -1 on error
  */
 ssize_t
-GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle *desc,
-                            void *buffer,
-                            size_t length)
+GNUNET_NETWORK_socket_recv(const struct GNUNET_NETWORK_Handle *desc,
+                           void *buffer,
+                           size_t length)
 {
   int ret;
   int flags;
@@ -911,13 +912,13 @@ GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle *desc,
 #ifdef MSG_DONTWAIT
   flags |= MSG_DONTWAIT;
 #endif
-  ret = recv (desc->fd,
-              buffer,
-              length,
-              flags);
+  ret = recv(desc->fd,
+             buffer,
+             length,
+             flags);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret;
 }
@@ -932,9 +933,9 @@ GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle *desc,
  * @return number of bytes sent, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle *desc,
-                            const void *buffer,
-                            size_t length)
+GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc,
+                           const void *buffer,
+                           size_t length)
 {
   int ret;
   int flags;
@@ -942,20 +943,17 @@ GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle *desc,
   flags = 0;
 #ifdef MSG_DONTWAIT
   flags |= MSG_DONTWAIT;
-
 #endif
 #ifdef MSG_NOSIGNAL
   flags |= MSG_NOSIGNAL;
-
 #endif
-  ret = send (desc->fd,
-              buffer,
-              length,
-              flags);
+  ret = send(desc->fd,
+             buffer,
+             length,
+             flags);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
-
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret;
 }
@@ -973,11 +971,11 @@ GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle *desc,
  * @return number of bytes sent, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle *desc,
-                              const void *message,
-                              size_t length,
-                              const struct sockaddr *dest_addr,
-                              socklen_t dest_len)
+GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc,
+                             const void *message,
+                             size_t length,
+                             const struct sockaddr *dest_addr,
+                             socklen_t dest_len)
 {
   int ret;
   int flags;
@@ -990,10 +988,10 @@ GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle *desc,
 #ifdef MSG_NOSIGNAL
   flags |= MSG_NOSIGNAL;
 #endif
-  ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);
+  ret = sendto(desc->fd, message, length, flags, dest_addr, dest_len);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret;
 }
@@ -1010,22 +1008,22 @@ GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
-                                  int level,
-                                  int option_name,
-                                  const void *option_value,
-                                  socklen_t option_len)
+GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd,
+                                 int level,
+                                 int option_name,
+                                 const void *option_value,
+                                 socklen_t option_len)
 {
   int ret;
 
-  ret = setsockopt (fd->fd,
-                    level,
-                    option_name,
-                    option_value,
-                    option_len);
+  ret = setsockopt(fd->fd,
+                   level,
+                   option_name,
+                   option_value,
+                   option_len);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -1042,22 +1040,22 @@ GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
  * @return new socket, NULL on error
  */
 struct GNUNET_NETWORK_Handle *
-GNUNET_NETWORK_socket_create (int domain,
-                              int type,
-                              int protocol)
+GNUNET_NETWORK_socket_create(int domain,
+                             int type,
+                             int protocol)
 {
   struct GNUNET_NETWORK_Handle *ret;
   int fd;
 
-  fd = socket (domain, type, protocol);
+  fd = socket(domain, type, protocol);
   if (-1 == fd)
     return NULL;
-  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
+  ret = GNUNET_new(struct GNUNET_NETWORK_Handle);
   ret->fd = fd;
   if (GNUNET_OK !=
-      initialize_network_handle (ret,
-                                 domain,
-                                 type))
+      initialize_network_handle(ret,
+                                domain,
+                                type))
     return NULL;
   return ret;
 }
@@ -1070,15 +1068,15 @@ GNUNET_NETWORK_socket_create (int domain,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
-                                int how)
+GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc,
+                               int how)
 {
   int ret;
 
-  ret = shutdown (desc->fd, how);
+  ret = shutdown(desc->fd, how);
 #ifdef MINGW
   if (0 != ret)
-    SetErrnoFromWinsockError (WSAGetLastError ());
+    SetErrnoFromWinsockError(WSAGetLastError());
 #endif
   return (0 == ret) ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -1094,7 +1092,7 @@ GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_NETWORK_socket_disable_corking (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_socket_disable_corking(struct GNUNET_NETWORK_Handle *desc)
 {
   int ret = 0;
 
@@ -1103,43 +1101,43 @@ GNUNET_NETWORK_socket_disable_corking (struct GNUNET_NETWORK_Handle *desc)
 
   if (0 !=
       (ret =
-       setsockopt (desc->fd,
-                   SOL_SOCKET,
-                   SO_SNDBUF,
-                   (char *) &value,
-                   sizeof (value))))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+         setsockopt(desc->fd,
+                    SOL_SOCKET,
+                    SO_SNDBUF,
+                    (char *)&value,
+                    sizeof(value))))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
   if (0 !=
       (ret =
-       setsockopt (desc->fd,
-                   SOL_SOCKET,
-                   SO_RCVBUF,
-                   (char *) &value,
-                   sizeof (value))))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+         setsockopt(desc->fd,
+                    SOL_SOCKET,
+                    SO_RCVBUF,
+                    (char *)&value,
+                    sizeof(value))))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
 #elif LINUX
   int value = 0;
 
   if (0 !=
       (ret =
-       setsockopt (desc->fd,
-                   SOL_SOCKET,
-                   SO_SNDBUF,
-                   &value,
-                   sizeof (value))))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+         setsockopt(desc->fd,
+                    SOL_SOCKET,
+                    SO_SNDBUF,
+                    &value,
+                    sizeof(value))))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
   if (0 !=
       (ret =
-       setsockopt (desc->fd,
-                   SOL_SOCKET,
-                   SO_RCVBUF,
-                   &value,
-                   sizeof (value))))
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                  "setsockopt");
+         setsockopt(desc->fd,
+                    SOL_SOCKET,
+                    SO_RCVBUF,
+                    &value,
+                    sizeof(value))))
+    LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                 "setsockopt");
 #endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
@@ -1151,9 +1149,9 @@ GNUNET_NETWORK_socket_disable_corking (struct GNUNET_NETWORK_Handle *desc)
  * @param fds fd set
  */
 void
-GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)
+GNUNET_NETWORK_fdset_zero(struct GNUNET_NETWORK_FDSet *fds)
 {
-  FD_ZERO (&fds->sds);
+  FD_ZERO(&fds->sds);
   fds->nsds = 0;
 #ifdef MINGW
   fds->handles_pos = 0;
@@ -1168,13 +1166,13 @@ GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)
  * @param desc socket to add
  */
 void
-GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,
-                          const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_fdset_set(struct GNUNET_NETWORK_FDSet *fds,
+                         const struct GNUNET_NETWORK_Handle *desc)
 {
-  FD_SET (desc->fd,
-          &fds->sds);
-  fds->nsds = GNUNET_MAX (fds->nsds,
-                          desc->fd + 1);
+  FD_SET(desc->fd,
+         &fds->sds);
+  fds->nsds = GNUNET_MAX(fds->nsds,
+                         desc->fd + 1);
 }
 
 
@@ -1186,11 +1184,11 @@ GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,
  * @return 0 if the FD is not set
  */
 int
-GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,
-                            const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds,
+                           const struct GNUNET_NETWORK_Handle *desc)
 {
-  return FD_ISSET (desc->fd,
-                   &fds->sds);
+  return FD_ISSET(desc->fd,
+                  &fds->sds);
 }
 
 
@@ -1201,17 +1199,17 @@ GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,
  * @param src the fd set to add from
  */
 void
-GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
-                          const struct GNUNET_NETWORK_FDSet *src)
+GNUNET_NETWORK_fdset_add(struct GNUNET_NETWORK_FDSet *dst,
+                         const struct GNUNET_NETWORK_FDSet *src)
 {
 #ifndef MINGW
   int nfds;
 
   for (nfds = src->nsds; nfds >= 0; nfds--)
-    if (FD_ISSET (nfds, &src->sds))
-      FD_SET (nfds, &dst->sds);
-  dst->nsds = GNUNET_MAX (dst->nsds,
-                          src->nsds);
+    if (FD_ISSET(nfds, &src->sds))
+      FD_SET(nfds, &dst->sds);
+  dst->nsds = GNUNET_MAX(dst->nsds,
+                         src->nsds);
 #else
   /* This is MinGW32-specific implementation that relies on the code that
    * winsock2.h defines for FD_SET. Namely, it relies on FD_SET checking
@@ -1224,16 +1222,16 @@ GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
   unsigned int i;
 
   for (i = 0; i < src->sds.fd_count; i++)
-    FD_SET (src->sds.fd_array[i],
-            &dst->sds);
-  dst->nsds = GNUNET_MAX (src->nsds,
-                          dst->nsds);
+    FD_SET(src->sds.fd_array[i],
+           &dst->sds);
+  dst->nsds = GNUNET_MAX(src->nsds,
+                         dst->nsds);
 
   /* also copy over `struct GNUNET_DISK_FileHandle` array */
   if (dst->handles_pos + src->handles_pos > dst->handles_size)
-    GNUNET_array_grow (dst->handles,
-                       dst->handles_size,
-                       ((dst->handles_pos + src->handles_pos) << 1));
+    GNUNET_array_grow(dst->handles,
+                      dst->handles_size,
+                      ((dst->handles_pos + src->handles_pos) << 1));
   for (i = 0; i < src->handles_pos; i++)
     dst->handles[dst->handles_pos++] = src->handles[i];
 #endif
@@ -1247,20 +1245,20 @@ GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
  * @param from source
  */
 void
-GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
-                           const struct GNUNET_NETWORK_FDSet *from)
+GNUNET_NETWORK_fdset_copy(struct GNUNET_NETWORK_FDSet *to,
+                          const struct GNUNET_NETWORK_FDSet *from)
 {
-  FD_COPY (&from->sds,
-           &to->sds);
+  FD_COPY(&from->sds,
+          &to->sds);
   to->nsds = from->nsds;
 #ifdef MINGW
   if (from->handles_pos > to->handles_size)
-    GNUNET_array_grow (to->handles,
-                       to->handles_size,
-                       from->handles_pos * 2);
-  GNUNET_memcpy (to->handles,
-                 from->handles,
-                 from->handles_pos * sizeof (struct GNUNET_NETWORK_Handle *));
+    GNUNET_array_grow(to->handles,
+                      to->handles_size,
+                      from->handles_pos * 2);
+  GNUNET_memcpy(to->handles,
+                from->handles,
+                from->handles_pos * sizeof(struct GNUNET_NETWORK_Handle *));
   to->handles_pos = from->handles_pos;
 #endif
 }
@@ -1273,7 +1271,7 @@ GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
  * @return POSIX file descriptor
  */
 int
-GNUNET_NETWORK_get_fd (const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->fd;
 }
@@ -1286,7 +1284,7 @@ GNUNET_NETWORK_get_fd (const struct GNUNET_NETWORK_Handle *desc)
  * @return sockaddr
  */
 struct sockaddr*
-GNUNET_NETWORK_get_addr (const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_addr(const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->addr;
 }
@@ -1299,7 +1297,7 @@ GNUNET_NETWORK_get_addr (const struct GNUNET_NETWORK_Handle *desc)
  * @return socklen_t for sockaddr
  */
 socklen_t
-GNUNET_NETWORK_get_addrlen (const struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_addrlen(const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->addrlen;
 }
@@ -1313,12 +1311,12 @@ GNUNET_NETWORK_get_addrlen (const struct GNUNET_NETWORK_Handle *desc)
  * @param nfds the biggest socket number in from + 1
  */
 void
-GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,
-                                  const fd_set *from,
-                                  int nfds)
+GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to,
+                                 const fd_set *from,
+                                 int nfds)
 {
-  FD_COPY (from,
-           &to->sds);
+  FD_COPY(from,
+          &to->sds);
   to->nsds = nfds;
 }
 
@@ -1330,13 +1328,13 @@ GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,
  * @param nfd native FD to set
  */
 void
-GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to,
-                                 int nfd)
+GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to,
+                                int nfd)
 {
-  GNUNET_assert ((nfd >= 0) && (nfd < FD_SETSIZE));
-  FD_SET (nfd, &to->sds);
-  to->nsds = GNUNET_MAX (nfd + 1,
-                         to->nsds);
+  GNUNET_assert((nfd >= 0) && (nfd < FD_SETSIZE));
+  FD_SET(nfd, &to->sds);
+  to->nsds = GNUNET_MAX(nfd + 1,
+                        to->nsds);
 }
 
 
@@ -1348,13 +1346,13 @@ GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to,
  * @return #GNUNET_YES if FD is set in the set
  */
 int
-GNUNET_NETWORK_fdset_test_native (const struct GNUNET_NETWORK_FDSet *to,
-                                  int nfd)
+GNUNET_NETWORK_fdset_test_native(const struct GNUNET_NETWORK_FDSet *to,
+                                 int nfd)
 {
-  if ( (-1 == nfd) ||
-       (NULL == to) )
+  if ((-1 == nfd) ||
+      (NULL == to))
     return GNUNET_NO;
-  return FD_ISSET (nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
+  return FD_ISSET(nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
 }
 
 
@@ -1364,26 +1362,26 @@ GNUNET_NETWORK_fdset_test_native (const struct GNUNET_NETWORK_FDSet *to,
  * @param h the file handle to add
  */
 void
-GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
-                                 const struct GNUNET_DISK_FileHandle *h)
+GNUNET_NETWORK_fdset_handle_set(struct GNUNET_NETWORK_FDSet *fds,
+                                const struct GNUNET_DISK_FileHandle *h)
 {
 #ifdef MINGW
   if (fds->handles_pos == fds->handles_size)
-    GNUNET_array_grow (fds->handles,
-                       fds->handles_size,
-                       fds->handles_size * 2 + 2);
+    GNUNET_array_grow(fds->handles,
+                      fds->handles_size,
+                      fds->handles_size * 2 + 2);
   fds->handles[fds->handles_pos++] = h;
 #else
   int fd;
 
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_DISK_internal_file_handle_ (h,
-                                                    &fd,
-                                                    sizeof (int)));
-  FD_SET (fd,
-          &fds->sds);
-  fds->nsds = GNUNET_MAX (fd + 1,
-                          fds->nsds);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_DISK_internal_file_handle_(h,
+                                                  &fd,
+                                                  sizeof(int)));
+  FD_SET(fd,
+         &fds->sds);
+  fds->nsds = GNUNET_MAX(fd + 1,
+                         fds->nsds);
 #endif
 }
 
@@ -1394,24 +1392,24 @@ GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
  * @param h the file handle to add
  */
 void
-GNUNET_NETWORK_fdset_handle_set_first (struct GNUNET_NETWORK_FDSet *fds,
-                                       const struct GNUNET_DISK_FileHandle *h)
+GNUNET_NETWORK_fdset_handle_set_first(struct GNUNET_NETWORK_FDSet *fds,
+                                      const struct GNUNET_DISK_FileHandle *h)
 {
 #ifdef MINGW
   if (fds->handles_pos == fds->handles_size)
-    GNUNET_array_grow (fds->handles,
-                       fds->handles_size,
-                       fds->handles_size * 2 + 2);
+    GNUNET_array_grow(fds->handles,
+                      fds->handles_size,
+                      fds->handles_size * 2 + 2);
   fds->handles[fds->handles_pos] = h;
   if (fds->handles[0] != h)
-  {
-    const struct GNUNET_DISK_FileHandle *bak = fds->handles[0];
-    fds->handles[0] = h;
-    fds->handles[fds->handles_pos] = bak;
-  }
+    {
+      const struct GNUNET_DISK_FileHandle *bak = fds->handles[0];
+      fds->handles[0] = h;
+      fds->handles[fds->handles_pos] = bak;
+    }
   fds->handles_pos++;
 #else
-  GNUNET_NETWORK_fdset_handle_set (fds, h);
+  GNUNET_NETWORK_fdset_handle_set(fds, h);
 #endif
 }
 
@@ -1424,19 +1422,19 @@ GNUNET_NETWORK_fdset_handle_set_first (struct GNUNET_NETWORK_FDSet *fds,
  * @return #GNUNET_YES if the file handle is part of the set
  */
 int
-GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
-                                   const struct GNUNET_DISK_FileHandle *h)
+GNUNET_NETWORK_fdset_handle_isset(const struct GNUNET_NETWORK_FDSet *fds,
+                                  const struct GNUNET_DISK_FileHandle *h)
 {
 #ifdef MINGW
   unsigned int i;
 
-  for (i=0;i<fds->handles_pos;i++)
+  for (i = 0; i < fds->handles_pos; i++)
     if (fds->handles[i] == h)
       return GNUNET_YES;
   return GNUNET_NO;
 #else
-  return FD_ISSET (h->fd,
-                   &fds->sds);
+  return FD_ISSET(h->fd,
+                  &fds->sds);
 #endif
 }
 
@@ -1451,12 +1449,12 @@ GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
  * @return -1, 0 or 1, if the p1 < p2, p1==p2 or p1 > p2.
  */
 static int
-ptr_cmp (const void *p1,
-         const void *p2)
+ptr_cmp(const void *p1,
+        const void *p2)
 {
   if (p1 == p2)
     return 0;
-  if ((intptr_t) p1 < (intptr_t) p2)
+  if ((intptr_t)p1 < (intptr_t)p2)
     return -1;
   return 1;
 }
@@ -1471,23 +1469,23 @@ ptr_cmp (const void *p1,
  * @return #GNUNET_YES if they do overlap, #GNUNET_NO otherwise
  */
 int
-GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
-                              const struct GNUNET_NETWORK_FDSet *fds2)
+GNUNET_NETWORK_fdset_overlap(const struct GNUNET_NETWORK_FDSet *fds1,
+                             const struct GNUNET_NETWORK_FDSet *fds2)
 {
 #ifndef MINGW
   int nfds;
 
-  nfds = GNUNET_MIN (fds1->nsds,
-                     fds2->nsds);
+  nfds = GNUNET_MIN(fds1->nsds,
+                    fds2->nsds);
   while (nfds > 0)
-  {
-    nfds--;
-    if ( (FD_ISSET (nfds,
+    {
+      nfds--;
+      if ((FD_ISSET(nfds,
                     &fds1->sds)) &&
-         (FD_ISSET (nfds,
-                    &fds2->sds)) )
-      return GNUNET_YES;
-  }
+          (FD_ISSET(nfds,
+                    &fds2->sds)))
+        return GNUNET_YES;
+    }
   return GNUNET_NO;
 #else
   unsigned int i;
@@ -1501,37 +1499,39 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
         return GNUNET_YES;
 
   /* take a short cut if possible */
-  if ( (0 == fds1->handles_pos) ||
-       (0 == fds2->handles_pos) )
+  if ((0 == fds1->handles_pos) ||
+      (0 == fds2->handles_pos))
     return GNUNET_NO;
 
   /* Sort file handles array to avoid quadratic complexity when
      checking for overlap */
-  qsort (fds1->handles,
-         fds1->handles_pos,
-         sizeof (void *),
-         &ptr_cmp);
-  qsort (fds2->handles,
-         fds2->handles_pos,
-         sizeof (void *),
-         &ptr_cmp);
+  qsort(fds1->handles,
+        fds1->handles_pos,
+        sizeof(void *),
+        &ptr_cmp);
+  qsort(fds2->handles,
+        fds2->handles_pos,
+        sizeof(void *),
+        &ptr_cmp);
   i = 0;
   j = 0;
-  while ( (i < fds1->handles_pos) &&
-          (j < fds2->handles_pos) )
-  {
-    switch (ptr_cmp (fds1->handles[i],
-                     fds2->handles[j]))
+  while ((i < fds1->handles_pos) &&
+         (j < fds2->handles_pos))
     {
-    case -1:
-      i++;
-      break;
-    case 0:
-      return GNUNET_YES;
-    case 1:
-      j++;
+      switch (ptr_cmp(fds1->handles[i],
+                      fds2->handles[j]))
+        {
+        case -1:
+          i++;
+          break;
+
+        case 0:
+          return GNUNET_YES;
+
+        case 1:
+          j++;
+        }
     }
-  }
   return GNUNET_NO;
 #endif
 }
@@ -1543,12 +1543,12 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
  * @return a new fd set
  */
 struct GNUNET_NETWORK_FDSet *
-GNUNET_NETWORK_fdset_create ()
+GNUNET_NETWORK_fdset_create()
 {
   struct GNUNET_NETWORK_FDSet *fds;
 
-  fds = GNUNET_new (struct GNUNET_NETWORK_FDSet);
-  GNUNET_NETWORK_fdset_zero (fds);
+  fds = GNUNET_new(struct GNUNET_NETWORK_FDSet);
+  GNUNET_NETWORK_fdset_zero(fds);
   return fds;
 }
 
@@ -1559,14 +1559,14 @@ GNUNET_NETWORK_fdset_create ()
  * @param fds fd set
  */
 void
-GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)
+GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
 {
 #ifdef MINGW
-  GNUNET_array_grow (fds->handles,
-                     fds->handles_size,
-                     0);
+  GNUNET_array_grow(fds->handles,
+                    fds->handles_size,
+                    0);
 #endif
-  GNUNET_free (fds);
+  GNUNET_free(fds);
 }
 
 
@@ -1574,8 +1574,7 @@ GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)
 /**
  * FIXME.
  */
-struct _select_params
-{
+struct _select_params {
   /**
    * Read set.
    */
@@ -1622,29 +1621,29 @@ struct _select_params
  * FIXME.
  */
 static DWORD WINAPI
-_selector (LPVOID p)
+_selector(LPVOID p)
 {
   struct _select_params *sp = p;
 
   while (1)
-  {
-    WaitForSingleObject (sp->standby,
-                         INFINITE);
-    ResetEvent (sp->standby);
-    sp->status = select (1,
-                         sp->r,
-                         sp->w,
-                         sp->e,
-                         sp->tv);
-    if (FD_ISSET (sp->wakeup_socket,
-                  sp->r))
     {
-      FD_CLR (sp->wakeup_socket,
-              sp->r);
-      sp->status -= 1;
+      WaitForSingleObject(sp->standby,
+                          INFINITE);
+      ResetEvent(sp->standby);
+      sp->status = select(1,
+                          sp->r,
+                          sp->w,
+                          sp->e,
+                          sp->tv);
+      if (FD_ISSET(sp->wakeup_socket,
+                   sp->r))
+        {
+          FD_CLR(sp->wakeup_socket,
+                 sp->r);
+          sp->status -= 1;
+        }
+      SetEvent(sp->wakeup);
     }
-    SetEvent (sp->wakeup);
-  }
   return 0;
 }
 
@@ -1674,7 +1673,7 @@ static struct timeval select_timeout;
  * initializes that thread.
  */
 static void
-initialize_select_thread ()
+initialize_select_thread()
 {
   SOCKET select_listening_socket = -1;
   struct sockaddr_in s_in;
@@ -1682,67 +1681,67 @@ initialize_select_thread ()
   int res;
   unsigned long p;
 
-  select_standby_event = CreateEvent (NULL, TRUE, FALSE, NULL);
-  select_finished_event = CreateEvent (NULL, TRUE, FALSE, NULL);
+  select_standby_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+  select_finished_event = CreateEvent(NULL, TRUE, FALSE, NULL);
 
-  select_wakeup_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  select_wakeup_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
-  select_listening_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  select_listening_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
   p = 1;
-  res = ioctlsocket (select_wakeup_socket, FIONBIO, &p);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Select thread initialization: ioctlsocket() returns %d\n",
-       res);
+  res = ioctlsocket(select_wakeup_socket, FIONBIO, &p);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Select thread initialization: ioctlsocket() returns %d\n",
+      res);
 
-  alen = sizeof (s_in);
+  alen = sizeof(s_in);
   s_in.sin_family = AF_INET;
   s_in.sin_port = 0;
   s_in.sin_addr.S_un.S_un_b.s_b1 = 127;
   s_in.sin_addr.S_un.S_un_b.s_b2 = 0;
   s_in.sin_addr.S_un.S_un_b.s_b3 = 0;
   s_in.sin_addr.S_un.S_un_b.s_b4 = 1;
-  res = bind (select_listening_socket,
-              (const struct sockaddr *) &s_in,
-              sizeof (s_in));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Select thread initialization: bind() returns %d\n",
-       res);
-
-  res = getsockname (select_listening_socket,
-                     (struct sockaddr *) &s_in,
-                     &alen);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Select thread initialization: getsockname() returns %d\n",
-       res);
-
-  res = listen (select_listening_socket,
-                SOMAXCONN);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Select thread initialization: listen() returns %d\n",
-       res);
-  res = connect (select_wakeup_socket,
-                 (const struct sockaddr *) &s_in,
-                 sizeof (s_in));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Select thread initialization: connect() returns %d\n",
-       res);
-
-  select_send_socket = accept (select_listening_socket,
-                               (struct sockaddr *) &s_in,
-                               &alen);
-
-  closesocket (select_listening_socket);
+  res = bind(select_listening_socket,
+             (const struct sockaddr *)&s_in,
+             sizeof(s_in));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Select thread initialization: bind() returns %d\n",
+      res);
+
+  res = getsockname(select_listening_socket,
+                    (struct sockaddr *)&s_in,
+                    &alen);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Select thread initialization: getsockname() returns %d\n",
+      res);
+
+  res = listen(select_listening_socket,
+               SOMAXCONN);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Select thread initialization: listen() returns %d\n",
+      res);
+  res = connect(select_wakeup_socket,
+                (const struct sockaddr *)&s_in,
+                sizeof(s_in));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Select thread initialization: connect() returns %d\n",
+      res);
+
+  select_send_socket = accept(select_listening_socket,
+                              (struct sockaddr *)&s_in,
+                              &alen);
+
+  closesocket(select_listening_socket);
 
   sp.wakeup = select_finished_event;
   sp.standby = select_standby_event;
   sp.wakeup_socket = select_wakeup_socket;
 
-  select_thread = CreateThread (NULL,
-                                0,
-                                _selector,
-                                &sp,
-                                0, NULL);
+  select_thread = CreateThread(NULL,
+                               0,
+                               _selector,
+                               &sp,
+                               0, NULL);
 }
 
 
@@ -1756,8 +1755,8 @@ initialize_select_thread ()
  * @return #GNUNET_OK if the port is available, #GNUNET_NO if not
  */
 int
-GNUNET_NETWORK_test_port_free (int ipproto,
-                               uint16_t port)
+GNUNET_NETWORK_test_port_free(int ipproto,
+                              uint16_t port)
 {
   struct GNUNET_NETWORK_Handle *socket;
   int bind_status;
@@ -1767,13 +1766,13 @@ GNUNET_NETWORK_test_port_free (int ipproto,
   struct addrinfo *ret;
   struct addrinfo *ai;
 
-  GNUNET_snprintf (open_port_str,
-                   sizeof (open_port_str),
-                   "%u",
-                   (unsigned int) port);
+  GNUNET_snprintf(open_port_str,
+                  sizeof(open_port_str),
+                  "%u",
+                  (unsigned int)port);
   socktype = (IPPROTO_TCP == ipproto) ? SOCK_STREAM : SOCK_DGRAM;
   ret = NULL;
-  memset (&hint, 0, sizeof (hint));
+  memset(&hint, 0, sizeof(hint));
   hint.ai_family = AF_UNSPEC; /* IPv4 and IPv6 */
   hint.ai_socktype = socktype;
   hint.ai_protocol = ipproto;
@@ -1782,26 +1781,26 @@ GNUNET_NETWORK_test_port_free (int ipproto,
   hint.ai_canonname = NULL;
   hint.ai_next = NULL;
   hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* Wild card address */
-  GNUNET_assert (0 == getaddrinfo (NULL,
-                                   open_port_str,
-                                   &hint,
-                                   &ret));
+  GNUNET_assert(0 == getaddrinfo(NULL,
+                                 open_port_str,
+                                 &hint,
+                                 &ret));
   bind_status = GNUNET_NO;
   for (ai = ret; NULL != ai; ai = ai->ai_next)
-  {
-    socket = GNUNET_NETWORK_socket_create (ai->ai_family,
-                                           ai->ai_socktype,
-                                           ai->ai_protocol);
-    if (NULL == socket)
-      continue;
-    bind_status = GNUNET_NETWORK_socket_bind (socket,
-                                              ai->ai_addr,
-                                              ai->ai_addrlen);
-    GNUNET_NETWORK_socket_close (socket);
-    if (GNUNET_OK != bind_status)
-      break;
-  }
-  freeaddrinfo (ret);
+    {
+      socket = GNUNET_NETWORK_socket_create(ai->ai_family,
+                                            ai->ai_socktype,
+                                            ai->ai_protocol);
+      if (NULL == socket)
+        continue;
+      bind_status = GNUNET_NETWORK_socket_bind(socket,
+                                               ai->ai_addr,
+                                               ai->ai_addrlen);
+      GNUNET_NETWORK_socket_close(socket);
+      if (GNUNET_OK != bind_status)
+        break;
+    }
+  freeaddrinfo(ret);
   return bind_status;
 }
 
@@ -1817,10 +1816,10 @@ GNUNET_NETWORK_test_port_free (int ipproto,
  * @return number of selected sockets or pipes, #GNUNET_SYSERR on error
  */
 int
-GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
-                              struct GNUNET_NETWORK_FDSet *wfds,
-                              struct GNUNET_NETWORK_FDSet *efds,
-                              const struct GNUNET_TIME_Relative timeout)
+GNUNET_NETWORK_socket_select(struct GNUNET_NETWORK_FDSet *rfds,
+                             struct GNUNET_NETWORK_FDSet *wfds,
+                             struct GNUNET_NETWORK_FDSet *efds,
+                             const struct GNUNET_TIME_Relative timeout)
 {
   int nfds;
   struct timeval tv;
@@ -1830,37 +1829,37 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   else
     nfds = 0;
   if (NULL != wfds)
-    nfds = GNUNET_MAX (nfds,
-                       wfds->nsds);
+    nfds = GNUNET_MAX(nfds,
+                      wfds->nsds);
   if (NULL != efds)
-    nfds = GNUNET_MAX (nfds,
-                       efds->nsds);
+    nfds = GNUNET_MAX(nfds,
+                      efds->nsds);
   if ((0 == nfds) &&
       (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us))
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
-         "select");
-  }
-  if (timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us > (unsigned long long) LONG_MAX)
-  {
-    tv.tv_sec = LONG_MAX;
-    tv.tv_usec = 999999L;
-  }
+    {
+      GNUNET_break(0);
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
+          "select");
+    }
+  if (timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us > (unsigned long long)LONG_MAX)
+    {
+      tv.tv_sec = LONG_MAX;
+      tv.tv_usec = 999999L;
+    }
   else
-  {
-    tv.tv_sec = (long) (timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us);
-    tv.tv_usec =
-      (timeout.rel_value_us -
-       (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
-  }
-  return select (nfds,
-                 (NULL != rfds) ? &rfds->sds : NULL,
-                 (NULL != wfds) ? &wfds->sds : NULL,
-                 (NULL != efds) ? &efds->sds : NULL,
-                 (timeout.rel_value_us ==
-                  GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) ? NULL : &tv);
+    {
+      tv.tv_sec = (long)(timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us);
+      tv.tv_usec =
+        (timeout.rel_value_us -
+         (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
+    }
+  return select(nfds,
+                (NULL != rfds) ? &rfds->sds : NULL,
+                (NULL != wfds) ? &wfds->sds : NULL,
+                (NULL != efds) ? &efds->sds : NULL,
+                (timeout.rel_value_us ==
+                 GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) ? NULL : &tv);
 }
 
 
@@ -1875,25 +1874,25 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
  * @return #GNUNET_YES if the pipe is ready for reading
  */
 static int
-pipe_read_ready (const struct GNUNET_DISK_FileHandle *fh)
+pipe_read_ready(const struct GNUNET_DISK_FileHandle *fh)
 {
   DWORD error;
   BOOL bret;
   DWORD waitstatus = 0;
 
-  SetLastError (0);
-  bret = PeekNamedPipe (fh->h, NULL, 0, NULL, &waitstatus, NULL);
-  error = GetLastError ();
+  SetLastError(0);
+  bret = PeekNamedPipe(fh->h, NULL, 0, NULL, &waitstatus, NULL);
+  error = GetLastError();
   if (0 == bret)
-  {
-    /* TODO: either add more errors to this condition, or eliminate it
-     * entirely (failed to peek -> pipe is in serious trouble, should
-     * be selected as readable).
-     */
-    if ( (error != ERROR_BROKEN_PIPE) &&
-         (error != ERROR_INVALID_HANDLE) )
-      return GNUNET_NO;
-  }
+    {
+      /* TODO: either add more errors to this condition, or eliminate it
+       * entirely (failed to peek -> pipe is in serious trouble, should
+       * be selected as readable).
+       */
+      if ((error != ERROR_BROKEN_PIPE) &&
+          (error != ERROR_INVALID_HANDLE))
+        return GNUNET_NO;
+    }
   else if (waitstatus <= 0)
     return GNUNET_NO;
   return GNUNET_YES;
@@ -1907,11 +1906,11 @@ pipe_read_ready (const struct GNUNET_DISK_FileHandle *fh)
  * @return #GNUNET_YES if the pipe is having an IO exception.
  */
 static int
-pipe_except_ready (const struct GNUNET_DISK_FileHandle *fh)
+pipe_except_ready(const struct GNUNET_DISK_FileHandle *fh)
 {
   DWORD dwBytes;
 
-  if (PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL))
+  if (PeekNamedPipe(fh->h, NULL, 0, NULL, &dwBytes, NULL))
     return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -1931,38 +1930,38 @@ pipe_except_ready (const struct GNUNET_DISK_FileHandle *fh)
  * @return number of ready handles
  */
 static int
-check_handles_status (struct GNUNET_NETWORK_FDSet *fds,
-                      int except,
-                      HANDLE set_for_sure)
+check_handles_status(struct GNUNET_NETWORK_FDSet *fds,
+                     int except,
+                     HANDLE set_for_sure)
 {
   const struct GNUNET_DISK_FileHandle *fh;
   unsigned int roff;
   unsigned int woff;
 
   for (woff = 0, roff = 0; roff < fds->handles_pos; roff++)
-  {
-    fh = fds->handles[roff];
-    if (fh == set_for_sure)
     {
-      fds->handles[woff++] = fh;
-    }
-    else if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE)
-    {
-      if ((except && pipe_except_ready (fh)) ||
-          (!except && pipe_read_ready (fh)))
-        fds->handles[woff++] = fh;
-    }
-    else if (fh->type == GNUNET_DISK_HANLDE_TYPE_FILE)
-    {
-      if (!except)
-        fds->handles[woff++] = fh;
-    }
-    else
-    {
-      if (WAIT_OBJECT_0 == WaitForSingleObject (fh->h, 0))
-        fds->handles[woff++] = fh;
+      fh = fds->handles[roff];
+      if (fh == set_for_sure)
+        {
+          fds->handles[woff++] = fh;
+        }
+      else if (fh->type == GNUNET_DISK_HANLDE_TYPE_PIPE)
+        {
+          if ((except && pipe_except_ready(fh)) ||
+              (!except && pipe_read_ready(fh)))
+            fds->handles[woff++] = fh;
+        }
+      else if (fh->type == GNUNET_DISK_HANLDE_TYPE_FILE)
+        {
+          if (!except)
+            fds->handles[woff++] = fh;
+        }
+      else
+        {
+          if (WAIT_OBJECT_0 == WaitForSingleObject(fh->h, 0))
+            fds->handles[woff++] = fh;
+        }
     }
-  }
   fds->handles_pos = woff;
   return woff;
 }
@@ -1978,10 +1977,10 @@ check_handles_status (struct GNUNET_NETWORK_FDSet *fds,
  * @return number of selected sockets or pipes, #GNUNET_SYSERR on error
  */
 int
-GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
-                              struct GNUNET_NETWORK_FDSet *wfds,
-                              struct GNUNET_NETWORK_FDSet *efds,
-                              const struct GNUNET_TIME_Relative timeout)
+GNUNET_NETWORK_socket_select(struct GNUNET_NETWORK_FDSet *rfds,
+                             struct GNUNET_NETWORK_FDSet *wfds,
+                             struct GNUNET_NETWORK_FDSet *efds,
+                             const struct GNUNET_TIME_Relative timeout)
 {
   const struct GNUNET_DISK_FileHandle *fh;
   int nfds;
@@ -2003,68 +2002,68 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   nfds = 0;
   handles = 0;
   if (NULL != rfds)
-  {
-    nfds = GNUNET_MAX (nfds, rfds->nsds);
-    handles += rfds->handles_pos;
-  }
+    {
+      nfds = GNUNET_MAX(nfds, rfds->nsds);
+      handles += rfds->handles_pos;
+    }
   if (NULL != wfds)
-  {
-    nfds = GNUNET_MAX (nfds, wfds->nsds);
-    handles += wfds->handles_pos;
-  }
+    {
+      nfds = GNUNET_MAX(nfds, wfds->nsds);
+      handles += wfds->handles_pos;
+    }
   if (NULL != efds)
-  {
-    nfds = GNUNET_MAX (nfds, efds->nsds);
-    handles += efds->handles_pos;
-  }
+    {
+      nfds = GNUNET_MAX(nfds, efds->nsds);
+      handles += efds->handles_pos;
+    }
 
   if ((0 == nfds) &&
       (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == timeout.rel_value_us) &&
-      (0 == handles) )
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
-         "select");
-  }
+      (0 == handles))
+    {
+      GNUNET_break(0);
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
+          "select");
+    }
 #define SAFE_FD_ISSET(fd, set)  (set != NULL && FD_ISSET(fd, set))
   /* calculate how long we need to wait in microseconds */
   if (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
-  {
-    mcs_total = INFINITE;
-    ms_rounded = INFINITE;
-  }
+    {
+      mcs_total = INFINITE;
+      ms_rounded = INFINITE;
+    }
   else
-  {
-    mcs_total = timeout.rel_value_us / GNUNET_TIME_UNIT_MICROSECONDS.rel_value_us;
-    ms_rounded = (DWORD) (mcs_total / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us);
-    if (mcs_total > 0 && ms_rounded == 0)
-      ms_rounded = 1;
-  }
+    {
+      mcs_total = timeout.rel_value_us / GNUNET_TIME_UNIT_MICROSECONDS.rel_value_us;
+      ms_rounded = (DWORD)(mcs_total / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us);
+      if (mcs_total > 0 && ms_rounded == 0)
+        ms_rounded = 1;
+    }
   /* select() may be used as a portable way to sleep */
-  if (! (rfds || wfds || efds))
-  {
-    Sleep (ms_rounded);
-    return 0;
-  }
+  if (!(rfds || wfds || efds))
+    {
+      Sleep(ms_rounded);
+      return 0;
+    }
 
   if (NULL == select_thread)
-    initialize_select_thread ();
+    initialize_select_thread();
 
-  FD_ZERO (&aread);
-  FD_ZERO (&awrite);
-  FD_ZERO (&aexcept);
+  FD_ZERO(&aread);
+  FD_ZERO(&awrite);
+  FD_ZERO(&aexcept);
   if (rfds)
-    FD_COPY (&rfds->sds, &aread);
+    FD_COPY(&rfds->sds, &aread);
   if (wfds)
-    FD_COPY (&wfds->sds, &awrite);
+    FD_COPY(&wfds->sds, &awrite);
   if (efds)
-    FD_COPY (&efds->sds, &aexcept);
+    FD_COPY(&efds->sds, &aexcept);
 
   /* Start by doing a fast check on sockets and pipes (without
      waiting). It is cheap, and is sufficient most of the time.  By
      profiling we detected that to be true in 90% of the cases.
-  */
+   */
 
   /* Do the select now */
   select_timeout.tv_sec = 0;
@@ -2072,304 +2071,306 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 
   /* Copy all the writes to the except, so we can detect connect() errors */
   for (i = 0; i < awrite.fd_count; i++)
-    FD_SET (awrite.fd_array[i],
-            &aexcept);
-  if ( (aread.fd_count > 0) ||
-       (awrite.fd_count > 0) ||
-       (aexcept.fd_count > 0) )
-    selectret = select (1,
-                        (NULL != rfds) ? &aread : NULL,
-                        (NULL != wfds) ? &awrite : NULL,
-                        &aexcept,
-                        &select_timeout);
+    FD_SET(awrite.fd_array[i],
+           &aexcept);
+  if ((aread.fd_count > 0) ||
+      (awrite.fd_count > 0) ||
+      (aexcept.fd_count > 0))
+    selectret = select(1,
+                       (NULL != rfds) ? &aread : NULL,
+                       (NULL != wfds) ? &awrite : NULL,
+                       &aexcept,
+                       &select_timeout);
   else
     selectret = 0;
   if (-1 == selectret)
-  {
-    /* Throw an error early on, while we still have the context. */
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         "W32 select(%d, %d, %d) failed: %lu\n",
-         rfds ? aread.fd_count : 0,
-         wfds ? awrite.fd_count : 0,
-         aexcept.fd_count,
-         GetLastError ());
-    GNUNET_assert (0);
-  }
+    {
+      /* Throw an error early on, while we still have the context. */
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          "W32 select(%d, %d, %d) failed: %lu\n",
+          rfds ? aread.fd_count : 0,
+          wfds ? awrite.fd_count : 0,
+          aexcept.fd_count,
+          GetLastError());
+      GNUNET_assert(0);
+    }
 
   /* Check aexcept, if something is in there and we copied that
      FD before to detect connect() errors, add it back to the
      write set to report errors. */
   if (NULL != wfds)
     for (i = 0; i < aexcept.fd_count; i++)
-      if (FD_ISSET (aexcept.fd_array[i],
-                    &wfds->sds))
-        FD_SET (aexcept.fd_array[i],
-                &awrite);
+      if (FD_ISSET(aexcept.fd_array[i],
+                   &wfds->sds))
+        FD_SET(aexcept.fd_array[i],
+               &awrite);
 
 
   /* If our select returned something or is a 0-timed request, then
      also check the pipes and get out of here! */
   /* Sadly, it means code duplication :( */
-  if ( (selectret > 0) || (0 == mcs_total) )
-  {
-    retcode = 0;
+  if ((selectret > 0) || (0 == mcs_total))
+    {
+      retcode = 0;
 
-    /* Read Pipes */
-    if (rfds && (rfds->handles_pos > 0))
-      retcode += check_handles_status (rfds, GNUNET_NO, NULL);
+      /* Read Pipes */
+      if (rfds && (rfds->handles_pos > 0))
+        retcode += check_handles_status(rfds, GNUNET_NO, NULL);
 
-    /* wfds handles remain untouched, on W32
-       we pretend our pipes are "always" write-ready */
+      /* wfds handles remain untouched, on W32
+         we pretend our pipes are "always" write-ready */
 
-    /* except pipes */
-    if (efds && (efds->handles_pos > 0))
-      retcode += check_handles_status (efds, GNUNET_YES, NULL);
+      /* except pipes */
+      if (efds && (efds->handles_pos > 0))
+        retcode += check_handles_status(efds, GNUNET_YES, NULL);
 
-    if (rfds)
-    {
-      GNUNET_NETWORK_fdset_zero (rfds);
-      if (selectret != -1)
-        GNUNET_NETWORK_fdset_copy_native (rfds, &aread, selectret);
-    }
-    if (wfds)
-    {
-      GNUNET_NETWORK_fdset_zero (wfds);
-      if (selectret != -1)
-        GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, selectret);
-    }
-    if (efds)
-    {
-      GNUNET_NETWORK_fdset_zero (efds);
-      if (selectret != -1)
-        GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, selectret);
+      if (rfds)
+        {
+          GNUNET_NETWORK_fdset_zero(rfds);
+          if (selectret != -1)
+            GNUNET_NETWORK_fdset_copy_native(rfds, &aread, selectret);
+        }
+      if (wfds)
+        {
+          GNUNET_NETWORK_fdset_zero(wfds);
+          if (selectret != -1)
+            GNUNET_NETWORK_fdset_copy_native(wfds, &awrite, selectret);
+        }
+      if (efds)
+        {
+          GNUNET_NETWORK_fdset_zero(efds);
+          if (selectret != -1)
+            GNUNET_NETWORK_fdset_copy_native(efds, &aexcept, selectret);
+        }
+      if (-1 == selectret)
+        return -1;
+      /* Add our select() FDs to the total return value */
+      retcode += selectret;
+      return retcode;
     }
-    if (-1 == selectret)
-      return -1;
-    /* Add our select() FDs to the total return value */
-    retcode += selectret;
-    return retcode;
-  }
 
   /* If we got this far, use slower implementation that is able to do a waiting select
      on both sockets and pipes simultaneously */
 
   /* Events for pipes */
-  if (! hEventReadReady)
-    hEventReadReady = CreateEvent (NULL, TRUE, TRUE, NULL);
-  if (! hEventPipeWrite)
-    hEventPipeWrite = CreateEvent (NULL, TRUE, TRUE, NULL);
+  if (!hEventReadReady)
+    hEventReadReady = CreateEvent(NULL, TRUE, TRUE, NULL);
+  if (!hEventPipeWrite)
+    hEventPipeWrite = CreateEvent(NULL, TRUE, TRUE, NULL);
   retcode = 0;
 
-  FD_ZERO (&aread);
-  FD_ZERO (&awrite);
-  FD_ZERO (&aexcept);
+  FD_ZERO(&aread);
+  FD_ZERO(&awrite);
+  FD_ZERO(&aexcept);
   if (rfds)
-    FD_COPY (&rfds->sds, &aread);
+    FD_COPY(&rfds->sds, &aread);
   if (wfds)
-    FD_COPY (&wfds->sds, &awrite);
+    FD_COPY(&wfds->sds, &awrite);
   if (efds)
-    FD_COPY (&efds->sds, &aexcept);
+    FD_COPY(&efds->sds, &aexcept);
   /* We will first Add the PIPES to the events */
   /* Track how far in `handle_array` the read pipes go,
      so we may by-pass them quickly if none of them
      are selected. */
   read_pipes_off = 0;
   if (rfds && (rfds->handles_pos > 0))
-  {
-    for (i = 0; i <rfds->handles_pos; i++)
     {
-      fh = rfds->handles[i];
-      if (fh->type == GNUNET_DISK_HANLDE_TYPE_EVENT)
-      {
-        handle_array[nhandles++] = fh->h;
-        continue;
-      }
-      if (fh->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
-        continue;
-      /* Read zero bytes to check the status of the pipe */
-      if (! ReadFile (fh->h, NULL, 0, NULL, fh->oOverlapRead))
-      {
-        DWORD error_code = GetLastError ();
-
-        if (error_code == ERROR_IO_PENDING)
+      for (i = 0; i < rfds->handles_pos; i++)
         {
-          /* add as unready */
-          handle_array[nhandles++] = fh->oOverlapRead->hEvent;
-          read_pipes_off++;
+          fh = rfds->handles[i];
+          if (fh->type == GNUNET_DISK_HANLDE_TYPE_EVENT)
+            {
+              handle_array[nhandles++] = fh->h;
+              continue;
+            }
+          if (fh->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
+            continue;
+          /* Read zero bytes to check the status of the pipe */
+          if (!ReadFile(fh->h, NULL, 0, NULL, fh->oOverlapRead))
+            {
+              DWORD error_code = GetLastError();
+
+              if (error_code == ERROR_IO_PENDING)
+                {
+                  /* add as unready */
+                  handle_array[nhandles++] = fh->oOverlapRead->hEvent;
+                  read_pipes_off++;
+                }
+              else
+                {
+                  /* add as ready */
+                  handle_array[nhandles++] = hEventReadReady;
+                  read_pipes_off++;
+                }
+            }
+          else
+            {
+              /* error also counts as ready */
+              handle_array[nhandles++] = hEventReadReady;
+              read_pipes_off++;
+            }
         }
-        else
-        {
-          /* add as ready */
-          handle_array[nhandles++] = hEventReadReady;
-          read_pipes_off++;
-        }
-      }
-      else
-      {
-        /* error also counts as ready */
-        handle_array[nhandles++] = hEventReadReady;
-        read_pipes_off++;
-      }
     }
-  }
 
   if (wfds && (wfds->handles_pos > 0))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Adding the write ready event to the array as %d\n",
-         nhandles);
-    handle_array[nhandles++] = hEventPipeWrite;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Adding the write ready event to the array as %d\n",
+          nhandles);
+      handle_array[nhandles++] = hEventPipeWrite;
+    }
 
   sp.status = 0;
   if (nfds > 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Adding the socket event to the array as %d\n",
-         nhandles);
-    handle_array[nhandles++] = select_finished_event;
-    if (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     {
-      sp.tv = NULL;
-    }
-    else
-    {
-      select_timeout.tv_sec = timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us;
-      select_timeout.tv_usec = (timeout.rel_value_us -
-                                (select_timeout.tv_sec *
-                                 GNUNET_TIME_UNIT_SECONDS.rel_value_us));
-      sp.tv = &select_timeout;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Adding the socket event to the array as %d\n",
+          nhandles);
+      handle_array[nhandles++] = select_finished_event;
+      if (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+        {
+          sp.tv = NULL;
+        }
+      else
+        {
+          select_timeout.tv_sec = timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us;
+          select_timeout.tv_usec = (timeout.rel_value_us -
+                                    (select_timeout.tv_sec *
+                                     GNUNET_TIME_UNIT_SECONDS.rel_value_us));
+          sp.tv = &select_timeout;
+        }
+      FD_SET(select_wakeup_socket, &aread);
+      do
+        {
+          i = recv(select_wakeup_socket,
+                   (char *)&returnedpos,
+                   1,
+                   0);
+        }
+      while (i == 1);
+      sp.r = &aread;
+      sp.w = &awrite;
+      sp.e = &aexcept;
+      /* Failed connections cause sockets to be set in errorfds on W32,
+       * but on POSIX it should set them in writefds.
+       * First copy all awrite sockets to aexcept, later we'll
+       * check aexcept and set its contents in awrite as well
+       * Sockets are also set in errorfds when OOB data is available,
+       * but we don't use OOB data.
+       */
+      for (i = 0; i < awrite.fd_count; i++)
+        FD_SET(awrite.fd_array[i],
+               &aexcept);
+      ResetEvent(select_finished_event);
+      SetEvent(select_standby_event);
     }
-    FD_SET (select_wakeup_socket, &aread);
-    do
-    {
-      i = recv (select_wakeup_socket,
-                (char *) &returnedpos,
-                1,
-                0);
-    } while (i == 1);
-    sp.r = &aread;
-    sp.w = &awrite;
-    sp.e = &aexcept;
-    /* Failed connections cause sockets to be set in errorfds on W32,
-     * but on POSIX it should set them in writefds.
-     * First copy all awrite sockets to aexcept, later we'll
-     * check aexcept and set its contents in awrite as well
-     * Sockets are also set in errorfds when OOB data is available,
-     * but we don't use OOB data.
-     */
-    for (i = 0; i < awrite.fd_count; i++)
-      FD_SET (awrite.fd_array[i],
-              &aexcept);
-    ResetEvent (select_finished_event);
-    SetEvent (select_standby_event);
-  }
 
   /* NULL-terminate array */
   handle_array[nhandles] = NULL;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "nfds: %d, handles: %d, will wait: %llu mcs\n",
-       nfds,
-       nhandles,
-       mcs_total);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "nfds: %d, handles: %d, will wait: %llu mcs\n",
+      nfds,
+      nhandles,
+      mcs_total);
   if (nhandles)
-  {
-    returncode
-      = WaitForMultipleObjects (nhandles,
-                                handle_array,
-                                FALSE,
-                                ms_rounded);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "WaitForMultipleObjects Returned: %d\n",
-         returncode);
-  }
+    {
+      returncode
+        = WaitForMultipleObjects(nhandles,
+                                 handle_array,
+                                 FALSE,
+                                 ms_rounded);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "WaitForMultipleObjects Returned: %d\n",
+          returncode);
+    }
   else if (nfds > 0)
-  {
-    GNUNET_break (0); /* This branch shouldn't actually be executed...*/
-    i = (int) WaitForSingleObject (select_finished_event,
+    {
+      GNUNET_break(0); /* This branch shouldn't actually be executed...*/
+      i = (int)WaitForSingleObject(select_finished_event,
                                    INFINITE);
-    returncode = WAIT_TIMEOUT;
-  }
+      returncode = WAIT_TIMEOUT;
+    }
   else
-  {
-    /* Shouldn't come this far. If it does - investigate. */
-    GNUNET_assert (0);
-  }
+    {
+      /* Shouldn't come this far. If it does - investigate. */
+      GNUNET_assert(0);
+    }
 
   if (nfds > 0)
-  {
-    /* Don't wake up select-thread when delay is 0, it should return immediately
-     * and wake up by itself.
-     */
-    if (0 != mcs_total)
-      i = send (select_send_socket,
-                (const char *) &returnedpos,
-                1,
-                0);
-    i = (int) WaitForSingleObject (select_finished_event,
-                                   INFINITE);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Finished waiting for the select thread: %d %d\n",
-         i,
-         sp.status);
-    if (0 != mcs_total)
     {
-      do
-      {
-        i = recv (select_wakeup_socket,
-                  (char *) &returnedpos,
-                  1, 0);
-      } while (1 == i);
+      /* Don't wake up select-thread when delay is 0, it should return immediately
+       * and wake up by itself.
+       */
+      if (0 != mcs_total)
+        i = send(select_send_socket,
+                 (const char *)&returnedpos,
+                 1,
+                 0);
+      i = (int)WaitForSingleObject(select_finished_event,
+                                   INFINITE);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Finished waiting for the select thread: %d %d\n",
+          i,
+          sp.status);
+      if (0 != mcs_total)
+        {
+          do
+            {
+              i = recv(select_wakeup_socket,
+                       (char *)&returnedpos,
+                       1, 0);
+            }
+          while (1 == i);
+        }
+      /* Check aexcept, add its contents to awrite */
+      for (i = 0; i < aexcept.fd_count; i++)
+        FD_SET(aexcept.fd_array[i], &awrite);
     }
-    /* Check aexcept, add its contents to awrite */
-    for (i = 0; i < aexcept.fd_count; i++)
-      FD_SET (aexcept.fd_array[i], &awrite);
-  }
 
   returnedpos = returncode - WAIT_OBJECT_0;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "return pos is: %d\n",
-       returnedpos);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "return pos is: %d\n",
+      returnedpos);
 
   if (rfds)
-  {
-    /* We queued a zero-long read on each pipe to check
-     * its state, now we must cancel these read operations.
-     * This must be done while rfds->handles_pos is still
-     * intact and matches the number of read handles that we
-     * got from the caller.
-     */
-    for (i = 0; i < rfds->handles_pos; i++)
     {
-      fh = rfds->handles[i];
-      if (GNUNET_DISK_HANLDE_TYPE_PIPE == fh->type)
-        CancelIo (fh->h);
-    }
+      /* We queued a zero-long read on each pipe to check
+       * its state, now we must cancel these read operations.
+       * This must be done while rfds->handles_pos is still
+       * intact and matches the number of read handles that we
+       * got from the caller.
+       */
+      for (i = 0; i < rfds->handles_pos; i++)
+        {
+          fh = rfds->handles[i];
+          if (GNUNET_DISK_HANLDE_TYPE_PIPE == fh->type)
+            CancelIo(fh->h);
+        }
 
-    /* We may have some pipes ready for reading. */
-    if (returnedpos < read_pipes_off)
-      retcode += check_handles_status (rfds, GNUNET_NO, handle_array[returnedpos]);
-    else
-      rfds->handles_pos = 0;
+      /* We may have some pipes ready for reading. */
+      if (returnedpos < read_pipes_off)
+        retcode += check_handles_status(rfds, GNUNET_NO, handle_array[returnedpos]);
+      else
+        rfds->handles_pos = 0;
 
-    if (-1 != sp.status)
-      GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);
-  }
+      if (-1 != sp.status)
+        GNUNET_NETWORK_fdset_copy_native(rfds, &aread, retcode);
+    }
   if (wfds)
-  {
-    retcode += wfds->handles_pos;
-    /* wfds handles remain untouched */
-    if (-1 != sp.status)
-      GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);
-  }
+    {
+      retcode += wfds->handles_pos;
+      /* wfds handles remain untouched */
+      if (-1 != sp.status)
+        GNUNET_NETWORK_fdset_copy_native(wfds, &awrite, retcode);
+    }
   if (efds)
-  {
-    retcode += check_handles_status (rfds,
-                                     GNUNET_YES,
-                                     returnedpos < nhandles ? handle_array[returnedpos] : NULL);
-    if (-1 != sp.status)
-      GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);
-  }
+    {
+      retcode += check_handles_status(rfds,
+                                      GNUNET_YES,
+                                      returnedpos < nhandles ? handle_array[returnedpos] : NULL);
+      if (-1 != sp.status)
+        GNUNET_NETWORK_fdset_copy_native(efds, &aexcept, retcode);
+    }
 
   if (sp.status > 0)
     retcode += sp.status;
diff --git a/src/util/op.c b/src/util/op.c
index 8fca7553e..20a0d3b0d 100644
--- a/src/util/op.c
+++ b/src/util/op.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
@@ -30,10 +30,9 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-op", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-op", __VA_ARGS__)
 
-struct OperationListItem
-{
+struct OperationListItem {
   struct OperationListItem *prev;
   struct OperationListItem *next;
 
@@ -63,8 +62,7 @@ struct OperationListItem
  * Operations handle.
  */
 
-struct GNUNET_OP_Handle
-{
+struct GNUNET_OP_Handle {
   /**
    * First operation in the linked list.
    */
@@ -86,9 +84,9 @@ struct GNUNET_OP_Handle
  * Create new operations handle.
  */
 struct GNUNET_OP_Handle *
-GNUNET_OP_create ()
+GNUNET_OP_create()
 {
-  return GNUNET_new (struct GNUNET_OP_Handle);
+  return GNUNET_new(struct GNUNET_OP_Handle);
 }
 
 
@@ -96,9 +94,9 @@ GNUNET_OP_create ()
  * Destroy operations handle.
  */
 void
-GNUNET_OP_destroy (struct GNUNET_OP_Handle *h)
+GNUNET_OP_destroy(struct GNUNET_OP_Handle *h)
 {
-  GNUNET_free (h);
+  GNUNET_free(h);
 }
 
 
@@ -111,7 +109,7 @@ GNUNET_OP_destroy (struct GNUNET_OP_Handle *h)
  * @return Operation ID to use.
  */
 uint64_t
-GNUNET_OP_get_next_id (struct GNUNET_OP_Handle *h)
+GNUNET_OP_get_next_id(struct GNUNET_OP_Handle *h)
 {
   return ++h->last_op_id;
 }
@@ -128,8 +126,8 @@ GNUNET_OP_get_next_id (struct GNUNET_OP_Handle *h)
  * @return Operation, or NULL if not found.
  */
 static struct OperationListItem *
-op_find (struct GNUNET_OP_Handle *h,
-         uint64_t op_id)
+op_find(struct GNUNET_OP_Handle *h,
+        uint64_t op_id)
 {
   struct OperationListItem *op;
 
@@ -158,23 +156,24 @@ op_find (struct GNUNET_OP_Handle *h,
  *         #GNUNET_NO  if not found.
  */
 int
-GNUNET_OP_get (struct GNUNET_OP_Handle *h,
-               uint64_t op_id,
-               GNUNET_ResultCallback *result_cb,
-               void **cls,
-               void **ctx)
+GNUNET_OP_get(struct GNUNET_OP_Handle *h,
+              uint64_t op_id,
+              GNUNET_ResultCallback *result_cb,
+              void **cls,
+              void **ctx)
 {
-  struct OperationListItem *op = op_find (h, op_id);
+  struct OperationListItem *op = op_find(h, op_id);
+
   if (NULL != op)
-  {
-    if (NULL != result_cb)
-      *result_cb = op->result_cb;
-    if (NULL != cls)
-      *cls = op->cls;
-    if (NULL != ctx)
-      *ctx = op->ctx;
-    return GNUNET_YES;
-  }
+    {
+      if (NULL != result_cb)
+        *result_cb = op->result_cb;
+      if (NULL != cls)
+        *cls = op->cls;
+      if (NULL != ctx)
+        *ctx = op->ctx;
+      return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -194,24 +193,24 @@ GNUNET_OP_get (struct GNUNET_OP_Handle *h,
  * @return ID of the new operation.
  */
 uint64_t
-GNUNET_OP_add (struct GNUNET_OP_Handle *h,
-               GNUNET_ResultCallback result_cb,
-               void *cls,
-               void *ctx)
+GNUNET_OP_add(struct GNUNET_OP_Handle *h,
+              GNUNET_ResultCallback result_cb,
+              void *cls,
+              void *ctx)
 {
   struct OperationListItem *op;
 
-  op = GNUNET_new (struct OperationListItem);
-  op->op_id = GNUNET_OP_get_next_id (h);
+  op = GNUNET_new(struct OperationListItem);
+  op->op_id = GNUNET_OP_get_next_id(h);
   op->result_cb = result_cb;
   op->cls = cls;
   op->ctx = ctx;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
-                                    h->op_tail,
-                                    op);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "%p Added operation #%" PRIu64 "\n",
-       h, op->op_id);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head,
+                                   h->op_tail,
+                                   op);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "%p Added operation #%" PRIu64 "\n",
+      h, op->op_id);
   return op->op_id;
 }
 
@@ -241,38 +240,38 @@ GNUNET_OP_add (struct GNUNET_OP_Handle *h,
  *         #GNUNET_NO  if the operation was not found.
  */
 static int
-op_result (struct GNUNET_OP_Handle *h,
-           uint64_t op_id,
-           int64_t result_code,
-           const void *data,
-           uint16_t data_size,
-           void **ctx,
-           uint8_t cancel)
+op_result(struct GNUNET_OP_Handle *h,
+          uint64_t op_id,
+          int64_t result_code,
+          const void *data,
+          uint16_t data_size,
+          void **ctx,
+          uint8_t cancel)
 {
   if (0 == op_id)
     return GNUNET_NO;
 
-  struct OperationListItem *op = op_find (h, op_id);
+  struct OperationListItem *op = op_find(h, op_id);
   if (NULL == op)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Could not find operation #%" PRIu64 "\n", op_id);
-    return GNUNET_NO;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Could not find operation #%" PRIu64 "\n", op_id);
+      return GNUNET_NO;
+    }
 
   if (NULL != ctx)
     *ctx = op->ctx;
 
-  GNUNET_CONTAINER_DLL_remove (h->op_head,
-                               h->op_tail,
-                               op);
+  GNUNET_CONTAINER_DLL_remove(h->op_head,
+                              h->op_tail,
+                              op);
 
-  if ( (GNUNET_YES != cancel) &&
-       (NULL != op->result_cb) )
-    op->result_cb (op->cls,
-                   result_code, data,
-                   data_size);
-  GNUNET_free (op);
+  if ((GNUNET_YES != cancel) &&
+      (NULL != op->result_cb))
+    op->result_cb(op->cls,
+                  result_code, data,
+                  data_size);
+  GNUNET_free(op);
   return GNUNET_YES;
 }
 
@@ -297,17 +296,17 @@ op_result (struct GNUNET_OP_Handle *h,
  *         #GNUNET_NO  if the operation was not found.
  */
 int
-GNUNET_OP_result (struct GNUNET_OP_Handle *h,
-                  uint64_t op_id,
-                  int64_t result_code,
-                  const void *data,
-                  uint16_t data_size,
-                  void **ctx)
+GNUNET_OP_result(struct GNUNET_OP_Handle *h,
+                 uint64_t op_id,
+                 int64_t result_code,
+                 const void *data,
+                 uint16_t data_size,
+                 void **ctx)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "%p Received result for operation #%" PRIu64 ": %" PRId64 " (size: %u)\n",
-       h, op_id, result_code, data_size);
-  return op_result (h, op_id, result_code, data, data_size, ctx, GNUNET_NO);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "%p Received result for operation #%" PRIu64 ": %" PRId64 " (size: %u)\n",
+      h, op_id, result_code, data_size);
+  return op_result(h, op_id, result_code, data, data_size, ctx, GNUNET_NO);
 }
 
 
@@ -323,11 +322,11 @@ GNUNET_OP_result (struct GNUNET_OP_Handle *h,
  *         #GNUNET_NO  if the operation was not found.
  */
 int
-GNUNET_OP_remove (struct GNUNET_OP_Handle *h,
-                  uint64_t op_id)
+GNUNET_OP_remove(struct GNUNET_OP_Handle *h,
+                 uint64_t op_id)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "%p Cancelling operation #%" PRIu64  "\n",
-       h, op_id);
-  return op_result (h, op_id, 0, NULL, 0, NULL, GNUNET_YES);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "%p Cancelling operation #%" PRIu64  "\n",
+      h, op_id);
+  return op_result(h, op_id, 0, NULL, 0, NULL, GNUNET_YES);
 }
diff --git a/src/util/os_installation.c b/src/util/os_installation.c
index 3e5a99811..656468707 100644
--- a/src/util/os_installation.c
+++ b/src/util/os_installation.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/util/os_installation.c
@@ -45,13 +45,13 @@
 
 
 #define LOG(kind, ...) \
-  GNUNET_log_from (kind, "util-os-installation", __VA_ARGS__)
+  GNUNET_log_from(kind, "util-os-installation", __VA_ARGS__)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename)       \
-  GNUNET_log_from_strerror_file (kind,                   \
-                                 "util-os-installation", \
-                                 syscall,                \
-                                 filename)
+  GNUNET_log_from_strerror_file(kind,                   \
+                                "util-os-installation", \
+                                syscall,                \
+                                filename)
 
 
 /**
@@ -91,7 +91,7 @@ static int gettextinit = 0;
  * Return default project data used by 'libgnunetutil' for GNUnet.
  */
 const struct GNUNET_OS_ProjectData *
-GNUNET_OS_project_data_default (void)
+GNUNET_OS_project_data_default(void)
 {
   return &default_pd;
 }
@@ -101,16 +101,16 @@ GNUNET_OS_project_data_default (void)
  * @return current project data.
  */
 const struct GNUNET_OS_ProjectData *
-GNUNET_OS_project_data_get ()
+GNUNET_OS_project_data_get()
 {
   if (0 == gettextinit)
-  {
-    char *path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
-    if (NULL != path)
-      bindtextdomain (PACKAGE, path);
-    GNUNET_free (path);
-    gettextinit = 1;
-  }
+    {
+      char *path = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR);
+      if (NULL != path)
+        bindtextdomain(PACKAGE, path);
+      GNUNET_free(path);
+      gettextinit = 1;
+    }
   return current_pd;
 }
 
@@ -121,17 +121,17 @@ GNUNET_OS_project_data_get ()
  * @param pd project data used to determine paths
  */
 void
-GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd)
+GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd)
 {
   if (0 == gettextinit)
-  {
-    char *path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
-    if (NULL != path)
-      bindtextdomain (PACKAGE, path);
-    GNUNET_free (path);
-    gettextinit = 1;
-  }
-  GNUNET_assert (NULL != pd);
+    {
+      char *path = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR);
+      if (NULL != path)
+        bindtextdomain(PACKAGE, path);
+      GNUNET_free(path);
+      gettextinit = 1;
+    }
+  GNUNET_assert(NULL != pd);
   current_pd = pd;
 }
 
@@ -143,7 +143,7 @@ GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd)
  * @return NULL on error
  */
 static char *
-get_path_from_proc_maps ()
+get_path_from_proc_maps()
 {
   char fn[64];
   char line[1024];
@@ -151,22 +151,22 @@ get_path_from_proc_maps ()
   FILE *f;
   char *lgu;
 
-  GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/maps", getpid ());
-  if (NULL == (f = fopen (fn, "r")))
+  GNUNET_snprintf(fn, sizeof(fn), "/proc/%u/maps", getpid());
+  if (NULL == (f = fopen(fn, "r")))
     return NULL;
-  while (NULL != fgets (line, sizeof (line), f))
-  {
-    if ((1 == SSCANF (line,
-                      "%*x-%*x %*c%*c%*c%*c %*x %*2x:%*2x %*u%*[ ]%1023s",
-                      dir)) &&
-        (NULL != (lgu = strstr (dir, current_pd->libname))))
+  while (NULL != fgets(line, sizeof(line), f))
     {
-      lgu[0] = '\0';
-      fclose (f);
-      return GNUNET_strdup (dir);
+      if ((1 == SSCANF(line,
+                       "%*x-%*x %*c%*c%*c%*c %*x %*2x:%*2x %*u%*[ ]%1023s",
+                       dir)) &&
+          (NULL != (lgu = strstr(dir, current_pd->libname))))
+        {
+          lgu[0] = '\0';
+          fclose(f);
+          return GNUNET_strdup(dir);
+        }
     }
-  }
-  fclose (f);
+  fclose(f);
   return NULL;
 }
 
@@ -177,37 +177,37 @@ get_path_from_proc_maps ()
  * @return NULL on error
  */
 static char *
-get_path_from_proc_exe ()
+get_path_from_proc_exe()
 {
   char fn[64];
   char lnk[1024];
   ssize_t size;
   char *lep;
 
-  GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/exe", getpid ());
-  size = readlink (fn, lnk, sizeof (lnk) - 1);
+  GNUNET_snprintf(fn, sizeof(fn), "/proc/%u/exe", getpid());
+  size = readlink(fn, lnk, sizeof(lnk) - 1);
   if (size <= 0)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
-    return NULL;
-  }
-  GNUNET_assert (((size_t) size) < sizeof (lnk));
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
+      return NULL;
+    }
+  GNUNET_assert(((size_t)size) < sizeof(lnk));
   lnk[size] = '\0';
   while ((lnk[size] != '/') && (size > 0))
     size--;
-  GNUNET_asprintf (&lep, "/%s/libexec/", current_pd->project_dirname);
+  GNUNET_asprintf(&lep, "/%s/libexec/", current_pd->project_dirname);
   /* test for being in lib/gnunet/libexec/ or lib/MULTIARCH/gnunet/libexec */
-  if ((((size_t) size) > strlen (lep)) &&
-      (0 == strcmp (lep, &lnk[size - strlen (lep)])))
-    size -= strlen (lep) - 1;
-  GNUNET_free (lep);
+  if ((((size_t)size) > strlen(lep)) &&
+      (0 == strcmp(lep, &lnk[size - strlen(lep)])))
+    size -= strlen(lep) - 1;
+  GNUNET_free(lep);
   if ((size < 4) || (lnk[size - 4] != '/'))
-  {
-    /* not installed in "/bin/" -- binary path probably useless */
-    return NULL;
-  }
+    {
+      /* not installed in "/bin/" -- binary path probably useless */
+      return NULL;
+    }
   lnk[size] = '\0';
-  return GNUNET_strdup (lnk);
+  return GNUNET_strdup(lnk);
 }
 #endif
 
@@ -222,20 +222,23 @@ static HINSTANCE dll_instance;
  * and hInstance saving.
  */
 BOOL WINAPI
-DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
   switch (fdwReason)
-  {
-  case DLL_PROCESS_ATTACH:
-    dll_instance = hinstDLL;
-    break;
-  case DLL_THREAD_ATTACH:
-    break;
-  case DLL_THREAD_DETACH:
-    break;
-  case DLL_PROCESS_DETACH:
-    break;
-  }
+    {
+    case DLL_PROCESS_ATTACH:
+      dll_instance = hinstDLL;
+      break;
+
+    case DLL_THREAD_ATTACH:
+      break;
+
+    case DLL_THREAD_DETACH:
+      break;
+
+    case DLL_PROCESS_DETACH:
+      break;
+    }
   return TRUE;
 }
 
@@ -246,7 +249,7 @@ DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  * @return NULL on error
  */
 static char *
-get_path_from_module_filename ()
+get_path_from_module_filename()
 {
   size_t pathlen = 512;
   DWORD real_pathlen;
@@ -261,15 +264,16 @@ get_path_from_module_filename ()
    * it fits, or we exceed the threshold.
    */
   do
-  {
-    pathlen = pathlen * 2;
-    modulepath = GNUNET_realloc (modulepath, pathlen * sizeof (wchar_t));
-    SetLastError (0);
-    real_pathlen =
-      GetModuleFileNameW (dll_instance, modulepath, pathlen * sizeof (wchar_t));
-  } while (real_pathlen >= pathlen && pathlen < 16 * 1024);
+    {
+      pathlen = pathlen * 2;
+      modulepath = GNUNET_realloc(modulepath, pathlen * sizeof(wchar_t));
+      SetLastError(0);
+      real_pathlen =
+        GetModuleFileNameW(dll_instance, modulepath, pathlen * sizeof(wchar_t));
+    }
+  while (real_pathlen >= pathlen && pathlen < 16 * 1024);
   if (real_pathlen >= pathlen)
-    GNUNET_assert (0);
+    GNUNET_assert(0);
   /* To be safe */
   modulepath[real_pathlen] = '\0';
 
@@ -281,45 +285,45 @@ get_path_from_module_filename ()
   /* Now modulepath holds full path to the directory where libgnunetutil is.
    * This directory should look like <GNUNET_PREFIX>/bin or <GNUNET_PREFIX>.
    */
-  if (wcschr (modulepath, L'/') || wcschr (modulepath, L'\\'))
-  {
-    /* At least one directory component (i.e. we're not in a root directory) */
-    wchar_t *dirname = idx;
-    while ((dirname > modulepath) && (*dirname != L'\\') && (*dirname != L'/'))
-      dirname--;
-    *dirname = L'\0';
-    if (dirname > modulepath)
+  if (wcschr(modulepath, L'/') || wcschr(modulepath, L'\\'))
     {
-      dirname++;
-      /* Now modulepath holds full path to the parent directory of the directory
-       * where libgnunetutil is.
-       * dirname holds the name of the directory where libgnunetutil is.
-       */
-      if (wcsicmp (dirname, L"bin") == 0)
-      {
-        /* pass */
-      }
-      else
-      {
-        /* Roll back our changes to modulepath */
+      /* At least one directory component (i.e. we're not in a root directory) */
+      wchar_t *dirname = idx;
+      while ((dirname > modulepath) && (*dirname != L'\\') && (*dirname != L'/'))
         dirname--;
-        *dirname = L'/';
-      }
+      *dirname = L'\0';
+      if (dirname > modulepath)
+        {
+          dirname++;
+          /* Now modulepath holds full path to the parent directory of the directory
+           * where libgnunetutil is.
+           * dirname holds the name of the directory where libgnunetutil is.
+           */
+          if (wcsicmp(dirname, L"bin") == 0)
+            {
+              /* pass */
+            }
+          else
+            {
+              /* Roll back our changes to modulepath */
+              dirname--;
+              *dirname = L'/';
+            }
+        }
     }
-  }
 
   /* modulepath is GNUNET_PREFIX */
   u8_string =
-    u16_to_u8 (modulepath, wcslen (modulepath), NULL, &u8_string_length);
+    u16_to_u8(modulepath, wcslen(modulepath), NULL, &u8_string_length);
   if (NULL == u8_string)
-    GNUNET_assert (0);
+    GNUNET_assert(0);
 
-  upath = GNUNET_malloc (u8_string_length + 1);
-  GNUNET_memcpy (upath, u8_string, u8_string_length);
+  upath = GNUNET_malloc(u8_string_length + 1);
+  GNUNET_memcpy(upath, u8_string, u8_string_length);
   upath[u8_string_length] = '\0';
 
-  free (u8_string);
-  GNUNET_free (modulepath);
+  free(u8_string);
+  GNUNET_free(modulepath);
 
   return upath;
 }
@@ -343,7 +347,7 @@ typedef int (*MyNSGetExecutablePathProto) (char *buf, size_t *bufsize);
  * @return NULL on error
  */
 static char *
-get_path_from_NSGetExecutablePath ()
+get_path_from_NSGetExecutablePath()
 {
   static char zero = '\0';
   char *path;
@@ -352,22 +356,22 @@ get_path_from_NSGetExecutablePath ()
 
   path = NULL;
   if (NULL ==
-      (func = (MyNSGetExecutablePathProto) dlsym (RTLD_DEFAULT,
-                                                  "_NSGetExecutablePath")))
+      (func = (MyNSGetExecutablePathProto)dlsym(RTLD_DEFAULT,
+                                                "_NSGetExecutablePath")))
     return NULL;
   path = &zero;
   len = 0;
   /* get the path len, including the trailing \0 */
-  (void) func (path, &len);
+  (void)func(path, &len);
   if (0 == len)
     return NULL;
-  path = GNUNET_malloc (len);
-  if (0 != func (path, &len))
-  {
-    GNUNET_free (path);
-    return NULL;
-  }
-  len = strlen (path);
+  path = GNUNET_malloc(len);
+  if (0 != func(path, &len))
+    {
+      GNUNET_free(path);
+      return NULL;
+    }
+  len = strlen(path);
   while ((path[len] != '/') && (len > 0))
     len--;
   path[len] = '\0';
@@ -381,7 +385,7 @@ get_path_from_NSGetExecutablePath ()
  * @return NULL on error
  */
 static char *
-get_path_from_dyld_image ()
+get_path_from_dyld_image()
 {
   const char *path;
   char *p;
@@ -389,23 +393,23 @@ get_path_from_dyld_image ()
   unsigned int i;
   int c;
 
-  c = _dyld_image_count ();
+  c = _dyld_image_count();
   for (i = 0; i < c; i++)
-  {
-    if (((const void *) _dyld_get_image_header (i)) !=
-        ((const void *) &_mh_dylib_header))
-      continue;
-    path = _dyld_get_image_name (i);
-    if ((NULL == path) || (0 == strlen (path)))
-      continue;
-    p = GNUNET_strdup (path);
-    s = p + strlen (p);
-    while ((s > p) && ('/' != *s))
-      s--;
-    s++;
-    *s = '\0';
-    return p;
-  }
+    {
+      if (((const void *)_dyld_get_image_header(i)) !=
+          ((const void *)&_mh_dylib_header))
+        continue;
+      path = _dyld_get_image_name(i);
+      if ((NULL == path) || (0 == strlen(path)))
+        continue;
+      p = GNUNET_strdup(path);
+      s = p + strlen(p);
+      while ((s > p) && ('/' != *s))
+        s--;
+      s++;
+      *s = '\0';
+      return p;
+    }
   return NULL;
 }
 #endif
@@ -419,7 +423,7 @@ get_path_from_dyld_image ()
  * @return path to binary, NULL if not found
  */
 static char *
-get_path_from_PATH (const char *binary)
+get_path_from_PATH(const char *binary)
 {
   char *path;
   char *pos;
@@ -427,39 +431,39 @@ get_path_from_PATH (const char *binary)
   char *buf;
   const char *p;
 
-  if (NULL == (p = getenv ("PATH")))
+  if (NULL == (p = getenv("PATH")))
     return NULL;
 #if WINDOWS
   /* On W32 look in CWD first. */
-  GNUNET_asprintf (&path, ".%c%s", PATH_SEPARATOR, p);
+  GNUNET_asprintf(&path, ".%c%s", PATH_SEPARATOR, p);
 #else
-  path = GNUNET_strdup (p); /* because we write on it */
+  path = GNUNET_strdup(p);  /* because we write on it */
 #endif
-  buf = GNUNET_malloc (strlen (path) + strlen (binary) + 1 + 1);
+  buf = GNUNET_malloc(strlen(path) + strlen(binary) + 1 + 1);
   pos = path;
-  while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-  {
-    *end = '\0';
-    sprintf (buf, "%s/%s", pos, binary);
-    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  while (NULL != (end = strchr(pos, PATH_SEPARATOR)))
     {
-      pos = GNUNET_strdup (pos);
-      GNUNET_free (buf);
-      GNUNET_free (path);
+      *end = '\0';
+      sprintf(buf, "%s/%s", pos, binary);
+      if (GNUNET_DISK_file_test(buf) == GNUNET_YES)
+        {
+          pos = GNUNET_strdup(pos);
+          GNUNET_free(buf);
+          GNUNET_free(path);
+          return pos;
+        }
+      pos = end + 1;
+    }
+  sprintf(buf, "%s/%s", pos, binary);
+  if (GNUNET_YES == GNUNET_DISK_file_test(buf))
+    {
+      pos = GNUNET_strdup(pos);
+      GNUNET_free(buf);
+      GNUNET_free(path);
       return pos;
     }
-    pos = end + 1;
-  }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_YES == GNUNET_DISK_file_test (buf))
-  {
-    pos = GNUNET_strdup (pos);
-    GNUNET_free (buf);
-    GNUNET_free (path);
-    return pos;
-  }
-  GNUNET_free (buf);
-  GNUNET_free (path);
+  GNUNET_free(buf);
+  GNUNET_free(path);
   return NULL;
 }
 
@@ -471,16 +475,16 @@ get_path_from_PATH (const char *binary)
  * @return NULL on error (environment variable not set)
  */
 static char *
-get_path_from_GNUNET_PREFIX ()
+get_path_from_GNUNET_PREFIX()
 {
   const char *p;
 
   if ((NULL != current_pd->env_varname) &&
-      (NULL != (p = getenv (current_pd->env_varname))))
-    return GNUNET_strdup (p);
+      (NULL != (p = getenv(current_pd->env_varname))))
+    return GNUNET_strdup(p);
   if ((NULL != current_pd->env_varname_alt) &&
-      (NULL != (p = getenv (current_pd->env_varname_alt))))
-    return GNUNET_strdup (p);
+      (NULL != (p = getenv(current_pd->env_varname_alt))))
+    return GNUNET_strdup(p);
   return NULL;
 }
 
@@ -492,41 +496,41 @@ get_path_from_GNUNET_PREFIX ()
  * @return a pointer to the executable path, or NULL on error
  */
 static char *
-os_get_gnunet_path ()
+os_get_gnunet_path()
 {
   char *ret;
 
-  if (NULL != (ret = get_path_from_GNUNET_PREFIX ()))
+  if (NULL != (ret = get_path_from_GNUNET_PREFIX()))
     return ret;
 #if LINUX
-  if (NULL != (ret = get_path_from_proc_maps ()))
+  if (NULL != (ret = get_path_from_proc_maps()))
     return ret;
   /* try path *first*, before /proc/exe, as /proc/exe can be wrong */
   if ((NULL != current_pd->binary_name) &&
-      (NULL != (ret = get_path_from_PATH (current_pd->binary_name))))
+      (NULL != (ret = get_path_from_PATH(current_pd->binary_name))))
     return ret;
-  if (NULL != (ret = get_path_from_proc_exe ()))
+  if (NULL != (ret = get_path_from_proc_exe()))
     return ret;
 #endif
 #if WINDOWS
-  if (NULL != (ret = get_path_from_module_filename ()))
+  if (NULL != (ret = get_path_from_module_filename()))
     return ret;
 #endif
 #if DARWIN
-  if (NULL != (ret = get_path_from_dyld_image ()))
+  if (NULL != (ret = get_path_from_dyld_image()))
     return ret;
-  if (NULL != (ret = get_path_from_NSGetExecutablePath ()))
+  if (NULL != (ret = get_path_from_NSGetExecutablePath()))
     return ret;
 #endif
   if ((NULL != current_pd->binary_name) &&
-      (NULL != (ret = get_path_from_PATH (current_pd->binary_name))))
+      (NULL != (ret = get_path_from_PATH(current_pd->binary_name))))
     return ret;
   /* other attempts here */
-  LOG (GNUNET_ERROR_TYPE_ERROR,
-       _ (
-         "Could not determine installation path for %s.  Set `%s' environment variable.\n"),
-       current_pd->project_dirname,
-       current_pd->env_varname);
+  LOG(GNUNET_ERROR_TYPE_ERROR,
+      _(
+        "Could not determine installation path for %s.  Set `%s' environment variable.\n"),
+      current_pd->project_dirname,
+      current_pd->env_varname);
   return NULL;
 }
 
@@ -536,20 +540,20 @@ os_get_gnunet_path ()
  * @return a pointer to the executable path, or NULL on error
  */
 static char *
-os_get_exec_path ()
+os_get_exec_path()
 {
   char *ret = NULL;
 
 #if LINUX
-  if (NULL != (ret = get_path_from_proc_exe ()))
+  if (NULL != (ret = get_path_from_proc_exe()))
     return ret;
 #endif
 #if WINDOWS
-  if (NULL != (ret = get_path_from_module_filename ()))
+  if (NULL != (ret = get_path_from_module_filename()))
     return ret;
 #endif
 #if DARWIN
-  if (NULL != (ret = get_path_from_NSGetExecutablePath ()))
+  if (NULL != (ret = get_path_from_NSGetExecutablePath()))
     return ret;
 #endif
   /* other attempts here */
@@ -563,7 +567,7 @@ os_get_exec_path ()
  * @return a pointer to the dir path (to be freed by the caller)
  */
 char *
-GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
+GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind)
 {
   size_t n;
   char *dirname;
@@ -575,207 +579,215 @@ GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
 
   /* if wanted, try to get the current app's bin/ */
   if (dirkind == GNUNET_OS_IPK_SELF_PREFIX)
-    execpath = os_get_exec_path ();
+    execpath = os_get_exec_path();
 
   /* try to get GNUnet's bin/ or lib/, or if previous was unsuccessful some
    * guess for the current app */
   if (NULL == execpath)
-    execpath = os_get_gnunet_path ();
+    execpath = os_get_gnunet_path();
 
   if (NULL == execpath)
     return NULL;
 
-  n = strlen (execpath);
+  n = strlen(execpath);
   if (0 == n)
-  {
-    /* should never happen, but better safe than sorry */
-    GNUNET_free (execpath);
-    return NULL;
-  }
+    {
+      /* should never happen, but better safe than sorry */
+      GNUNET_free(execpath);
+      return NULL;
+    }
   /* remove filename itself */
   while ((n > 1) && (DIR_SEPARATOR == execpath[n - 1]))
     execpath[--n] = '\0';
 
   isbasedir = 1;
-  if ((n > 6) && ((0 == strcasecmp (&execpath[n - 6], "/lib32")) ||
-                  (0 == strcasecmp (&execpath[n - 6], "/lib64"))))
-  {
-    if ((GNUNET_OS_IPK_LIBDIR != dirkind) &&
-        (GNUNET_OS_IPK_LIBEXECDIR != dirkind))
+  if ((n > 6) && ((0 == strcasecmp(&execpath[n - 6], "/lib32")) ||
+                  (0 == strcasecmp(&execpath[n - 6], "/lib64"))))
+    {
+      if ((GNUNET_OS_IPK_LIBDIR != dirkind) &&
+          (GNUNET_OS_IPK_LIBEXECDIR != dirkind))
+        {
+          /* strip '/lib32' or '/lib64' */
+          execpath[n - 6] = '\0';
+          n -= 6;
+        }
+      else
+        isbasedir = 0;
+    }
+  else if ((n > 4) && ((0 == strcasecmp(&execpath[n - 4], "/bin")) ||
+                       (0 == strcasecmp(&execpath[n - 4], "/lib"))))
     {
-      /* strip '/lib32' or '/lib64' */
-      execpath[n - 6] = '\0';
-      n -= 6;
+      /* strip '/bin' or '/lib' */
+      execpath[n - 4] = '\0';
+      n -= 4;
     }
-    else
-      isbasedir = 0;
-  }
-  else if ((n > 4) && ((0 == strcasecmp (&execpath[n - 4], "/bin")) ||
-                       (0 == strcasecmp (&execpath[n - 4], "/lib"))))
-  {
-    /* strip '/bin' or '/lib' */
-    execpath[n - 4] = '\0';
-    n -= 4;
-  }
   multiarch = NULL;
-  if (NULL != (libdir = strstr (execpath, "/lib/")))
-  {
-    /* test for multi-arch path of the form "PREFIX/lib/MULTIARCH/";
-       here we need to re-add 'multiarch' to lib and libexec paths later! */
-    multiarch = &libdir[5];
-    if (NULL == strchr (multiarch, '/'))
-      libdir[0] =
-        '\0'; /* Debian multiarch format, cut of from 'execpath' but preserve in multicarch */
-    else
-      multiarch =
-        NULL; /* maybe not, multiarch still has a '/', which is not OK */
-  }
+  if (NULL != (libdir = strstr(execpath, "/lib/")))
+    {
+      /* test for multi-arch path of the form "PREFIX/lib/MULTIARCH/";
+         here we need to re-add 'multiarch' to lib and libexec paths later! */
+      multiarch = &libdir[5];
+      if (NULL == strchr(multiarch, '/'))
+        libdir[0] =
+          '\0'; /* Debian multiarch format, cut of from 'execpath' but preserve in multicarch */
+      else
+        multiarch =
+          NULL; /* maybe not, multiarch still has a '/', which is not OK */
+    }
   /* in case this was a directory named foo-bin, remove "foo-" */
   while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
     execpath[--n] = '\0';
   switch (dirkind)
-  {
-  case GNUNET_OS_IPK_PREFIX:
-  case GNUNET_OS_IPK_SELF_PREFIX:
-    dirname = GNUNET_strdup (DIR_SEPARATOR_STR);
-    break;
-  case GNUNET_OS_IPK_BINDIR:
-    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR);
-    break;
-  case GNUNET_OS_IPK_LIBDIR:
-    if (isbasedir)
-    {
-      GNUNET_asprintf (&tmp,
-                       "%s%s%s%s%s%s%s",
-                       execpath,
-                       DIR_SEPARATOR_STR "lib",
-                       (NULL != multiarch) ? DIR_SEPARATOR_STR : "",
-                       (NULL != multiarch) ? multiarch : "",
-                       DIR_SEPARATOR_STR,
-                       current_pd->project_dirname,
-                       DIR_SEPARATOR_STR);
-      if (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES))
-      {
-        GNUNET_free (execpath);
-        return tmp;
-      }
-      GNUNET_free (tmp);
-      tmp = NULL;
-      dirname = NULL;
-      if (4 == sizeof (void *))
-      {
-        GNUNET_asprintf (&dirname,
-                         DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
-                                           "%s" DIR_SEPARATOR_STR,
-                         current_pd->project_dirname);
-        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
-      }
-      if (8 == sizeof (void *))
-      {
-        GNUNET_asprintf (&dirname,
-                         DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
-                                           "%s" DIR_SEPARATOR_STR,
-                         current_pd->project_dirname);
-        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
-      }
-
-      if ((NULL != tmp) &&
-          (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES)))
-      {
-        GNUNET_free (execpath);
-        GNUNET_free_non_null (dirname);
-        return tmp;
-      }
-      GNUNET_free (tmp);
-      GNUNET_free_non_null (dirname);
-    }
-    GNUNET_asprintf (&dirname,
-                     DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
-                     current_pd->project_dirname);
-    break;
-  case GNUNET_OS_IPK_DATADIR:
-    GNUNET_asprintf (&dirname,
-                     DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
-                                       "%s" DIR_SEPARATOR_STR,
-                     current_pd->project_dirname);
-    break;
-  case GNUNET_OS_IPK_LOCALEDIR:
-    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
-                                               "locale" DIR_SEPARATOR_STR);
-    break;
-  case GNUNET_OS_IPK_ICONDIR:
-    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
-                                               "icons" DIR_SEPARATOR_STR);
-    break;
-  case GNUNET_OS_IPK_DOCDIR:
-    GNUNET_asprintf (&dirname,
-                     DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
-                                       "doc" DIR_SEPARATOR_STR
-                                       "%s" DIR_SEPARATOR_STR,
-                     current_pd->project_dirname);
-    break;
-  case GNUNET_OS_IPK_LIBEXECDIR:
-    if (isbasedir)
     {
-      GNUNET_asprintf (&dirname,
-                       DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
-                                         "libexec" DIR_SEPARATOR_STR,
-                       current_pd->project_dirname);
-      GNUNET_asprintf (&tmp,
-                       "%s%s%s%s",
-                       execpath,
-                       DIR_SEPARATOR_STR "lib" DIR_SEPARATOR_STR,
-                       (NULL != multiarch) ? multiarch : "",
-                       dirname);
-      if (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES))
-      {
-        GNUNET_free (execpath);
-        GNUNET_free (dirname);
-        return tmp;
-      }
-      GNUNET_free (tmp);
-      tmp = NULL;
-      dirname = NULL;
-      if (4 == sizeof (void *))
-      {
-        GNUNET_asprintf (&dirname,
-                         DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
-                                           "%s" DIR_SEPARATOR_STR
-                                           "libexec" DIR_SEPARATOR_STR,
-                         current_pd->project_dirname);
-        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
-      }
-      if (8 == sizeof (void *))
-      {
-        GNUNET_asprintf (&dirname,
-                         DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
-                                           "%s" DIR_SEPARATOR_STR
-                                           "libexec" DIR_SEPARATOR_STR,
-                         current_pd->project_dirname);
-        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
-      }
-      if ((NULL != tmp) &&
-          (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES)))
-      {
-        GNUNET_free (execpath);
-        GNUNET_free_non_null (dirname);
-        return tmp;
-      }
-      GNUNET_free (tmp);
-      GNUNET_free_non_null (dirname);
+    case GNUNET_OS_IPK_PREFIX:
+    case GNUNET_OS_IPK_SELF_PREFIX:
+      dirname = GNUNET_strdup(DIR_SEPARATOR_STR);
+      break;
+
+    case GNUNET_OS_IPK_BINDIR:
+      dirname = GNUNET_strdup(DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR);
+      break;
+
+    case GNUNET_OS_IPK_LIBDIR:
+      if (isbasedir)
+        {
+          GNUNET_asprintf(&tmp,
+                          "%s%s%s%s%s%s%s",
+                          execpath,
+                          DIR_SEPARATOR_STR "lib",
+                          (NULL != multiarch) ? DIR_SEPARATOR_STR : "",
+                          (NULL != multiarch) ? multiarch : "",
+                          DIR_SEPARATOR_STR,
+                          current_pd->project_dirname,
+                          DIR_SEPARATOR_STR);
+          if (GNUNET_YES == GNUNET_DISK_directory_test(tmp, GNUNET_YES))
+            {
+              GNUNET_free(execpath);
+              return tmp;
+            }
+          GNUNET_free(tmp);
+          tmp = NULL;
+          dirname = NULL;
+          if (4 == sizeof(void *))
+            {
+              GNUNET_asprintf(&dirname,
+                              DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
+                              "%s" DIR_SEPARATOR_STR,
+                              current_pd->project_dirname);
+              GNUNET_asprintf(&tmp, "%s%s", execpath, dirname);
+            }
+          if (8 == sizeof(void *))
+            {
+              GNUNET_asprintf(&dirname,
+                              DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
+                              "%s" DIR_SEPARATOR_STR,
+                              current_pd->project_dirname);
+              GNUNET_asprintf(&tmp, "%s%s", execpath, dirname);
+            }
+
+          if ((NULL != tmp) &&
+              (GNUNET_YES == GNUNET_DISK_directory_test(tmp, GNUNET_YES)))
+            {
+              GNUNET_free(execpath);
+              GNUNET_free_non_null(dirname);
+              return tmp;
+            }
+          GNUNET_free(tmp);
+          GNUNET_free_non_null(dirname);
+        }
+      GNUNET_asprintf(&dirname,
+                      DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
+                      current_pd->project_dirname);
+      break;
+
+    case GNUNET_OS_IPK_DATADIR:
+      GNUNET_asprintf(&dirname,
+                      DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
+                      "%s" DIR_SEPARATOR_STR,
+                      current_pd->project_dirname);
+      break;
+
+    case GNUNET_OS_IPK_LOCALEDIR:
+      dirname = GNUNET_strdup(DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
+                              "locale" DIR_SEPARATOR_STR);
+      break;
+
+    case GNUNET_OS_IPK_ICONDIR:
+      dirname = GNUNET_strdup(DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
+                              "icons" DIR_SEPARATOR_STR);
+      break;
+
+    case GNUNET_OS_IPK_DOCDIR:
+      GNUNET_asprintf(&dirname,
+                      DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
+                      "doc" DIR_SEPARATOR_STR
+                      "%s" DIR_SEPARATOR_STR,
+                      current_pd->project_dirname);
+      break;
+
+    case GNUNET_OS_IPK_LIBEXECDIR:
+      if (isbasedir)
+        {
+          GNUNET_asprintf(&dirname,
+                          DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
+                          "libexec" DIR_SEPARATOR_STR,
+                          current_pd->project_dirname);
+          GNUNET_asprintf(&tmp,
+                          "%s%s%s%s",
+                          execpath,
+                          DIR_SEPARATOR_STR "lib" DIR_SEPARATOR_STR,
+                          (NULL != multiarch) ? multiarch : "",
+                          dirname);
+          if (GNUNET_YES == GNUNET_DISK_directory_test(tmp, GNUNET_YES))
+            {
+              GNUNET_free(execpath);
+              GNUNET_free(dirname);
+              return tmp;
+            }
+          GNUNET_free(tmp);
+          tmp = NULL;
+          dirname = NULL;
+          if (4 == sizeof(void *))
+            {
+              GNUNET_asprintf(&dirname,
+                              DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
+                              "%s" DIR_SEPARATOR_STR
+                              "libexec" DIR_SEPARATOR_STR,
+                              current_pd->project_dirname);
+              GNUNET_asprintf(&tmp, "%s%s", execpath, dirname);
+            }
+          if (8 == sizeof(void *))
+            {
+              GNUNET_asprintf(&dirname,
+                              DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
+                              "%s" DIR_SEPARATOR_STR
+                              "libexec" DIR_SEPARATOR_STR,
+                              current_pd->project_dirname);
+              GNUNET_asprintf(&tmp, "%s%s", execpath, dirname);
+            }
+          if ((NULL != tmp) &&
+              (GNUNET_YES == GNUNET_DISK_directory_test(tmp, GNUNET_YES)))
+            {
+              GNUNET_free(execpath);
+              GNUNET_free_non_null(dirname);
+              return tmp;
+            }
+          GNUNET_free(tmp);
+          GNUNET_free_non_null(dirname);
+        }
+      GNUNET_asprintf(&dirname,
+                      DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
+                      "libexec" DIR_SEPARATOR_STR,
+                      current_pd->project_dirname);
+      break;
+
+    default:
+      GNUNET_free(execpath);
+      return NULL;
     }
-    GNUNET_asprintf (&dirname,
-                     DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
-                                       "libexec" DIR_SEPARATOR_STR,
-                     current_pd->project_dirname);
-    break;
-  default:
-    GNUNET_free (execpath);
-    return NULL;
-  }
-  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
-  GNUNET_free (dirname);
-  GNUNET_free (execpath);
+  GNUNET_asprintf(&tmp, "%s%s", execpath, dirname);
+  GNUNET_free(dirname);
+  GNUNET_free(execpath);
   return tmp;
 }
 
@@ -789,7 +801,7 @@ GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
  * @return full path to the binary, if possible, otherwise copy of 'progname'
  */
 char *
-GNUNET_OS_get_libexec_binary_path (const char *progname)
+GNUNET_OS_get_libexec_binary_path(const char *progname)
 {
   static char *cache;
   char *libexecdir;
@@ -797,15 +809,15 @@ GNUNET_OS_get_libexec_binary_path (const char *progname)
 
   if ((DIR_SEPARATOR == progname[0]) ||
       (GNUNET_YES ==
-       GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL)))
-    return GNUNET_strdup (progname);
+       GNUNET_STRINGS_path_is_absolute(progname, GNUNET_NO, NULL, NULL)))
+    return GNUNET_strdup(progname);
   if (NULL != cache)
     libexecdir = cache;
   else
-    libexecdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBEXECDIR);
+    libexecdir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LIBEXECDIR);
   if (NULL == libexecdir)
-    return GNUNET_strdup (progname);
-  GNUNET_asprintf (&binary, "%s%s", libexecdir, progname);
+    return GNUNET_strdup(progname);
+  GNUNET_asprintf(&binary, "%s%s", libexecdir, progname);
   cache = libexecdir;
   return binary;
 }
@@ -824,8 +836,8 @@ GNUNET_OS_get_libexec_binary_path (const char *progname)
  *         otherwise
  */
 char *
-GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                const char *progname)
+GNUNET_OS_get_suid_binary_path(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                               const char *progname)
 {
   static char *cache;
   char *binary = NULL;
@@ -833,26 +845,26 @@ GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
   size_t path_len;
 
   if (GNUNET_YES ==
-      GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL))
-  {
-    return GNUNET_strdup (progname);
-  }
+      GNUNET_STRINGS_path_is_absolute(progname, GNUNET_NO, NULL, NULL))
+    {
+      return GNUNET_strdup(progname);
+    }
   if (NULL != cache)
     path = cache;
   else
-    GNUNET_CONFIGURATION_get_value_string (cfg,
-                                           "PATHS",
-                                           "SUID_BINARY_PATH",
-                                           &path);
-  if ((NULL == path) || (0 == strlen (path)))
-    return GNUNET_OS_get_libexec_binary_path (progname);
-  path_len = strlen (path);
-  GNUNET_asprintf (&binary,
-                   "%s%s%s",
-                   path,
-                   (path[path_len - 1] == DIR_SEPARATOR) ? ""
-                                                         : DIR_SEPARATOR_STR,
-                   progname);
+    GNUNET_CONFIGURATION_get_value_string(cfg,
+                                          "PATHS",
+                                          "SUID_BINARY_PATH",
+                                          &path);
+  if ((NULL == path) || (0 == strlen(path)))
+    return GNUNET_OS_get_libexec_binary_path(progname);
+  path_len = strlen(path);
+  GNUNET_asprintf(&binary,
+                  "%s%s%s",
+                  path,
+                  (path[path_len - 1] == DIR_SEPARATOR) ? ""
+                  : DIR_SEPARATOR_STR,
+                  progname);
   cache = path;
   return binary;
 }
@@ -875,143 +887,144 @@ GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
  *         #GNUNET_SYSERR on error (no such binary or not executable)
  */
 int
-GNUNET_OS_check_helper_binary (const char *binary,
-                               int check_suid,
-                               const char *params)
+GNUNET_OS_check_helper_binary(const char *binary,
+                              int check_suid,
+                              const char *params)
 {
   struct stat statbuf;
   char *p;
   char *pf;
+
 #ifdef MINGW
   char *binaryexe;
 
-  GNUNET_asprintf (&binaryexe, "%s.exe", binary);
+  GNUNET_asprintf(&binaryexe, "%s.exe", binary);
   if ((GNUNET_YES ==
-       GNUNET_STRINGS_path_is_absolute (binaryexe, GNUNET_NO, NULL, NULL)) ||
-      (0 == strncmp (binary, "./", 2)))
-    p = GNUNET_strdup (binaryexe);
+       GNUNET_STRINGS_path_is_absolute(binaryexe, GNUNET_NO, NULL, NULL)) ||
+      (0 == strncmp(binary, "./", 2)))
+    p = GNUNET_strdup(binaryexe);
   else
-  {
-    p = get_path_from_PATH (binaryexe);
-    if (NULL != p)
     {
-      GNUNET_asprintf (&pf, "%s/%s", p, binaryexe);
-      GNUNET_free (p);
-      p = pf;
+      p = get_path_from_PATH(binaryexe);
+      if (NULL != p)
+        {
+          GNUNET_asprintf(&pf, "%s/%s", p, binaryexe);
+          GNUNET_free(p);
+          p = pf;
+        }
     }
-  }
-  GNUNET_free (binaryexe);
+  GNUNET_free(binaryexe);
 #else
   if ((GNUNET_YES ==
-       GNUNET_STRINGS_path_is_absolute (binary, GNUNET_NO, NULL, NULL)) ||
-      (0 == strncmp (binary, "./", 2)))
-  {
-    p = GNUNET_strdup (binary);
-  }
+       GNUNET_STRINGS_path_is_absolute(binary, GNUNET_NO, NULL, NULL)) ||
+      (0 == strncmp(binary, "./", 2)))
+    {
+      p = GNUNET_strdup(binary);
+    }
   else
-  {
-    p = get_path_from_PATH (binary);
-    if (NULL != p)
     {
-      GNUNET_asprintf (&pf, "%s/%s", p, binary);
-      GNUNET_free (p);
-      p = pf;
+      p = get_path_from_PATH(binary);
+      if (NULL != p)
+        {
+          GNUNET_asprintf(&pf, "%s/%s", p, binary);
+          GNUNET_free(p);
+          p = pf;
+        }
     }
-  }
 #endif
   if (NULL == p)
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _ ("Could not find binary `%s' in PATH!\n"),
-         binary);
-    return GNUNET_SYSERR;
-  }
-  if (0 != access (p, X_OK))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", p);
-    GNUNET_free (p);
-    return GNUNET_SYSERR;
-  }
-#ifndef MINGW
-  if (0 == getuid ())
-  {
-    /* as we run as root, we don't insist on SUID */
-    GNUNET_free (p);
-    return GNUNET_YES;
-  }
-#endif
-  if (0 != stat (p, &statbuf))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", p);
-    GNUNET_free (p);
-    return GNUNET_SYSERR;
-  }
-  if (check_suid)
-  {
-#ifndef MINGW
-    (void) params;
-    if ((0 != (statbuf.st_mode & S_ISUID)) && (0 == statbuf.st_uid))
     {
-      GNUNET_free (p);
-      return GNUNET_YES;
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Could not find binary `%s' in PATH!\n"),
+          binary);
+      return GNUNET_SYSERR;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _ ("Binary `%s' exists, but is not SUID\n"),
-                p);
-    /* binary exists, but not SUID */
-#else
-    STARTUPINFO start;
-    char parameters[512];
-    PROCESS_INFORMATION proc;
-    DWORD exit_value;
-
-    GNUNET_snprintf (parameters, sizeof (parameters), "-d %s", params);
-    memset (&start, 0, sizeof (start));
-    start.cb = sizeof (start);
-    memset (&proc, 0, sizeof (proc));
-
-
-    // Start the child process.
-    if (! (CreateProcess (
-          p, // current windows (2k3 and up can handle / instead of \ in paths))
-          parameters, // execute dryrun/priviliege checking mode
-          NULL, // Process handle not inheritable
-          NULL, // Thread handle not inheritable
-          FALSE, // Set handle inheritance to FALSE
-          CREATE_DEFAULT_ERROR_MODE, // No creation flags
-          NULL, // Use parent's environment block
-          NULL, // Use parent's starting directory
-          &start, // Pointer to STARTUPINFO structure
-          &proc) // Pointer to PROCESS_INFORMATION structure
-           ))
+  if (0 != access(p, X_OK))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("CreateProcess failed for binary %s (%d).\n"),
-           p,
-           GetLastError ());
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "access", p);
+      GNUNET_free(p);
       return GNUNET_SYSERR;
     }
-
-    // Wait until child process exits.
-    WaitForSingleObject (proc.hProcess, INFINITE);
-
-    if (! GetExitCodeProcess (proc.hProcess, &exit_value))
+#ifndef MINGW
+  if (0 == getuid())
+    {
+      /* as we run as root, we don't insist on SUID */
+      GNUNET_free(p);
+      return GNUNET_YES;
+    }
+#endif
+  if (0 != stat(p, &statbuf))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("GetExitCodeProcess failed for binary %s (%d).\n"),
-           p,
-           GetLastError ());
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", p);
+      GNUNET_free(p);
       return GNUNET_SYSERR;
     }
-    // Close process and thread handles.
-    CloseHandle (proc.hProcess);
-    CloseHandle (proc.hThread);
-
-    if (! exit_value)
-      return GNUNET_YES;
+  if (check_suid)
+    {
+#ifndef MINGW
+      (void)params;
+      if ((0 != (statbuf.st_mode & S_ISUID)) && (0 == statbuf.st_uid))
+        {
+          GNUNET_free(p);
+          return GNUNET_YES;
+        }
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                 _("Binary `%s' exists, but is not SUID\n"),
+                 p);
+      /* binary exists, but not SUID */
+#else
+      STARTUPINFO start;
+      char parameters[512];
+      PROCESS_INFORMATION proc;
+      DWORD exit_value;
+
+      GNUNET_snprintf(parameters, sizeof(parameters), "-d %s", params);
+      memset(&start, 0, sizeof(start));
+      start.cb = sizeof(start);
+      memset(&proc, 0, sizeof(proc));
+
+
+      // Start the child process.
+      if (!(CreateProcess(
+              p, // current windows (2k3 and up can handle / instead of \ in paths))
+              parameters, // execute dryrun/priviliege checking mode
+              NULL, // Process handle not inheritable
+              NULL, // Thread handle not inheritable
+              FALSE, // Set handle inheritance to FALSE
+              CREATE_DEFAULT_ERROR_MODE, // No creation flags
+              NULL, // Use parent's environment block
+              NULL, // Use parent's starting directory
+              &start, // Pointer to STARTUPINFO structure
+              &proc) // Pointer to PROCESS_INFORMATION structure
+            ))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("CreateProcess failed for binary %s (%d).\n"),
+              p,
+              GetLastError());
+          return GNUNET_SYSERR;
+        }
+
+      // Wait until child process exits.
+      WaitForSingleObject(proc.hProcess, INFINITE);
+
+      if (!GetExitCodeProcess(proc.hProcess, &exit_value))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("GetExitCodeProcess failed for binary %s (%d).\n"),
+              p,
+              GetLastError());
+          return GNUNET_SYSERR;
+        }
+      // Close process and thread handles.
+      CloseHandle(proc.hProcess);
+      CloseHandle(proc.hThread);
+
+      if (!exit_value)
+        return GNUNET_YES;
 #endif
-  }
-  GNUNET_free (p);
+    }
+  GNUNET_free(p);
   return GNUNET_NO;
 }
 
diff --git a/src/util/os_network.c b/src/util/os_network.c
index 9008c5c5a..6bf9d1846 100644
--- a/src/util/os_network.c
+++ b/src/util/os_network.c
@@ -17,7 +17,7 @@
 
      SPDX-License-Identifier: AGPL3.0-or-later
 
-*/
+ */
 /**
  * @file util/os_network.c
  * @brief function to determine available network interfaces
@@ -31,11 +31,11 @@
 #include "gnunet_util_lib.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-os-network", __VA_ARGS__)
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-os-network", syscall, filename)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-os-network", __VA_ARGS__)
+#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util-os-network", syscall, filename)
 
 
-#if ! (HAVE_GETIFADDRS && HAVE_FREEIFADDRS) && !MINGW
+#if !(HAVE_GETIFADDRS && HAVE_FREEIFADDRS) && !MINGW
 /**
  * Try to enumerate all network interfaces using 'ifconfig'.
  *
@@ -44,8 +44,8 @@
  * @return #GNUNET_OK if it worked
  */
 static int
-try_ifconfig (GNUNET_OS_NetworkInterfaceProcessor proc,
-              void *proc_cls)
+try_ifconfig(GNUNET_OS_NetworkInterfaceProcessor proc,
+             void *proc_cls)
 {
   int i;
   char line[1024];
@@ -70,159 +70,159 @@ try_ifconfig (GNUNET_OS_NetworkInterfaceProcessor proc,
   static char *pcall;
 
   if (NULL == pcall)
-  {
-    const char *sbin_ifconfig;
+    {
+      const char *sbin_ifconfig;
 
 #ifdef IFCONFIG
-    if (0 == access (IFCONFIG, X_OK))
-      sbin_ifconfig = IFCONFIG;
-    else
+      if (0 == access(IFCONFIG, X_OK))
+        sbin_ifconfig = IFCONFIG;
+      else
 #endif
-    if (0 == access ("/sbin/ifconfig", X_OK))
-      sbin_ifconfig = "/sbin/ifconfig";
-    else if (0 == access ("/usr/sbin/ifconfig", X_OK))
-      sbin_ifconfig = "/usr/sbin/ifconfig";
-    else
-      sbin_ifconfig = "ifconfig";
-    GNUNET_asprintf (&pcall,
-                     "%s -a 2> /dev/null",
-                     sbin_ifconfig);
-  }
-  f = popen (pcall, "r");
+      if (0 == access("/sbin/ifconfig", X_OK))
+        sbin_ifconfig = "/sbin/ifconfig";
+      else if (0 == access("/usr/sbin/ifconfig", X_OK))
+        sbin_ifconfig = "/usr/sbin/ifconfig";
+      else
+        sbin_ifconfig = "ifconfig";
+      GNUNET_asprintf(&pcall,
+                      "%s -a 2> /dev/null",
+                      sbin_ifconfig);
+    }
+  f = popen(pcall, "r");
   if (NULL == f)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                       "popen",
-                       "ifconfig");
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                        "popen",
+                        "ifconfig");
 
-    return GNUNET_SYSERR;
-  }
+      return GNUNET_SYSERR;
+    }
 
   have_ifc = GNUNET_NO;
   ifc[11] = '\0';
-  while (NULL != fgets (line, sizeof (line), f))
-  {
-    if (strlen (line) == 0)
+  while (NULL != fgets(line, sizeof(line), f))
     {
-      have_ifc = GNUNET_NO;
-      continue;
-    }
-    if (!isspace (line[0]))
-    {
-      have_ifc = (1 == SSCANF (line, "%11s", ifc)) ? GNUNET_YES : GNUNET_NO;
-      /* would end with ':' on OSX, fix it! */
-      if (ifc[strlen (ifc) - 1] == ':')
-        ifc[strlen (ifc) - 1] = '\0';
-      continue;
-    }
-    if (!have_ifc)
-      continue;                 /* strange input, hope for the best */
+      if (strlen(line) == 0)
+        {
+          have_ifc = GNUNET_NO;
+          continue;
+        }
+      if (!isspace(line[0]))
+        {
+          have_ifc = (1 == SSCANF(line, "%11s", ifc)) ? GNUNET_YES : GNUNET_NO;
+          /* would end with ':' on OSX, fix it! */
+          if (ifc[strlen(ifc) - 1] == ':')
+            ifc[strlen(ifc) - 1] = '\0';
+          continue;
+        }
+      if (!have_ifc)
+        continue;               /* strange input, hope for the best */
 
-    /* make parsing of ipv6 addresses easier */
-    for (replace = line; *replace != '\0'; replace++)
-    {
-      if (*replace == '/')
-        *replace = ' ';
-    }
-    prefixlen = -1;
-
-    start = line;
-    while (('\0' != *start) && (isspace (*start)))
-      start++;
-
-    /* Zero-out stack allocated values */
-    memset (addrstr, 0, 128);
-    memset (netmaskstr, 0, 128);
-    memset (bcstr, 0, 128);
-    prefixlen = 0;
-
-    if ( /* Linux */
-         (3 == SSCANF (start, "inet addr:%127s Bcast:%127s Mask:%127s", addrstr, bcstr, netmaskstr)) ||
-         (2 == SSCANF (start, "inet addr:%127s Mask:%127s", addrstr, netmaskstr)) ||
-         (2 == SSCANF (start, "inet6 addr:%127s %d", addrstr, &prefixlen)) ||
-         /* Solaris, OS X */
-         (1 == SSCANF (start, "inet %127s", addrstr)) ||
-         (1 == SSCANF (start, "inet6 %127s", addrstr)))
-    {
-      /* IPv4 */
-      if (1 == inet_pton (AF_INET, addrstr, &v4))
-      {
-        memset (&a4, 0, sizeof (a4));
-        a4.sin_family = AF_INET;
+      /* make parsing of ipv6 addresses easier */
+      for (replace = line; *replace != '\0'; replace++)
+        {
+          if (*replace == '/')
+            *replace = ' ';
+        }
+      prefixlen = -1;
+
+      start = line;
+      while (('\0' != *start) && (isspace(*start)))
+        start++;
+
+      /* Zero-out stack allocated values */
+      memset(addrstr, 0, 128);
+      memset(netmaskstr, 0, 128);
+      memset(bcstr, 0, 128);
+      prefixlen = 0;
+
+      if ( /* Linux */
+        (3 == SSCANF(start, "inet addr:%127s Bcast:%127s Mask:%127s", addrstr, bcstr, netmaskstr)) ||
+        (2 == SSCANF(start, "inet addr:%127s Mask:%127s", addrstr, netmaskstr)) ||
+        (2 == SSCANF(start, "inet6 addr:%127s %d", addrstr, &prefixlen)) ||
+        /* Solaris, OS X */
+        (1 == SSCANF(start, "inet %127s", addrstr)) ||
+        (1 == SSCANF(start, "inet6 %127s", addrstr)))
+        {
+          /* IPv4 */
+          if (1 == inet_pton(AF_INET, addrstr, &v4))
+            {
+              memset(&a4, 0, sizeof(a4));
+              a4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-        a4.sin_len = (u_char) sizeof (struct sockaddr_in);
+              a4.sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-        a4.sin_addr = v4;
-
-        pass_bcaddr = NULL;
-        pass_netmask = NULL;
-        if (1 == inet_pton (AF_INET, bcstr, &v4))
-        {
-          memset (&bcaddr, 0, sizeof (bcaddr));
-          bcaddr.sin_family = AF_INET;
+              a4.sin_addr = v4;
+
+              pass_bcaddr = NULL;
+              pass_netmask = NULL;
+              if (1 == inet_pton(AF_INET, bcstr, &v4))
+                {
+                  memset(&bcaddr, 0, sizeof(bcaddr));
+                  bcaddr.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          bcaddr.sin_len = (u_char) sizeof (struct sockaddr_in);
+                  bcaddr.sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-          bcaddr.sin_addr = v4;
-          pass_bcaddr = (struct sockaddr *) &bcaddr;
-        }
-        if (1 == inet_pton (AF_INET, netmaskstr, &v4))
-        {
-          memset (&netmask, 0, sizeof (netmask));
-          netmask.sin_family = AF_INET;
+                  bcaddr.sin_addr = v4;
+                  pass_bcaddr = (struct sockaddr *)&bcaddr;
+                }
+              if (1 == inet_pton(AF_INET, netmaskstr, &v4))
+                {
+                  memset(&netmask, 0, sizeof(netmask));
+                  netmask.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          netmask.sin_len = (u_char) sizeof (struct sockaddr_in);
+                  netmask.sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-          netmask.sin_addr = v4;
-          pass_netmask = (struct sockaddr *) &netmask;
-        }
-
-
-        if (GNUNET_OK !=
-            proc (proc_cls, ifc, 0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
-                  (const struct sockaddr *) &a4,
-                  pass_bcaddr, pass_netmask, sizeof (a4)))
-          break;
-        continue;
-      }
-      /* IPv6 */
-      if (1 == inet_pton (AF_INET6, addrstr, &v6))
-      {
-        memset (&a6, 0, sizeof (a6));
-        a6.sin6_family = AF_INET6;
+                  netmask.sin_addr = v4;
+                  pass_netmask = (struct sockaddr *)&netmask;
+                }
+
+
+              if (GNUNET_OK !=
+                  proc(proc_cls, ifc, 0 == strcmp(ifc, GNUNET_DEFAULT_INTERFACE),
+                       (const struct sockaddr *)&a4,
+                       pass_bcaddr, pass_netmask, sizeof(a4)))
+                break;
+              continue;
+            }
+          /* IPv6 */
+          if (1 == inet_pton(AF_INET6, addrstr, &v6))
+            {
+              memset(&a6, 0, sizeof(a6));
+              a6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-        a6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
+              a6.sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-        a6.sin6_addr = v6;
-
-        pass_netmask = NULL;
-        if (prefixlen != -1)
-        {
-          memset (v6.s6_addr, 0, sizeof (v6.s6_addr));
-          for (i = 0; i < prefixlen; i++)
-          {
-            v6.s6_addr[i >> 3] |= 1 << (i & 7);
-          }
-          memset (&netmask6, 0, sizeof (netmask6));
-          netmask6.sin6_family = AF_INET6;
+              a6.sin6_addr = v6;
+
+              pass_netmask = NULL;
+              if (prefixlen != -1)
+                {
+                  memset(v6.s6_addr, 0, sizeof(v6.s6_addr));
+                  for (i = 0; i < prefixlen; i++)
+                    {
+                      v6.s6_addr[i >> 3] |= 1 << (i & 7);
+                    }
+                  memset(&netmask6, 0, sizeof(netmask6));
+                  netmask6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          netmask6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
+                  netmask6.sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-          netmask6.sin6_addr = v6;
-
-          pass_netmask = (struct sockaddr *) &netmask6;
+                  netmask6.sin6_addr = v6;
+
+                  pass_netmask = (struct sockaddr *)&netmask6;
+                }
+
+              if (GNUNET_OK !=
+                  proc(proc_cls, ifc, 0 == strcmp(ifc, GNUNET_DEFAULT_INTERFACE),
+                       (const struct sockaddr *)&a6,
+                       NULL, pass_netmask, sizeof(a6)))
+                break;
+              continue;
+            }
         }
-
-        if (GNUNET_OK !=
-            proc (proc_cls, ifc, 0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
-                  (const struct sockaddr *) &a6,
-                  NULL, pass_netmask, sizeof (a6)))
-          break;
-        continue;
-      }
     }
-  }
-  pclose (f);
+  pclose(f);
   return GNUNET_OK;
 }
 
@@ -235,8 +235,8 @@ try_ifconfig (GNUNET_OS_NetworkInterfaceProcessor proc,
  * @return #GNUNET_OK if it worked
  */
 static int
-try_ip (GNUNET_OS_NetworkInterfaceProcessor proc,
-        void *proc_cls)
+try_ip(GNUNET_OS_NetworkInterfaceProcessor proc,
+       void *proc_cls)
 {
   char line[1024];
   char *replace;
@@ -255,124 +255,124 @@ try_ip (GNUNET_OS_NetworkInterfaceProcessor proc,
   static char *pcall;
 
   if (NULL == pcall)
-  {
-    const char *sbin_ip;
+    {
+      const char *sbin_ip;
 
 #ifdef IFCONFIG
-    if (0 == access (PATH_TO_IP, X_OK))
-      sbin_ip = PATH_TO_IP;
-    else
+      if (0 == access(PATH_TO_IP, X_OK))
+        sbin_ip = PATH_TO_IP;
+      else
 #endif
-    if (0 == access ("/sbin/ip", X_OK))
-      sbin_ip = "/sbin/ip";
-    else if (0 == access ("/usr/sbin/ip", X_OK))
-      sbin_ip = "/usr/sbin/ip";
-    else
-      sbin_ip = "if";
-    GNUNET_asprintf (&pcall,
-                     "%s -o add 2> /dev/null",
-                     sbin_ip);
-  }
-  f = popen (pcall, "r");
-  if (! f)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                       "popen",
-                       "ip");
-    return GNUNET_SYSERR;
-  }
-
-  while (NULL != fgets (line, sizeof (line), f))
-  {
-    /* make parsing easier */
-    for (replace = line; *replace != '\0'; replace++)
+      if (0 == access("/sbin/ip", X_OK))
+        sbin_ip = "/sbin/ip";
+      else if (0 == access("/usr/sbin/ip", X_OK))
+        sbin_ip = "/usr/sbin/ip";
+      else
+        sbin_ip = "if";
+      GNUNET_asprintf(&pcall,
+                      "%s -o add 2> /dev/null",
+                      sbin_ip);
+    }
+  f = popen(pcall, "r");
+  if (!f)
     {
-      if (*replace == '/')
-        *replace = ' ';
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                        "popen",
+                        "ip");
+      return GNUNET_SYSERR;
     }
-    /* Zero-out stack allocated values */
-    memset (ifname, 0, 64);
-    memset (afstr, 0, 6);
-    memset (addrstr, 0, 128);
-    if (4 != SSCANF (line,
-                     "%*u: %63s %5s %127s %6u",
-                     ifname,
-                     afstr,
-                     addrstr,
-                     &prefixlen))
-      continue;
-    /* IPv4 */
-    if ( (0 == strcasecmp ("inet",
+
+  while (NULL != fgets(line, sizeof(line), f))
+    {
+      /* make parsing easier */
+      for (replace = line; *replace != '\0'; replace++)
+        {
+          if (*replace == '/')
+            *replace = ' ';
+        }
+      /* Zero-out stack allocated values */
+      memset(ifname, 0, 64);
+      memset(afstr, 0, 6);
+      memset(addrstr, 0, 128);
+      if (4 != SSCANF(line,
+                      "%*u: %63s %5s %127s %6u",
+                      ifname,
+                      afstr,
+                      addrstr,
+                      &prefixlen))
+        continue;
+      /* IPv4 */
+      if ((0 == strcasecmp("inet",
                            afstr)) &&
-         (1 == inet_pton (AF_INET,
+          (1 == inet_pton(AF_INET,
                           addrstr,
-                          &v4)) )
-    {
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
+                          &v4)))
+        {
+          memset(&a4, 0, sizeof(a4));
+          a4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a4.sin_len = (u_char) sizeof (struct sockaddr_in);
+          a4.sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-      a4.sin_addr = v4;
+          a4.sin_addr = v4;
 
-      memset (&v4.s_addr, 0, sizeof (v4.s_addr));
-      for (i = 0; i < prefixlen; i++)
-        v4.s_addr |= 1 << (i & 7);
-      memset (&netmask, 0, sizeof (netmask));
-      netmask.sin_family = AF_INET;
+          memset(&v4.s_addr, 0, sizeof(v4.s_addr));
+          for (i = 0; i < prefixlen; i++)
+            v4.s_addr |= 1 << (i & 7);
+          memset(&netmask, 0, sizeof(netmask));
+          netmask.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      netmask.sin_len = (u_char) sizeof (struct sockaddr_in);
+          netmask.sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-      netmask.sin_addr = v4;
+          netmask.sin_addr = v4;
 
-      if (GNUNET_OK !=
-          proc (proc_cls,
-                ifname,
-                (0 == strcmp (ifname,
-                              GNUNET_DEFAULT_INTERFACE)),
-                (const struct sockaddr *) &a4,
-                NULL,
-                (const struct sockaddr *) &netmask,
-                sizeof (a4)))
-        break;
-    }
-    /* IPv6 */
-    if ( (0 == strcasecmp ("inet6",
+          if (GNUNET_OK !=
+              proc(proc_cls,
+                   ifname,
+                   (0 == strcmp(ifname,
+                                GNUNET_DEFAULT_INTERFACE)),
+                   (const struct sockaddr *)&a4,
+                   NULL,
+                   (const struct sockaddr *)&netmask,
+                   sizeof(a4)))
+            break;
+        }
+      /* IPv6 */
+      if ((0 == strcasecmp("inet6",
                            afstr)) &&
-         (1 == inet_pton (AF_INET6,
+          (1 == inet_pton(AF_INET6,
                           addrstr,
-                          &v6)) )
-    {
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
+                          &v6)))
+        {
+          memset(&a6, 0, sizeof(a6));
+          a6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
+          a6.sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-      a6.sin6_addr = v6;
+          a6.sin6_addr = v6;
 
-      memset (v6.s6_addr, 0, sizeof (v6.s6_addr));
-      for (i = 0; i < prefixlen; i++)
-        v6.s6_addr[i >> 3] |= 1 << (i & 7);
-      memset (&netmask6, 0, sizeof (netmask6));
-      netmask6.sin6_family = AF_INET6;
+          memset(v6.s6_addr, 0, sizeof(v6.s6_addr));
+          for (i = 0; i < prefixlen; i++)
+            v6.s6_addr[i >> 3] |= 1 << (i & 7);
+          memset(&netmask6, 0, sizeof(netmask6));
+          netmask6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      netmask6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
+          netmask6.sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-      netmask6.sin6_addr = v6;
+          netmask6.sin6_addr = v6;
 
-      if (GNUNET_OK !=
-          proc (proc_cls,
-                ifname,
-                (0 == strcmp (ifname,
-                              GNUNET_DEFAULT_INTERFACE)),
-                (const struct sockaddr *) &a6,
-                NULL,
-                (const struct sockaddr *) &netmask6,
-                sizeof (a6)))
-        break;
+          if (GNUNET_OK !=
+              proc(proc_cls,
+                   ifname,
+                   (0 == strcmp(ifname,
+                                GNUNET_DEFAULT_INTERFACE)),
+                   (const struct sockaddr *)&a6,
+                   NULL,
+                   (const struct sockaddr *)&netmask6,
+                   sizeof(a6)))
+            break;
+        }
     }
-  }
-  pclose (f);
+  pclose(f);
   return GNUNET_OK;
 }
 #endif
@@ -385,8 +385,8 @@ try_ip (GNUNET_OS_NetworkInterfaceProcessor proc,
  * @param proc_cls closure for @a proc
  */
 void
-GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
-                                   void *proc_cls)
+GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc,
+                                  void *proc_cls)
 {
 #ifdef MINGW
   int r;
@@ -394,67 +394,65 @@ GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
   struct EnumNICs3_results *results = NULL;
   int results_count;
 
-  r = EnumNICs3 (&results, &results_count);
+  r = EnumNICs3(&results, &results_count);
   if (r != GNUNET_OK)
     return;
 
   for (i = 0; i < results_count; i++)
-  {
-    if (GNUNET_OK !=
-        proc (proc_cls, results[i].pretty_name, results[i].is_default,
-              (const struct sockaddr *) &results[i].address,
-              results[i].
-              flags & ENUMNICS3_BCAST_OK ?
-              (const struct sockaddr *) &results[i].broadcast : NULL,
-              results[i].flags & ENUMNICS3_MASK_OK ?
-              (const struct sockaddr *) &results[i].mask : NULL,
-              results[i].addr_size))
-      break;
-  }
-  EnumNICs3_free (results);
+    {
+      if (GNUNET_OK !=
+          proc(proc_cls, results[i].pretty_name, results[i].is_default,
+               (const struct sockaddr *)&results[i].address,
+               results[i].
+               flags & ENUMNICS3_BCAST_OK ?
+               (const struct sockaddr *)&results[i].broadcast : NULL,
+               results[i].flags & ENUMNICS3_MASK_OK ?
+               (const struct sockaddr *)&results[i].mask : NULL,
+               results[i].addr_size))
+        break;
+    }
+  EnumNICs3_free(results);
   return;
-
 #elif HAVE_GETIFADDRS && HAVE_FREEIFADDRS
-
   struct ifaddrs *ifa_first;
   struct ifaddrs *ifa_ptr;
   socklen_t alen;
 
-  if (getifaddrs (&ifa_first) == 0)
-  {
-    for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
+  if (getifaddrs(&ifa_first) == 0)
     {
-      if (ifa_ptr->ifa_name != NULL && ifa_ptr->ifa_addr != NULL &&
-          (ifa_ptr->ifa_flags & IFF_UP) != 0)
-      {
-        if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
-            (ifa_ptr->ifa_addr->sa_family != AF_INET6))
-          continue;
-        if (ifa_ptr->ifa_addr->sa_family == AF_INET)
-          alen = sizeof (struct sockaddr_in);
-        else
-          alen = sizeof (struct sockaddr_in6);
-        if (GNUNET_OK !=
-            proc (proc_cls, ifa_ptr->ifa_name,
-                  0 == strcmp (ifa_ptr->ifa_name, GNUNET_DEFAULT_INTERFACE),
-                  ifa_ptr->ifa_addr, ifa_ptr->ifa_broadaddr,
-                  ifa_ptr->ifa_netmask, alen))
-          break;
-      }
+      for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
+        {
+          if (ifa_ptr->ifa_name != NULL && ifa_ptr->ifa_addr != NULL &&
+              (ifa_ptr->ifa_flags & IFF_UP) != 0)
+            {
+              if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
+                  (ifa_ptr->ifa_addr->sa_family != AF_INET6))
+                continue;
+              if (ifa_ptr->ifa_addr->sa_family == AF_INET)
+                alen = sizeof(struct sockaddr_in);
+              else
+                alen = sizeof(struct sockaddr_in6);
+              if (GNUNET_OK !=
+                  proc(proc_cls, ifa_ptr->ifa_name,
+                       0 == strcmp(ifa_ptr->ifa_name, GNUNET_DEFAULT_INTERFACE),
+                       ifa_ptr->ifa_addr, ifa_ptr->ifa_broadaddr,
+                       ifa_ptr->ifa_netmask, alen))
+                break;
+            }
+        }
+      freeifaddrs(ifa_first);
     }
-    freeifaddrs (ifa_first);
-  }
 #else
   if (GNUNET_OK ==
-      try_ip (proc,
-              proc_cls))
+      try_ip(proc,
+             proc_cls))
     return;
   if (GNUNET_OK ==
-      try_ifconfig (proc,
-                    proc_cls))
+      try_ifconfig(proc,
+                   proc_cls))
     return;
-  LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-       "Failed to enumerate network interfaces\n");
+  LOG(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+      "Failed to enumerate network interfaces\n");
 #endif
 }
 
diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index 17baa0df8..e4f2371e7 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.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 util/os_priority.c
@@ -29,19 +29,18 @@
 #include "disk.h"
 #include <unistr.h>
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-os-priority", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-os-priority", syscall)
+  GNUNET_log_from_strerror(kind, "util-os-priority", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-os-priority", syscall, filename)
 
 #define GNUNET_OS_CONTROL_PIPE "GNUNET_OS_CONTROL_PIPE"
 
 
-struct GNUNET_OS_Process
-{
+struct GNUNET_OS_Process {
   /**
    * PID of the process.
    */
@@ -84,13 +83,13 @@ static struct GNUNET_SCHEDULER_Task *spch;
  * @param cls the `struct GNUNET_DISK_FileHandle` of the control pipe
  */
 static void
-shutdown_pch (void *cls)
+shutdown_pch(void *cls)
 {
   struct GNUNET_DISK_FileHandle *control_pipe = cls;
 
-  GNUNET_SCHEDULER_cancel (pch);
+  GNUNET_SCHEDULER_cancel(pch);
   pch = NULL;
-  GNUNET_DISK_file_close (control_pipe);
+  GNUNET_DISK_file_close(control_pipe);
   control_pipe = NULL;
 }
 
@@ -101,7 +100,7 @@ shutdown_pch (void *cls)
  * @param cls the `struct GNUNET_DISK_FileHandle` of the control pipe
  */
 static void
-parent_control_handler (void *cls)
+parent_control_handler(void *cls)
 {
   struct GNUNET_DISK_FileHandle *control_pipe = cls;
   char sig;
@@ -109,29 +108,29 @@ parent_control_handler (void *cls)
   ssize_t ret;
 
   pch = NULL;
-  ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig));
-  if (sizeof (sig) != ret)
-  {
-    if (-1 == ret)
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
-    GNUNET_DISK_file_close (control_pipe);
-    control_pipe = NULL;
-    GNUNET_SCHEDULER_cancel (spch);
-    spch = NULL;
-    return;
-  }
-  pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
-  GNUNET_assert ((NULL == pipe_fd) || (strlen (pipe_fd) <= 0));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Got control code %d from parent via pipe %s\n",
-       sig,
-       pipe_fd);
-  pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        control_pipe,
-                                        &parent_control_handler,
-                                        control_pipe);
-  GNUNET_SIGNAL_raise ((int) sig);
+  ret = GNUNET_DISK_file_read(control_pipe, &sig, sizeof(sig));
+  if (sizeof(sig) != ret)
+    {
+      if (-1 == ret)
+        LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
+      GNUNET_DISK_file_close(control_pipe);
+      control_pipe = NULL;
+      GNUNET_SCHEDULER_cancel(spch);
+      spch = NULL;
+      return;
+    }
+  pipe_fd = getenv(GNUNET_OS_CONTROL_PIPE);
+  GNUNET_assert((NULL == pipe_fd) || (strlen(pipe_fd) <= 0));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Got control code %d from parent via pipe %s\n",
+      sig,
+      pipe_fd);
+  pch = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       control_pipe,
+                                       &parent_control_handler,
+                                       control_pipe);
+  GNUNET_SIGNAL_raise((int)sig);
 }
 
 
@@ -144,71 +143,71 @@ parent_control_handler (void *cls)
  * @param cls closure (unused)
  */
 void
-GNUNET_OS_install_parent_control_handler (void *cls)
+GNUNET_OS_install_parent_control_handler(void *cls)
 {
   const char *env_buf;
   char *env_buf_end;
   struct GNUNET_DISK_FileHandle *control_pipe;
   uint64_t pipe_fd;
 
-  (void) cls;
+  (void)cls;
   if (NULL != pch)
-  {
-    /* already done, we've been called twice... */
-    GNUNET_break (0);
-    return;
-  }
-  env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
-  if ((NULL == env_buf) || (strlen (env_buf) <= 0))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Not installing a handler because $%s is empty\n",
-         GNUNET_OS_CONTROL_PIPE);
-    putenv (GNUNET_OS_CONTROL_PIPE "=");
-    return;
-  }
+    {
+      /* already done, we've been called twice... */
+      GNUNET_break(0);
+      return;
+    }
+  env_buf = getenv(GNUNET_OS_CONTROL_PIPE);
+  if ((NULL == env_buf) || (strlen(env_buf) <= 0))
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Not installing a handler because $%s is empty\n",
+          GNUNET_OS_CONTROL_PIPE);
+      putenv(GNUNET_OS_CONTROL_PIPE "=");
+      return;
+    }
   errno = 0;
-  pipe_fd = strtoull (env_buf, &env_buf_end, 16);
+  pipe_fd = strtoull(env_buf, &env_buf_end, 16);
   if ((0 != errno) || (env_buf == env_buf_end))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
-    putenv (GNUNET_OS_CONTROL_PIPE "=");
-    return;
-  }
-#if ! defined(WINDOWS)
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
+      putenv(GNUNET_OS_CONTROL_PIPE "=");
+      return;
+    }
+#if !defined(WINDOWS)
   if (pipe_fd >= FD_SETSIZE)
 #else
-  if ((FILE_TYPE_UNKNOWN == GetFileType ((HANDLE) (uintptr_t) pipe_fd)) &&
-      (0 != GetLastError ()))
+  if ((FILE_TYPE_UNKNOWN == GetFileType((HANDLE)(uintptr_t)pipe_fd)) &&
+      (0 != GetLastError()))
 #endif
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
-         env_buf);
-    putenv (GNUNET_OS_CONTROL_PIPE "=");
-    return;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
+          env_buf);
+      putenv(GNUNET_OS_CONTROL_PIPE "=");
+      return;
+    }
 #if WINDOWS
   control_pipe =
-    GNUNET_DISK_get_handle_from_w32_handle ((HANDLE) (uintptr_t) pipe_fd);
+    GNUNET_DISK_get_handle_from_w32_handle((HANDLE)(uintptr_t)pipe_fd);
 #else
-  control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
+  control_pipe = GNUNET_DISK_get_handle_from_int_fd((int)pipe_fd);
 #endif
   if (NULL == control_pipe)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
-    putenv (GNUNET_OS_CONTROL_PIPE "=");
-    return;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding parent control handler pipe `%s' to the scheduler\n",
-       env_buf);
-  pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                        control_pipe,
-                                        &parent_control_handler,
-                                        control_pipe);
-  spch = GNUNET_SCHEDULER_add_shutdown (&shutdown_pch, control_pipe);
-  putenv (GNUNET_OS_CONTROL_PIPE "=");
+    {
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
+      putenv(GNUNET_OS_CONTROL_PIPE "=");
+      return;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Adding parent control handler pipe `%s' to the scheduler\n",
+      env_buf);
+  pch = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       control_pipe,
+                                       &parent_control_handler,
+                                       control_pipe);
+  spch = GNUNET_SCHEDULER_add_shutdown(&shutdown_pch, control_pipe);
+  putenv(GNUNET_OS_CONTROL_PIPE "=");
 }
 
 
@@ -221,11 +220,11 @@ GNUNET_OS_install_parent_control_handler (void *cls)
  * @return pointer to the process sturcutre for this process
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_process_current ()
+GNUNET_OS_process_current()
 {
 #if WINDOWS
-  current_process.pid = GetCurrentProcessId ();
-  current_process.handle = GetCurrentProcess ();
+  current_process.pid = GetCurrentProcessId();
+  current_process.handle = GetCurrentProcess();
 #else
   current_process.pid = 0;
 #endif
@@ -241,92 +240,92 @@ GNUNET_OS_process_current ()
  * @return 0 on success, -1 on error
  */
 int
-GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
+GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
 {
   int ret;
   char csig;
 
-  csig = (char) sig;
+  csig = (char)sig;
   if (NULL != proc->control_pipe)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Sending signal %d to pid: %u via pipe\n",
-         sig,
-         proc->pid);
-    ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof (csig));
-    if (sizeof (csig) == ret)
-      return 0;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Sending signal %d to pid: %u via pipe\n",
+          sig,
+          proc->pid);
+      ret = GNUNET_DISK_file_write(proc->control_pipe, &csig, sizeof(csig));
+      if (sizeof(csig) == ret)
+        return 0;
+    }
   /* pipe failed or non-existent, try other methods */
   switch (sig)
-  {
-#if ! defined(WINDOWS)
-  case SIGHUP:
+    {
+#if !defined(WINDOWS)
+    case SIGHUP:
 #endif
-  case SIGINT:
-  case SIGKILL:
-  case SIGTERM:
+    case SIGINT:
+    case SIGKILL:
+    case SIGTERM:
 #if (SIGTERM != GNUNET_TERM_SIG)
-  case GNUNET_TERM_SIG:
+    case GNUNET_TERM_SIG:
 #endif
-#if defined(WINDOWS) && ! defined(__CYGWIN__)
-  {
-    DWORD exitcode;
-    int must_kill = GNUNET_YES;
-    if (0 != GetExitCodeProcess (proc->handle, &exitcode))
-      must_kill = (exitcode == STILL_ACTIVE) ? GNUNET_YES : GNUNET_NO;
-    if (GNUNET_YES == must_kill)
-    {
-      if (0 == SafeTerminateProcess (proc->handle, 0, 0))
+#if defined(WINDOWS) && !defined(__CYGWIN__)
       {
-        DWORD error_code = GetLastError ();
-        if ((error_code != WAIT_TIMEOUT) &&
-            (error_code != ERROR_PROCESS_ABORTED))
-        {
-          LOG ((error_code == ERROR_ACCESS_DENIED) ? GNUNET_ERROR_TYPE_INFO
-                                                   : GNUNET_ERROR_TYPE_WARNING,
-               "SafeTermiateProcess failed with code %lu\n",
-               error_code);
-          /* The problem here is that a process that is already dying
-             * might cause SafeTerminateProcess to fail with
-             * ERROR_ACCESS_DENIED, but the process WILL die eventually.
-             * If we really had a permissions problem, hanging up (which
-             * is what will happen in process_wait() in that case) is
-             * a valid option.
-             */
-          if (ERROR_ACCESS_DENIED == error_code)
-          {
-            errno = 0;
-          }
-          else
+        DWORD exitcode;
+        int must_kill = GNUNET_YES;
+        if (0 != GetExitCodeProcess(proc->handle, &exitcode))
+          must_kill = (exitcode == STILL_ACTIVE) ? GNUNET_YES : GNUNET_NO;
+        if (GNUNET_YES == must_kill)
           {
-            SetErrnoFromWinError (error_code);
-            return -1;
+            if (0 == SafeTerminateProcess(proc->handle, 0, 0))
+              {
+                DWORD error_code = GetLastError();
+                if ((error_code != WAIT_TIMEOUT) &&
+                    (error_code != ERROR_PROCESS_ABORTED))
+                  {
+                    LOG((error_code == ERROR_ACCESS_DENIED) ? GNUNET_ERROR_TYPE_INFO
+                        : GNUNET_ERROR_TYPE_WARNING,
+                        "SafeTermiateProcess failed with code %lu\n",
+                        error_code);
+                    /* The problem here is that a process that is already dying
+                     * might cause SafeTerminateProcess to fail with
+                     * ERROR_ACCESS_DENIED, but the process WILL die eventually.
+                     * If we really had a permissions problem, hanging up (which
+                     * is what will happen in process_wait() in that case) is
+                     * a valid option.
+                     */
+                    if (ERROR_ACCESS_DENIED == error_code)
+                      {
+                        errno = 0;
+                      }
+                    else
+                      {
+                        SetErrnoFromWinError(error_code);
+                        return -1;
+                      }
+                  }
+              }
           }
-        }
       }
-    }
-  }
-    return 0;
+      return 0;
 #else
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Sending signal %d to pid: %u via system call\n",
-         sig,
-         proc->pid);
-    return kill (proc->pid, sig);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Sending signal %d to pid: %u via system call\n",
+          sig,
+          proc->pid);
+      return kill(proc->pid, sig);
 #endif
-  default:
+    default:
 #if defined(WINDOWS)
-    errno = EINVAL;
-    return -1;
+      errno = EINVAL;
+      return -1;
 #else
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Sending signal %d to pid: %u via system call\n",
-         sig,
-         proc->pid);
-    return kill (proc->pid, sig);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Sending signal %d to pid: %u via system call\n",
+          sig,
+          proc->pid);
+      return kill(proc->pid, sig);
 #endif
-  }
+    }
 }
 
 
@@ -338,7 +337,7 @@ GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
  * @return the current process id
  */
 pid_t
-GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc)
+GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc)
 {
   return proc->pid;
 }
@@ -351,15 +350,15 @@ GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc)
  * @param proc pointer to process structure
  */
 void
-GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
+GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
 {
   if (NULL != proc->control_pipe)
-    GNUNET_DISK_file_close (proc->control_pipe);
+    GNUNET_DISK_file_close(proc->control_pipe);
 #if defined(WINDOWS)
   if (NULL != proc->handle)
-    CloseHandle (proc->handle);
+    CloseHandle(proc->handle);
 #endif
-  GNUNET_free (proc);
+  GNUNET_free(proc);
 }
 
 
@@ -379,14 +378,14 @@ extern GNUNET_SIGNAL_Handler w32_sigchld_handler;
  * @param proc pointer to process structure
  */
 static DWORD_WINAPI
-child_wait_thread (void *arg)
+child_wait_thread(void *arg)
 {
-  struct GNUNET_OS_Process *proc = (struct GNUNET_OS_Process *) arg;
+  struct GNUNET_OS_Process *proc = (struct GNUNET_OS_Process *)arg;
 
-  WaitForSingleObject (proc->handle, INFINITE);
+  WaitForSingleObject(proc->handle, INFINITE);
 
   if (w32_sigchld_handler)
-    w32_sigchld_handler ();
+    w32_sigchld_handler();
 
   return 0;
 }
@@ -395,7 +394,7 @@ child_wait_thread (void *arg)
 
 #if MINGW
 static char *
-CreateCustomEnvTable (char **vars)
+CreateCustomEnvTable(char **vars)
 {
   char *win32_env_table;
   char *ptr;
@@ -412,90 +411,90 @@ CreateCustomEnvTable (char **vars)
   char *var;
   char *val;
 
-  win32_env_table = GetEnvironmentStringsA ();
+  win32_env_table = GetEnvironmentStringsA();
   if (NULL == win32_env_table)
     return NULL;
   for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++)
     ;
   n_var = c;
-  index = GNUNET_malloc (sizeof (char *) * n_var);
+  index = GNUNET_malloc(sizeof(char *) * n_var);
   for (c = 0; c < n_var; c++)
     index[c] = 0;
   for (items_count = 0, ptr = win32_env_table; ptr[0] != 0; items_count++)
-  {
-    size_t len = strlen (ptr);
-    int found = 0;
-
-    for (var_ptr = vars; *var_ptr; var_ptr++)
     {
-      var = *var_ptr++;
-      val = *var_ptr;
-      var_len = strlen (var);
-      if (strncmp (var, ptr, var_len) == 0)
-      {
-        found = 1;
-        index[c] = 1;
-        tablesize += var_len + strlen (val) + 1;
-        break;
-      }
+      size_t len = strlen(ptr);
+      int found = 0;
+
+      for (var_ptr = vars; *var_ptr; var_ptr++)
+        {
+          var = *var_ptr++;
+          val = *var_ptr;
+          var_len = strlen(var);
+          if (strncmp(var, ptr, var_len) == 0)
+            {
+              found = 1;
+              index[c] = 1;
+              tablesize += var_len + strlen(val) + 1;
+              break;
+            }
+        }
+      if (!found)
+        tablesize += len + 1;
+      ptr += len + 1;
     }
-    if (! found)
-      tablesize += len + 1;
-    ptr += len + 1;
-  }
   for (n_found = 0, c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
-  {
-    var = *var_ptr++;
-    val = *var_ptr;
-    if (index[c] != 1)
-      n_found += strlen (var) + strlen (val) + 1;
-  }
-  result = GNUNET_malloc (tablesize + n_found + 1);
-  for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
-  {
-    size_t len = strlen (ptr);
-    int found = 0;
-
-    for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
     {
       var = *var_ptr++;
       val = *var_ptr;
-      var_len = strlen (var);
-      if (strncmp (var, ptr, var_len) == 0)
-      {
-        found = 1;
-        break;
-      }
-    }
-    if (! found)
-    {
-      strcpy (result_ptr, ptr);
-      result_ptr += len + 1;
+      if (index[c] != 1)
+        n_found += strlen(var) + strlen(val) + 1;
     }
-    else
+  result = GNUNET_malloc(tablesize + n_found + 1);
+  for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
     {
-      strcpy (result_ptr, var);
-      result_ptr += var_len;
-      strcpy (result_ptr, val);
-      result_ptr += strlen (val) + 1;
+      size_t len = strlen(ptr);
+      int found = 0;
+
+      for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
+        {
+          var = *var_ptr++;
+          val = *var_ptr;
+          var_len = strlen(var);
+          if (strncmp(var, ptr, var_len) == 0)
+            {
+              found = 1;
+              break;
+            }
+        }
+      if (!found)
+        {
+          strcpy(result_ptr, ptr);
+          result_ptr += len + 1;
+        }
+      else
+        {
+          strcpy(result_ptr, var);
+          result_ptr += var_len;
+          strcpy(result_ptr, val);
+          result_ptr += strlen(val) + 1;
+        }
+      ptr += len + 1;
     }
-    ptr += len + 1;
-  }
   for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
-  {
-    var = *var_ptr++;
-    val = *var_ptr;
-    var_len = strlen (var);
-    if (index[c] != 1)
     {
-      strcpy (result_ptr, var);
-      result_ptr += var_len;
-      strcpy (result_ptr, val);
-      result_ptr += strlen (val) + 1;
+      var = *var_ptr++;
+      val = *var_ptr;
+      var_len = strlen(var);
+      if (index[c] != 1)
+        {
+          strcpy(result_ptr, var);
+          result_ptr += var_len;
+          strcpy(result_ptr, val);
+          result_ptr += strlen(val) + 1;
+        }
     }
-  }
-  FreeEnvironmentStrings (win32_env_table);
-  GNUNET_free (index);
+  FreeEnvironmentStrings(win32_env_table);
+  GNUNET_free(index);
   *result_ptr = 0;
   return result;
 }
@@ -510,25 +509,25 @@ CreateCustomEnvTable (char **vars)
  * @param flags open flags (O_RDONLY, O_WRONLY)
  */
 static void
-open_dev_null (int target_fd, int flags)
+open_dev_null(int target_fd, int flags)
 {
   int fd;
 
-  fd = open ("/dev/null", flags);
+  fd = open("/dev/null", flags);
   if (-1 == fd)
-  {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null");
-    return;
-  }
+    {
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null");
+      return;
+    }
   if (fd == target_fd)
     return;
-  if (-1 == dup2 (fd, target_fd))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
-    (void) close (fd);
-    return;
-  }
-  GNUNET_break (0 == close (fd));
+  if (-1 == dup2(fd, target_fd))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "dup2");
+      (void)close(fd);
+      return;
+    }
+  GNUNET_break(0 == close(fd));
 }
 #endif
 
@@ -551,14 +550,14 @@ open_dev_null (int target_fd, int flags)
  * @return process ID of the new process, -1 on error
  */
 static struct GNUNET_OS_Process *
-start_process (int pipe_control,
-               enum GNUNET_OS_InheritStdioFlags std_inheritance,
-               struct GNUNET_DISK_PipeHandle *pipe_stdin,
-               struct GNUNET_DISK_PipeHandle *pipe_stdout,
-               struct GNUNET_DISK_PipeHandle *pipe_stderr,
-               const SOCKTYPE *lsocks,
-               const char *filename,
-               char *const argv[])
+start_process(int pipe_control,
+              enum GNUNET_OS_InheritStdioFlags std_inheritance,
+              struct GNUNET_DISK_PipeHandle *pipe_stdin,
+              struct GNUNET_DISK_PipeHandle *pipe_stdout,
+              struct GNUNET_DISK_PipeHandle *pipe_stderr,
+              const SOCKTYPE *lsocks,
+              const char *filename,
+              char *const argv[])
 {
 #ifndef MINGW
   pid_t ret;
@@ -582,223 +581,223 @@ start_process (int pipe_control,
   int fd_stdin_write;
 
   if (GNUNET_SYSERR ==
-      GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
+      GNUNET_OS_check_helper_binary(filename, GNUNET_NO, NULL))
     return NULL; /* not executable */
   if (GNUNET_YES == pipe_control)
-  {
-    struct GNUNET_DISK_PipeHandle *childpipe;
-    int dup_childpipe_read_fd = -1;
-
-    childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
-    if (NULL == childpipe)
-      return NULL;
-    childpipe_read =
-      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
-    childpipe_write =
-      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
-    GNUNET_DISK_pipe_close (childpipe);
-    if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
-        (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
-                                                         &childpipe_read_fd,
-                                                         sizeof (int))) ||
-        (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
-    {
-      if (NULL != childpipe_read)
-        GNUNET_DISK_file_close (childpipe_read);
-      if (NULL != childpipe_write)
-        GNUNET_DISK_file_close (childpipe_write);
-      if (0 <= dup_childpipe_read_fd)
-        close (dup_childpipe_read_fd);
-      return NULL;
+    {
+      struct GNUNET_DISK_PipeHandle *childpipe;
+      int dup_childpipe_read_fd = -1;
+
+      childpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
+      if (NULL == childpipe)
+        return NULL;
+      childpipe_read =
+        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_READ);
+      childpipe_write =
+        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_WRITE);
+      GNUNET_DISK_pipe_close(childpipe);
+      if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
+          (GNUNET_OK != GNUNET_DISK_internal_file_handle_(childpipe_read,
+                                                          &childpipe_read_fd,
+                                                          sizeof(int))) ||
+          (-1 == (dup_childpipe_read_fd = dup(childpipe_read_fd))))
+        {
+          if (NULL != childpipe_read)
+            GNUNET_DISK_file_close(childpipe_read);
+          if (NULL != childpipe_write)
+            GNUNET_DISK_file_close(childpipe_write);
+          if (0 <= dup_childpipe_read_fd)
+            close(dup_childpipe_read_fd);
+          return NULL;
+        }
+      childpipe_read_fd = dup_childpipe_read_fd;
+      GNUNET_DISK_file_close(childpipe_read);
     }
-    childpipe_read_fd = dup_childpipe_read_fd;
-    GNUNET_DISK_file_close (childpipe_read);
-  }
   else
-  {
-    childpipe_write = NULL;
-    childpipe_read_fd = -1;
-  }
+    {
+      childpipe_write = NULL;
+      childpipe_read_fd = -1;
+    }
   if (NULL != pipe_stdin)
-  {
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
-        &fd_stdin_read,
-        sizeof (int)));
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
-        &fd_stdin_write,
-        sizeof (int)));
-  }
+    {
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stdin, GNUNET_DISK_PIPE_END_READ),
+          &fd_stdin_read,
+          sizeof(int)));
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
+          &fd_stdin_write,
+          sizeof(int)));
+    }
   if (NULL != pipe_stdout)
-  {
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
-        &fd_stdout_write,
-        sizeof (int)));
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ),
-        &fd_stdout_read,
-        sizeof (int)));
-  }
+    {
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
+          &fd_stdout_write,
+          sizeof(int)));
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_READ),
+          &fd_stdout_read,
+          sizeof(int)));
+    }
   if (NULL != pipe_stderr)
-  {
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stderr, GNUNET_DISK_PIPE_END_READ),
-        &fd_stderr_read,
-        sizeof (int)));
-    GNUNET_assert (
-      GNUNET_OK ==
-      GNUNET_DISK_internal_file_handle_ (
-        GNUNET_DISK_pipe_handle (pipe_stderr, GNUNET_DISK_PIPE_END_WRITE),
-        &fd_stderr_write,
-        sizeof (int)));
-  }
+    {
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stderr, GNUNET_DISK_PIPE_END_READ),
+          &fd_stderr_read,
+          sizeof(int)));
+      GNUNET_assert(
+        GNUNET_OK ==
+        GNUNET_DISK_internal_file_handle_(
+          GNUNET_DISK_pipe_handle(pipe_stderr, GNUNET_DISK_PIPE_END_WRITE),
+          &fd_stderr_write,
+          sizeof(int)));
+    }
   lscp = NULL;
   ls = 0;
   if (NULL != lsocks)
-  {
-    i = 0;
-    while (-1 != (k = lsocks[i++]))
-      GNUNET_array_append (lscp, ls, k);
-    GNUNET_array_append (lscp, ls, -1);
-  }
+    {
+      i = 0;
+      while (-1 != (k = lsocks[i++]))
+        GNUNET_array_append(lscp, ls, k);
+      GNUNET_array_append(lscp, ls, -1);
+    }
 #if DARWIN
   /* see https://gnunet.org/vfork */
-  ret = vfork ();
+  ret = vfork();
 #else
-  ret = fork ();
+  ret = fork();
 #endif
   if (-1 == ret)
-  {
-    int eno = errno;
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
-    GNUNET_array_grow (lscp, ls, 0);
-    if (NULL != childpipe_write)
-      GNUNET_DISK_file_close (childpipe_write);
-    if (0 <= childpipe_read_fd)
-      close (childpipe_read_fd);
-    errno = eno;
-    return NULL;
-  }
+    {
+      int eno = errno;
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fork");
+      GNUNET_array_grow(lscp, ls, 0);
+      if (NULL != childpipe_write)
+        GNUNET_DISK_file_close(childpipe_write);
+      if (0 <= childpipe_read_fd)
+        close(childpipe_read_fd);
+      errno = eno;
+      return NULL;
+    }
   if (0 != ret)
-  {
-    unsetenv (GNUNET_OS_CONTROL_PIPE);
-    gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
-    gnunet_proc->pid = ret;
-    gnunet_proc->control_pipe = childpipe_write;
-    if (GNUNET_YES == pipe_control)
     {
-      close (childpipe_read_fd);
+      unsetenv(GNUNET_OS_CONTROL_PIPE);
+      gnunet_proc = GNUNET_new(struct GNUNET_OS_Process);
+      gnunet_proc->pid = ret;
+      gnunet_proc->control_pipe = childpipe_write;
+      if (GNUNET_YES == pipe_control)
+        {
+          close(childpipe_read_fd);
+        }
+      GNUNET_array_grow(lscp, ls, 0);
+      return gnunet_proc;
     }
-    GNUNET_array_grow (lscp, ls, 0);
-    return gnunet_proc;
-  }
   if (0 <= childpipe_read_fd)
-  {
-    char fdbuf[100];
+    {
+      char fdbuf[100];
 #ifndef DARWIN
-    /* due to vfork, we must NOT free memory on DARWIN! */
-    GNUNET_DISK_file_close (childpipe_write);
+      /* due to vfork, we must NOT free memory on DARWIN! */
+      GNUNET_DISK_file_close(childpipe_write);
 #endif
-    snprintf (fdbuf, 100, "%x", childpipe_read_fd);
-    setenv (GNUNET_OS_CONTROL_PIPE, fdbuf, 1);
-  }
+      snprintf(fdbuf, 100, "%x", childpipe_read_fd);
+      setenv(GNUNET_OS_CONTROL_PIPE, fdbuf, 1);
+    }
   else
-    unsetenv (GNUNET_OS_CONTROL_PIPE);
+    unsetenv(GNUNET_OS_CONTROL_PIPE);
   if (NULL != pipe_stdin)
-  {
-    GNUNET_break (0 == close (fd_stdin_write));
-    if (-1 == dup2 (fd_stdin_read, 0))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-    GNUNET_break (0 == close (fd_stdin_read));
-  }
+    {
+      GNUNET_break(0 == close(fd_stdin_write));
+      if (-1 == dup2(fd_stdin_read, 0))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2");
+      GNUNET_break(0 == close(fd_stdin_read));
+    }
   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
-  {
-    GNUNET_break (0 == close (0));
-    open_dev_null (0, O_RDONLY);
-  }
+    {
+      GNUNET_break(0 == close(0));
+      open_dev_null(0, O_RDONLY);
+    }
   if (NULL != pipe_stdout)
-  {
-    GNUNET_break (0 == close (fd_stdout_read));
-    if (-1 == dup2 (fd_stdout_write, 1))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-    GNUNET_break (0 == close (fd_stdout_write));
-  }
+    {
+      GNUNET_break(0 == close(fd_stdout_read));
+      if (-1 == dup2(fd_stdout_write, 1))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2");
+      GNUNET_break(0 == close(fd_stdout_write));
+    }
   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
-  {
-    GNUNET_break (0 == close (1));
-    open_dev_null (1, O_WRONLY);
-  }
+    {
+      GNUNET_break(0 == close(1));
+      open_dev_null(1, O_WRONLY);
+    }
   if (NULL != pipe_stderr)
-  {
-    GNUNET_break (0 == close (fd_stderr_read));
-    if (-1 == dup2 (fd_stderr_write, 2))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-    GNUNET_break (0 == close (fd_stderr_write));
-  }
+    {
+      GNUNET_break(0 == close(fd_stderr_read));
+      if (-1 == dup2(fd_stderr_write, 2))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2");
+      GNUNET_break(0 == close(fd_stderr_write));
+    }
   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
-  {
-    GNUNET_break (0 == close (2));
-    open_dev_null (2, O_WRONLY);
-  }
+    {
+      GNUNET_break(0 == close(2));
+      open_dev_null(2, O_WRONLY);
+    }
   if (NULL != lscp)
-  {
-    /* read systemd documentation... */
-    i = 0;
-    tgt = 3;
-    while (-1 != lscp[i])
     {
-      j = i + 1;
-      while (-1 != lscp[j])
-      {
-        if (lscp[j] == tgt)
+      /* read systemd documentation... */
+      i = 0;
+      tgt = 3;
+      while (-1 != lscp[i])
         {
-          /* dup away */
-          k = dup (lscp[j]);
-          GNUNET_assert (-1 != k);
-          GNUNET_assert (0 == close (lscp[j]));
-          lscp[j] = k;
-          break;
+          j = i + 1;
+          while (-1 != lscp[j])
+            {
+              if (lscp[j] == tgt)
+                {
+                  /* dup away */
+                  k = dup(lscp[j]);
+                  GNUNET_assert(-1 != k);
+                  GNUNET_assert(0 == close(lscp[j]));
+                  lscp[j] = k;
+                  break;
+                }
+              j++;
+            }
+          if (lscp[i] != tgt)
+            {
+              /* Bury any existing FD, no matter what; they should all be closed
+               * on exec anyway and the important onces have been dup'ed away */
+              (void)close(tgt);
+              GNUNET_assert(-1 != dup2(lscp[i], tgt));
+            }
+          /* unset close-on-exec flag */
+          flags = fcntl(tgt, F_GETFD);
+          GNUNET_assert(flags >= 0);
+          flags &= ~FD_CLOEXEC;
+          fflush(stderr);
+          (void)fcntl(tgt, F_SETFD, flags);
+          tgt++;
+          i++;
         }
-        j++;
-      }
-      if (lscp[i] != tgt)
-      {
-        /* Bury any existing FD, no matter what; they should all be closed
-         * on exec anyway and the important onces have been dup'ed away */
-        (void) close (tgt);
-        GNUNET_assert (-1 != dup2 (lscp[i], tgt));
-      }
-      /* unset close-on-exec flag */
-      flags = fcntl (tgt, F_GETFD);
-      GNUNET_assert (flags >= 0);
-      flags &= ~FD_CLOEXEC;
-      fflush (stderr);
-      (void) fcntl (tgt, F_SETFD, flags);
-      tgt++;
-      i++;
-    }
-    GNUNET_snprintf (fds, sizeof (fds), "%u", i);
-    setenv ("LISTEN_FDS", fds, 1);
-  }
+      GNUNET_snprintf(fds, sizeof(fds), "%u", i);
+      setenv("LISTEN_FDS", fds, 1);
+    }
 #ifndef DARWIN
   /* due to vfork, we must NOT free memory on DARWIN! */
-  GNUNET_array_grow (lscp, ls, 0);
+  GNUNET_array_grow(lscp, ls, 0);
 #endif
-  execvp (filename, argv);
-  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
-  _exit (1);
+  execvp(filename, argv);
+  LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
+  _exit(1);
 #else
   struct GNUNET_DISK_FileHandle *childpipe_read;
   struct GNUNET_DISK_FileHandle *childpipe_write;
@@ -813,7 +812,7 @@ start_process (int pipe_control,
   int argcount = 0;
   struct GNUNET_OS_Process *gnunet_proc;
   char path[MAX_PATH + 1];
-  char *our_env[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+  char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
   char *env_block = NULL;
   char *pathbuf;
   DWORD pathbuf_len;
@@ -844,499 +843,500 @@ start_process (int pipe_control,
   DWORD create_no_window;
 
   if (GNUNET_SYSERR ==
-      GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
+      GNUNET_OS_check_helper_binary(filename, GNUNET_NO, NULL))
     return NULL; /* not executable */
 
   /* Search in prefix dir (hopefully - the directory from which
    * the current module was loaded), bindir and libdir, then in PATH
    */
-  self_prefix = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_SELF_PREFIX);
-  bindir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_BINDIR);
-  libdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
+  self_prefix = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_SELF_PREFIX);
+  bindir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_BINDIR);
+  libdir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LIBDIR);
 
-  pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0);
+  pathbuf_len = GetEnvironmentVariableA("PATH", (char *)&pathbuf, 0);
 
-  alloc_len = pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
-              strlen (libdir);
+  alloc_len = pathbuf_len + 1 + strlen(self_prefix) + 1 + strlen(bindir) + 1 +
+              strlen(libdir);
 
-  pathbuf = GNUNET_malloc (alloc_len * sizeof (char));
+  pathbuf = GNUNET_malloc(alloc_len * sizeof(char));
 
   ptr = pathbuf;
-  ptr += sprintf (pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir);
-  GNUNET_free (self_prefix);
-  GNUNET_free (bindir);
-  GNUNET_free (libdir);
+  ptr += sprintf(pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir);
+  GNUNET_free(self_prefix);
+  GNUNET_free(bindir);
+  GNUNET_free(libdir);
 
-  alloc_len = GetEnvironmentVariableA ("PATH", ptr, pathbuf_len);
+  alloc_len = GetEnvironmentVariableA("PATH", ptr, pathbuf_len);
   if (alloc_len != pathbuf_len - 1)
-  {
-    GNUNET_free (pathbuf);
-    errno = ENOSYS; /* PATH changed on the fly. What kind of error is that? */
-    return NULL;
-  }
+    {
+      GNUNET_free(pathbuf);
+      errno = ENOSYS; /* PATH changed on the fly. What kind of error is that? */
+      return NULL;
+    }
 
-  cmdlen = strlen (filename);
-  if ((cmdlen < 5) || (0 != strcmp (&filename[cmdlen - 4], ".exe")))
-    GNUNET_asprintf (&non_const_filename, "%s.exe", filename);
+  cmdlen = strlen(filename);
+  if ((cmdlen < 5) || (0 != strcmp(&filename[cmdlen - 4], ".exe")))
+    GNUNET_asprintf(&non_const_filename, "%s.exe", filename);
   else
-    GNUNET_asprintf (&non_const_filename, "%s", filename);
+    GNUNET_asprintf(&non_const_filename, "%s", filename);
 
   /* It could be in POSIX form, convert it to a DOS path early on */
   if (ERROR_SUCCESS !=
-      (lRet = plibc_conv_to_win_path (non_const_filename, win_path)))
-  {
-    SetErrnoFromWinError (lRet);
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
-                       "plibc_conv_to_win_path",
-                       non_const_filename);
-    GNUNET_free (non_const_filename);
-    GNUNET_free (pathbuf);
-    return NULL;
-  }
-  GNUNET_free (non_const_filename);
-  non_const_filename = GNUNET_strdup (win_path);
+      (lRet = plibc_conv_to_win_path(non_const_filename, win_path)))
+    {
+      SetErrnoFromWinError(lRet);
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR,
+                        "plibc_conv_to_win_path",
+                        non_const_filename);
+      GNUNET_free(non_const_filename);
+      GNUNET_free(pathbuf);
+      return NULL;
+    }
+  GNUNET_free(non_const_filename);
+  non_const_filename = GNUNET_strdup(win_path);
   /* Check that this is the full path. If it isn't, search. */
   /* FIXME: convert it to wchar_t and use SearchPathW?
    * Remember: arguments to _start_process() are technically in UTF-8...
    */
   if (non_const_filename[1] == ':')
-  {
-    snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Using path `%s' as-is. PATH is %s\n",
-         path,
-         ptr);
-  }
-  else if (! SearchPathA (pathbuf,
-                          non_const_filename,
-                          NULL,
-                          sizeof (path) / sizeof (char),
-                          path,
-                          NULL))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
-                       "SearchPath",
-                       non_const_filename);
-    GNUNET_free (non_const_filename);
-    GNUNET_free (pathbuf);
-    return NULL;
-  }
+    {
+      snprintf(path, sizeof(path) / sizeof(char), "%s", non_const_filename);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Using path `%s' as-is. PATH is %s\n",
+          path,
+          ptr);
+    }
+  else if (!SearchPathA(pathbuf,
+                        non_const_filename,
+                        NULL,
+                        sizeof(path) / sizeof(char),
+                        path,
+                        NULL))
+    {
+      SetErrnoFromWinError(GetLastError());
+      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR,
+                        "SearchPath",
+                        non_const_filename);
+      GNUNET_free(non_const_filename);
+      GNUNET_free(pathbuf);
+      return NULL;
+    }
   else
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Found `%s' in PATH `%s'\n", path, pathbuf);
-  GNUNET_free (pathbuf);
-  GNUNET_free (non_const_filename);
+    LOG(GNUNET_ERROR_TYPE_DEBUG, "Found `%s' in PATH `%s'\n", path, pathbuf);
+  GNUNET_free(pathbuf);
+  GNUNET_free(non_const_filename);
 
   /* Count the number of arguments */
-  arg = (char **) argv;
+  arg = (char **)argv;
   while (*arg)
-  {
-    arg++;
-    argcount++;
-  }
+    {
+      arg++;
+      argcount++;
+    }
 
   /* Allocate a copy argv */
-  non_const_argv = GNUNET_malloc (sizeof (char *) * (argcount + 1));
+  non_const_argv = GNUNET_malloc(sizeof(char *) * (argcount + 1));
 
   /* Copy all argv strings */
   argcount = 0;
-  arg = (char **) argv;
+  arg = (char **)argv;
   while (*arg)
-  {
-    if (arg == argv)
-      non_const_argv[argcount] = GNUNET_strdup (path);
-    else
-      non_const_argv[argcount] = GNUNET_strdup (*arg);
-    arg++;
-    argcount++;
-  }
+    {
+      if (arg == argv)
+        non_const_argv[argcount] = GNUNET_strdup(path);
+      else
+        non_const_argv[argcount] = GNUNET_strdup(*arg);
+      arg++;
+      argcount++;
+    }
   non_const_argv[argcount] = NULL;
 
   /* Count cmd len */
   cmdlen = 1;
   arg = non_const_argv;
   while (*arg)
-  {
-    cmdlen = cmdlen + strlen (*arg) + 4;
-    arg++;
-  }
+    {
+      cmdlen = cmdlen + strlen(*arg) + 4;
+      arg++;
+    }
 
   /* Allocate and create cmd */
-  cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
+  cmd = idx = GNUNET_malloc(sizeof(char) * cmdlen);
   arg = non_const_argv;
   while (*arg)
-  {
-    char arg_last_char = (*arg)[strlen (*arg) - 1];
-    idx += sprintf (idx,
-                    "\"%s%s\"%s",
-                    *arg,
-                    arg_last_char == '\\' ? "\\" : "",
-                    *(arg + 1) ? " " : "");
-    arg++;
-  }
+    {
+      char arg_last_char = (*arg)[strlen(*arg) - 1];
+      idx += sprintf(idx,
+                     "\"%s%s\"%s",
+                     *arg,
+                     arg_last_char == '\\' ? "\\" : "",
+                     *(arg + 1) ? " " : "");
+      arg++;
+    }
 
   while (argcount > 0)
-    GNUNET_free (non_const_argv[--argcount]);
-  GNUNET_free (non_const_argv);
+    GNUNET_free(non_const_argv[--argcount]);
+  GNUNET_free(non_const_argv);
 
-  memset (&start, 0, sizeof (start));
-  start.cb = sizeof (start);
+  memset(&start, 0, sizeof(start));
+  start.cb = sizeof(start);
   if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0))
     start.dwFlags |= STARTF_USESTDHANDLES;
 
-  stdih = GetStdHandle (STD_INPUT_HANDLE);
-  GetHandleInformation (stdih, &stdif);
+  stdih = GetStdHandle(STD_INPUT_HANDLE);
+  GetHandleInformation(stdih, &stdif);
   if (pipe_stdin != NULL)
-  {
-    GNUNET_DISK_internal_file_handle_ (
-      GNUNET_DISK_pipe_handle (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
-      &stdin_handle,
-      sizeof (HANDLE));
-    start.hStdInput = stdin_handle;
-  }
+    {
+      GNUNET_DISK_internal_file_handle_(
+        GNUNET_DISK_pipe_handle(pipe_stdin, GNUNET_DISK_PIPE_END_READ),
+        &stdin_handle,
+        sizeof(HANDLE));
+      start.hStdInput = stdin_handle;
+    }
   else if (stdih)
-  {
-    if (std_inheritance & GNUNET_OS_INHERIT_STD_IN)
     {
-      SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 1);
-      if (pipe_stdin == NULL)
-        start.hStdInput = stdih;
+      if (std_inheritance & GNUNET_OS_INHERIT_STD_IN)
+        {
+          SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, 1);
+          if (pipe_stdin == NULL)
+            start.hStdInput = stdih;
+        }
+      else
+        SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, 0);
     }
-    else
-      SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 0);
-  }
 
 
-  stdoh = GetStdHandle (STD_OUTPUT_HANDLE);
-  GetHandleInformation (stdoh, &stdof);
+  stdoh = GetStdHandle(STD_OUTPUT_HANDLE);
+  GetHandleInformation(stdoh, &stdof);
   if (NULL != pipe_stdout)
-  {
-    GNUNET_DISK_internal_file_handle_ (
-      GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
-      &stdout_handle,
-      sizeof (HANDLE));
-    start.hStdOutput = stdout_handle;
-  }
+    {
+      GNUNET_DISK_internal_file_handle_(
+        GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
+        &stdout_handle,
+        sizeof(HANDLE));
+      start.hStdOutput = stdout_handle;
+    }
   else if (stdoh)
-  {
-    if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)
     {
-      SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 1);
-      if (pipe_stdout == NULL)
-        start.hStdOutput = stdoh;
+      if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)
+        {
+          SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, 1);
+          if (pipe_stdout == NULL)
+            start.hStdOutput = stdoh;
+        }
+      else
+        SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, 0);
     }
-    else
-      SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 0);
-  }
 
-  stdeh = GetStdHandle (STD_ERROR_HANDLE);
-  GetHandleInformation (stdeh, &stdef);
+  stdeh = GetStdHandle(STD_ERROR_HANDLE);
+  GetHandleInformation(stdeh, &stdef);
   if (stdeh)
-  {
-    if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)
     {
-      SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 1);
-      start.hStdError = stdeh;
+      if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)
+        {
+          SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, 1);
+          start.hStdError = stdeh;
+        }
+      else
+        SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, 0);
     }
-    else
-      SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 0);
-  }
 
   if (GNUNET_YES == pipe_control)
-  {
-    struct GNUNET_DISK_PipeHandle *childpipe;
-    childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
-    if (NULL == childpipe)
-      return NULL;
-    childpipe_read =
-      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
-    childpipe_write =
-      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
-    GNUNET_DISK_pipe_close (childpipe);
-    if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
-        (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
-                                                         &childpipe_read_handle,
-                                                         sizeof (HANDLE))))
-    {
-      if (childpipe_read)
-        GNUNET_DISK_file_close (childpipe_read);
-      if (childpipe_write)
-        GNUNET_DISK_file_close (childpipe_write);
-      GNUNET_free (cmd);
-      return NULL;
+    {
+      struct GNUNET_DISK_PipeHandle *childpipe;
+      childpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
+      if (NULL == childpipe)
+        return NULL;
+      childpipe_read =
+        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_READ);
+      childpipe_write =
+        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_WRITE);
+      GNUNET_DISK_pipe_close(childpipe);
+      if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
+          (GNUNET_OK != GNUNET_DISK_internal_file_handle_(childpipe_read,
+                                                          &childpipe_read_handle,
+                                                          sizeof(HANDLE))))
+        {
+          if (childpipe_read)
+            GNUNET_DISK_file_close(childpipe_read);
+          if (childpipe_write)
+            GNUNET_DISK_file_close(childpipe_write);
+          GNUNET_free(cmd);
+          return NULL;
+        }
+      /* Unlike *nix variant, we don't dup the handle, so can't close
+       * filehandle right now.
+       */
+      SetHandleInformation(childpipe_read_handle, HANDLE_FLAG_INHERIT, 1);
     }
-    /* Unlike *nix variant, we don't dup the handle, so can't close
-     * filehandle right now.
-     */
-    SetHandleInformation (childpipe_read_handle, HANDLE_FLAG_INHERIT, 1);
-  }
   else
-  {
-    childpipe_read = NULL;
-    childpipe_write = NULL;
-  }
+    {
+      childpipe_read = NULL;
+      childpipe_write = NULL;
+    }
 
   if (lsocks != NULL && lsocks[0] != INVALID_SOCKET)
-  {
-    lsocks_pipe =
-      GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
-
-    if (lsocks_pipe == NULL)
     {
-      GNUNET_free (cmd);
-      GNUNET_DISK_pipe_close (lsocks_pipe);
-      if (GNUNET_YES == pipe_control)
-      {
-        GNUNET_DISK_file_close (childpipe_write);
-        GNUNET_DISK_file_close (childpipe_read);
-      }
-      return NULL;
+      lsocks_pipe =
+        GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
+
+      if (lsocks_pipe == NULL)
+        {
+          GNUNET_free(cmd);
+          GNUNET_DISK_pipe_close(lsocks_pipe);
+          if (GNUNET_YES == pipe_control)
+            {
+              GNUNET_DISK_file_close(childpipe_write);
+              GNUNET_DISK_file_close(childpipe_read);
+            }
+          return NULL;
+        }
+      lsocks_write_fd =
+        GNUNET_DISK_pipe_handle(lsocks_pipe, GNUNET_DISK_PIPE_END_WRITE);
+      GNUNET_DISK_internal_file_handle_(lsocks_write_fd,
+                                        &lsocks_write,
+                                        sizeof(HANDLE));
+      GNUNET_DISK_internal_file_handle_(
+        GNUNET_DISK_pipe_handle(lsocks_pipe, GNUNET_DISK_PIPE_END_READ),
+        &lsocks_read,
+        sizeof(HANDLE));
     }
-    lsocks_write_fd =
-      GNUNET_DISK_pipe_handle (lsocks_pipe, GNUNET_DISK_PIPE_END_WRITE);
-    GNUNET_DISK_internal_file_handle_ (lsocks_write_fd,
-                                       &lsocks_write,
-                                       sizeof (HANDLE));
-    GNUNET_DISK_internal_file_handle_ (
-      GNUNET_DISK_pipe_handle (lsocks_pipe, GNUNET_DISK_PIPE_END_READ),
-      &lsocks_read,
-      sizeof (HANDLE));
-  }
   else
-  {
-    lsocks_pipe = NULL;
-    lsocks_write_fd = NULL;
-  }
+    {
+      lsocks_pipe = NULL;
+      lsocks_write_fd = NULL;
+    }
 
   env_off = 0;
   if (GNUNET_YES == pipe_control)
-  {
-    GNUNET_asprintf (&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE);
-    GNUNET_asprintf (&our_env[env_off++], "%p", childpipe_read_handle);
-  }
+    {
+      GNUNET_asprintf(&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE);
+      GNUNET_asprintf(&our_env[env_off++], "%p", childpipe_read_handle);
+    }
   if ((lsocks != NULL) && (lsocks[0] != INVALID_SOCKET))
-  {
-    /*This will tell the child that we're going to send lsocks over the pipe*/
-    GNUNET_asprintf (&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS");
-    GNUNET_asprintf (&our_env[env_off++], "%lu", lsocks_read);
-  }
+    {
+      /*This will tell the child that we're going to send lsocks over the pipe*/
+      GNUNET_asprintf(&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS");
+      GNUNET_asprintf(&our_env[env_off++], "%lu", lsocks_read);
+    }
   our_env[env_off++] = NULL;
-  env_block = CreateCustomEnvTable (our_env);
+  env_block = CreateCustomEnvTable(our_env);
   while (0 > env_off)
-    GNUNET_free_non_null (our_env[--env_off]);
+    GNUNET_free_non_null(our_env[--env_off]);
 
   wpath_len = 0;
   if (NULL ==
       (wpath =
-         u8_to_u16 ((uint8_t *) path, 1 + strlen (path), NULL, &wpath_len)))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
-         path,
-         errno);
-    GNUNET_free (env_block);
-    GNUNET_free (cmd);
-    if (lsocks_pipe)
-      GNUNET_DISK_pipe_close (lsocks_pipe);
-    if (GNUNET_YES == pipe_control)
-    {
-      GNUNET_DISK_file_close (childpipe_write);
-      GNUNET_DISK_file_close (childpipe_read);
+         u8_to_u16((uint8_t *)path, 1 + strlen(path), NULL, &wpath_len)))
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
+          path,
+          errno);
+      GNUNET_free(env_block);
+      GNUNET_free(cmd);
+      if (lsocks_pipe)
+        GNUNET_DISK_pipe_close(lsocks_pipe);
+      if (GNUNET_YES == pipe_control)
+        {
+          GNUNET_DISK_file_close(childpipe_write);
+          GNUNET_DISK_file_close(childpipe_read);
+        }
+      return NULL;
     }
-    return NULL;
-  }
 
   wcmd_len = 0;
   if (NULL ==
-      (wcmd = u8_to_u16 ((uint8_t *) cmd, 1 + strlen (cmd), NULL, &wcmd_len)))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
-         cmd,
-         errno);
-    GNUNET_free (env_block);
-    GNUNET_free (cmd);
-    free (wpath);
-    if (lsocks_pipe)
-      GNUNET_DISK_pipe_close (lsocks_pipe);
-    if (GNUNET_YES == pipe_control)
-    {
-      GNUNET_DISK_file_close (childpipe_write);
-      GNUNET_DISK_file_close (childpipe_read);
+      (wcmd = u8_to_u16((uint8_t *)cmd, 1 + strlen(cmd), NULL, &wcmd_len)))
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
+          cmd,
+          errno);
+      GNUNET_free(env_block);
+      GNUNET_free(cmd);
+      free(wpath);
+      if (lsocks_pipe)
+        GNUNET_DISK_pipe_close(lsocks_pipe);
+      if (GNUNET_YES == pipe_control)
+        {
+          GNUNET_DISK_file_close(childpipe_write);
+          GNUNET_DISK_file_close(childpipe_read);
+        }
+      return NULL;
     }
-    return NULL;
-  }
 
   create_no_window = 0;
   {
-    HANDLE console_input = CreateFile ("CONIN$",
-                                       GENERIC_READ,
-                                       FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                       NULL,
-                                       OPEN_EXISTING,
-                                       0,
-                                       NULL);
+    HANDLE console_input = CreateFile("CONIN$",
+                                      GENERIC_READ,
+                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                      NULL,
+                                      OPEN_EXISTING,
+                                      0,
+                                      NULL);
     if (INVALID_HANDLE_VALUE == console_input)
       create_no_window = CREATE_NO_WINDOW;
     else
-      CloseHandle (console_input);
+      CloseHandle(console_input);
   }
 
-  bresult = CreateProcessW (wpath,
-                            wcmd,
-                            NULL,
-                            NULL,
-                            GNUNET_YES,
-                            create_no_window | CREATE_SUSPENDED,
-                            env_block,
-                            NULL,
-                            &start,
-                            &proc);
-  error_code = GetLastError ();
+  bresult = CreateProcessW(wpath,
+                           wcmd,
+                           NULL,
+                           NULL,
+                           GNUNET_YES,
+                           create_no_window | CREATE_SUSPENDED,
+                           env_block,
+                           NULL,
+                           &start,
+                           &proc);
+  error_code = GetLastError();
 
   if ((NULL == pipe_stdin) && (stdih))
-    SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, stdif);
+    SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, stdif);
 
 
   if ((NULL == pipe_stdout) && (stdoh))
-    SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, stdof);
+    SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, stdof);
 
   if (stdeh)
-    SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, stdef);
-
-  if (! bresult)
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         "CreateProcess(%s, %s) failed: %lu\n",
-         path,
-         cmd,
-         error_code);
-
-  GNUNET_free (env_block);
-  GNUNET_free (cmd);
-  free (wpath);
-  free (wcmd);
+    SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, stdef);
+
+  if (!bresult)
+    LOG(GNUNET_ERROR_TYPE_ERROR,
+        "CreateProcess(%s, %s) failed: %lu\n",
+        path,
+        cmd,
+        error_code);
+
+  GNUNET_free(env_block);
+  GNUNET_free(cmd);
+  free(wpath);
+  free(wcmd);
   if (GNUNET_YES == pipe_control)
-  {
-    GNUNET_DISK_file_close (childpipe_read);
-  }
+    {
+      GNUNET_DISK_file_close(childpipe_read);
+    }
 
-  if (! bresult)
-  {
-    if (GNUNET_YES == pipe_control)
+  if (!bresult)
     {
-      GNUNET_DISK_file_close (childpipe_write);
+      if (GNUNET_YES == pipe_control)
+        {
+          GNUNET_DISK_file_close(childpipe_write);
+        }
+      if (NULL != lsocks)
+        GNUNET_DISK_pipe_close(lsocks_pipe);
+      SetErrnoFromWinError(error_code);
+      return NULL;
     }
-    if (NULL != lsocks)
-      GNUNET_DISK_pipe_close (lsocks_pipe);
-    SetErrnoFromWinError (error_code);
-    return NULL;
-  }
 
-  gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
+  gnunet_proc = GNUNET_new(struct GNUNET_OS_Process);
   gnunet_proc->pid = proc.dwProcessId;
   gnunet_proc->handle = proc.hProcess;
   gnunet_proc->control_pipe = childpipe_write;
 
-  CreateThread (NULL, 64000, &child_wait_thread, (void *) gnunet_proc, 0, NULL);
+  CreateThread(NULL, 64000, &child_wait_thread, (void *)gnunet_proc, 0, NULL);
 
-  ResumeThread (proc.hThread);
-  CloseHandle (proc.hThread);
+  ResumeThread(proc.hThread);
+  CloseHandle(proc.hThread);
 
   if ((NULL == lsocks) || (INVALID_SOCKET == lsocks[0]))
     return gnunet_proc;
 
-  GNUNET_DISK_pipe_close_end (lsocks_pipe, GNUNET_DISK_PIPE_END_READ);
+  GNUNET_DISK_pipe_close_end(lsocks_pipe, GNUNET_DISK_PIPE_END_READ);
 
   /* This is a replacement for "goto error" that doesn't use goto */
   fail = 1;
   do
-  {
-    ssize_t wrote;
-    uint64_t size;
-    uint64_t count;
-    unsigned int i;
-
-    /* Tell the number of sockets */
-    for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++)
-      ;
-
-    wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
-    if (sizeof (count) != wrote)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to write %u count bytes to the child: %lu\n",
-                  sizeof (count),
-                  GetLastError ());
-      break;
-    }
-    for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++)
-    {
-      WSAPROTOCOL_INFOA pi;
-      /* Get a socket duplication info */
-      if (SOCKET_ERROR ==
-          WSADuplicateSocketA (lsocks[i], gnunet_proc->pid, &pi))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Failed to duplicate an socket[%u]: %lu\n",
-                    i,
-                    GetLastError ());
-        break;
-      }
-      /* Synchronous I/O is not nice, but we can't schedule this:
-       * lsocks will be closed/freed by the caller soon, and until
-       * the child creates a duplicate, closing a socket here will
-       * close it for good.
-       */
-      /* Send the size of the structure
-       * (the child might be built with different headers...)
+    {
+      ssize_t wrote;
+      uint64_t size;
+      uint64_t count;
+      unsigned int i;
+
+      /* Tell the number of sockets */
+      for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++)
+        ;
+
+      wrote = GNUNET_DISK_file_write(lsocks_write_fd, &count, sizeof(count));
+      if (sizeof(count) != wrote)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Failed to write %u count bytes to the child: %lu\n",
+                     sizeof(count),
+                     GetLastError());
+          break;
+        }
+      for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++)
+        {
+          WSAPROTOCOL_INFOA pi;
+          /* Get a socket duplication info */
+          if (SOCKET_ERROR ==
+              WSADuplicateSocketA(lsocks[i], gnunet_proc->pid, &pi))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Failed to duplicate an socket[%u]: %lu\n",
+                         i,
+                         GetLastError());
+              break;
+            }
+          /* Synchronous I/O is not nice, but we can't schedule this:
+           * lsocks will be closed/freed by the caller soon, and until
+           * the child creates a duplicate, closing a socket here will
+           * close it for good.
+           */
+          /* Send the size of the structure
+           * (the child might be built with different headers...)
+           */
+          size = sizeof(pi);
+          wrote = GNUNET_DISK_file_write(lsocks_write_fd, &size, sizeof(size));
+          if (sizeof(size) != wrote)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Failed to write %u size[%u] bytes to the child: %lu\n",
+                         sizeof(size),
+                         i,
+                         GetLastError());
+              break;
+            }
+          /* Finally! Send the data */
+          wrote = GNUNET_DISK_file_write(lsocks_write_fd, &pi, sizeof(pi));
+          if (sizeof(pi) != wrote)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         "Failed to write %u socket[%u] bytes to the child: %lu\n",
+                         sizeof(pi),
+                         i,
+                         GetLastError());
+              break;
+            }
+        }
+      /* This will block us until the child makes a final read or closes
+       * the pipe (hence no 'wrote' check), since we have to wait for it
+       * to duplicate the last socket, before we return and start closing
+       * our own copies)
        */
-      size = sizeof (pi);
-      wrote = GNUNET_DISK_file_write (lsocks_write_fd, &size, sizeof (size));
-      if (sizeof (size) != wrote)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Failed to write %u size[%u] bytes to the child: %lu\n",
-                    sizeof (size),
-                    i,
-                    GetLastError ());
-        break;
-      }
-      /* Finally! Send the data */
-      wrote = GNUNET_DISK_file_write (lsocks_write_fd, &pi, sizeof (pi));
-      if (sizeof (pi) != wrote)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "Failed to write %u socket[%u] bytes to the child: %lu\n",
-                    sizeof (pi),
-                    i,
-                    GetLastError ());
-        break;
-      }
+      wrote = GNUNET_DISK_file_write(lsocks_write_fd, &count, sizeof(count));
+      fail = 0;
     }
-    /* This will block us until the child makes a final read or closes
-     * the pipe (hence no 'wrote' check), since we have to wait for it
-     * to duplicate the last socket, before we return and start closing
-     * our own copies)
-     */
-    wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
-    fail = 0;
-  } while (fail);
+  while (fail);
 
-  GNUNET_DISK_file_sync (lsocks_write_fd);
-  GNUNET_DISK_pipe_close (lsocks_pipe);
+  GNUNET_DISK_file_sync(lsocks_write_fd);
+  GNUNET_DISK_pipe_close(lsocks_pipe);
 
   if (fail)
-  {
-    /* If we can't pass on the socket(s), the child will block forever,
-     * better put it out of its misery.
-     */
-    SafeTerminateProcess (gnunet_proc->handle, 0, 0);
-    CloseHandle (gnunet_proc->handle);
-    if (NULL != gnunet_proc->control_pipe)
-      GNUNET_DISK_file_close (gnunet_proc->control_pipe);
-    GNUNET_free (gnunet_proc);
-    return NULL;
-  }
+    {
+      /* If we can't pass on the socket(s), the child will block forever,
+       * better put it out of its misery.
+       */
+      SafeTerminateProcess(gnunet_proc->handle, 0, 0);
+      CloseHandle(gnunet_proc->handle);
+      if (NULL != gnunet_proc->control_pipe)
+        GNUNET_DISK_file_close(gnunet_proc->control_pipe);
+      GNUNET_free(gnunet_proc);
+      return NULL;
+    }
   return gnunet_proc;
 #endif
 }
@@ -1355,22 +1355,22 @@ start_process (int pipe_control,
  * @return pointer to process structure of the new process, NULL on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process_vap (int pipe_control,
-                             enum GNUNET_OS_InheritStdioFlags std_inheritance,
-                             struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                             struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                             struct GNUNET_DISK_PipeHandle *pipe_stderr,
-                             const char *filename,
-                             char *const argv[])
+GNUNET_OS_start_process_vap(int pipe_control,
+                            enum GNUNET_OS_InheritStdioFlags std_inheritance,
+                            struct GNUNET_DISK_PipeHandle *pipe_stdin,
+                            struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                            struct GNUNET_DISK_PipeHandle *pipe_stderr,
+                            const char *filename,
+                            char *const argv[])
 {
-  return start_process (pipe_control,
-                        std_inheritance,
-                        pipe_stdin,
-                        pipe_stdout,
-                        pipe_stderr,
-                        NULL,
-                        filename,
-                        argv);
+  return start_process(pipe_control,
+                       std_inheritance,
+                       pipe_stdin,
+                       pipe_stdout,
+                       pipe_stderr,
+                       NULL,
+                       filename,
+                       argv);
 }
 
 
@@ -1387,13 +1387,13 @@ GNUNET_OS_start_process_vap (int pipe_control,
  * @return pointer to process structure of the new process, NULL on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process_va (int pipe_control,
-                            enum GNUNET_OS_InheritStdioFlags std_inheritance,
-                            struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                            struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                            struct GNUNET_DISK_PipeHandle *pipe_stderr,
-                            const char *filename,
-                            va_list va)
+GNUNET_OS_start_process_va(int pipe_control,
+                           enum GNUNET_OS_InheritStdioFlags std_inheritance,
+                           struct GNUNET_DISK_PipeHandle *pipe_stdin,
+                           struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                           struct GNUNET_DISK_PipeHandle *pipe_stderr,
+                           const char *filename,
+                           va_list va)
 {
   struct GNUNET_OS_Process *ret;
   va_list ap;
@@ -1401,24 +1401,24 @@ GNUNET_OS_start_process_va (int pipe_control,
   int argc;
 
   argc = 0;
-  va_copy (ap, va);
-  while (NULL != va_arg (ap, char *))
+  va_copy(ap, va);
+  while (NULL != va_arg(ap, char *))
     argc++;
-  va_end (ap);
-  argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
+  va_end(ap);
+  argv = GNUNET_malloc(sizeof(char *) * (argc + 1));
   argc = 0;
-  va_copy (ap, va);
-  while (NULL != (argv[argc] = va_arg (ap, char *)))
+  va_copy(ap, va);
+  while (NULL != (argv[argc] = va_arg(ap, char *)))
     argc++;
-  va_end (ap);
-  ret = GNUNET_OS_start_process_vap (pipe_control,
-                                     std_inheritance,
-                                     pipe_stdin,
-                                     pipe_stdout,
-                                     pipe_stderr,
-                                     filename,
-                                     argv);
-  GNUNET_free (argv);
+  va_end(ap);
+  ret = GNUNET_OS_start_process_vap(pipe_control,
+                                    std_inheritance,
+                                    pipe_stdin,
+                                    pipe_stdout,
+                                    pipe_stderr,
+                                    filename,
+                                    argv);
+  GNUNET_free(argv);
   return ret;
 }
 
@@ -1435,26 +1435,26 @@ GNUNET_OS_start_process_va (int pipe_control,
  * @return pointer to process structure of the new process, NULL on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process (int pipe_control,
-                         enum GNUNET_OS_InheritStdioFlags std_inheritance,
-                         struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                         struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                         struct GNUNET_DISK_PipeHandle *pipe_stderr,
-                         const char *filename,
-                         ...)
+GNUNET_OS_start_process(int pipe_control,
+                        enum GNUNET_OS_InheritStdioFlags std_inheritance,
+                        struct GNUNET_DISK_PipeHandle *pipe_stdin,
+                        struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                        struct GNUNET_DISK_PipeHandle *pipe_stderr,
+                        const char *filename,
+                        ...)
 {
   struct GNUNET_OS_Process *ret;
   va_list ap;
 
-  va_start (ap, filename);
-  ret = GNUNET_OS_start_process_va (pipe_control,
-                                    std_inheritance,
-                                    pipe_stdin,
-                                    pipe_stdout,
-                                    pipe_stderr,
-                                    filename,
-                                    ap);
-  va_end (ap);
+  va_start(ap, filename);
+  ret = GNUNET_OS_start_process_va(pipe_control,
+                                   std_inheritance,
+                                   pipe_stdin,
+                                   pipe_stdout,
+                                   pipe_stderr,
+                                   filename,
+                                   ap);
+  va_end(ap);
   return ret;
 }
 
@@ -1474,20 +1474,20 @@ GNUNET_OS_start_process (int pipe_control,
  * @return process ID of the new process, -1 on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process_v (int pipe_control,
-                           enum GNUNET_OS_InheritStdioFlags std_inheritance,
-                           const SOCKTYPE *lsocks,
-                           const char *filename,
-                           char *const argv[])
+GNUNET_OS_start_process_v(int pipe_control,
+                          enum GNUNET_OS_InheritStdioFlags std_inheritance,
+                          const SOCKTYPE *lsocks,
+                          const char *filename,
+                          char *const argv[])
 {
-  return start_process (pipe_control,
-                        std_inheritance,
-                        NULL,
-                        NULL,
-                        NULL,
-                        lsocks,
-                        filename,
-                        argv);
+  return start_process(pipe_control,
+                       std_inheritance,
+                       NULL,
+                       NULL,
+                       NULL,
+                       lsocks,
+                       filename,
+                       argv);
 }
 
 
@@ -1510,11 +1510,11 @@ GNUNET_OS_start_process_v (int pipe_control,
  * @return pointer to process structure of the new process, NULL on error
  */
 struct GNUNET_OS_Process *
-GNUNET_OS_start_process_s (int pipe_control,
-                           unsigned int std_inheritance,
-                           const SOCKTYPE *lsocks,
-                           const char *filename,
-                           ...)
+GNUNET_OS_start_process_s(int pipe_control,
+                          unsigned int std_inheritance,
+                          const SOCKTYPE *lsocks,
+                          const char *filename,
+                          ...)
 {
   va_list ap;
   char **argv;
@@ -1531,101 +1531,103 @@ GNUNET_OS_start_process_s (int pipe_control,
   size_t len;
 
   argv_size = 1;
-  va_start (ap, filename);
+  va_start(ap, filename);
   arg = filename;
   last = NULL;
   do
-  {
-    rpos = arg;
-    quote_on = 0;
-    while ('\0' != *rpos)
     {
-      if ('"' == *rpos)
-      {
-        if (1 == quote_on)
-          quote_on = 0;
-        else
-          quote_on = 1;
-      }
-      if ((' ' == *rpos) && (0 == quote_on))
-      {
-        if (NULL != last)
-          argv_size++;
-        last = NULL;
-        rpos++;
-        while (' ' == *rpos)
-          rpos++;
-      }
-      if ((NULL == last) && ('\0' != *rpos)) // FIXME: == or !=?
-        last = rpos;
-      if ('\0' != *rpos)
-        rpos++;
+      rpos = arg;
+      quote_on = 0;
+      while ('\0' != *rpos)
+        {
+          if ('"' == *rpos)
+            {
+              if (1 == quote_on)
+                quote_on = 0;
+              else
+                quote_on = 1;
+            }
+          if ((' ' == *rpos) && (0 == quote_on))
+            {
+              if (NULL != last)
+                argv_size++;
+              last = NULL;
+              rpos++;
+              while (' ' == *rpos)
+                rpos++;
+            }
+          if ((NULL == last) && ('\0' != *rpos)) // FIXME: == or !=?
+            last = rpos;
+          if ('\0' != *rpos)
+            rpos++;
+        }
+      if (NULL != last)
+        argv_size++;
     }
-    if (NULL != last)
-      argv_size++;
-  } while (NULL != (arg = (va_arg (ap, const char *))));
-  va_end (ap);
+  while (NULL != (arg = (va_arg(ap, const char *))));
+  va_end(ap);
 
-  argv = GNUNET_malloc (argv_size * sizeof (char *));
+  argv = GNUNET_malloc(argv_size * sizeof(char *));
   argv_size = 0;
-  va_start (ap, filename);
+  va_start(ap, filename);
   arg = filename;
   last = NULL;
   do
-  {
-    cp = GNUNET_strdup (arg);
-    quote_on = 0;
-    pos = cp;
-    while ('\0' != *pos)
     {
-      if ('"' == *pos)
-      {
-        if (1 == quote_on)
-          quote_on = 0;
-        else
-          quote_on = 1;
-      }
-      if ((' ' == *pos) && (0 == quote_on))
-      {
-        *pos = '\0';
-        if (NULL != last)
-          argv[argv_size++] = GNUNET_strdup (last);
-        last = NULL;
-        pos++;
-        while (' ' == *pos)
-          pos++;
-      }
-      if ((NULL == last) && ('\0' != *pos)) // FIXME: == or !=?
-        last = pos;
-      if ('\0' != *pos)
-        pos++;
-    }
-    if (NULL != last)
-      argv[argv_size++] = GNUNET_strdup (last);
-    last = NULL;
-    GNUNET_free (cp);
-  } while (NULL != (arg = (va_arg (ap, const char *))));
-  va_end (ap);
+      cp = GNUNET_strdup(arg);
+      quote_on = 0;
+      pos = cp;
+      while ('\0' != *pos)
+        {
+          if ('"' == *pos)
+            {
+              if (1 == quote_on)
+                quote_on = 0;
+              else
+                quote_on = 1;
+            }
+          if ((' ' == *pos) && (0 == quote_on))
+            {
+              *pos = '\0';
+              if (NULL != last)
+                argv[argv_size++] = GNUNET_strdup(last);
+              last = NULL;
+              pos++;
+              while (' ' == *pos)
+                pos++;
+            }
+          if ((NULL == last) && ('\0' != *pos)) // FIXME: == or !=?
+            last = pos;
+          if ('\0' != *pos)
+            pos++;
+        }
+      if (NULL != last)
+        argv[argv_size++] = GNUNET_strdup(last);
+      last = NULL;
+      GNUNET_free(cp);
+    }
+  while (NULL != (arg = (va_arg(ap, const char *))));
+  va_end(ap);
   argv[argv_size] = NULL;
 
   for (i = 0; i < argv_size; i++)
-  {
-    len = strlen (argv[i]);
-    if ((argv[i][0] == '"') && (argv[i][len - 1] == '"'))
     {
-      memmove (&argv[i][0], &argv[i][1], len - 2);
-      argv[i][len - 2] = '\0';
+      len = strlen(argv[i]);
+      if ((argv[i][0] == '"') && (argv[i][len - 1] == '"'))
+        {
+          memmove(&argv[i][0], &argv[i][1], len - 2);
+          argv[i][len - 2] = '\0';
+        }
     }
-  }
   binary_path = argv[0];
-  proc = GNUNET_OS_start_process_v (pipe_control,
-                                    std_inheritance,
-                                    lsocks,
-                                    binary_path,
-                                    argv);
+  proc = GNUNET_OS_start_process_v(pipe_control,
+                                   std_inheritance,
+                                   lsocks,
+                                   binary_path,
+                                   argv);
   while (argv_size > 0)
-    GNUNET_free (argv[--argv_size]);
-  GNUNET_free (argv);
+    GNUNET_free(argv[--argv_size]);
+  GNUNET_free(argv);
   return proc;
 }
 
@@ -1641,60 +1643,60 @@ GNUNET_OS_start_process_s (int pipe_control,
  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
  */
 static int
-process_status (struct GNUNET_OS_Process *proc,
-                enum GNUNET_OS_ProcessStatusType *type,
-                unsigned long *code,
-                int options)
+process_status(struct GNUNET_OS_Process *proc,
+               enum GNUNET_OS_ProcessStatusType *type,
+               unsigned long *code,
+               int options)
 {
 #ifndef MINGW
   int status;
   int ret;
 
-  GNUNET_assert (0 != proc);
-  ret = waitpid (proc->pid, &status, options);
+  GNUNET_assert(0 != proc);
+  ret = waitpid(proc->pid, &status, options);
   if (ret < 0)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "waitpid");
+      return GNUNET_SYSERR;
+    }
   if (0 == ret)
-  {
-    *type = GNUNET_OS_PROCESS_RUNNING;
-    *code = 0;
-    return GNUNET_NO;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_RUNNING;
+      *code = 0;
+      return GNUNET_NO;
+    }
   if (proc->pid != ret)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-    return GNUNET_SYSERR;
-  }
-  if (WIFEXITED (status))
-  {
-    *type = GNUNET_OS_PROCESS_EXITED;
-    *code = WEXITSTATUS (status);
-  }
-  else if (WIFSIGNALED (status))
-  {
-    *type = GNUNET_OS_PROCESS_SIGNALED;
-    *code = WTERMSIG (status);
-  }
-  else if (WIFSTOPPED (status))
-  {
-    *type = GNUNET_OS_PROCESS_SIGNALED;
-    *code = WSTOPSIG (status);
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "waitpid");
+      return GNUNET_SYSERR;
+    }
+  if (WIFEXITED(status))
+    {
+      *type = GNUNET_OS_PROCESS_EXITED;
+      *code = WEXITSTATUS(status);
+    }
+  else if (WIFSIGNALED(status))
+    {
+      *type = GNUNET_OS_PROCESS_SIGNALED;
+      *code = WTERMSIG(status);
+    }
+  else if (WIFSTOPPED(status))
+    {
+      *type = GNUNET_OS_PROCESS_SIGNALED;
+      *code = WSTOPSIG(status);
+    }
 #ifdef WIFCONTINUED
-  else if (WIFCONTINUED (status))
-  {
-    *type = GNUNET_OS_PROCESS_RUNNING;
-    *code = 0;
-  }
+  else if (WIFCONTINUED(status))
+    {
+      *type = GNUNET_OS_PROCESS_RUNNING;
+      *code = 0;
+    }
 #endif
   else
-  {
-    *type = GNUNET_OS_PROCESS_UNKNOWN;
-    *code = 0;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_UNKNOWN;
+      *code = 0;
+    }
 #else
 #ifndef WNOHANG
 #define WNOHANG 42 /* just a flag for W32, purely internal at this point */
@@ -1706,39 +1708,39 @@ process_status (struct GNUNET_OS_Process *proc,
   h = proc->handle;
   ret = proc->pid;
   if (h == NULL || ret == 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Invalid process information {%d, %08X}\n",
-         ret,
-         h);
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Invalid process information {%d, %08X}\n",
+          ret,
+          h);
+      return GNUNET_SYSERR;
+    }
   if (h == NULL)
-    h = GetCurrentProcess ();
+    h = GetCurrentProcess();
 
   if (WNOHANG != options)
-  {
-    if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
     {
-      SetErrnoFromWinError (GetLastError ());
-      return GNUNET_SYSERR;
+      if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
+        {
+          SetErrnoFromWinError(GetLastError());
+          return GNUNET_SYSERR;
+        }
     }
-  }
-  SetLastError (0);
-  ret = GetExitCodeProcess (h, &c);
-  error_code = GetLastError ();
+  SetLastError(0);
+  ret = GetExitCodeProcess(h, &c);
+  error_code = GetLastError();
   if (ret == 0 || error_code != NO_ERROR)
-  {
-    SetErrnoFromWinError (error_code);
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
-    return GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinError(error_code);
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
+      return GNUNET_SYSERR;
+    }
   if (STILL_ACTIVE == c)
-  {
-    *type = GNUNET_OS_PROCESS_RUNNING;
-    *code = 0;
-    return GNUNET_NO;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_RUNNING;
+      *code = 0;
+      return GNUNET_NO;
+    }
   *type = GNUNET_OS_PROCESS_EXITED;
   *code = c;
 #endif
@@ -1757,11 +1759,11 @@ process_status (struct GNUNET_OS_Process *proc,
  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
-                          enum GNUNET_OS_ProcessStatusType *type,
-                          unsigned long *code)
+GNUNET_OS_process_status(struct GNUNET_OS_Process *proc,
+                         enum GNUNET_OS_ProcessStatusType *type,
+                         unsigned long *code)
 {
-  return process_status (proc, type, code, WNOHANG);
+  return process_status(proc, type, code, WNOHANG);
 }
 
 
@@ -1775,11 +1777,11 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc,
-                               enum GNUNET_OS_ProcessStatusType *type,
-                               unsigned long *code)
+GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc,
+                              enum GNUNET_OS_ProcessStatusType *type,
+                              unsigned long *code)
 {
-  return process_status (proc, type, code, 0);
+  return process_status(proc, type, code, 0);
 }
 
 
@@ -1794,40 +1796,40 @@ GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
+GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
 {
 #ifndef MINGW
   pid_t pid = proc->pid;
   pid_t ret;
 
-  while ((pid != (ret = waitpid (pid, NULL, 0))) && (EINTR == errno))
+  while ((pid != (ret = waitpid(pid, NULL, 0))) && (EINTR == errno))
     ;
   if (pid != ret)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "waitpid");
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 #else
   HANDLE h;
 
   h = proc->handle;
   if (NULL == h)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Invalid process information {%d, %08X}\n",
-         proc->pid,
-         h);
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "Invalid process information {%d, %08X}\n",
+          proc->pid,
+          h);
+      return GNUNET_SYSERR;
+    }
   if (NULL == h)
-    h = GetCurrentProcess ();
+    h = GetCurrentProcess();
 
-  if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
+  if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
+    {
+      SetErrnoFromWinError(GetLastError());
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 #endif
 }
@@ -1836,9 +1838,7 @@ GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
 /**
  * Handle to a command.
  */
-struct GNUNET_OS_CommandHandle
-{
-
+struct GNUNET_OS_CommandHandle {
   /**
    * Process handle.
    */
@@ -1894,18 +1894,18 @@ struct GNUNET_OS_CommandHandle
  * @param cmd handle to the process
  */
 void
-GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
+GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd)
 {
   if (NULL != cmd->proc)
-  {
-    GNUNET_assert (NULL != cmd->rtask);
-    GNUNET_SCHEDULER_cancel (cmd->rtask);
-  }
-  (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
-  GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip));
-  GNUNET_OS_process_destroy (cmd->eip);
-  GNUNET_DISK_pipe_close (cmd->opipe);
-  GNUNET_free (cmd);
+    {
+      GNUNET_assert(NULL != cmd->rtask);
+      GNUNET_SCHEDULER_cancel(cmd->rtask);
+    }
+  (void)GNUNET_OS_process_kill(cmd->eip, SIGKILL);
+  GNUNET_break(GNUNET_OK == GNUNET_OS_process_wait(cmd->eip));
+  GNUNET_OS_process_destroy(cmd->eip);
+  GNUNET_DISK_pipe_close(cmd->opipe);
+  GNUNET_free(cmd);
 }
 
 
@@ -1915,7 +1915,7 @@ GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
  * @param cls the `struct GNUNET_OS_CommandHandle *`
  */
 static void
-cmd_read (void *cls)
+cmd_read(void *cls)
 {
   struct GNUNET_OS_CommandHandle *cmd = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
@@ -1924,46 +1924,46 @@ cmd_read (void *cls)
   ssize_t ret;
 
   cmd->rtask = NULL;
-  tc = GNUNET_SCHEDULER_get_task_context ();
-  if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
-  {
-    /* timeout */
-    proc = cmd->proc;
-    cmd->proc = NULL;
-    proc (cmd->proc_cls, NULL);
-    return;
-  }
-  ret = GNUNET_DISK_file_read (cmd->r,
-                               &cmd->buf[cmd->off],
-                               sizeof (cmd->buf) - cmd->off);
+  tc = GNUNET_SCHEDULER_get_task_context();
+  if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset(tc->read_ready, cmd->r))
+    {
+      /* timeout */
+      proc = cmd->proc;
+      cmd->proc = NULL;
+      proc(cmd->proc_cls, NULL);
+      return;
+    }
+  ret = GNUNET_DISK_file_read(cmd->r,
+                              &cmd->buf[cmd->off],
+                              sizeof(cmd->buf) - cmd->off);
   if (ret <= 0)
-  {
-    if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
     {
-      cmd->buf[cmd->off] = '\0';
-      cmd->proc (cmd->proc_cls, cmd->buf);
+      if ((cmd->off > 0) && (cmd->off < sizeof(cmd->buf)))
+        {
+          cmd->buf[cmd->off] = '\0';
+          cmd->proc(cmd->proc_cls, cmd->buf);
+        }
+      proc = cmd->proc;
+      cmd->proc = NULL;
+      proc(cmd->proc_cls, NULL);
+      return;
     }
-    proc = cmd->proc;
-    cmd->proc = NULL;
-    proc (cmd->proc_cls, NULL);
-    return;
-  }
-  end = memchr (&cmd->buf[cmd->off], '\n', ret);
+  end = memchr(&cmd->buf[cmd->off], '\n', ret);
   cmd->off += ret;
   while (NULL != end)
-  {
-    *end = '\0';
-    cmd->proc (cmd->proc_cls, cmd->buf);
-    memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
-    cmd->off -= (end + 1 - cmd->buf);
-    end = memchr (cmd->buf, '\n', cmd->off);
-  }
+    {
+      *end = '\0';
+      cmd->proc(cmd->proc_cls, cmd->buf);
+      memmove(cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
+      cmd->off -= (end + 1 - cmd->buf);
+      end = memchr(cmd->buf, '\n', cmd->off);
+    }
   cmd->rtask =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining (
-                                      cmd->timeout),
-                                    cmd->r,
-                                    &cmd_read,
-                                    cmd);
+    GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_absolute_get_remaining(
+                                     cmd->timeout),
+                                   cmd->r,
+                                   &cmd_read,
+                                   cmd);
 }
 
 
@@ -1979,39 +1979,39 @@ cmd_read (void *cls)
  * @return NULL on error
  */
 struct GNUNET_OS_CommandHandle *
-GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc,
-                       void *proc_cls,
-                       struct GNUNET_TIME_Relative timeout,
-                       const char *binary,
-                       ...)
+GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc,
+                      void *proc_cls,
+                      struct GNUNET_TIME_Relative timeout,
+                      const char *binary,
+                      ...)
 {
   struct GNUNET_OS_CommandHandle *cmd;
   struct GNUNET_OS_Process *eip;
   struct GNUNET_DISK_PipeHandle *opipe;
   va_list ap;
 
-  opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  opipe = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if (NULL == opipe)
     return NULL;
-  va_start (ap, binary);
+  va_start(ap, binary);
   /* redirect stdout, don't inherit stderr/stdin */
   eip =
-    GNUNET_OS_start_process_va (GNUNET_NO, 0, NULL, opipe, NULL, binary, ap);
-  va_end (ap);
+    GNUNET_OS_start_process_va(GNUNET_NO, 0, NULL, opipe, NULL, binary, ap);
+  va_end(ap);
   if (NULL == eip)
-  {
-    GNUNET_DISK_pipe_close (opipe);
-    return NULL;
-  }
-  GNUNET_DISK_pipe_close_end (opipe, GNUNET_DISK_PIPE_END_WRITE);
-  cmd = GNUNET_new (struct GNUNET_OS_CommandHandle);
-  cmd->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+    {
+      GNUNET_DISK_pipe_close(opipe);
+      return NULL;
+    }
+  GNUNET_DISK_pipe_close_end(opipe, GNUNET_DISK_PIPE_END_WRITE);
+  cmd = GNUNET_new(struct GNUNET_OS_CommandHandle);
+  cmd->timeout = GNUNET_TIME_relative_to_absolute(timeout);
   cmd->eip = eip;
   cmd->opipe = opipe;
   cmd->proc = proc;
   cmd->proc_cls = proc_cls;
-  cmd->r = GNUNET_DISK_pipe_handle (opipe, GNUNET_DISK_PIPE_END_READ);
-  cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
+  cmd->r = GNUNET_DISK_pipe_handle(opipe, GNUNET_DISK_PIPE_END_READ);
+  cmd->rtask = GNUNET_SCHEDULER_add_read_file(timeout, cmd->r, &cmd_read, cmd);
   return cmd;
 }
 
diff --git a/src/util/peer.c b/src/util/peer.c
index 00a259a3b..09347cbfd 100644
--- a/src/util/peer.c
+++ b/src/util/peer.c
@@ -11,7 +11,7 @@
       WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       Affero General Public License for more details.
-     
+
       You should have received a copy of the GNU Affero General Public License
       along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -26,11 +26,10 @@
 #include "platform.h"
 #include "gnunet_peer_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-peer", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-peer", __VA_ARGS__)
 
 
-struct PeerEntry
-{
+struct PeerEntry {
   /**
    * The identifier itself
    */
@@ -80,7 +79,7 @@ static unsigned int free_list_start;
  * @return the interned identity or 0.
  */
 GNUNET_PEER_Id
-GNUNET_PEER_search (const struct GNUNET_PeerIdentity *pid)
+GNUNET_PEER_search(const struct GNUNET_PeerIdentity *pid)
 {
   struct PeerEntry *e;
 
@@ -88,10 +87,10 @@ GNUNET_PEER_search (const struct GNUNET_PeerIdentity *pid)
     return 0;
   if (NULL == map)
     return 0;
-  e = GNUNET_CONTAINER_multipeermap_get (map, pid);
+  e = GNUNET_CONTAINER_multipeermap_get(map, pid);
   if (NULL == e)
     return 0;
-  GNUNET_assert (e->rc > 0);
+  GNUNET_assert(e->rc > 0);
   return e->pid;
 }
 
@@ -104,7 +103,7 @@ GNUNET_PEER_search (const struct GNUNET_PeerIdentity *pid)
  * @return the interned identity.
  */
 GNUNET_PEER_Id
-GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
+GNUNET_PEER_intern(const struct GNUNET_PeerIdentity *pid)
 {
   GNUNET_PEER_Id ret;
   struct PeerEntry *e;
@@ -113,42 +112,42 @@ GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
   if (NULL == pid)
     return 0;
   if (NULL == map)
-    map = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
-  e = GNUNET_CONTAINER_multipeermap_get (map, pid);
+    map = GNUNET_CONTAINER_multipeermap_create(32, GNUNET_YES);
+  e = GNUNET_CONTAINER_multipeermap_get(map, pid);
   if (NULL != e)
-  {
-    GNUNET_assert (e->rc > 0);
-    e->rc++;
-    return e->pid;
-  }
+    {
+      GNUNET_assert(e->rc > 0);
+      e->rc++;
+      return e->pid;
+    }
   ret = free_list_start;
   if (ret == size)
-  {
-    GNUNET_array_grow (table, size, size + 16);
-    for (i = ret; i < size; i++)
     {
-      table[i] = GNUNET_new (struct PeerEntry);
-      table[i]->pid = i + 1;
+      GNUNET_array_grow(table, size, size + 16);
+      for (i = ret; i < size; i++)
+        {
+          table[i] = GNUNET_new(struct PeerEntry);
+          table[i]->pid = i + 1;
+        }
     }
-  }
   if (0 == ret)
-  {
-    memset (&table[0]->id, 0, sizeof (struct GNUNET_PeerIdentity));
-    table[0]->pid = 0;
-    table[0]->rc = 1;
-    ret = 1;
-  }
-  GNUNET_assert (ret < size);
-  GNUNET_assert (0 == table[ret]->rc);
+    {
+      memset(&table[0]->id, 0, sizeof(struct GNUNET_PeerIdentity));
+      table[0]->pid = 0;
+      table[0]->rc = 1;
+      ret = 1;
+    }
+  GNUNET_assert(ret < size);
+  GNUNET_assert(0 == table[ret]->rc);
   free_list_start = table[ret]->pid;
   table[ret]->id = *pid;
   table[ret]->rc = 1;
   table[ret]->pid = ret;
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_put (map,
-                                                   &table[ret]->id,
-                                                   table[ret],
-                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_CONTAINER_multipeermap_put(map,
+                                                 &table[ret]->id,
+                                                 table[ret],
+                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return ret;
 }
 
@@ -160,7 +159,7 @@ GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
  * @param count size of the ids array
  */
 void
-GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id *ids, unsigned int count)
+GNUNET_PEER_decrement_rcs(const GNUNET_PEER_Id *ids, unsigned int count)
 {
   int i;
   GNUNET_PEER_Id id;
@@ -168,23 +167,23 @@ GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id *ids, unsigned int count)
   if (0 == count)
     return;
   for (i = count - 1; i >= 0; i--)
-  {
-    id = ids[i];
-    if (0 == id)
-      continue;
-    GNUNET_assert (id < size);
-    GNUNET_assert (table[id]->rc > 0);
-    table[id]->rc--;
-    if (0 == table[id]->rc)
     {
-      GNUNET_break (GNUNET_OK ==
-                    GNUNET_CONTAINER_multipeermap_remove (map,
-                                                          &table[id]->id,
-                                                          table[id]));
-      table[id]->pid = free_list_start;
-      free_list_start = id;
+      id = ids[i];
+      if (0 == id)
+        continue;
+      GNUNET_assert(id < size);
+      GNUNET_assert(table[id]->rc > 0);
+      table[id]->rc--;
+      if (0 == table[id]->rc)
+        {
+          GNUNET_break(GNUNET_OK ==
+                       GNUNET_CONTAINER_multipeermap_remove(map,
+                                                            &table[id]->id,
+                                                            table[id]));
+          table[id]->pid = free_list_start;
+          free_list_start = id;
+        }
     }
-  }
 }
 
 
@@ -195,24 +194,24 @@ GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id *ids, unsigned int count)
  * @param delta how much to change the RC
  */
 void
-GNUNET_PEER_change_rc (GNUNET_PEER_Id id, int delta)
+GNUNET_PEER_change_rc(GNUNET_PEER_Id id, int delta)
 {
   if (0 == id)
     return;
-  GNUNET_assert (id < size);
-  GNUNET_assert (table[id]->rc > 0);
-  GNUNET_assert ( (delta >= 0) ||
-                  (table[id]->rc >= (unsigned int) (-delta)) );
+  GNUNET_assert(id < size);
+  GNUNET_assert(table[id]->rc > 0);
+  GNUNET_assert((delta >= 0) ||
+                (table[id]->rc >= (unsigned int)(-delta)));
   table[id]->rc += delta;
   if (0 == table[id]->rc)
-  {
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONTAINER_multipeermap_remove (map,
+    {
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_remove(map,
                                                         &table[id]->id,
                                                         table[id]));
-    table[id]->pid = free_list_start;
-    free_list_start = id;
-  }
+      table[id]->pid = free_list_start;
+      free_list_start = id;
+    }
 }
 
 
@@ -223,15 +222,15 @@ GNUNET_PEER_change_rc (GNUNET_PEER_Id id, int delta)
  * @param pid where to write the normal peer identity
  */
 void
-GNUNET_PEER_resolve (GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
+GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
 {
   if (0 == id)
-  {
-    memset (pid, 0, sizeof (struct GNUNET_PeerIdentity));
-    return;
-  }
-  GNUNET_assert (id < size);
-  GNUNET_assert (table[id]->rc > 0);
+    {
+      memset(pid, 0, sizeof(struct GNUNET_PeerIdentity));
+      return;
+    }
+  GNUNET_assert(id < size);
+  GNUNET_assert(table[id]->rc > 0);
   *pid = table[id]->id;
 }
 
@@ -243,10 +242,10 @@ GNUNET_PEER_resolve (GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
  * @return pointer to peer identity, valid as long 'id' is valid
  */
 const struct GNUNET_PeerIdentity *
-GNUNET_PEER_resolve2 (GNUNET_PEER_Id id)
+GNUNET_PEER_resolve2(GNUNET_PEER_Id id)
 {
-  GNUNET_assert (id < size);
-  GNUNET_assert (table[id]->rc > 0);
+  GNUNET_assert(id < size);
+  GNUNET_assert(table[id]->rc > 0);
   return &table[id]->id;
 }
 
diff --git a/src/util/perf_crypto_asymmetric.c b/src/util/perf_crypto_asymmetric.c
index f42706bda..91679afa5 100644
--- a/src/util/perf_crypto_asymmetric.c
+++ b/src/util/perf_crypto_asymmetric.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
-*/
+ */
 
 /**
  * @author Bart Polot
@@ -31,8 +31,7 @@ static struct GNUNET_TIME_Absolute start;
 
 #define l 500
 
-struct TestSig
-{
+struct TestSig {
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_HashCode h;
   struct GNUNET_CRYPTO_EddsaSignature sig;
@@ -40,26 +39,26 @@ struct TestSig
 
 
 static void
-log_duration (const char *cryptosystem,
-              const char *description)
+log_duration(const char *cryptosystem,
+             const char *description)
 {
   struct GNUNET_TIME_Relative t;
   char s[64];
 
-  sprintf (s, "%6s %15s", cryptosystem, description);
-  t = GNUNET_TIME_absolute_get_duration (start);
-  t = GNUNET_TIME_relative_divide (t, l);
-  fprintf (stdout,
-           "%s: %10s\n",
-           s,
-           GNUNET_STRINGS_relative_time_to_string (t,
-                                                   GNUNET_NO));
-  GAUGER ("UTIL", s, t.rel_value_us, "us");
+  sprintf(s, "%6s %15s", cryptosystem, description);
+  t = GNUNET_TIME_absolute_get_duration(start);
+  t = GNUNET_TIME_relative_divide(t, l);
+  fprintf(stdout,
+          "%s: %10s\n",
+          s,
+          GNUNET_STRINGS_relative_time_to_string(t,
+                                                 GNUNET_NO));
+  GAUGER("UTIL", s, t.rel_value_us, "us");
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int i;
   struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe[l];
@@ -70,60 +69,60 @@ main (int argc, char *argv[])
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
-  {
-    sig[i].purp.purpose = 0;
-    sig[i].purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose)
-                              + sizeof (struct GNUNET_HashCode));
-    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                &sig[i].h,
-                                sizeof (sig[i].h));
-  }
-  log_duration ("", "Init");
+    {
+      sig[i].purp.purpose = 0;
+      sig[i].purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+                               + sizeof(struct GNUNET_HashCode));
+      GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                                 &sig[i].h,
+                                 sizeof(sig[i].h));
+    }
+  log_duration("", "Init");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
     eddsa[i] = GNUNET_CRYPTO_eddsa_key_create();
-  log_duration ("EdDSA", "create key");
+  log_duration("EdDSA", "create key");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
-    GNUNET_CRYPTO_eddsa_key_get_public (eddsa[i], &dspub[i]);
-  log_duration ("EdDSA", "get public");
+    GNUNET_CRYPTO_eddsa_key_get_public(eddsa[i], &dspub[i]);
+  log_duration("EdDSA", "get public");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_eddsa_sign (eddsa[i],
-                                             &sig[i].purp,
-                                             &sig[i].sig));
-  log_duration ("EdDSA", "sign HashCode");
+    GNUNET_assert(GNUNET_OK ==
+                  GNUNET_CRYPTO_eddsa_sign(eddsa[i],
+                                           &sig[i].purp,
+                                           &sig[i].sig));
+  log_duration("EdDSA", "sign HashCode");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_eddsa_verify (0,
-                                               &sig[i].purp,
-                                               &sig[i].sig,
-                                               &dspub[i]));
-  log_duration ("EdDSA", "verify HashCode");
+    GNUNET_assert(GNUNET_OK ==
+                  GNUNET_CRYPTO_eddsa_verify(0,
+                                             &sig[i].purp,
+                                             &sig[i].sig,
+                                             &dspub[i]));
+  log_duration("EdDSA", "verify HashCode");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
     ecdhe[i] = GNUNET_CRYPTO_ecdhe_key_create();
-  log_duration ("ECDH", "create key");
+  log_duration("ECDH", "create key");
 
   start = GNUNET_TIME_absolute_get();
   for (i = 0; i < l; i++)
-    GNUNET_CRYPTO_ecdhe_key_get_public (ecdhe[i], &dhpub[i]);
-  log_duration ("ECDH", "get public");
+    GNUNET_CRYPTO_ecdhe_key_get_public(ecdhe[i], &dhpub[i]);
+  log_duration("ECDH", "get public");
 
   start = GNUNET_TIME_absolute_get();
-  for (i = 0; i < l - 1; i+=2)
-  {
-    GNUNET_CRYPTO_ecc_ecdh (ecdhe[i], &dhpub[i+1], &sig[i].h);
-    GNUNET_CRYPTO_ecc_ecdh (ecdhe[i+1], &dhpub[i], &sig[i+1].h);
-  }
-  log_duration ("ECDH", "do DH");
+  for (i = 0; i < l - 1; i += 2)
+    {
+      GNUNET_CRYPTO_ecc_ecdh(ecdhe[i], &dhpub[i + 1], &sig[i].h);
+      GNUNET_CRYPTO_ecc_ecdh(ecdhe[i + 1], &dhpub[i], &sig[i + 1].h);
+    }
+  log_duration("ECDH", "do DH");
 
   return 0;
 }
diff --git a/src/util/perf_crypto_ecc_dlog.c b/src/util/perf_crypto_ecc_dlog.c
index 2729241e2..b09a6ed6f 100644
--- a/src/util/perf_crypto_ecc_dlog.c
+++ b/src/util/perf_crypto_ecc_dlog.c
@@ -11,13 +11,13 @@
      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 util/perf_crypto_ecc_dlog.c
  * @brief benchmark for ECC DLOG calculation
@@ -49,12 +49,12 @@
 
 /**
  * How many values do we test?
- */  
+ */
 #define TEST_ITER 10
 
 /**
  * Range of values to use for MATH tests.
- */  
+ */
 #define MATH_MAX 500000
 
 
@@ -65,8 +65,8 @@
  * @param do_dlog #GNUNET_YES if we want to actually do the bencharked operation
  */
 static void
-test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc, 
-           int do_dlog)
+test_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc,
+          int do_dlog)
 {
   gcry_mpi_t fact;
   gcry_mpi_t n;
@@ -77,96 +77,96 @@ test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
   int x;
   int iret;
 
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, NULL, CURVE));
-  g = gcry_mpi_ec_get_point ("g", ctx, 0);
-  GNUNET_assert (NULL != g);
-  n = gcry_mpi_ec_get_mpi ("n", ctx, 0);
-  q = gcry_mpi_point_new (0);
-  fact = gcry_mpi_new (0);
-  for (i=0;i<TEST_ITER;i++)
-  {
-    fprintf (stderr, ".");
-    x = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                  MAX_FACT);
-    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                       2))
-    {
-      gcry_mpi_set_ui (fact, x);
-      gcry_mpi_sub (fact, n, fact);
-      x = - x;
-    }
-    else 
-    {
-      gcry_mpi_set_ui (fact, x);
-    }
-    gcry_mpi_ec_mul (q, fact, g, ctx);
-    if ( (GNUNET_YES == do_dlog) &&
-         (x !=
-          (iret = GNUNET_CRYPTO_ecc_dlog (edc,
-                                          q))) )
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, NULL, CURVE));
+  g = gcry_mpi_ec_get_point("g", ctx, 0);
+  GNUNET_assert(NULL != g);
+  n = gcry_mpi_ec_get_mpi("n", ctx, 0);
+  q = gcry_mpi_point_new(0);
+  fact = gcry_mpi_new(0);
+  for (i = 0; i < TEST_ITER; i++)
     {
-      fprintf (stderr, 
-               "DLOG failed for value %d (%d)\n", 
-               x,
-               iret);
-      GNUNET_assert (0);
+      fprintf(stderr, ".");
+      x = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                                   MAX_FACT);
+      if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                                        2))
+        {
+          gcry_mpi_set_ui(fact, x);
+          gcry_mpi_sub(fact, n, fact);
+          x = -x;
+        }
+      else
+        {
+          gcry_mpi_set_ui(fact, x);
+        }
+      gcry_mpi_ec_mul(q, fact, g, ctx);
+      if ((GNUNET_YES == do_dlog) &&
+          (x !=
+           (iret = GNUNET_CRYPTO_ecc_dlog(edc,
+                                          q))))
+        {
+          fprintf(stderr,
+                  "DLOG failed for value %d (%d)\n",
+                  x,
+                  iret);
+          GNUNET_assert(0);
+        }
     }
-  }
-  gcry_mpi_release (fact);
-  gcry_mpi_release (n);
-  gcry_mpi_point_release (g);
-  gcry_mpi_point_release (q);
-  gcry_ctx_release (ctx);
-  fprintf (stderr, "\n");
+  gcry_mpi_release(fact);
+  gcry_mpi_release(n);
+  gcry_mpi_point_release(g);
+  gcry_mpi_point_release(q);
+  gcry_ctx_release(ctx);
+  fprintf(stderr, "\n");
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_CRYPTO_EccDlogContext *edc;
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_TIME_Relative delta;
 
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _
-             ("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  GNUNET_log_setup ("perf-crypto-ecc-dlog", 
-                    "WARNING", 
-                    NULL);
-  start = GNUNET_TIME_absolute_get ();
-  edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_FACT,
-                                        MAX_MEM);
-  printf ("DLOG precomputation 1M/1K took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "ECC DLOG initialization",
-          GNUNET_TIME_absolute_get_duration
-          (start).rel_value_us / 1000LL, "ms/op");
-  start = GNUNET_TIME_absolute_get ();
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _
+                ("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("perf-crypto-ecc-dlog",
+                   "WARNING",
+                   NULL);
+  start = GNUNET_TIME_absolute_get();
+  edc = GNUNET_CRYPTO_ecc_dlog_prepare(MAX_FACT,
+                                       MAX_MEM);
+  printf("DLOG precomputation 1M/1K took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "ECC DLOG initialization",
+         GNUNET_TIME_absolute_get_duration
+           (start).rel_value_us / 1000LL, "ms/op");
+  start = GNUNET_TIME_absolute_get();
   /* first do a baseline run without the DLOG */
-  test_dlog (edc, GNUNET_NO);
-  delta = GNUNET_TIME_absolute_get_duration (start);
-  start = GNUNET_TIME_absolute_get ();
-  test_dlog (edc, GNUNET_YES);
-  delta = GNUNET_TIME_relative_subtract (GNUNET_TIME_absolute_get_duration (start),
-                                         delta);
-  printf ("%u DLOG calculations took %s\n",
-          TEST_ITER,
-          GNUNET_STRINGS_relative_time_to_string (delta,
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "ECC DLOG operations",
-          delta.rel_value_us / 1000LL / TEST_ITER, 
-          "ms/op");
-
-  GNUNET_CRYPTO_ecc_dlog_release (edc);
+  test_dlog(edc, GNUNET_NO);
+  delta = GNUNET_TIME_absolute_get_duration(start);
+  start = GNUNET_TIME_absolute_get();
+  test_dlog(edc, GNUNET_YES);
+  delta = GNUNET_TIME_relative_subtract(GNUNET_TIME_absolute_get_duration(start),
+                                        delta);
+  printf("%u DLOG calculations took %s\n",
+         TEST_ITER,
+         GNUNET_STRINGS_relative_time_to_string(delta,
+                                                GNUNET_YES));
+  GAUGER("UTIL", "ECC DLOG operations",
+         delta.rel_value_us / 1000LL / TEST_ITER,
+         "ms/op");
+
+  GNUNET_CRYPTO_ecc_dlog_release(edc);
   return 0;
 }
 
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c
index c74f425ce..cdcff2824 100644
--- a/src/util/perf_crypto_hash.c
+++ b/src/util/perf_crypto_hash.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -30,80 +30,80 @@
 
 
 static void
-perfHash ()
+perfHash()
 {
   struct GNUNET_HashCode hc;
   unsigned int i;
   char buf[64 * 1024];
 
-  memset (buf, 1, sizeof (buf));
+  memset(buf, 1, sizeof(buf));
   for (i = 0; i < 1024; i++)
-    GNUNET_CRYPTO_hash (buf, sizeof (buf), &hc);
+    GNUNET_CRYPTO_hash(buf, sizeof(buf), &hc);
 }
 
 
 static void
-perfHashSmall ()
+perfHashSmall()
 {
   struct GNUNET_HashCode hc;
   unsigned int i;
   char buf[64];
 
-  memset (buf, 1, sizeof (buf));
+  memset(buf, 1, sizeof(buf));
   for (i = 0; i < 1024; i++)
-    GNUNET_CRYPTO_hash (buf, sizeof (buf), &hc);
+    GNUNET_CRYPTO_hash(buf, sizeof(buf), &hc);
 }
 
 
 static void
-perfHKDF ()
+perfHKDF()
 {
   unsigned int i;
   char res[128];
   char buf[128];
   char skm[64];
 
-  memset (buf, 1, sizeof (buf));
-  memset (skm, 2, sizeof (skm));
+  memset(buf, 1, sizeof(buf));
+  memset(skm, 2, sizeof(skm));
   for (i = 0; i < 1024; i++)
-    GNUNET_CRYPTO_hkdf (res, sizeof (res),
-                        GCRY_MD_SHA512, GCRY_MD_SHA256,
-                        buf, sizeof (buf),
-                        skm, sizeof (skm),
-                        "test", (size_t) 4,
-                        NULL, 0);
+    GNUNET_CRYPTO_hkdf(res, sizeof(res),
+                       GCRY_MD_SHA512, GCRY_MD_SHA256,
+                       buf, sizeof(buf),
+                       skm, sizeof(skm),
+                       "test", (size_t)4,
+                       NULL, 0);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
 
-  start = GNUNET_TIME_absolute_get ();
-  perfHashSmall ();
-  printf ("1024x 64-byte Hash perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-
-  start = GNUNET_TIME_absolute_get ();
-  perfHash ();
-  printf ("1024x 64k Hash perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Cryptographic hashing",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "kb/ms");
-  start = GNUNET_TIME_absolute_get ();
-  perfHKDF ();
-  printf ("HKDF perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Cryptographic HKDF",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "kb/ms");
+  start = GNUNET_TIME_absolute_get();
+  perfHashSmall();
+  printf("1024x 64-byte Hash perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+
+  start = GNUNET_TIME_absolute_get();
+  perfHash();
+  printf("1024x 64k Hash perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Cryptographic hashing",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "kb/ms");
+  start = GNUNET_TIME_absolute_get();
+  perfHKDF();
+  printf("HKDF perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Cryptographic HKDF",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "kb/ms");
   return 0;
 }
 
diff --git a/src/util/perf_crypto_paillier.c b/src/util/perf_crypto_paillier.c
index a62b72c96..f2aa132d5 100644
--- a/src/util/perf_crypto_paillier.c
+++ b/src/util/perf_crypto_paillier.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -29,7 +29,7 @@
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_CRYPTO_PaillierPublicKey public_key;
@@ -38,51 +38,51 @@ main (int argc, char *argv[])
   gcry_mpi_t m1;
   unsigned int i;
 
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-    GNUNET_CRYPTO_paillier_create (&public_key,
-                                   &private_key);
-  printf ("10x key generation took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Paillier key generation",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "keys/ms");
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    GNUNET_CRYPTO_paillier_create(&public_key,
+                                  &private_key);
+  printf("10x key generation took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Paillier key generation",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "keys/ms");
 
-  m1 = gcry_mpi_new (0);
-  m1 = gcry_mpi_set_ui (m1, 1);
+  m1 = gcry_mpi_new(0);
+  m1 = gcry_mpi_set_ui(m1, 1);
   /* m1 = m1 * 2 ^ (GCPB - 3) */
-  gcry_mpi_mul_2exp (m1,
-                     m1,
-                     GNUNET_CRYPTO_PAILLIER_BITS - 3);
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-    GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                    m1,
-                                    2,
-                                    &c1);
-  printf ("10x encryption took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Paillier encryption",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
+  gcry_mpi_mul_2exp(m1,
+                    m1,
+                    GNUNET_CRYPTO_PAILLIER_BITS - 3);
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                   m1,
+                                   2,
+                                   &c1);
+  printf("10x encryption took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Paillier encryption",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
 
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-    GNUNET_CRYPTO_paillier_decrypt (&private_key,
-                                    &public_key,
-                                    &c1,
-                                    m1);
-  printf ("10x decryption took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Paillier decryption",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    GNUNET_CRYPTO_paillier_decrypt(&private_key,
+                                   &public_key,
+                                   &c1,
+                                   m1);
+  printf("10x decryption took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Paillier decryption",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
 
 
   return 0;
diff --git a/src/util/perf_crypto_rsa.c b/src/util/perf_crypto_rsa.c
index 1140738f6..33740666e 100644
--- a/src/util/perf_crypto_rsa.c
+++ b/src/util/perf_crypto_rsa.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -34,7 +34,7 @@
  * @param len keylength to evaluate with
  */
 static void
-eval (unsigned int len)
+eval(unsigned int len)
 {
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_CRYPTO_RsaSignature *sig;
@@ -48,153 +48,153 @@ eval (unsigned int len)
   size_t bbuf_len;
   struct GNUNET_HashCode hc;
 
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
-    GNUNET_CRYPTO_rsa_private_key_free (private_key);
-  }
-  printf ("10x %u-key generation took %s\n",
-          len,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "RSA %u-key generation",
-                   len);
-  GAUGER ("UTIL", sbuf,
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "keys/ms");
-  private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
-  public_key = GNUNET_CRYPTO_rsa_private_key_get_public (private_key);
-  for (i=0;i<10;i++)
-    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                &bsec[i], sizeof (bsec[0]));
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      private_key = GNUNET_CRYPTO_rsa_private_key_create(len);
+      GNUNET_CRYPTO_rsa_private_key_free(private_key);
+    }
+  printf("10x %u-key generation took %s\n",
+         len,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GNUNET_snprintf(sbuf,
+                  sizeof(sbuf),
+                  "RSA %u-key generation",
+                  len);
+  GAUGER("UTIL", sbuf,
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "keys/ms");
+  private_key = GNUNET_CRYPTO_rsa_private_key_create(len);
+  public_key = GNUNET_CRYPTO_rsa_private_key_get_public(private_key);
+  for (i = 0; i < 10; i++)
+    GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                               &bsec[i], sizeof(bsec[0]));
   /*
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-    rsa_blinding_key_derive(public_key, &bsec[i]);
-  printf ("10x %u-blinding key generation took %s\n",
+     start = GNUNET_TIME_absolute_get ();
+     for (i=0;i<10;i++)
+     rsa_blinding_key_derive(public_key, &bsec[i]);
+     printf ("10x %u-blinding key generation took %s\n",
           len,
           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
                                                   GNUNET_YES));
-  GNUNET_snprintf (sbuf,
+     GNUNET_snprintf (sbuf,
                    sizeof (sbuf),
                    "RSA %u-blinding key generation",
                    len);
-  GAUGER ("UTIL", sbuf,
+     GAUGER ("UTIL", sbuf,
           64 * 1024 / (1 +
                        GNUNET_TIME_absolute_get_duration
                        (start).rel_value_us / 1000LL), "keys/ms");
-  */
-  start = GNUNET_TIME_absolute_get ();
-  GNUNET_CRYPTO_hash ("test", 4, &hc);
-  for (i=0;i<10;i++)
-  {
-    GNUNET_CRYPTO_rsa_blind (&hc,
-                             &bsec[i],
-                             public_key,
-                             &bbuf, &bbuf_len);
-    GNUNET_free (bbuf);
-  }
-  printf ("10x %u-blinding took %s\n",
-          len,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "RSA %u-blinding",
-                   len);
-  GAUGER ("UTIL",
-          sbuf,
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
-  GNUNET_CRYPTO_rsa_blind (&hc,
-                           &bsec[0],
-                           public_key,
-                           &bbuf, &bbuf_len);
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
-                                          bbuf, bbuf_len);
-    GNUNET_CRYPTO_rsa_signature_free (sig);
-  }
-  printf ("10x %u-signing took %s\n",
-          len,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "RSA %u-signing",
-                   len);
-  GAUGER ("UTIL",
-          sbuf,
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
-  sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
-                                        bbuf,
-                                        bbuf_len);
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    rsig = GNUNET_CRYPTO_rsa_unblind (sig,
-                                      &bsec[0],
-                                      public_key);
-    GNUNET_CRYPTO_rsa_signature_free (rsig);
-  }
-  printf ("10x %u-unblinding took %s\n",
-          len,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "RSA %u-unblinding",
-                   len);
-  GAUGER ("UTIL",
-          sbuf,
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
-  rsig = GNUNET_CRYPTO_rsa_unblind (sig,
-                                    &bsec[0],
-                                    public_key);
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_rsa_verify (&hc,
+   */
+  start = GNUNET_TIME_absolute_get();
+  GNUNET_CRYPTO_hash("test", 4, &hc);
+  for (i = 0; i < 10; i++)
+    {
+      GNUNET_CRYPTO_rsa_blind(&hc,
+                              &bsec[i],
+                              public_key,
+                              &bbuf, &bbuf_len);
+      GNUNET_free(bbuf);
+    }
+  printf("10x %u-blinding took %s\n",
+         len,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GNUNET_snprintf(sbuf,
+                  sizeof(sbuf),
+                  "RSA %u-blinding",
+                  len);
+  GAUGER("UTIL",
+         sbuf,
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
+  GNUNET_CRYPTO_rsa_blind(&hc,
+                          &bsec[0],
+                          public_key,
+                          &bbuf, &bbuf_len);
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      sig = GNUNET_CRYPTO_rsa_sign_blinded(private_key,
+                                           bbuf, bbuf_len);
+      GNUNET_CRYPTO_rsa_signature_free(sig);
+    }
+  printf("10x %u-signing took %s\n",
+         len,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GNUNET_snprintf(sbuf,
+                  sizeof(sbuf),
+                  "RSA %u-signing",
+                  len);
+  GAUGER("UTIL",
+         sbuf,
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
+  sig = GNUNET_CRYPTO_rsa_sign_blinded(private_key,
+                                       bbuf,
+                                       bbuf_len);
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      rsig = GNUNET_CRYPTO_rsa_unblind(sig,
+                                       &bsec[0],
+                                       public_key);
+      GNUNET_CRYPTO_rsa_signature_free(rsig);
+    }
+  printf("10x %u-unblinding took %s\n",
+         len,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GNUNET_snprintf(sbuf,
+                  sizeof(sbuf),
+                  "RSA %u-unblinding",
+                  len);
+  GAUGER("UTIL",
+         sbuf,
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
+  rsig = GNUNET_CRYPTO_rsa_unblind(sig,
+                                   &bsec[0],
+                                   public_key);
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CRYPTO_rsa_verify(&hc,
                                              rsig,
                                              public_key));
-  }
-  printf ("10x %u-verifying took %s\n",
-          len,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "RSA %u-verification",
-                   len);
-  GAUGER ("UTIL",
-          sbuf,
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "ops/ms");
-  GNUNET_CRYPTO_rsa_signature_free (sig);
-  GNUNET_CRYPTO_rsa_public_key_free (public_key);
-  GNUNET_CRYPTO_rsa_private_key_free (private_key);
-  GNUNET_free (bbuf);
+    }
+  printf("10x %u-verifying took %s\n",
+         len,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GNUNET_snprintf(sbuf,
+                  sizeof(sbuf),
+                  "RSA %u-verification",
+                  len);
+  GAUGER("UTIL",
+         sbuf,
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "ops/ms");
+  GNUNET_CRYPTO_rsa_signature_free(sig);
+  GNUNET_CRYPTO_rsa_public_key_free(public_key);
+  GNUNET_CRYPTO_rsa_private_key_free(private_key);
+  GNUNET_free(bbuf);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  eval (1024); 
-  eval (2048); 
+  eval(1024);
+  eval(2048);
   /* eval (4096); */
   return 0;
 }
diff --git a/src/util/perf_crypto_symmetric.c b/src/util/perf_crypto_symmetric.c
index 0bef04b7a..01bec8f11 100644
--- a/src/util/perf_crypto_symmetric.c
+++ b/src/util/perf_crypto_symmetric.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -29,7 +29,7 @@
 
 
 static void
-perfEncrypt ()
+perfEncrypt()
 {
   unsigned int i;
   char buf[64 * 1024];
@@ -37,38 +37,38 @@ perfEncrypt ()
   struct GNUNET_CRYPTO_SymmetricSessionKey sk;
   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
-  GNUNET_CRYPTO_symmetric_create_session_key (&sk);
+  GNUNET_CRYPTO_symmetric_create_session_key(&sk);
 
-  memset (buf, 1, sizeof (buf));
+  memset(buf, 1, sizeof(buf));
   for (i = 0; i < 1024; i++)
-  {
-    memset (&iv, (int8_t) i, sizeof (iv));
-    GNUNET_CRYPTO_symmetric_encrypt (buf, sizeof (buf),
-                               &sk, &iv,
-                               rbuf);
-    GNUNET_CRYPTO_symmetric_decrypt (rbuf, sizeof (buf),
-                               &sk, &iv,
-                               buf);
-  }
-  memset (rbuf, 1, sizeof (rbuf));
-  GNUNET_assert (0 == memcmp (rbuf, buf, sizeof (buf)));
+    {
+      memset(&iv, (int8_t)i, sizeof(iv));
+      GNUNET_CRYPTO_symmetric_encrypt(buf, sizeof(buf),
+                                      &sk, &iv,
+                                      rbuf);
+      GNUNET_CRYPTO_symmetric_decrypt(rbuf, sizeof(buf),
+                                      &sk, &iv,
+                                      buf);
+    }
+  memset(rbuf, 1, sizeof(rbuf));
+  GNUNET_assert(0 == memcmp(rbuf, buf, sizeof(buf)));
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
 
-  start = GNUNET_TIME_absolute_get ();
-  perfEncrypt ();
-  printf ("Encrypt perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Symmetric encryption",
-          64 * 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "kb/ms");
+  start = GNUNET_TIME_absolute_get();
+  perfEncrypt();
+  printf("Encrypt perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Symmetric encryption",
+         64 * 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "kb/ms");
   return 0;
 }
 
diff --git a/src/util/perf_malloc.c b/src/util/perf_malloc.c
index 4447934af..ee2281edd 100644
--- a/src/util/perf_malloc.c
+++ b/src/util/perf_malloc.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -28,36 +28,36 @@
 #include <gauger.h>
 
 static uint64_t
-perfMalloc ()
+perfMalloc()
 {
   size_t i;
   uint64_t ret;
 
   ret = 0;
-  for (i=1;i<1024 * 1024;i+=1024)
+  for (i = 1; i < 1024 * 1024; i += 1024)
     {
       ret += i;
-      GNUNET_free (GNUNET_malloc (i));
+      GNUNET_free(GNUNET_malloc(i));
     }
   return ret;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
   uint64_t kb;
 
-  start = GNUNET_TIME_absolute_get ();
-  kb = perfMalloc ();
-  printf ("Malloc perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("UTIL", "Allocation",
-          kb / 1024 / (1 +
-                       GNUNET_TIME_absolute_get_duration
-                       (start).rel_value_us / 1000LL), "kb/ms");
+  start = GNUNET_TIME_absolute_get();
+  kb = perfMalloc();
+  printf("Malloc perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("UTIL", "Allocation",
+         kb / 1024 / (1 +
+                      GNUNET_TIME_absolute_get_duration
+                        (start).rel_value_us / 1000LL), "kb/ms");
   return 0;
 }
 
diff --git a/src/util/plugin.c b/src/util/plugin.c
index 19169f070..2b11e5c3c 100644
--- a/src/util/plugin.c
+++ b/src/util/plugin.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 util/plugin.c
@@ -28,13 +28,12 @@
 #include <ltdl.h>
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-plugin", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-plugin", __VA_ARGS__)
 
 /**
  * Linked list of active plugins.
  */
-struct PluginList
-{
+struct PluginList {
   /**
    * This is a linked list.
    */
@@ -72,40 +71,40 @@ static struct PluginList *plugins;
  * Setup libtool paths.
  */
 static void
-plugin_init ()
+plugin_init()
 {
   int err;
   const char *opath;
   char *path;
   char *cpath;
 
-  err = lt_dlinit ();
+  err = lt_dlinit();
   if (err > 0)
-  {
-    fprintf (stderr,
-             _ ("Initialization of plugin mechanism failed: %s!\n"),
-             lt_dlerror ());
-    return;
-  }
-  opath = lt_dlgetsearchpath ();
-  if (NULL != opath)
-    old_dlsearchpath = GNUNET_strdup (opath);
-  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
-  if (NULL != path)
-  {
-    if (NULL != opath)
     {
-      GNUNET_asprintf (&cpath, "%s:%s", opath, path);
-      lt_dlsetsearchpath (cpath);
-      GNUNET_free (path);
-      GNUNET_free (cpath);
+      fprintf(stderr,
+              _("Initialization of plugin mechanism failed: %s!\n"),
+              lt_dlerror());
+      return;
     }
-    else
+  opath = lt_dlgetsearchpath();
+  if (NULL != opath)
+    old_dlsearchpath = GNUNET_strdup(opath);
+  path = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LIBDIR);
+  if (NULL != path)
     {
-      lt_dlsetsearchpath (path);
-      GNUNET_free (path);
+      if (NULL != opath)
+        {
+          GNUNET_asprintf(&cpath, "%s:%s", opath, path);
+          lt_dlsetsearchpath(cpath);
+          GNUNET_free(path);
+          GNUNET_free(cpath);
+        }
+      else
+        {
+          lt_dlsetsearchpath(path);
+          GNUNET_free(path);
+        }
     }
-  }
 }
 
 
@@ -113,15 +112,15 @@ plugin_init ()
  * Shutdown libtool.
  */
 static void
-plugin_fini ()
+plugin_fini()
 {
-  lt_dlsetsearchpath (old_dlsearchpath);
+  lt_dlsetsearchpath(old_dlsearchpath);
   if (NULL != old_dlsearchpath)
-  {
-    GNUNET_free (old_dlsearchpath);
-    old_dlsearchpath = NULL;
-  }
-  lt_dlexit ();
+    {
+      GNUNET_free(old_dlsearchpath);
+      old_dlsearchpath = NULL;
+    }
+  lt_dlexit();
 }
 
 
@@ -133,22 +132,22 @@ plugin_fini ()
  * @return NULL if the symbol was not found
  */
 static GNUNET_PLUGIN_Callback
-resolve_function (struct PluginList *plug, const char *name)
+resolve_function(struct PluginList *plug, const char *name)
 {
   char *initName;
   void *mptr;
 
-  GNUNET_asprintf (&initName, "_%s_%s", plug->name, name);
-  mptr = lt_dlsym (plug->handle, &initName[1]);
+  GNUNET_asprintf(&initName, "_%s_%s", plug->name, name);
+  mptr = lt_dlsym(plug->handle, &initName[1]);
   if (NULL == mptr)
-    mptr = lt_dlsym (plug->handle, initName);
+    mptr = lt_dlsym(plug->handle, initName);
   if (NULL == mptr)
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("`%s' failed to resolve method '%s' with error: %s\n"),
-         "lt_dlsym",
-         &initName[1],
-         lt_dlerror ());
-  GNUNET_free (initName);
+    LOG(GNUNET_ERROR_TYPE_ERROR,
+        _("`%s' failed to resolve method '%s' with error: %s\n"),
+        "lt_dlsym",
+        &initName[1],
+        lt_dlerror());
+  GNUNET_free(initName);
   return mptr;
 }
 
@@ -163,30 +162,30 @@ resolve_function (struct PluginList *plug, const char *name)
  * @return #GNUNET_YES if the plugin exists, #GNUNET_NO if not
  */
 int
-GNUNET_PLUGIN_test (const char *library_name)
+GNUNET_PLUGIN_test(const char *library_name)
 {
   void *libhandle;
   GNUNET_PLUGIN_Callback init;
   struct PluginList plug;
 
-  if (! initialized)
-  {
-    initialized = GNUNET_YES;
-    plugin_init ();
-  }
-  libhandle = lt_dlopenext (library_name);
+  if (!initialized)
+    {
+      initialized = GNUNET_YES;
+      plugin_init();
+    }
+  libhandle = lt_dlopenext(library_name);
   if (NULL == libhandle)
     return GNUNET_NO;
   plug.handle = libhandle;
-  plug.name = (char *) library_name;
-  init = resolve_function (&plug, "init");
+  plug.name = (char *)library_name;
+  init = resolve_function(&plug, "init");
   if (NULL == init)
-  {
-    GNUNET_break (0);
-    lt_dlclose (libhandle);
-    return GNUNET_NO;
-  }
-  lt_dlclose (libhandle);
+    {
+      GNUNET_break(0);
+      lt_dlclose(libhandle);
+      return GNUNET_NO;
+    }
+  lt_dlclose(libhandle);
   return GNUNET_YES;
 }
 
@@ -204,42 +203,42 @@ GNUNET_PLUGIN_test (const char *library_name)
  * @return whatever the initialization function returned
  */
 void *
-GNUNET_PLUGIN_load (const char *library_name, void *arg)
+GNUNET_PLUGIN_load(const char *library_name, void *arg)
 {
   void *libhandle;
   struct PluginList *plug;
   GNUNET_PLUGIN_Callback init;
   void *ret;
 
-  if (! initialized)
-  {
-    initialized = GNUNET_YES;
-    plugin_init ();
-  }
-  libhandle = lt_dlopenext (library_name);
+  if (!initialized)
+    {
+      initialized = GNUNET_YES;
+      plugin_init();
+    }
+  libhandle = lt_dlopenext(library_name);
   if (libhandle == NULL)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("`%s' failed for library `%s' with error: %s\n"),
-         "lt_dlopenext",
-         library_name,
-         lt_dlerror ());
-    return NULL;
-  }
-  plug = GNUNET_new (struct PluginList);
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("`%s' failed for library `%s' with error: %s\n"),
+          "lt_dlopenext",
+          library_name,
+          lt_dlerror());
+      return NULL;
+    }
+  plug = GNUNET_new(struct PluginList);
   plug->handle = libhandle;
-  plug->name = GNUNET_strdup (library_name);
+  plug->name = GNUNET_strdup(library_name);
   plug->next = plugins;
   plugins = plug;
-  init = resolve_function (plug, "init");
-  if ((init == NULL) || (NULL == (ret = init (arg))))
-  {
-    lt_dlclose (libhandle);
-    GNUNET_free (plug->name);
-    plugins = plug->next;
-    GNUNET_free (plug);
-    return NULL;
-  }
+  init = resolve_function(plug, "init");
+  if ((init == NULL) || (NULL == (ret = init(arg))))
+    {
+      lt_dlclose(libhandle);
+      GNUNET_free(plug->name);
+      plugins = plug->next;
+      GNUNET_free(plug);
+      return NULL;
+    }
   return ret;
 }
 
@@ -253,7 +252,7 @@ GNUNET_PLUGIN_load (const char *library_name, void *arg)
  * @return whatever the shutdown function returned
  */
 void *
-GNUNET_PLUGIN_unload (const char *library_name, void *arg)
+GNUNET_PLUGIN_unload(const char *library_name, void *arg)
 {
   struct PluginList *pos;
   struct PluginList *prev;
@@ -262,30 +261,30 @@ GNUNET_PLUGIN_unload (const char *library_name, void *arg)
 
   prev = NULL;
   pos = plugins;
-  while ((NULL != pos) && (0 != strcmp (pos->name, library_name)))
-  {
-    prev = pos;
-    pos = pos->next;
-  }
+  while ((NULL != pos) && (0 != strcmp(pos->name, library_name)))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
   if (NULL == pos)
     return NULL;
 
-  done = resolve_function (pos, "done");
+  done = resolve_function(pos, "done");
   ret = NULL;
   if (NULL != done)
-    ret = done (arg);
+    ret = done(arg);
   if (NULL == prev)
     plugins = pos->next;
   else
     prev->next = pos->next;
-  lt_dlclose (pos->handle);
-  GNUNET_free (pos->name);
-  GNUNET_free (pos);
+  lt_dlclose(pos->handle);
+  GNUNET_free(pos->name);
+  GNUNET_free(pos);
   if (NULL == plugins)
-  {
-    plugin_fini ();
-    initialized = GNUNET_NO;
-  }
+    {
+      plugin_fini();
+      initialized = GNUNET_NO;
+    }
   return ret;
 }
 
@@ -293,8 +292,7 @@ GNUNET_PLUGIN_unload (const char *library_name, void *arg)
 /**
  * Closure for #find_libraries().
  */
-struct LoadAllContext
-{
+struct LoadAllContext {
   /**
    * Prefix the plugin names we find have to match.
    */
@@ -327,7 +325,7 @@ struct LoadAllContext
  * @return #GNUNET_OK (continue loading)
  */
 static int
-find_libraries (void *cls, const char *filename)
+find_libraries(void *cls, const char *filename)
 {
   struct LoadAllContext *lac = cls;
   const char *slashpos;
@@ -338,20 +336,20 @@ find_libraries (void *cls, const char *filename)
   size_t n;
 
   libname = filename;
-  while (NULL != (slashpos = strstr (libname, DIR_SEPARATOR_STR)))
+  while (NULL != (slashpos = strstr(libname, DIR_SEPARATOR_STR)))
     libname = slashpos + 1;
-  n = strlen (libname);
-  if (0 != strncmp (lac->basename, libname, strlen (lac->basename)))
+  n = strlen(libname);
+  if (0 != strncmp(lac->basename, libname, strlen(lac->basename)))
     return GNUNET_OK; /* wrong name */
-  if ((n > 3) && (0 == strcmp (&libname[n - 3], ".la")))
+  if ((n > 3) && (0 == strcmp(&libname[n - 3], ".la")))
     return GNUNET_OK; /* .la file */
-  basename = GNUNET_strdup (libname);
-  if (NULL != (dot = strstr (basename, ".")))
+  basename = GNUNET_strdup(libname);
+  if (NULL != (dot = strstr(basename, ".")))
     *dot = '\0';
-  lib_ret = GNUNET_PLUGIN_load (basename, lac->arg);
+  lib_ret = GNUNET_PLUGIN_load(basename, lac->arg);
   if (NULL != lib_ret)
-    lac->cb (lac->cb_cls, basename, lib_ret);
-  GNUNET_free (basename);
+    lac->cb(lac->cb_cls, basename, lib_ret);
+  GNUNET_free(basename);
   return GNUNET_OK;
 }
 
@@ -369,27 +367,27 @@ find_libraries (void *cls, const char *filename)
  * @param cb_cls closure for @a cb
  */
 void
-GNUNET_PLUGIN_load_all (const char *basename,
-                        void *arg,
-                        GNUNET_PLUGIN_LoaderCallback cb,
-                        void *cb_cls)
+GNUNET_PLUGIN_load_all(const char *basename,
+                       void *arg,
+                       GNUNET_PLUGIN_LoaderCallback cb,
+                       void *cb_cls)
 {
   struct LoadAllContext lac;
   char *path;
 
-  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
+  path = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LIBDIR);
   if (NULL == path)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not determine plugin installation path.\n"));
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not determine plugin installation path.\n"));
+      return;
+    }
   lac.basename = basename;
   lac.arg = arg;
   lac.cb = cb;
   lac.cb_cls = cb_cls;
-  GNUNET_DISK_directory_scan (path, &find_libraries, &lac);
-  GNUNET_free (path);
+  GNUNET_DISK_directory_scan(path, &find_libraries, &lac);
+  GNUNET_free(path);
 }
 
 
diff --git a/src/util/proc_compat.c b/src/util/proc_compat.c
index 7abea446a..3d73d7889 100644
--- a/src/util/proc_compat.c
+++ b/src/util/proc_compat.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
-*/
+ */
 #include "platform.h"
 
 /**
@@ -35,16 +35,16 @@
  * @param n search character limit
  */
 void*
-GN_memrchr_ (const void *s,
-             int c,
-             size_t n)
+GN_memrchr_(const void *s,
+            int c,
+            size_t n)
 {
   const unsigned char *ucs = s;
   ssize_t i;
 
   for (i = n - 1; i >= 0; i--)
-    if (c == (int) ucs[i])
-      return (void *) &ucs[i];
+    if (c == (int)ucs[i])
+      return (void *)&ucs[i];
   return NULL;
 }
 
diff --git a/src/util/program.c b/src/util/program.c
index 77f4ea3ae..9bd3d64f9 100644
--- a/src/util/program.c
+++ b/src/util/program.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 util/program.c
@@ -31,16 +31,15 @@
 #include "speedup.h"
 #include <gcrypt.h>
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-program", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-program", __VA_ARGS__)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-program", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-program", syscall, filename)
 
 /**
  * Context for the command.
  */
-struct CommandContext
-{
+struct CommandContext {
   /**
    * Argv argument.
    */
@@ -72,10 +71,10 @@ struct CommandContext
  * task run when the scheduler shuts down
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) cls;
-  GNUNET_SPEEDUP_stop_ ();
+  (void)cls;
+  GNUNET_SPEEDUP_stop_();
 }
 
 
@@ -84,14 +83,14 @@ shutdown_task (void *cls)
  * program.  Runs the program-specific main task.
  */
 static void
-program_main (void *cls)
+program_main(void *cls)
 {
   struct CommandContext *cc = cls;
 
-  GNUNET_SPEEDUP_start_ (cc->cfg);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
-  GNUNET_RESOLVER_connect (cc->cfg);
-  cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
+  GNUNET_SPEEDUP_start_(cc->cfg);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  GNUNET_RESOLVER_connect(cc->cfg);
+  cc->task(cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
 }
 
 
@@ -103,16 +102,16 @@ program_main (void *cls)
  * @param a2 second command line option
  */
 static int
-cmd_sorter (const void *a1, const void *a2)
+cmd_sorter(const void *a1, const void *a2)
 {
   const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
   const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
 
-  if (toupper ((unsigned char) c1->shortName) >
-      toupper ((unsigned char) c2->shortName))
+  if (toupper((unsigned char)c1->shortName) >
+      toupper((unsigned char)c2->shortName))
     return 1;
-  if (toupper ((unsigned char) c1->shortName) <
-      toupper ((unsigned char) c2->shortName))
+  if (toupper((unsigned char)c1->shortName) <
+      toupper((unsigned char)c2->shortName))
     return -1;
   if (c1->shortName > c2->shortName)
     return 1;
@@ -138,16 +137,17 @@ cmd_sorter (const void *a1, const void *a2)
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_PROGRAM_run2 (int argc,
-                     char *const *argv,
-                     const char *binaryName,
-                     const char *binaryHelp,
-                     const struct GNUNET_GETOPT_CommandLineOption *options,
-                     GNUNET_PROGRAM_Main task,
-                     void *task_cls,
-                     int run_without_scheduler)
+GNUNET_PROGRAM_run2(int argc,
+                    char *const *argv,
+                    const char *binaryName,
+                    const char *binaryHelp,
+                    const struct GNUNET_GETOPT_CommandLineOption *options,
+                    GNUNET_PROGRAM_Main task,
+                    void *task_cls,
+                    int run_without_scheduler)
 {
   struct CommandContext cc;
+
 #if ENABLE_NLS
   char *path;
 #endif
@@ -161,191 +161,191 @@ GNUNET_PROGRAM_run2 (int argc,
   unsigned long long skew_variance;
   long long clock_offset;
   struct GNUNET_CONFIGURATION_Handle *cfg;
-  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
+  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get();
   struct GNUNET_GETOPT_CommandLineOption defoptions[] =
-    {GNUNET_GETOPT_option_cfgfile (&cc.cfgfile),
-     GNUNET_GETOPT_option_help (binaryHelp),
-     GNUNET_GETOPT_option_loglevel (&loglev),
-     GNUNET_GETOPT_option_logfile (&logfile),
-     GNUNET_GETOPT_option_version (pd->version)};
+  { GNUNET_GETOPT_option_cfgfile(&cc.cfgfile),
+    GNUNET_GETOPT_option_help(binaryHelp),
+    GNUNET_GETOPT_option_loglevel(&loglev),
+    GNUNET_GETOPT_option_logfile(&logfile),
+    GNUNET_GETOPT_option_version(pd->version) };
   struct GNUNET_GETOPT_CommandLineOption *allopts;
   const char *gargs;
   char *lpfx;
   char *spc;
 
   logfile = NULL;
-  gargs = getenv ("GNUNET_ARGS");
+  gargs = getenv("GNUNET_ARGS");
   if (NULL != gargs)
-  {
-    char **gargv;
-    unsigned int gargc;
-    char *cargs;
+    {
+      char **gargv;
+      unsigned int gargc;
+      char *cargs;
 
-    gargv = NULL;
-    gargc = 0;
-    for (int i = 0; i < argc; i++)
-      GNUNET_array_append (gargv, gargc, GNUNET_strdup (argv[i]));
-    cargs = GNUNET_strdup (gargs);
-    for (char *tok = strtok (cargs, " "); NULL != tok; tok = strtok (NULL, " "))
-      GNUNET_array_append (gargv, gargc, GNUNET_strdup (tok));
-    GNUNET_free (cargs);
-    GNUNET_array_append (gargv, gargc, NULL);
-    argv = (char *const *) gargv;
-    argc = gargc - 1;
-  }
-  memset (&cc, 0, sizeof (cc));
+      gargv = NULL;
+      gargc = 0;
+      for (int i = 0; i < argc; i++)
+        GNUNET_array_append(gargv, gargc, GNUNET_strdup(argv[i]));
+      cargs = GNUNET_strdup(gargs);
+      for (char *tok = strtok(cargs, " "); NULL != tok; tok = strtok(NULL, " "))
+        GNUNET_array_append(gargv, gargc, GNUNET_strdup(tok));
+      GNUNET_free(cargs);
+      GNUNET_array_append(gargv, gargc, NULL);
+      argv = (char *const *)gargv;
+      argc = gargc - 1;
+    }
+  memset(&cc, 0, sizeof(cc));
   loglev = NULL;
   cc.task = task;
   cc.task_cls = task_cls;
-  cc.cfg = cfg = GNUNET_CONFIGURATION_create ();
+  cc.cfg = cfg = GNUNET_CONFIGURATION_create();
   /* prepare */
 #if ENABLE_NLS
   if (NULL != pd->gettext_domain)
-  {
-    setlocale (LC_ALL, "");
-    path = (NULL == pd->gettext_path)
-             ? GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR)
-             : GNUNET_strdup (pd->gettext_path);
-    if (NULL != path)
     {
-      bindtextdomain (pd->gettext_domain, path);
-      GNUNET_free (path);
+      setlocale(LC_ALL, "");
+      path = (NULL == pd->gettext_path)
+             ? GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR)
+             : GNUNET_strdup(pd->gettext_path);
+      if (NULL != path)
+        {
+          bindtextdomain(pd->gettext_domain, path);
+          GNUNET_free(path);
+        }
+      textdomain(pd->gettext_domain);
     }
-    textdomain (pd->gettext_domain);
-  }
 #endif
   cnt = 0;
   while (NULL != options[cnt].name)
     cnt++;
   allopts =
-    GNUNET_malloc ((cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) +
-                   sizeof (defoptions));
-  GNUNET_memcpy (allopts, defoptions, sizeof (defoptions));
-  GNUNET_memcpy (&allopts[sizeof (defoptions) /
-                          sizeof (struct GNUNET_GETOPT_CommandLineOption)],
-                 options,
-                 (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption));
-  cnt += sizeof (defoptions) / sizeof (struct GNUNET_GETOPT_CommandLineOption);
-  qsort (allopts,
-         cnt,
-         sizeof (struct GNUNET_GETOPT_CommandLineOption),
-         &cmd_sorter);
+    GNUNET_malloc((cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption) +
+                  sizeof(defoptions));
+  GNUNET_memcpy(allopts, defoptions, sizeof(defoptions));
+  GNUNET_memcpy(&allopts[sizeof(defoptions) /
+                         sizeof(struct GNUNET_GETOPT_CommandLineOption)],
+                options,
+                (cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption));
+  cnt += sizeof(defoptions) / sizeof(struct GNUNET_GETOPT_CommandLineOption);
+  qsort(allopts,
+        cnt,
+        sizeof(struct GNUNET_GETOPT_CommandLineOption),
+        &cmd_sorter);
   loglev = NULL;
-  xdg = getenv ("XDG_CONFIG_HOME");
+  xdg = getenv("XDG_CONFIG_HOME");
   if (NULL != xdg)
-    GNUNET_asprintf (&cfg_fn,
-                     "%s%s%s",
-                     xdg,
-                     DIR_SEPARATOR_STR,
-                     pd->config_file);
+    GNUNET_asprintf(&cfg_fn,
+                    "%s%s%s",
+                    xdg,
+                    DIR_SEPARATOR_STR,
+                    pd->config_file);
   else
-    cfg_fn = GNUNET_strdup (pd->user_config_file);
-  lpfx = GNUNET_strdup (binaryName);
-  if (NULL != (spc = strstr (lpfx, " ")))
+    cfg_fn = GNUNET_strdup(pd->user_config_file);
+  lpfx = GNUNET_strdup(binaryName);
+  if (NULL != (spc = strstr(lpfx, " ")))
     *spc = '\0';
-  ret = GNUNET_GETOPT_run (binaryName, allopts, (unsigned int) argc, argv);
+  ret = GNUNET_GETOPT_run(binaryName, allopts, (unsigned int)argc, argv);
   if ((GNUNET_OK > ret) ||
-      (GNUNET_OK != GNUNET_log_setup (lpfx, loglev, logfile)))
-  {
-    GNUNET_free (allopts);
-    GNUNET_free (lpfx);
-    goto cleanup;
-  }
-  if (NULL != cc.cfgfile)
-  {
-    if ((GNUNET_YES != GNUNET_DISK_file_test (cc.cfgfile)) ||
-        (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cc.cfgfile)))
+      (GNUNET_OK != GNUNET_log_setup(lpfx, loglev, logfile)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ (
-                    "Unreadable or malformed configuration file `%s', exit ...\n"),
-                  cc.cfgfile);
-      ret = GNUNET_SYSERR;
-      GNUNET_free (allopts);
-      GNUNET_free (lpfx);
+      GNUNET_free(allopts);
+      GNUNET_free(lpfx);
       goto cleanup;
     }
-  }
-  else
-  {
-    if (GNUNET_YES == GNUNET_DISK_file_test (cfg_fn))
+  if (NULL != cc.cfgfile)
     {
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cfg_fn))
-      {
-        GNUNET_log (
-          GNUNET_ERROR_TYPE_ERROR,
-          _ (
-            "Unreadable or malformed default configuration file `%s', exit ...\n"),
-          cfg_fn);
-        ret = GNUNET_SYSERR;
-        GNUNET_free (allopts);
-        GNUNET_free (lpfx);
-        goto cleanup;
-      }
+      if ((GNUNET_YES != GNUNET_DISK_file_test(cc.cfgfile)) ||
+          (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cc.cfgfile)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _(
+                       "Unreadable or malformed configuration file `%s', exit ...\n"),
+                     cc.cfgfile);
+          ret = GNUNET_SYSERR;
+          GNUNET_free(allopts);
+          GNUNET_free(lpfx);
+          goto cleanup;
+        }
     }
-    else
+  else
     {
-      GNUNET_free (cfg_fn);
-      cfg_fn = NULL;
-      if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, NULL))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _ ("Unreadable or malformed configuration, exit ...\n"));
-        ret = GNUNET_SYSERR;
-        GNUNET_free (allopts);
-        GNUNET_free (lpfx);
-        goto cleanup;
-      }
+      if (GNUNET_YES == GNUNET_DISK_file_test(cfg_fn))
+        {
+          if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cfg_fn))
+            {
+              GNUNET_log(
+                GNUNET_ERROR_TYPE_ERROR,
+                _(
+                  "Unreadable or malformed default configuration file `%s', exit ...\n"),
+                cfg_fn);
+              ret = GNUNET_SYSERR;
+              GNUNET_free(allopts);
+              GNUNET_free(lpfx);
+              goto cleanup;
+            }
+        }
+      else
+        {
+          GNUNET_free(cfg_fn);
+          cfg_fn = NULL;
+          if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg, NULL))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         _("Unreadable or malformed configuration, exit ...\n"));
+              ret = GNUNET_SYSERR;
+              GNUNET_free(allopts);
+              GNUNET_free(lpfx);
+              goto cleanup;
+            }
+        }
     }
-  }
-  GNUNET_free (allopts);
-  GNUNET_free (lpfx);
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cc.cfg,
+  GNUNET_free(allopts);
+  GNUNET_free(lpfx);
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cc.cfg,
+                                                         "testing",
+                                                         "skew_offset",
+                                                         &skew_offset) &&
+      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cc.cfg,
                                                           "testing",
-                                                          "skew_offset",
-                                                          &skew_offset) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cc.cfg,
-                                                           "testing",
-                                                           "skew_variance",
-                                                           &skew_variance)))
-  {
-    clock_offset = skew_offset - skew_variance;
-    GNUNET_TIME_set_offset (clock_offset);
-  }
+                                                          "skew_variance",
+                                                          &skew_variance)))
+    {
+      clock_offset = skew_offset - skew_variance;
+      GNUNET_TIME_set_offset(clock_offset);
+    }
   /* ARM needs to know which configuration file to use when starting
      services.  If we got a command-line option *and* if nothing is
      specified in the configuration, remember the command-line option
      in "cfg".  This is typically really only having an effect if we
      are running code in src/arm/, as obviously the rest of the code
      has little business with ARM-specific options. */
-  if (GNUNET_YES != GNUNET_CONFIGURATION_have_value (cfg, "arm", "CONFIG"))
-  {
-    if (NULL != cc.cfgfile)
-      GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", cc.cfgfile);
-    else if (NULL != cfg_fn)
-      GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", cfg_fn);
-  }
+  if (GNUNET_YES != GNUNET_CONFIGURATION_have_value(cfg, "arm", "CONFIG"))
+    {
+      if (NULL != cc.cfgfile)
+        GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", cc.cfgfile);
+      else if (NULL != cfg_fn)
+        GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", cfg_fn);
+    }
 
   /* run */
   cc.args = &argv[ret];
   if ((NULL == cc.cfgfile) && (NULL != cfg_fn))
-    cc.cfgfile = GNUNET_strdup (cfg_fn);
+    cc.cfgfile = GNUNET_strdup(cfg_fn);
   if (GNUNET_NO == run_without_scheduler)
-  {
-    GNUNET_SCHEDULER_run (&program_main, &cc);
-  }
+    {
+      GNUNET_SCHEDULER_run(&program_main, &cc);
+    }
   else
-  {
-    GNUNET_RESOLVER_connect (cc.cfg);
-    cc.task (cc.task_cls, cc.args, cc.cfgfile, cc.cfg);
-  }
+    {
+      GNUNET_RESOLVER_connect(cc.cfg);
+      cc.task(cc.task_cls, cc.args, cc.cfgfile, cc.cfg);
+    }
   ret = GNUNET_OK;
 cleanup:
-  GNUNET_CONFIGURATION_destroy (cfg);
-  GNUNET_free_non_null (cc.cfgfile);
-  GNUNET_free_non_null (cfg_fn);
-  GNUNET_free_non_null (loglev);
-  GNUNET_free_non_null (logfile);
+  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_free_non_null(cc.cfgfile);
+  GNUNET_free_non_null(cfg_fn);
+  GNUNET_free_non_null(loglev);
+  GNUNET_free_non_null(logfile);
   return ret;
 }
 
@@ -364,22 +364,22 @@ cleanup:
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_PROGRAM_run (int argc,
-                    char *const *argv,
-                    const char *binaryName,
-                    const char *binaryHelp,
-                    const struct GNUNET_GETOPT_CommandLineOption *options,
-                    GNUNET_PROGRAM_Main task,
-                    void *task_cls)
+GNUNET_PROGRAM_run(int argc,
+                   char *const *argv,
+                   const char *binaryName,
+                   const char *binaryHelp,
+                   const struct GNUNET_GETOPT_CommandLineOption *options,
+                   GNUNET_PROGRAM_Main task,
+                   void *task_cls)
 {
-  return GNUNET_PROGRAM_run2 (argc,
-                              argv,
-                              binaryName,
-                              binaryHelp,
-                              options,
-                              task,
-                              task_cls,
-                              GNUNET_NO);
+  return GNUNET_PROGRAM_run2(argc,
+                             argv,
+                             binaryName,
+                             binaryHelp,
+                             options,
+                             task,
+                             task_cls,
+                             GNUNET_NO);
 }
 
 
diff --git a/src/util/regex.c b/src/util/regex.c
index 70bf5c485..24e83cfd1 100644
--- a/src/util/regex.c
+++ b/src/util/regex.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file src/tun/regex.c
  * @brief functions to convert IP networks to regexes
@@ -42,15 +42,15 @@
  *              bytes long.
  */
 void
-GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
-                              uint16_t port,
-                              char *rxstr)
+GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip,
+                             uint16_t port,
+                             char *rxstr)
 {
-  GNUNET_snprintf (rxstr,
-                   GNUNET_TUN_IPV4_REGEXLEN,
-                   "4-%04X-%08X",
-                   (unsigned int) port,
-                   ntohl (ip->s_addr));
+  GNUNET_snprintf(rxstr,
+                  GNUNET_TUN_IPV4_REGEXLEN,
+                  "4-%04X-%08X",
+                  (unsigned int)port,
+                  ntohl(ip->s_addr));
 }
 
 
@@ -63,21 +63,21 @@ GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
  *              bytes long.
  */
 void
-GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
-                              uint16_t port,
-                              char *rxstr)
+GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6,
+                             uint16_t port,
+                             char *rxstr)
 {
   const uint32_t *addr;
 
-  addr = (const uint32_t *) ipv6;
-  GNUNET_snprintf (rxstr,
-                   GNUNET_TUN_IPV6_REGEXLEN,
-                   "6-%04X-%08X%08X%08X%08X",
-                   (unsigned int) port,
-                   ntohl (addr[0]),
-                   ntohl (addr[1]),
-                   ntohl (addr[2]),
-                   ntohl (addr[3]));
+  addr = (const uint32_t *)ipv6;
+  GNUNET_snprintf(rxstr,
+                  GNUNET_TUN_IPV6_REGEXLEN,
+                  "6-%04X-%08X%08X%08X%08X",
+                  (unsigned int)port,
+                  ntohl(addr[0]),
+                  ntohl(addr[1]),
+                  ntohl(addr[2]),
+                  ntohl(addr[3]));
 }
 
 
@@ -88,54 +88,59 @@ GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
  * @param mask which bits in value are wildcards (any value)?
  */
 static char *
-nibble_to_regex (uint8_t value,
-                 uint8_t mask)
+nibble_to_regex(uint8_t value,
+                uint8_t mask)
 {
   char *ret;
 
   value &= mask;
   switch (mask)
-  {
-  case 0:
-    return GNUNET_strdup (DOT);
-  case 8:
-    GNUNET_asprintf (&ret,
-                     "(%X|%X|%X|%X|%X|%X|%X|%X)",
-                     value,
-                     value + 1,
-                     value + 2,
-                     value + 3,
-                     value + 4,
-                     value + 5,
-                     value + 6,
-                     value + 7);
-    return ret;
-  case 12:
-    GNUNET_asprintf (&ret,
-                     "(%X|%X|%X|%X)",
-                     value,
-                     value + 1,
-                     value + 2,
-                     value + 3);
-    return ret;
-  case 14:
-    GNUNET_asprintf (&ret,
-                     "(%X|%X)",
-                     value,
-                     value + 1);
-    return ret;
-  case 15:
-    GNUNET_asprintf (&ret,
-                     "%X",
-                     value);
-    return ret;
-  default:
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Bad mask: %d\n"),
-                mask);
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+    case 0:
+      return GNUNET_strdup(DOT);
+
+    case 8:
+      GNUNET_asprintf(&ret,
+                      "(%X|%X|%X|%X|%X|%X|%X|%X)",
+                      value,
+                      value + 1,
+                      value + 2,
+                      value + 3,
+                      value + 4,
+                      value + 5,
+                      value + 6,
+                      value + 7);
+      return ret;
+
+    case 12:
+      GNUNET_asprintf(&ret,
+                      "(%X|%X|%X|%X)",
+                      value,
+                      value + 1,
+                      value + 2,
+                      value + 3);
+      return ret;
+
+    case 14:
+      GNUNET_asprintf(&ret,
+                      "(%X|%X)",
+                      value,
+                      value + 1);
+      return ret;
+
+    case 15:
+      GNUNET_asprintf(&ret,
+                      "%X",
+                      value);
+      return ret;
+
+    default:
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Bad mask: %d\n"),
+                 mask);
+      GNUNET_break(0);
+      return NULL;
+    }
 }
 
 
@@ -146,33 +151,33 @@ nibble_to_regex (uint8_t value,
  * @param mask which bits in value are wildcards (any value)?
  */
 static char *
-num_to_regex (uint16_t value,
-              uint16_t mask)
+num_to_regex(uint16_t value,
+             uint16_t mask)
 {
-  const uint8_t *v = (const uint8_t *) &value;
-  const uint8_t *m = (const uint8_t *) &mask;
+  const uint8_t *v = (const uint8_t *)&value;
+  const uint8_t *m = (const uint8_t *)&mask;
   char *a;
   char *b;
   char *c;
   char *d;
   char *ret;
 
-  a = nibble_to_regex (v[0] >> 4, m[0] >> 4);
-  b = nibble_to_regex (v[0] & 15, m[0] & 15);
-  c = nibble_to_regex (v[1] >> 4, m[1] >> 4);
-  d = nibble_to_regex (v[1] & 15, m[1] & 15);
+  a = nibble_to_regex(v[0] >> 4, m[0] >> 4);
+  b = nibble_to_regex(v[0] & 15, m[0] & 15);
+  c = nibble_to_regex(v[1] >> 4, m[1] >> 4);
+  d = nibble_to_regex(v[1] & 15, m[1] & 15);
   ret = NULL;
-  if ( (NULL != a) &&
-       (NULL != b) &&
-       (NULL != c) &&
-       (NULL != d) )
-    GNUNET_asprintf (&ret,
-                     "%s%s%s%s",
-                     a, b, c, d);
-  GNUNET_free_non_null (a);
-  GNUNET_free_non_null (b);
-  GNUNET_free_non_null (c);
-  GNUNET_free_non_null (d);
+  if ((NULL != a) &&
+      (NULL != b) &&
+      (NULL != c) &&
+      (NULL != d))
+    GNUNET_asprintf(&ret,
+                    "%s%s%s%s",
+                    a, b, c, d);
+  GNUNET_free_non_null(a);
+  GNUNET_free_non_null(b);
+  GNUNET_free_non_null(c);
+  GNUNET_free_non_null(d);
   return ret;
 }
 
@@ -185,33 +190,36 @@ num_to_regex (uint16_t value,
  *         #GNUNET_NO if not
  */
 static int
-needs_parens (const char *arg)
+needs_parens(const char *arg)
 {
   size_t off;
   size_t len;
   unsigned int op;
 
   op = 0;
-  len = strlen (arg);
-  for (off=0;off<len;off++)
-  {
-    switch (arg[off])
+  len = strlen(arg);
+  for (off = 0; off < len; off++)
     {
-    case '(':
-      op++;
-      break;
-    case ')':
-      GNUNET_assert (op > 0);
-      op--;
-      break;
-    case '|':
-      if (0 == op)
-        return GNUNET_YES;
-      break;
-    default:
-      break;
+      switch (arg[off])
+        {
+        case '(':
+          op++;
+          break;
+
+        case ')':
+          GNUNET_assert(op > 0);
+          op--;
+          break;
+
+        case '|':
+          if (0 == op)
+            return GNUNET_YES;
+          break;
+
+        default:
+          break;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -227,21 +235,21 @@ needs_parens (const char *arg)
  * @return corresponding regex
  */
 static char *
-compute_policy (unsigned int start,
-                unsigned int end,
-                unsigned int step,
-                const struct GNUNET_STRINGS_PortPolicy *pp)
+compute_policy(unsigned int start,
+               unsigned int end,
+               unsigned int step,
+               const struct GNUNET_STRINGS_PortPolicy *pp)
 {
   unsigned int i;
   char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
   char middlel[33]; /* 16 * 2 + 0-terminator */
   char middleh[33]; /* 16 * 2 + 0-terminator */
   char after[36]; /* 16 * 2 + 3 dots + 0-terminator */
-  char beforep[36+2]; /* 16 * 2 + 3 dots + 0-terminator + ()*/
-  char middlehp[33+2]; /* 16 * 2 + 0-terminator + () */
-  char middlelp[33+2]; /* 16 * 2 + 0-terminator + () */
-  char afterp[36+2]; /* 16 * 2 + 3 dots + 0-terminator + () */
-  char dots[5 * strlen (DOT)];
+  char beforep[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + ()*/
+  char middlehp[33 + 2]; /* 16 * 2 + 0-terminator + () */
+  char middlelp[33 + 2]; /* 16 * 2 + 0-terminator + () */
+  char afterp[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + () */
+  char dots[5 * strlen(DOT)];
   char buf[3];
   char *middle;
   char *ret;
@@ -253,248 +261,248 @@ compute_policy (unsigned int start,
   unsigned int start_port;
   unsigned int end_port;
 
-  GNUNET_assert (GNUNET_YES == pp->negate_portrange);
+  GNUNET_assert(GNUNET_YES == pp->negate_portrange);
   start_port = pp->start_port;
   if (1 == start_port)
     start_port = 0;
   end_port = pp->end_port;
-  GNUNET_assert ((end - start) / step <= 0xF);
+  GNUNET_assert((end - start) / step <= 0xF);
   before[0] = '\0';
   middlel[0] = '\0';
   middleh[0] = '\0';
   after[0] = '\0';
-  for (i=start;i<=end;i+=step)
-  {
-    GNUNET_snprintf (buf,
-                     sizeof (buf),
-                     "%X|",
-                     (i - start) / step);
-    if (i / step < start_port / step)
-      strcat (before, buf);
-    else if (i / step > end_port / step)
-      strcat (after, buf);
-    else if (i / step == start_port / step)
-      strcat (middlel, buf);
-    else if (i / step == end_port / step)
-      strcat (middleh, buf);
-  }
-  if (strlen (before) > 0)
-    before[strlen (before)-1] = '\0';
-  if (strlen (middlel) > 0)
-    middlel[strlen (middlel)-1] = '\0';
-  if (strlen (middleh) > 0)
-    middleh[strlen (middleh)-1] = '\0';
-  if (strlen (after) > 0)
-    after[strlen (after)-1] = '\0';
-  if (needs_parens (before))
-    GNUNET_snprintf (beforep,
-                     sizeof (beforep),
-                     "(%s)",
-                     before);
+  for (i = start; i <= end; i += step)
+    {
+      GNUNET_snprintf(buf,
+                      sizeof(buf),
+                      "%X|",
+                      (i - start) / step);
+      if (i / step < start_port / step)
+        strcat(before, buf);
+      else if (i / step > end_port / step)
+        strcat(after, buf);
+      else if (i / step == start_port / step)
+        strcat(middlel, buf);
+      else if (i / step == end_port / step)
+        strcat(middleh, buf);
+    }
+  if (strlen(before) > 0)
+    before[strlen(before) - 1] = '\0';
+  if (strlen(middlel) > 0)
+    middlel[strlen(middlel) - 1] = '\0';
+  if (strlen(middleh) > 0)
+    middleh[strlen(middleh) - 1] = '\0';
+  if (strlen(after) > 0)
+    after[strlen(after) - 1] = '\0';
+  if (needs_parens(before))
+    GNUNET_snprintf(beforep,
+                    sizeof(beforep),
+                    "(%s)",
+                    before);
   else
-    strcpy (beforep, before);
-  if (needs_parens (middlel))
-    GNUNET_snprintf (middlelp,
-                     sizeof (middlelp),
-                     "(%s)",
-                     middlel);
+    strcpy(beforep, before);
+  if (needs_parens(middlel))
+    GNUNET_snprintf(middlelp,
+                    sizeof(middlelp),
+                    "(%s)",
+                    middlel);
   else
-    strcpy (middlelp, middlel);
-  if (needs_parens (middleh))
-    GNUNET_snprintf (middlehp,
-                     sizeof (middlehp),
-                     "(%s)",
-                     middleh);
+    strcpy(middlelp, middlel);
+  if (needs_parens(middleh))
+    GNUNET_snprintf(middlehp,
+                    sizeof(middlehp),
+                    "(%s)",
+                    middleh);
   else
-    strcpy (middlehp, middleh);
-  if (needs_parens (after))
-    GNUNET_snprintf (afterp,
-                     sizeof (afterp),
-                     "(%s)",
-                     after);
+    strcpy(middlehp, middleh);
+  if (needs_parens(after))
+    GNUNET_snprintf(afterp,
+                    sizeof(afterp),
+                    "(%s)",
+                    after);
   else
-    strcpy (afterp, after);
+    strcpy(afterp, after);
   dots[0] = '\0';
-  for (xstep=step/16;xstep>0;xstep/=16)
-    strcat (dots, DOT);
+  for (xstep = step / 16; xstep > 0; xstep /= 16)
+    strcat(dots, DOT);
   if (step >= 16)
-  {
-    if (strlen (middlel) > 0)
-      recl = compute_policy ((start_port / step) * step,
-                             (start_port / step) * step + step - 1,
-                             step / 16,
-                             pp);
-    else
-      recl = GNUNET_strdup ("");
-    if (strlen (middleh) > 0)
-      rech = compute_policy ((end_port / step) * step,
-                             (end_port / step) * step + step - 1,
-                             step / 16,
-                             pp);
-    else
-      rech = GNUNET_strdup ("");
-  }
-  else
-  {
-    recl = GNUNET_strdup ("");
-    rech = GNUNET_strdup ("");
-    middlel[0] = '\0';
-    middlelp[0] = '\0';
-    middleh[0] = '\0';
-    middlehp[0] = '\0';
-  }
-  if (needs_parens (recl))
-    GNUNET_asprintf (&reclp,
-                     "(%s)",
-                     recl);
+    {
+      if (strlen(middlel) > 0)
+        recl = compute_policy((start_port / step) * step,
+                              (start_port / step) * step + step - 1,
+                              step / 16,
+                              pp);
+      else
+        recl = GNUNET_strdup("");
+      if (strlen(middleh) > 0)
+        rech = compute_policy((end_port / step) * step,
+                              (end_port / step) * step + step - 1,
+                              step / 16,
+                              pp);
+      else
+        rech = GNUNET_strdup("");
+    }
   else
-    reclp = GNUNET_strdup (recl);
-  if (needs_parens (rech))
-    GNUNET_asprintf (&rechp,
-                     "(%s)",
-                     rech);
+    {
+      recl = GNUNET_strdup("");
+      rech = GNUNET_strdup("");
+      middlel[0] = '\0';
+      middlelp[0] = '\0';
+      middleh[0] = '\0';
+      middlehp[0] = '\0';
+    }
+  if (needs_parens(recl))
+    GNUNET_asprintf(&reclp,
+                    "(%s)",
+                    recl);
   else
-    rechp = GNUNET_strdup (rech);
-
-  if ( (strlen (middleh) > 0) &&
-       (strlen (rech) > 0) &&
-       (strlen (middlel) > 0) &&
-       (strlen (recl) > 0) )
-  {
-    GNUNET_asprintf (&middle,
-                     "%s%s|%s%s",
-                     middlel,
-                     reclp,
-                     middleh,
-                     rechp);
-  }
-  else if ( (strlen (middleh) > 0) &&
-            (strlen (rech) > 0) )
-  {
-    GNUNET_asprintf (&middle,
-                     "%s%s",
-                     middleh,
-                     rechp);
-  }
-  else if ( (strlen (middlel) > 0) &&
-            (strlen (recl) > 0) )
-  {
-    GNUNET_asprintf (&middle,
-                     "%s%s",
-                     middlel,
-                     reclp);
-  }
+    reclp = GNUNET_strdup(recl);
+  if (needs_parens(rech))
+    GNUNET_asprintf(&rechp,
+                    "(%s)",
+                    rech);
   else
-  {
-    middle = GNUNET_strdup ("");
-  }
-  if ( (strlen(before) > 0) &&
-       (strlen(after) > 0) )
-  {
-    if (strlen (dots) > 0)
+    rechp = GNUNET_strdup(rech);
+
+  if ((strlen(middleh) > 0) &&
+      (strlen(rech) > 0) &&
+      (strlen(middlel) > 0) &&
+      (strlen(recl) > 0))
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "(%s%s|%s|%s%s)",
-                         beforep, dots,
-                         middle,
-                         afterp, dots);
-      else
-        GNUNET_asprintf (&ret,
-                         "(%s|%s)%s",
-                         beforep,
-                         afterp,
-                         dots);
+      GNUNET_asprintf(&middle,
+                      "%s%s|%s%s",
+                      middlel,
+                      reclp,
+                      middleh,
+                      rechp);
     }
-    else
+  else if ((strlen(middleh) > 0) &&
+           (strlen(rech) > 0))
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "(%s|%s|%s)",
-                         before,
-                         middle,
-                         after);
-      else if (1 == step)
-        GNUNET_asprintf (&ret,
-                         "%s|%s",
-                         before,
-                         after);
-      else
-        GNUNET_asprintf (&ret,
-                         "(%s|%s)",
-                         before,
-                         after);
+      GNUNET_asprintf(&middle,
+                      "%s%s",
+                      middleh,
+                      rechp);
     }
-  }
-  else if (strlen (before) > 0)
-  {
-    if (strlen (dots) > 0)
+  else if ((strlen(middlel) > 0) &&
+           (strlen(recl) > 0))
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "(%s%s|%s)",
-                         beforep, dots,
-                         middle);
-      else
-        GNUNET_asprintf (&ret,
-                         "%s%s",
-                         beforep, dots);
+      GNUNET_asprintf(&middle,
+                      "%s%s",
+                      middlel,
+                      reclp);
     }
-    else
+  else
+    {
+      middle = GNUNET_strdup("");
+    }
+  if ((strlen(before) > 0) &&
+      (strlen(after) > 0))
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "(%s|%s)",
-                         before,
-                         middle);
+      if (strlen(dots) > 0)
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "(%s%s|%s|%s%s)",
+                            beforep, dots,
+                            middle,
+                            afterp, dots);
+          else
+            GNUNET_asprintf(&ret,
+                            "(%s|%s)%s",
+                            beforep,
+                            afterp,
+                            dots);
+        }
       else
-        GNUNET_asprintf (&ret,
-                         "%s",
-                         before);
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "(%s|%s|%s)",
+                            before,
+                            middle,
+                            after);
+          else if (1 == step)
+            GNUNET_asprintf(&ret,
+                            "%s|%s",
+                            before,
+                            after);
+          else
+            GNUNET_asprintf(&ret,
+                            "(%s|%s)",
+                            before,
+                            after);
+        }
     }
-  }
-  else if (strlen (after) > 0)
-  {
-    if (strlen (dots) > 0)
+  else if (strlen(before) > 0)
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "(%s|%s%s)",
-                         middle,
-                         afterp, dots);
+      if (strlen(dots) > 0)
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "(%s%s|%s)",
+                            beforep, dots,
+                            middle);
+          else
+            GNUNET_asprintf(&ret,
+                            "%s%s",
+                            beforep, dots);
+        }
       else
-        GNUNET_asprintf (&ret,
-                         "%s%s",
-                         afterp, dots);
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "(%s|%s)",
+                            before,
+                            middle);
+          else
+            GNUNET_asprintf(&ret,
+                            "%s",
+                            before);
+        }
     }
-    else
+  else if (strlen(after) > 0)
     {
-      if (strlen (middle) > 0)
-        GNUNET_asprintf (&ret,
-                         "%s|%s",
-                         middle,
-                         after);
+      if (strlen(dots) > 0)
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "(%s|%s%s)",
+                            middle,
+                            afterp, dots);
+          else
+            GNUNET_asprintf(&ret,
+                            "%s%s",
+                            afterp, dots);
+        }
       else
-        GNUNET_asprintf (&ret,
-                         "%s",
-                         after);
+        {
+          if (strlen(middle) > 0)
+            GNUNET_asprintf(&ret,
+                            "%s|%s",
+                            middle,
+                            after);
+          else
+            GNUNET_asprintf(&ret,
+                            "%s",
+                            after);
+        }
+    }
+  else if (strlen(middle) > 0)
+    {
+      GNUNET_asprintf(&ret,
+                      "%s",
+                      middle);
     }
-  }
-  else if (strlen (middle) > 0)
-  {
-    GNUNET_asprintf (&ret,
-                     "%s",
-                     middle);
-  }
   else
-  {
-    ret = GNUNET_strdup ("");
-  }
-  GNUNET_free (middle);
-  GNUNET_free (reclp);
-  GNUNET_free (rechp);
-  GNUNET_free (recl);
-  GNUNET_free (rech);
+    {
+      ret = GNUNET_strdup("");
+    }
+  GNUNET_free(middle);
+  GNUNET_free(reclp);
+  GNUNET_free(rechp);
+  GNUNET_free(recl);
+  GNUNET_free(rech);
   return ret;
 }
 
@@ -509,7 +517,7 @@ compute_policy (unsigned int start,
  * @return NULL on error
  */
 static char *
-port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
+port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp)
 {
   char *reg;
   char *ret;
@@ -517,57 +525,57 @@ port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
   unsigned int i;
   unsigned int cnt;
 
-  if ( (0 == pp->start_port) ||
-       ( (1 == pp->start_port) &&
-         (0xFFFF == pp->end_port) &&
-         (GNUNET_NO == pp->negate_portrange)) )
-    return GNUNET_strdup (DOT DOT DOT DOT);
-  if ( (pp->start_port == pp->end_port) &&
-       (GNUNET_NO == pp->negate_portrange))
-  {
-    GNUNET_asprintf (&ret,
-                     "%04X",
-                     pp->start_port);
-    return ret;
-  }
+  if ((0 == pp->start_port) ||
+      ((1 == pp->start_port) &&
+       (0xFFFF == pp->end_port) &&
+       (GNUNET_NO == pp->negate_portrange)))
+    return GNUNET_strdup(DOT DOT DOT DOT);
+  if ((pp->start_port == pp->end_port) &&
+      (GNUNET_NO == pp->negate_portrange))
+    {
+      GNUNET_asprintf(&ret,
+                      "%04X",
+                      pp->start_port);
+      return ret;
+    }
   if (pp->end_port < pp->start_port)
     return NULL;
 
   if (GNUNET_YES == pp->negate_portrange)
-  {
-    ret = compute_policy (0, 0xFFFF, 0x1000, pp);
-  }
+    {
+      ret = compute_policy(0, 0xFFFF, 0x1000, pp);
+    }
   else
-  {
-    cnt = pp->end_port - pp->start_port + 1;
-    reg = GNUNET_malloc (cnt * 5 + 1);
-    pos = reg;
-    for (i=1;i<=0xFFFF;i++)
     {
-      if ( (i >= pp->start_port) && (i <= pp->end_port) )
-      {
-        if (pos == reg)
+      cnt = pp->end_port - pp->start_port + 1;
+      reg = GNUNET_malloc(cnt * 5 + 1);
+      pos = reg;
+      for (i = 1; i <= 0xFFFF; i++)
         {
-          GNUNET_snprintf (pos,
-                           5,
-                           "%04X",
-                           i);
+          if ((i >= pp->start_port) && (i <= pp->end_port))
+            {
+              if (pos == reg)
+                {
+                  GNUNET_snprintf(pos,
+                                  5,
+                                  "%04X",
+                                  i);
+                }
+              else
+                {
+                  GNUNET_snprintf(pos,
+                                  6,
+                                  "|%04X",
+                                  i);
+                }
+              pos += strlen(pos);
+            }
         }
-        else
-        {
-          GNUNET_snprintf (pos,
-                           6,
-                           "|%04X",
-                           i);
-        }
-        pos += strlen (pos);
-      }
+      GNUNET_asprintf(&ret,
+                      "(%s)",
+                      reg);
+      GNUNET_free(reg);
     }
-    GNUNET_asprintf (&ret,
-                     "(%s)",
-                     reg);
-    GNUNET_free (reg);
-  }
   return ret;
 }
 
@@ -581,9 +589,9 @@ port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
  * @return NULL on error, otherwise regex for the address
  */
 static char *
-address_to_regex (const void *addr,
-                  const void *mask,
-                  size_t len)
+address_to_regex(const void *addr,
+                 const void *mask,
+                 size_t len)
 {
   const uint16_t *a = addr;
   const uint16_t *m = mask;
@@ -593,29 +601,29 @@ address_to_regex (const void *addr,
   unsigned int i;
 
   ret = NULL;
-  GNUNET_assert (1 != (len % 2));
-  for (i=0;i<len / 2;i++)
-  {
-    reg = num_to_regex (a[i], m[i]);
-    if (NULL == reg)
-    {
-      GNUNET_free_non_null (ret);
-      return NULL;
-    }
-    if (NULL == ret)
-    {
-      ret = reg;
-    }
-    else
+  GNUNET_assert(1 != (len % 2));
+  for (i = 0; i < len / 2; i++)
     {
-      GNUNET_asprintf (&tmp,
-                       "%s%s",
-                       ret, reg);
-      GNUNET_free (ret);
-      GNUNET_free (reg);
-      ret = tmp;
+      reg = num_to_regex(a[i], m[i]);
+      if (NULL == reg)
+        {
+          GNUNET_free_non_null(ret);
+          return NULL;
+        }
+      if (NULL == ret)
+        {
+          ret = reg;
+        }
+      else
+        {
+          GNUNET_asprintf(&tmp,
+                          "%s%s",
+                          ret, reg);
+          GNUNET_free(ret);
+          GNUNET_free(reg);
+          ret = tmp;
+        }
     }
-  }
   return ret;
 }
 
@@ -627,28 +635,28 @@ address_to_regex (const void *addr,
  * @return NULL on error
  */
 static char *
-ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
+ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
 {
   char *reg;
   char *pp;
   char *ret;
 
-  reg = address_to_regex (&v4->network,
-                          &v4->netmask,
-                          sizeof (struct in_addr));
+  reg = address_to_regex(&v4->network,
+                         &v4->netmask,
+                         sizeof(struct in_addr));
   if (NULL == reg)
     return NULL;
-  pp = port_to_regex (&v4->pp);
+  pp = port_to_regex(&v4->pp);
   if (NULL == pp)
-  {
-    GNUNET_free (reg);
-    return NULL;
-  }
-  GNUNET_asprintf (&ret,
-                   "4-%s-%s",
-                   pp, reg);
-  GNUNET_free (pp);
-  GNUNET_free (reg);
+    {
+      GNUNET_free(reg);
+      return NULL;
+    }
+  GNUNET_asprintf(&ret,
+                  "4-%s-%s",
+                  pp, reg);
+  GNUNET_free(pp);
+  GNUNET_free(reg);
   return ret;
 }
 
@@ -660,28 +668,28 @@ ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
  * @return NULL on error
  */
 static char *
-ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
+ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
 {
   char *reg;
   char *pp;
   char *ret;
 
-  reg = address_to_regex (&v6->network,
-                          &v6->netmask,
-                          sizeof (struct in6_addr));
+  reg = address_to_regex(&v6->network,
+                         &v6->netmask,
+                         sizeof(struct in6_addr));
   if (NULL == reg)
     return NULL;
-  pp = port_to_regex (&v6->pp);
+  pp = port_to_regex(&v6->pp);
   if (NULL == pp)
-  {
-    GNUNET_free (reg);
-    return NULL;
-  }
-  GNUNET_asprintf (&ret,
-                   "6-%s-%s",
-                   pp, reg);
-  GNUNET_free (pp);
-  GNUNET_free (reg);
+    {
+      GNUNET_free(reg);
+      return NULL;
+    }
+  GNUNET_asprintf(&ret,
+                  "6-%s-%s",
+                  pp, reg);
+  GNUNET_free(pp);
+  GNUNET_free(reg);
   return ret;
 }
 
@@ -696,7 +704,7 @@ ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
  * @return regular expression, NULL on error
  */
 char *
-GNUNET_TUN_ipv4policy2regex (const char *policy)
+GNUNET_TUN_ipv4policy2regex(const char *policy)
 {
   struct GNUNET_STRINGS_IPv4NetworkPolicy *np;
   char *reg;
@@ -704,36 +712,36 @@ GNUNET_TUN_ipv4policy2regex (const char *policy)
   char *line;
   unsigned int i;
 
-  np = GNUNET_STRINGS_parse_ipv4_policy (policy);
+  np = GNUNET_STRINGS_parse_ipv4_policy(policy);
   if (NULL == np)
     return NULL;
   reg = NULL;
-  for (i=0; (0 == i) || (0 != np[i].network.s_addr); i++)
-  {
-    line = ipv4_to_regex (&np[i]);
-    if (NULL == line)
-    {
-      GNUNET_free_non_null (reg);
-      GNUNET_free (np);
-      return NULL;
-    }
-    if (NULL == reg)
-    {
-      reg = line;
-    }
-    else
+  for (i = 0; (0 == i) || (0 != np[i].network.s_addr); i++)
     {
-      GNUNET_asprintf (&tmp,
-                       "%s|(%s)",
-                       reg, line);
-      GNUNET_free (reg);
-      GNUNET_free (line);
-      reg = tmp;
+      line = ipv4_to_regex(&np[i]);
+      if (NULL == line)
+        {
+          GNUNET_free_non_null(reg);
+          GNUNET_free(np);
+          return NULL;
+        }
+      if (NULL == reg)
+        {
+          reg = line;
+        }
+      else
+        {
+          GNUNET_asprintf(&tmp,
+                          "%s|(%s)",
+                          reg, line);
+          GNUNET_free(reg);
+          GNUNET_free(line);
+          reg = tmp;
+        }
+      if (0 == np[i].network.s_addr)
+        break;
     }
-    if (0 == np[i].network.s_addr)
-      break;
-  }
-  GNUNET_free (np);
+  GNUNET_free(np);
   return reg;
 }
 
@@ -748,7 +756,7 @@ GNUNET_TUN_ipv4policy2regex (const char *policy)
  * @return regular expression, NULL on error
  */
 char *
-GNUNET_TUN_ipv6policy2regex (const char *policy)
+GNUNET_TUN_ipv6policy2regex(const char *policy)
 {
   struct in6_addr zero;
   struct GNUNET_STRINGS_IPv6NetworkPolicy *np;
@@ -757,37 +765,37 @@ GNUNET_TUN_ipv6policy2regex (const char *policy)
   char *line;
   unsigned int i;
 
-  np = GNUNET_STRINGS_parse_ipv6_policy (policy);
+  np = GNUNET_STRINGS_parse_ipv6_policy(policy);
   if (NULL == np)
     return NULL;
   reg = NULL;
-  memset (&zero, 0, sizeof (struct in6_addr));
-  for (i=0; (0 == i) || (0 != memcmp (&zero, &np[i].network, sizeof (struct in6_addr))); i++)
-  {
-    line = ipv6_to_regex (&np[i]);
-    if (NULL == line)
+  memset(&zero, 0, sizeof(struct in6_addr));
+  for (i = 0; (0 == i) || (0 != memcmp(&zero, &np[i].network, sizeof(struct in6_addr))); i++)
     {
-      GNUNET_free_non_null (reg);
-      GNUNET_free (np);
-      return NULL;
-    }
-    if (NULL == reg)
-    {
-      reg = line;
-    }
-    else
-    {
-      GNUNET_asprintf (&tmp,
-                       "%s|(%s)",
-                       reg, line);
-      GNUNET_free (reg);
-      GNUNET_free (line);
-      reg = tmp;
+      line = ipv6_to_regex(&np[i]);
+      if (NULL == line)
+        {
+          GNUNET_free_non_null(reg);
+          GNUNET_free(np);
+          return NULL;
+        }
+      if (NULL == reg)
+        {
+          reg = line;
+        }
+      else
+        {
+          GNUNET_asprintf(&tmp,
+                          "%s|(%s)",
+                          reg, line);
+          GNUNET_free(reg);
+          GNUNET_free(line);
+          reg = tmp;
+        }
+      if (0 == memcmp(&zero, &np[i].network, sizeof(struct in6_addr)))
+        break;
     }
-    if (0 == memcmp (&zero, &np[i].network, sizeof (struct in6_addr)))
-      break;
-  }
-  GNUNET_free (np);
+  GNUNET_free(np);
   return reg;
 }
 
@@ -801,12 +809,12 @@ GNUNET_TUN_ipv6policy2regex (const char *policy)
  * @param hc corresponding hash
  */
 void
-GNUNET_TUN_service_name_to_hash (const char *service_name,
-                                 struct GNUNET_HashCode *hc)
+GNUNET_TUN_service_name_to_hash(const char *service_name,
+                                struct GNUNET_HashCode *hc)
 {
-  GNUNET_CRYPTO_hash (service_name,
-                      strlen (service_name),
-                      hc);
+  GNUNET_CRYPTO_hash(service_name,
+                     strlen(service_name),
+                     hc);
 }
 
 
@@ -820,16 +828,16 @@ GNUNET_TUN_service_name_to_hash (const char *service_name,
  * @param[out] cadet_port CADET port to use
  */
 void
-GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
-                                       uint16_t ip_port,
-                                       struct GNUNET_HashCode *cadet_port)
+GNUNET_TUN_compute_service_cadet_port(const struct GNUNET_HashCode *desc,
+                                      uint16_t ip_port,
+                                      struct GNUNET_HashCode *cadet_port)
 {
-  uint16_t be_port = htons (ip_port);
+  uint16_t be_port = htons(ip_port);
 
   *cadet_port = *desc;
-  GNUNET_memcpy (cadet_port,
-                 &be_port,
-                 sizeof (uint16_t));
+  GNUNET_memcpy(cadet_port,
+                &be_port,
+                sizeof(uint16_t));
 }
 
 
diff --git a/src/util/resolver.h b/src/util/resolver.h
index 0991ad39f..9b75b0c66 100644
--- a/src/util/resolver.h
+++ b/src/util/resolver.h
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -40,8 +40,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * will just be a header without any data (used to indicate the end of
  * the list).
  */
-struct GNUNET_RESOLVER_GetMessage
-{
+struct GNUNET_RESOLVER_GetMessage {
   /**
    * Type:  #GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST
    */
@@ -66,12 +65,10 @@ struct GNUNET_RESOLVER_GetMessage
 
   /* followed by 0-terminated string for A/AAAA-lookup or
      by 'struct in_addr' / 'struct in6_addr' for reverse lookup */
-
 };
 
 
-struct GNUNET_RESOLVER_ResponseMessage
-{
+struct GNUNET_RESOLVER_ResponseMessage {
   /**
    * Type: #GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE
    */
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index 78ce222e6..6c56786b0 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.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 util/resolver_api.c
@@ -29,9 +29,9 @@
 #include "gnunet_resolver_service.h"
 #include "resolver.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-resolver-api", __VA_ARGS__)
 
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-resolver-api", syscall)
+#define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror(kind, "util-resolver-api", syscall)
 
 /**
  * Maximum supported length for a hostname
@@ -97,9 +97,7 @@ static struct GNUNET_SCHEDULER_Task *s_task;
  * the request prior to the timeout or successful execution.  Also
  * used to track our internal state for the request.
  */
-struct GNUNET_RESOLVER_RequestHandle
-{
-
+struct GNUNET_RESOLVER_RequestHandle {
   /**
    * Next entry in DLL of requests.
    */
@@ -186,61 +184,61 @@ struct GNUNET_RESOLVER_RequestHandle
  *         #GNUNET_SYSERR otherwise.
  */
 static int
-check_config ()
+check_config()
 {
   char *hostname;
   struct sockaddr_in v4;
   struct sockaddr_in6 v6;
 
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_have_value (resolver_cfg,
-                                       "resolver",
-                                       "UNIXPATH"))
+      GNUNET_CONFIGURATION_have_value(resolver_cfg,
+                                      "resolver",
+                                      "UNIXPATH"))
     return GNUNET_OK;
-  memset (&v4, 0, sizeof (v4));
-  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  memset(&v4, 0, sizeof(v4));
+  v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   v4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v4.sin_len = sizeof (v4);
+  v4.sin_len = sizeof(v4);
 #endif
-  memset (&v6, 0, sizeof (v6));
+  memset(&v6, 0, sizeof(v6));
   v6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v6.sin6_len = sizeof (v6);
+  v6.sin6_len = sizeof(v6);
 #endif
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
-                                             "resolver",
-                                             "HOSTNAME",
-                                             &hostname))
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
-         "HOSTNAME",
-         "resolver");
-    return GNUNET_SYSERR;
-  }
-  if ( (1 == inet_pton (AF_INET, hostname, &v4)) ||
-       (1 == inet_pton (AF_INET6, hostname, &v6)) )
-  {
-    GNUNET_free (hostname);
-    return GNUNET_OK;
-  }
-  for (unsigned int i = 0;
-       NULL != loopback[i];
-       i++)
-    if (0 == strcasecmp (loopback[i],
-                         hostname))
+      GNUNET_CONFIGURATION_get_value_string(resolver_cfg,
+                                            "resolver",
+                                            "HOSTNAME",
+                                            &hostname))
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
+          "HOSTNAME",
+          "resolver");
+      return GNUNET_SYSERR;
+    }
+  if ((1 == inet_pton(AF_INET, hostname, &v4)) ||
+      (1 == inet_pton(AF_INET6, hostname, &v6)))
     {
-      GNUNET_free (hostname);
+      GNUNET_free(hostname);
       return GNUNET_OK;
     }
-  LOG (GNUNET_ERROR_TYPE_INFO,
-       _("Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
-       "localhost",
-       "HOSTNAME",
-       "resolver");
-  GNUNET_free (hostname);
+  for (unsigned int i = 0;
+       NULL != loopback[i];
+       i++)
+    if (0 == strcasecmp(loopback[i],
+                        hostname))
+      {
+        GNUNET_free(hostname);
+        return GNUNET_OK;
+      }
+  LOG(GNUNET_ERROR_TYPE_INFO,
+      _("Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
+      "localhost",
+      "HOSTNAME",
+      "resolver");
+  GNUNET_free(hostname);
   return GNUNET_SYSERR;
 }
 
@@ -251,9 +249,9 @@ check_config ()
  * @param cfg configuration to use
  */
 void
-GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_RESOLVER_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_assert (NULL != cfg);
+  GNUNET_assert(NULL != cfg);
   backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   resolver_cfg = cfg;
 }
@@ -263,35 +261,35 @@ GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * Destroy the connection to the resolver service.
  */
 void
-GNUNET_RESOLVER_disconnect ()
+GNUNET_RESOLVER_disconnect()
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
 
   while (NULL != (rh = req_head))
-  {
-    GNUNET_assert (GNUNET_SYSERR == rh->was_transmitted);
-    GNUNET_CONTAINER_DLL_remove (req_head,
-                                 req_tail,
-                                 rh);
-    GNUNET_free (rh);
-  }
+    {
+      GNUNET_assert(GNUNET_SYSERR == rh->was_transmitted);
+      GNUNET_CONTAINER_DLL_remove(req_head,
+                                  req_tail,
+                                  rh);
+      GNUNET_free(rh);
+    }
   if (NULL != mq)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Disconnecting from DNS service\n");
-    GNUNET_MQ_destroy (mq);
-    mq = NULL;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Disconnecting from DNS service\n");
+      GNUNET_MQ_destroy(mq);
+      mq = NULL;
+    }
   if (NULL != r_task)
-  {
-    GNUNET_SCHEDULER_cancel (r_task);
-    r_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(r_task);
+      r_task = NULL;
+    }
   if (NULL != s_task)
-  {
-    GNUNET_SCHEDULER_cancel (s_task);
-    s_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(s_task);
+      s_task = NULL;
+    }
 }
 
 
@@ -299,11 +297,11 @@ GNUNET_RESOLVER_disconnect ()
  * Task executed on system shutdown.
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) cls;
+  (void)cls;
   s_task = NULL;
-  GNUNET_RESOLVER_disconnect ();
+  GNUNET_RESOLVER_disconnect();
   backoff = GNUNET_TIME_UNIT_MILLISECONDS;
 }
 
@@ -312,7 +310,7 @@ shutdown_task (void *cls)
  * Consider disconnecting if we have no further requests pending.
  */
 static void
-check_disconnect ()
+check_disconnect()
 {
   for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
        NULL != rh;
@@ -320,15 +318,15 @@ check_disconnect ()
     if (GNUNET_SYSERR != rh->was_transmitted)
       return;
   if (NULL != r_task)
-  {
-    GNUNET_SCHEDULER_cancel (r_task);
-    r_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(r_task);
+      r_task = NULL;
+    }
   if (NULL != s_task)
     return;
-  s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                         &shutdown_task,
-                                         NULL);
+  s_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS,
+                                        &shutdown_task,
+                                        NULL);
 }
 
 
@@ -341,47 +339,49 @@ check_disconnect ()
  * @return address as a string, NULL on error
  */
 static char *
-no_resolve (int af,
-            const void *ip,
-            socklen_t ip_len)
+no_resolve(int af,
+           const void *ip,
+           socklen_t ip_len)
 {
   char buf[INET6_ADDRSTRLEN];
 
   switch (af)
-  {
-  case AF_INET:
-    if (ip_len != sizeof (struct in_addr))
-      return NULL;
-    if (NULL ==
-        inet_ntop (AF_INET,
-                   ip,
-                   buf,
-                   sizeof (buf)))
     {
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                    "inet_ntop");
-      return NULL;
-    }
-    break;
-  case AF_INET6:
-    if (ip_len != sizeof (struct in6_addr))
-      return NULL;
-    if (NULL ==
-        inet_ntop (AF_INET6,
-                   ip,
-                   buf,
-                   sizeof (buf)))
-    {
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                    "inet_ntop");
+    case AF_INET:
+      if (ip_len != sizeof(struct in_addr))
+        return NULL;
+      if (NULL ==
+          inet_ntop(AF_INET,
+                    ip,
+                    buf,
+                    sizeof(buf)))
+        {
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                       "inet_ntop");
+          return NULL;
+        }
+      break;
+
+    case AF_INET6:
+      if (ip_len != sizeof(struct in6_addr))
+        return NULL;
+      if (NULL ==
+          inet_ntop(AF_INET6,
+                    ip,
+                    buf,
+                    sizeof(buf)))
+        {
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                       "inet_ntop");
+          return NULL;
+        }
+      break;
+
+    default:
+      GNUNET_break(0);
       return NULL;
     }
-    break;
-  default:
-    GNUNET_break (0);
-    return NULL;
-  }
-  return GNUNET_strdup (buf);
+  return GNUNET_strdup(buf);
 }
 
 
@@ -389,7 +389,7 @@ no_resolve (int af,
  * Adjust exponential back-off and reconnect to the service.
  */
 static void
-reconnect (void);
+reconnect(void);
 
 
 /**
@@ -401,16 +401,16 @@ reconnect (void);
  * @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)
 {
-  (void) cls;
-  GNUNET_MQ_destroy (mq);
+  (void)cls;
+  GNUNET_MQ_destroy(mq);
   mq = NULL;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "MQ error %d, reconnecting\n",
-       error);
-  reconnect ();
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "MQ error %d, reconnecting\n",
+      error);
+  reconnect();
 }
 
 
@@ -418,44 +418,44 @@ mq_error_handler (void *cls,
  * Process pending requests to the resolver.
  */
 static void
-process_requests ()
+process_requests()
 {
   struct GNUNET_RESOLVER_GetMessage *msg;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
 
   if (NULL == mq)
-  {
-    reconnect ();
-    return;
-  }
+    {
+      reconnect();
+      return;
+    }
   if (NULL == rh)
-  {
-    /* nothing to do, release socket really soon if there is nothing
-     * else happening... */
-    if (NULL == s_task)
-      s_task =
-        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                      &shutdown_task,
-                                      NULL);
-    return;
-  }
+    {
+      /* nothing to do, release socket really soon if there is nothing
+       * else happening... */
+      if (NULL == s_task)
+        s_task =
+          GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS,
+                                       &shutdown_task,
+                                       NULL);
+      return;
+    }
   if (GNUNET_NO != rh->was_transmitted)
     return;                     /* waiting for reply */
-  env = GNUNET_MQ_msg_extra (msg,
-                             rh->data_len,
-                             GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
-  msg->direction = htonl (rh->direction);
-  msg->af = htonl (rh->af);
+  env = GNUNET_MQ_msg_extra(msg,
+                            rh->data_len,
+                            GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
+  msg->direction = htonl(rh->direction);
+  msg->af = htonl(rh->af);
   msg->client_id = rh->id;
-  GNUNET_memcpy (&msg[1],
-                 &rh[1],
-                 rh->data_len);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Transmitting DNS resolution request (ID %u) to DNS service\n",
-       rh->id);
-  GNUNET_MQ_send (mq,
-                  env);
+  GNUNET_memcpy(&msg[1],
+                &rh[1],
+                rh->data_len);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Transmitting DNS resolution request (ID %u) to DNS service\n",
+      rh->id);
+  GNUNET_MQ_send(mq,
+                 env);
   rh->was_transmitted = GNUNET_YES;
 }
 
@@ -467,11 +467,11 @@ process_requests ()
  * @param msg message with the hostname
  */
 static int
-check_response (void *cls,
-                const struct GNUNET_RESOLVER_ResponseMessage *msg)
+check_response(void *cls,
+               const struct GNUNET_RESOLVER_ResponseMessage *msg)
 {
-  (void) cls;
-  (void) msg;
+  (void)cls;
+  (void)msg;
 
   /* implemented in #handle_response() for now */
   return GNUNET_OK;
@@ -487,8 +487,8 @@ check_response (void *cls,
  * @param msg message with the response
  */
 static void
-handle_response (void *cls,
-                 const struct GNUNET_RESOLVER_ResponseMessage *msg)
+handle_response(void *cls,
+                const struct GNUNET_RESOLVER_ResponseMessage *msg)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
   uint16_t size;
@@ -496,141 +496,141 @@ handle_response (void *cls,
   uint32_t client_request_id = msg->client_id;
 
   for (; rh != NULL; rh = rh->next)
-  {
-    if (rh->id == client_request_id)
-      break;
-  }
+    {
+      if (rh->id == client_request_id)
+        break;
+    }
 
-  (void) cls;
+  (void)cls;
   if (NULL == rh)
-  {
-    /* Resolver service sent extra replies to query (after terminator)? Bad! */
-    GNUNET_break (0);
-    GNUNET_MQ_destroy (mq);
-    mq = NULL;
-    reconnect ();
-    return;
-  }
-  size = ntohs (msg->header.size);
-  if (size == sizeof (struct GNUNET_RESOLVER_ResponseMessage))
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Received empty response from DNS service\n");
-    /* message contains not data, just header; end of replies */
-    /* check if request was canceled */
-    if (GNUNET_SYSERR != rh->was_transmitted)
     {
-      /* no reverse lookup was successful, return IP as string */
-      if (NULL != rh->name_callback)
-      {
-        if (GNUNET_NO == rh->received_response)
-        {
-          nret = no_resolve (rh->af,
-                             &rh[1],
-                             rh->data_len);
-          rh->name_callback (rh->cls, nret);
-          GNUNET_free (nret);
-        }
-        /* finally, make termination call */
-        if (GNUNET_SYSERR != rh->was_transmitted)
-          rh->name_callback (rh->cls,
-                             NULL);
-      }
-      if ( (NULL != rh->addr_callback) &&
-           (GNUNET_SYSERR != rh->was_transmitted) )
-          rh->addr_callback (rh->cls,
-                             NULL,
-                             0);
+      /* Resolver service sent extra replies to query (after terminator)? Bad! */
+      GNUNET_break(0);
+      GNUNET_MQ_destroy(mq);
+      mq = NULL;
+      reconnect();
+      return;
     }
-    rh->was_transmitted = GNUNET_NO;
-    GNUNET_RESOLVER_request_cancel (rh);
-    process_requests ();
-    return;
-  }
-  /* return reverse lookup results to caller */
-  if (NULL != rh->name_callback)
-  {
-    const char *hostname;
-
-    hostname = (const char *) &msg[1];
-    if (hostname[size - sizeof (struct GNUNET_RESOLVER_ResponseMessage) - 1] != '\0')
+  size = ntohs(msg->header.size);
+  if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
     {
-      GNUNET_break (0);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Received empty response from DNS service\n");
+      /* message contains not data, just header; end of replies */
+      /* check if request was canceled */
       if (GNUNET_SYSERR != rh->was_transmitted)
-        rh->name_callback (rh->cls,
-                           NULL);
+        {
+          /* no reverse lookup was successful, return IP as string */
+          if (NULL != rh->name_callback)
+            {
+              if (GNUNET_NO == rh->received_response)
+                {
+                  nret = no_resolve(rh->af,
+                                    &rh[1],
+                                    rh->data_len);
+                  rh->name_callback(rh->cls, nret);
+                  GNUNET_free(nret);
+                }
+              /* finally, make termination call */
+              if (GNUNET_SYSERR != rh->was_transmitted)
+                rh->name_callback(rh->cls,
+                                  NULL);
+            }
+          if ((NULL != rh->addr_callback) &&
+              (GNUNET_SYSERR != rh->was_transmitted))
+            rh->addr_callback(rh->cls,
+                              NULL,
+                              0);
+        }
       rh->was_transmitted = GNUNET_NO;
-      GNUNET_RESOLVER_request_cancel (rh);
-      GNUNET_MQ_destroy (mq);
-      mq = NULL;
-      reconnect ();
+      GNUNET_RESOLVER_request_cancel(rh);
+      process_requests();
       return;
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Resolver returns `%s' for IP `%s'.\n",
-         hostname,
-         GNUNET_a2s ((const void *) &rh[1],
+  /* return reverse lookup results to caller */
+  if (NULL != rh->name_callback)
+    {
+      const char *hostname;
+
+      hostname = (const char *)&msg[1];
+      if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] != '\0')
+        {
+          GNUNET_break(0);
+          if (GNUNET_SYSERR != rh->was_transmitted)
+            rh->name_callback(rh->cls,
+                              NULL);
+          rh->was_transmitted = GNUNET_NO;
+          GNUNET_RESOLVER_request_cancel(rh);
+          GNUNET_MQ_destroy(mq);
+          mq = NULL;
+          reconnect();
+          return;
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Resolver returns `%s' for IP `%s'.\n",
+          hostname,
+          GNUNET_a2s((const void *)&rh[1],
                      rh->data_len));
-    if (rh->was_transmitted != GNUNET_SYSERR)
-      rh->name_callback (rh->cls,
-                         hostname);
-    rh->received_response = GNUNET_YES;
-  }
+      if (rh->was_transmitted != GNUNET_SYSERR)
+        rh->name_callback(rh->cls,
+                          hostname);
+      rh->received_response = GNUNET_YES;
+    }
   /* return lookup results to caller */
   if (NULL != rh->addr_callback)
-  {
-    struct sockaddr_in v4;
-    struct sockaddr_in6 v6;
-    const struct sockaddr *sa;
-    socklen_t salen;
-    const void *ip;
-    size_t ip_len;
-
-    ip = &msg[1];
-    ip_len = size - sizeof (struct GNUNET_RESOLVER_ResponseMessage);
-    if (ip_len == sizeof (struct in_addr))
     {
-      memset (&v4, 0, sizeof (v4));
-      v4.sin_family = AF_INET;
-      v4.sin_addr = *(struct in_addr*) ip;
+      struct sockaddr_in v4;
+      struct sockaddr_in6 v6;
+      const struct sockaddr *sa;
+      socklen_t salen;
+      const void *ip;
+      size_t ip_len;
+
+      ip = &msg[1];
+      ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
+      if (ip_len == sizeof(struct in_addr))
+        {
+          memset(&v4, 0, sizeof(v4));
+          v4.sin_family = AF_INET;
+          v4.sin_addr = *(struct in_addr*)ip;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v4.sin_len = sizeof (v4);
+          v4.sin_len = sizeof(v4);
 #endif
-      salen = sizeof (v4);
-      sa = (const struct sockaddr *) &v4;
-    }
-    else if (ip_len == sizeof (struct in6_addr))
-    {
-      memset (&v6, 0, sizeof (v6));
-      v6.sin6_family = AF_INET6;
-      v6.sin6_addr = *(struct in6_addr*) ip;
+          salen = sizeof(v4);
+          sa = (const struct sockaddr *)&v4;
+        }
+      else if (ip_len == sizeof(struct in6_addr))
+        {
+          memset(&v6, 0, sizeof(v6));
+          v6.sin6_family = AF_INET6;
+          v6.sin6_addr = *(struct in6_addr*)ip;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v6.sin6_len = sizeof (v6);
+          v6.sin6_len = sizeof(v6);
 #endif
-      salen = sizeof (v6);
-      sa = (const struct sockaddr *) &v6;
-    }
-    else
-    {
-      GNUNET_break (0);
+          salen = sizeof(v6);
+          sa = (const struct sockaddr *)&v6;
+        }
+      else
+        {
+          GNUNET_break(0);
+          if (GNUNET_SYSERR != rh->was_transmitted)
+            rh->addr_callback(rh->cls,
+                              NULL,
+                              0);
+          rh->was_transmitted = GNUNET_NO;
+          GNUNET_RESOLVER_request_cancel(rh);
+          GNUNET_MQ_destroy(mq);
+          mq = NULL;
+          reconnect();
+          return;
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Received IP from DNS service\n");
       if (GNUNET_SYSERR != rh->was_transmitted)
-        rh->addr_callback (rh->cls,
-                           NULL,
-                           0);
-      rh->was_transmitted = GNUNET_NO;
-      GNUNET_RESOLVER_request_cancel (rh);
-      GNUNET_MQ_destroy (mq);
-      mq = NULL;
-      reconnect ();
-      return;
+        rh->addr_callback(rh->cls,
+                          sa,
+                          salen);
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Received IP from DNS service\n");
-    if (GNUNET_SYSERR != rh->was_transmitted)
-      rh->addr_callback (rh->cls,
-                         sa,
-                         salen);
-  }
 }
 
 
@@ -642,7 +642,7 @@ handle_response (void *cls,
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
  */
 static void
-numeric_resolution (void *cls)
+numeric_resolution(void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   struct sockaddr_in v4;
@@ -650,63 +650,63 @@ numeric_resolution (void *cls)
   const char *hostname;
 
   rh->task = NULL;
-  memset (&v4, 0, sizeof (v4));
+  memset(&v4, 0, sizeof(v4));
   v4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v4.sin_len = sizeof (v4);
+  v4.sin_len = sizeof(v4);
 #endif
-  memset (&v6, 0, sizeof (v6));
+  memset(&v6, 0, sizeof(v6));
   v6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v6.sin6_len = sizeof (v6);
+  v6.sin6_len = sizeof(v6);
 #endif
-  hostname = (const char *) &rh[1];
-  if ( ( (rh->af == AF_UNSPEC) ||
-         (rh->af == AF_INET) ) &&
-       (1 == inet_pton (AF_INET,
-                        hostname,
-                        &v4.sin_addr)) )
-  {
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v4,
-                       sizeof (v4));
-    if ( (rh->af == AF_UNSPEC) &&
-         (GNUNET_SYSERR != rh->was_transmitted) &&
-         (1 == inet_pton (AF_INET6,
-                          hostname,
-                          &v6.sin6_addr)) )
+  hostname = (const char *)&rh[1];
+  if (((rh->af == AF_UNSPEC) ||
+       (rh->af == AF_INET)) &&
+      (1 == inet_pton(AF_INET,
+                      hostname,
+                      &v4.sin_addr)))
     {
-      /* this can happen on some systems IF "hostname" is "localhost" */
-      rh->addr_callback (rh->cls,
-                         (const struct sockaddr *) &v6,
-                         sizeof (v6));
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v4,
+                        sizeof(v4));
+      if ((rh->af == AF_UNSPEC) &&
+          (GNUNET_SYSERR != rh->was_transmitted) &&
+          (1 == inet_pton(AF_INET6,
+                          hostname,
+                          &v6.sin6_addr)))
+        {
+          /* this can happen on some systems IF "hostname" is "localhost" */
+          rh->addr_callback(rh->cls,
+                            (const struct sockaddr *)&v6,
+                            sizeof(v6));
+        }
+      if (GNUNET_SYSERR != rh->was_transmitted)
+        rh->addr_callback(rh->cls,
+                          NULL,
+                          0);
+      GNUNET_free(rh);
+      return;
+    }
+  if (((rh->af == AF_UNSPEC) ||
+       (rh->af == AF_INET6)) &&
+      (1 == inet_pton(AF_INET6,
+                      hostname,
+                      &v6.sin6_addr)))
+    {
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v6,
+                        sizeof(v6));
+      if (GNUNET_SYSERR != rh->was_transmitted)
+        rh->addr_callback(rh->cls,
+                          NULL,
+                          0);
+      GNUNET_free(rh);
+      return;
     }
-    if (GNUNET_SYSERR != rh->was_transmitted)
-      rh->addr_callback (rh->cls,
-                         NULL,
-                         0);
-    GNUNET_free (rh);
-    return;
-  }
-  if ( ( (rh->af == AF_UNSPEC) ||
-         (rh->af == AF_INET6) ) &&
-       (1 == inet_pton (AF_INET6,
-                        hostname,
-                        &v6.sin6_addr) ) )
-  {
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v6,
-                       sizeof (v6));
-    if (GNUNET_SYSERR != rh->was_transmitted)
-      rh->addr_callback (rh->cls,
-                         NULL,
-                         0);
-    GNUNET_free (rh);
-    return;
-  }
   /* why are we here? this task should not have been scheduled! */
-  GNUNET_assert (0);
-  GNUNET_free (rh);
+  GNUNET_assert(0);
+  GNUNET_free(rh);
 }
 
 
@@ -718,58 +718,61 @@ numeric_resolution (void *cls)
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
  */
 static void
-loopback_resolution (void *cls)
+loopback_resolution(void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   struct sockaddr_in v4;
   struct sockaddr_in6 v6;
 
   rh->task = NULL;
-  memset (&v4, 0, sizeof (v4));
-  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  memset(&v4, 0, sizeof(v4));
+  v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   v4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v4.sin_len = sizeof (v4);
+  v4.sin_len = sizeof(v4);
 #endif
-  memset (&v6, 0, sizeof (v6));
+  memset(&v6, 0, sizeof(v6));
   v6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  v6.sin6_len = sizeof (v6);
+  v6.sin6_len = sizeof(v6);
 #endif
   v6.sin6_addr = in6addr_loopback;
   switch (rh->af)
-  {
-  case AF_INET:
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v4,
-                       sizeof (v4));
-    break;
-  case AF_INET6:
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v6,
-                       sizeof (v6));
-    break;
-  case AF_UNSPEC:
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v6,
-                       sizeof (v6));
-    rh->addr_callback (rh->cls,
-                       (const struct sockaddr *) &v4,
-                       sizeof (v4));
-
-    break;
-  default:
-    GNUNET_break (0);
-    break;
-  }
+    {
+    case AF_INET:
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v4,
+                        sizeof(v4));
+      break;
+
+    case AF_INET6:
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v6,
+                        sizeof(v6));
+      break;
+
+    case AF_UNSPEC:
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v6,
+                        sizeof(v6));
+      rh->addr_callback(rh->cls,
+                        (const struct sockaddr *)&v4,
+                        sizeof(v4));
+
+      break;
+
+    default:
+      GNUNET_break(0);
+      break;
+    }
   if (GNUNET_SYSERR != rh->was_transmitted)
-    rh->addr_callback (rh->cls,
-                       NULL,
-                       0);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Finished resolving hostname `%s'.\n",
-       (const char *) &rh[1]);
-  GNUNET_free (rh);
+    rh->addr_callback(rh->cls,
+                      NULL,
+                      0);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Finished resolving hostname `%s'.\n",
+      (const char *)&rh[1]);
+  GNUNET_free(rh);
 }
 
 
@@ -779,35 +782,35 @@ loopback_resolution (void *cls)
  * @param cls NULL
  */
 static void
-reconnect_task (void *cls)
+reconnect_task(void *cls)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (response,
-                           GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
-                           struct GNUNET_RESOLVER_ResponseMessage,
-                           NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_var_size(response,
+                          GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
+                          struct GNUNET_RESOLVER_ResponseMessage,
+                          NULL),
+    GNUNET_MQ_handler_end()
   };
 
-  (void) cls;
+  (void)cls;
   r_task = NULL;
   if (NULL == req_head)
     return;                     /* no work pending */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Trying to connect to DNS service\n");
-  mq = GNUNET_CLIENT_connect (resolver_cfg,
-                              "resolver",
-                              handlers,
-                              &mq_error_handler,
-                              NULL);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to connect to DNS service\n");
+  mq = GNUNET_CLIENT_connect(resolver_cfg,
+                             "resolver",
+                             handlers,
+                             &mq_error_handler,
+                             NULL);
   if (NULL == mq)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Failed to connect, will try again later\n");
-    reconnect ();
-    return;
-  }
-  process_requests ();
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Failed to connect, will try again later\n");
+      reconnect();
+      return;
+    }
+  process_requests();
 }
 
 
@@ -815,46 +818,49 @@ reconnect_task (void *cls)
  * Adjust exponential back-off and reconnect to the service.
  */
 static void
-reconnect ()
+reconnect()
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
 
   if (NULL != r_task)
     return;
-  GNUNET_assert (NULL == mq);
+  GNUNET_assert(NULL == mq);
   if (NULL != (rh = req_head))
-  {
-    switch (rh->was_transmitted)
     {
-    case GNUNET_NO:
-      /* nothing more to do */
-      break;
-    case GNUNET_YES:
-      /* disconnected, transmit again! */
-      rh->was_transmitted = GNUNET_NO;
-      break;
-    case GNUNET_SYSERR:
-      /* request was cancelled, remove entirely */
-      GNUNET_CONTAINER_DLL_remove (req_head,
-                                   req_tail,
-                                   rh);
-      GNUNET_free (rh);
-      check_disconnect ();
-      break;
-    default:
-      GNUNET_assert (0);
-      break;
+      switch (rh->was_transmitted)
+        {
+        case GNUNET_NO:
+          /* nothing more to do */
+          break;
+
+        case GNUNET_YES:
+          /* disconnected, transmit again! */
+          rh->was_transmitted = GNUNET_NO;
+          break;
+
+        case GNUNET_SYSERR:
+          /* request was cancelled, remove entirely */
+          GNUNET_CONTAINER_DLL_remove(req_head,
+                                      req_tail,
+                                      rh);
+          GNUNET_free(rh);
+          check_disconnect();
+          break;
+
+        default:
+          GNUNET_assert(0);
+          break;
+        }
     }
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Will try to connect to DNS service in %s\n",
-       GNUNET_STRINGS_relative_time_to_string (backoff,
-                                               GNUNET_YES));
-  GNUNET_assert (NULL != resolver_cfg);
-  r_task = GNUNET_SCHEDULER_add_delayed (backoff,
-                                         &reconnect_task,
-                                         NULL);
-  backoff = GNUNET_TIME_STD_BACKOFF (backoff);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Will try to connect to DNS service in %s\n",
+      GNUNET_STRINGS_relative_time_to_string(backoff,
+                                             GNUNET_YES));
+  GNUNET_assert(NULL != resolver_cfg);
+  r_task = GNUNET_SCHEDULER_add_delayed(backoff,
+                                        &reconnect_task,
+                                        NULL);
+  backoff = GNUNET_TIME_STD_BACKOFF(backoff);
 }
 
 
@@ -864,52 +870,52 @@ reconnect ()
  * @param cls the `struct GNUNET_RESOLVER_RequestHandle *`
  */
 static void
-handle_lookup_timeout (void *cls)
+handle_lookup_timeout(void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
 
   rh->task = NULL;
   if (GNUNET_NO == rh->direction)
-  {
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Timeout trying to resolve hostname `%s'.\n"),
-         (const char *) &rh[1]);
-    if (NULL != rh->addr_callback)
-      rh->addr_callback (rh->cls,
-                         NULL,
-                         0);
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Timeout trying to resolve hostname `%s'.\n"),
+          (const char *)&rh[1]);
+      if (NULL != rh->addr_callback)
+        rh->addr_callback(rh->cls,
+                          NULL,
+                          0);
+    }
   else
-  {
+    {
 #if !defined(GNUNET_CULL_LOGGING)
-    char buf[INET6_ADDRSTRLEN];
+      char buf[INET6_ADDRSTRLEN];
 
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Timeout trying to resolve IP address `%s'.\n"),
-         inet_ntop (rh->af,
-                    (const void *) &rh[1],
+      LOG(GNUNET_ERROR_TYPE_INFO,
+          _("Timeout trying to resolve IP address `%s'.\n"),
+          inet_ntop(rh->af,
+                    (const void *)&rh[1],
                     buf,
                     sizeof(buf)));
 #endif
-    if (GNUNET_NO == rh->received_response)
-    {
-      char *nret;
-
-      nret = no_resolve (rh->af,
-                         &rh[1],
-                         rh->data_len);
+      if (GNUNET_NO == rh->received_response)
+        {
+          char *nret;
+
+          nret = no_resolve(rh->af,
+                            &rh[1],
+                            rh->data_len);
+          if (NULL != rh->name_callback)
+            rh->name_callback(rh->cls, nret);
+          GNUNET_free(nret);
+        }
+      /* finally, make termination call */
       if (NULL != rh->name_callback)
-        rh->name_callback (rh->cls, nret);
-      GNUNET_free (nret);
+        rh->name_callback(rh->cls,
+                          NULL);
     }
-    /* finally, make termination call */
-    if (NULL != rh->name_callback)
-      rh->name_callback (rh->cls,
-                         NULL);
-  }
   rh->was_transmitted = GNUNET_NO;
-  GNUNET_RESOLVER_request_cancel (rh);
-  process_requests ();
+  GNUNET_RESOLVER_request_cancel(rh);
+  process_requests();
 }
 
 
@@ -924,83 +930,83 @@ handle_lookup_timeout (void *cls)
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (const char *hostname,
-                        int af,
-                        struct GNUNET_TIME_Relative timeout,
-                        GNUNET_RESOLVER_AddressCallback callback,
-                        void *callback_cls)
+GNUNET_RESOLVER_ip_get(const char *hostname,
+                       int af,
+                       struct GNUNET_TIME_Relative timeout,
+                       GNUNET_RESOLVER_AddressCallback callback,
+                       void *callback_cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
   size_t slen;
   struct in_addr v4;
   struct in6_addr v6;
 
-  slen = strlen (hostname) + 1;
-  if (slen + sizeof (struct GNUNET_RESOLVER_GetMessage) >=
+  slen = strlen(hostname) + 1;
+  if (slen + sizeof(struct GNUNET_RESOLVER_GetMessage) >=
       GNUNET_MAX_MESSAGE_SIZE)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Trying to resolve hostname `%s'.\n",
-       hostname);
-  rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to resolve hostname `%s'.\n",
+      hostname);
+  rh = GNUNET_malloc(sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
   rh->af = af;
   rh->id = ++last_request_id;
   rh->addr_callback = callback;
   rh->cls = callback_cls;
-  GNUNET_memcpy (&rh[1],
-                 hostname,
-                 slen);
+  GNUNET_memcpy(&rh[1],
+                hostname,
+                slen);
   rh->data_len = slen;
-  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  rh->timeout = GNUNET_TIME_relative_to_absolute(timeout);
   rh->direction = GNUNET_NO;
   /* first, check if this is a numeric address */
-  if ( ( (1 == inet_pton (AF_INET,
-                          hostname,
-                          &v4)) &&
-         ( (af == AF_INET) ||
-           (af == AF_UNSPEC) ) ) ||
-       ( (1 == inet_pton (AF_INET6,
-                          hostname,
-                          &v6)) &&
-         ( (af == AF_INET6) ||
-           (af == AF_UNSPEC)) ) )
-  {
-    rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution,
-                                         rh);
-    return rh;
-  }
+  if (((1 == inet_pton(AF_INET,
+                       hostname,
+                       &v4)) &&
+       ((af == AF_INET) ||
+        (af == AF_UNSPEC))) ||
+      ((1 == inet_pton(AF_INET6,
+                       hostname,
+                       &v6)) &&
+       ((af == AF_INET6) ||
+        (af == AF_UNSPEC))))
+    {
+      rh->task = GNUNET_SCHEDULER_add_now(&numeric_resolution,
+                                          rh);
+      return rh;
+    }
   /* then, check if this is a loopback address */
   for (unsigned int i = 0;
        NULL != loopback[i];
        i++)
-    if (0 == strcasecmp (loopback[i],
-                         hostname))
+    if (0 == strcasecmp(loopback[i],
+                        hostname))
+      {
+        rh->task = GNUNET_SCHEDULER_add_now(&loopback_resolution,
+                                            rh);
+        return rh;
+      }
+  if (GNUNET_OK != check_config())
     {
-      rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution,
-                                           rh);
-      return rh;
+      GNUNET_free(rh);
+      return NULL;
     }
-  if (GNUNET_OK != check_config ())
-  {
-    GNUNET_free (rh);
-    return NULL;
-  }
-  rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                           &handle_lookup_timeout,
-                                           rh);
-  GNUNET_CONTAINER_DLL_insert_tail (req_head,
-                                    req_tail,
-                                    rh);
+  rh->task = GNUNET_SCHEDULER_add_delayed(timeout,
+                                          &handle_lookup_timeout,
+                                          rh);
+  GNUNET_CONTAINER_DLL_insert_tail(req_head,
+                                   req_tail,
+                                   rh);
   rh->was_queued = GNUNET_YES;
   if (NULL != s_task)
-  {
-    GNUNET_SCHEDULER_cancel (s_task);
-    s_task = NULL;
-  }
-  process_requests ();
+    {
+      GNUNET_SCHEDULER_cancel(s_task);
+      s_task = NULL;
+    }
+  process_requests();
   return rh;
 }
 
@@ -1014,32 +1020,32 @@ GNUNET_RESOLVER_ip_get (const char *hostname,
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
  */
 static void
-numeric_reverse (void *cls)
+numeric_reverse(void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   char *result;
 
   rh->task = NULL;
-  result = no_resolve (rh->af,
-                       &rh[1],
-                       rh->data_len);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Resolver returns `%s'.\n",
-       result);
+  result = no_resolve(rh->af,
+                      &rh[1],
+                      rh->data_len);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Resolver returns `%s'.\n",
+      result);
   if (NULL != result)
-  {
-    rh->name_callback (rh->cls,
-                       result);
-    GNUNET_free (result);
-  }
-  rh->name_callback (rh->cls,
-                     NULL);
+    {
+      rh->name_callback(rh->cls,
+                        result);
+      GNUNET_free(result);
+    }
+  rh->name_callback(rh->cls,
+                    NULL);
   if (NULL != rh->task)
-  {
-    GNUNET_SCHEDULER_cancel (rh->task);
-    rh->task = NULL;
-  }
-  GNUNET_free (rh);
+    {
+      GNUNET_SCHEDULER_cancel(rh->task);
+      rh->task = NULL;
+    }
+  GNUNET_free(rh);
 }
 
 
@@ -1056,71 +1062,73 @@ numeric_reverse (void *cls)
  * @return handle that can be used to cancel the request
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
-                              socklen_t salen,
-                              int do_resolve,
-                              struct GNUNET_TIME_Relative timeout,
-                              GNUNET_RESOLVER_HostnameCallback callback,
-                              void *cls)
+GNUNET_RESOLVER_hostname_get(const struct sockaddr *sa,
+                             socklen_t salen,
+                             int do_resolve,
+                             struct GNUNET_TIME_Relative timeout,
+                             GNUNET_RESOLVER_HostnameCallback callback,
+                             void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
   size_t ip_len;
   const void *ip;
 
-  if (GNUNET_OK != check_config ())
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Resolver not configured correctly.\n"));
-    return NULL;
-  }
+  if (GNUNET_OK != check_config())
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Resolver not configured correctly.\n"));
+      return NULL;
+    }
 
   switch (sa->sa_family)
-  {
-  case AF_INET:
-    GNUNET_assert (salen == sizeof (struct sockaddr_in));
-    ip_len = sizeof (struct in_addr);
-    ip = &((const struct sockaddr_in*)sa)->sin_addr;
-    break;
-  case AF_INET6:
-    GNUNET_assert (salen == sizeof (struct sockaddr_in6));
-    ip_len = sizeof (struct in6_addr);
-    ip = &((const struct sockaddr_in6*)sa)->sin6_addr;
-    break;
-  default:
-    GNUNET_break (0);
-    return NULL;
-  }
-  rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen);
+    {
+    case AF_INET:
+      GNUNET_assert(salen == sizeof(struct sockaddr_in));
+      ip_len = sizeof(struct in_addr);
+      ip = &((const struct sockaddr_in*)sa)->sin_addr;
+      break;
+
+    case AF_INET6:
+      GNUNET_assert(salen == sizeof(struct sockaddr_in6));
+      ip_len = sizeof(struct in6_addr);
+      ip = &((const struct sockaddr_in6*)sa)->sin6_addr;
+      break;
+
+    default:
+      GNUNET_break(0);
+      return NULL;
+    }
+  rh = GNUNET_malloc(sizeof(struct GNUNET_RESOLVER_RequestHandle) + salen);
   rh->name_callback = callback;
   rh->cls = cls;
   rh->af = sa->sa_family;
   rh->id = ++last_request_id;
-  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  GNUNET_memcpy (&rh[1],
-                 ip,
-                 ip_len);
+  rh->timeout = GNUNET_TIME_relative_to_absolute(timeout);
+  GNUNET_memcpy(&rh[1],
+                ip,
+                ip_len);
   rh->data_len = ip_len;
   rh->direction = GNUNET_YES;
   rh->received_response = GNUNET_NO;
   if (GNUNET_NO == do_resolve)
-  {
-    rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse,
-                                         rh);
-    return rh;
-  }
-  rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                           &handle_lookup_timeout,
-                                           rh);
-  GNUNET_CONTAINER_DLL_insert_tail (req_head,
-                                    req_tail,
-                                    rh);
+    {
+      rh->task = GNUNET_SCHEDULER_add_now(&numeric_reverse,
+                                          rh);
+      return rh;
+    }
+  rh->task = GNUNET_SCHEDULER_add_delayed(timeout,
+                                          &handle_lookup_timeout,
+                                          rh);
+  GNUNET_CONTAINER_DLL_insert_tail(req_head,
+                                   req_tail,
+                                   rh);
   rh->was_queued = GNUNET_YES;
   if (NULL != s_task)
-  {
-    GNUNET_SCHEDULER_cancel (s_task);
-    s_task = NULL;
-  }
-  process_requests ();
+    {
+      GNUNET_SCHEDULER_cancel(s_task);
+      s_task = NULL;
+    }
+  process_requests();
   return rh;
 }
 
@@ -1131,78 +1139,78 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
  * @return fqdn
  */
 char *
-GNUNET_RESOLVER_local_fqdn_get ()
+GNUNET_RESOLVER_local_fqdn_get()
 {
-  char hostname[GNUNET_OS_get_hostname_max_length () + 1];
+  char hostname[GNUNET_OS_get_hostname_max_length() + 1];
 
-  if (0 != gethostname (hostname,
-                        sizeof (hostname) - 1))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "gethostname");
-    return NULL;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Resolving our FQDN `%s'\n",
-       hostname);
+  if (0 != gethostname(hostname,
+                       sizeof(hostname) - 1))
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                   "gethostname");
+      return NULL;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Resolving our FQDN `%s'\n",
+      hostname);
 #if HAVE_GETADDRINFO
   {
     struct addrinfo *ai;
     int ret;
     char *rval;
 
-    if (0 != (ret = getaddrinfo (hostname,
-                                 NULL,
-                                 NULL,
-                                 &ai)))
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _("Could not resolve our FQDN: %s\n"),
-           gai_strerror (ret));
-      return NULL;
-    }
+    if (0 != (ret = getaddrinfo(hostname,
+                                NULL,
+                                NULL,
+                                &ai)))
+      {
+        LOG(GNUNET_ERROR_TYPE_ERROR,
+            _("Could not resolve our FQDN: %s\n"),
+            gai_strerror(ret));
+        return NULL;
+      }
     if (NULL != ai->ai_canonname)
-      rval = GNUNET_strdup (ai->ai_canonname);
+      rval = GNUNET_strdup(ai->ai_canonname);
     else
-      rval = GNUNET_strdup (hostname);
-    freeaddrinfo (ai);
+      rval = GNUNET_strdup(hostname);
+    freeaddrinfo(ai);
     return rval;
   }
 #elif HAVE_GETHOSTBYNAME2
   {
     struct hostent *host;
 
-    host = gethostbyname2 (hostname,
-                           AF_INET);
+    host = gethostbyname2(hostname,
+                          AF_INET);
     if (NULL == host)
-      host = gethostbyname2 (hostname,
-                             AF_INET6);
+      host = gethostbyname2(hostname,
+                            AF_INET6);
     if (NULL == host)
       {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not resolve our FQDN: %s\n"),
-             hstrerror (h_errno));
+        LOG(GNUNET_ERROR_TYPE_ERROR,
+            _("Could not resolve our FQDN: %s\n"),
+            hstrerror(h_errno));
         return NULL;
       }
-    return GNUNET_strdup (host->h_name);
+    return GNUNET_strdup(host->h_name);
   }
 #elif HAVE_GETHOSTBYNAME
   {
     struct hostent *host;
 
-    host = gethostbyname (hostname);
+    host = gethostbyname(hostname);
     if (NULL == host)
       {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not resolve our FQDN: %s\n"),
-             hstrerror (h_errno));
+        LOG(GNUNET_ERROR_TYPE_ERROR,
+            _("Could not resolve our FQDN: %s\n"),
+            hstrerror(h_errno));
         return NULL;
       }
-    return GNUNET_strdup (host->h_name);
+    return GNUNET_strdup(host->h_name);
   }
 #else
   /* fallback: just hope name is already FQDN */
-  return GNUNET_strdup (hostname);
+  return GNUNET_strdup(hostname);
 #endif
 }
 
@@ -1217,27 +1225,27 @@ GNUNET_RESOLVER_local_fqdn_get ()
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_resolve (int af,
-                                  struct GNUNET_TIME_Relative timeout,
-                                  GNUNET_RESOLVER_AddressCallback callback,
-                                  void *cls)
+GNUNET_RESOLVER_hostname_resolve(int af,
+                                 struct GNUNET_TIME_Relative timeout,
+                                 GNUNET_RESOLVER_AddressCallback callback,
+                                 void *cls)
 {
-  char hostname[GNUNET_OS_get_hostname_max_length () + 1];
+  char hostname[GNUNET_OS_get_hostname_max_length() + 1];
 
-  if (0 != gethostname (hostname, sizeof (hostname) - 1))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "gethostname");
-    return NULL;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Resolving our hostname `%s'\n",
-       hostname);
-  return GNUNET_RESOLVER_ip_get (hostname,
-                                 af,
-                                 timeout,
-                                 callback,
-                                 cls);
+  if (0 != gethostname(hostname, sizeof(hostname) - 1))
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                   "gethostname");
+      return NULL;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Resolving our hostname `%s'\n",
+      hostname);
+  return GNUNET_RESOLVER_ip_get(hostname,
+                                af,
+                                timeout,
+                                callback,
+                                cls);
 }
 
 
@@ -1250,30 +1258,30 @@ GNUNET_RESOLVER_hostname_resolve (int af,
  * @param rh handle of request to cancel
  */
 void
-GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
+GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
 {
   if (GNUNET_NO == rh->direction)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Asked to cancel request to resolve hostname `%s'.\n",
-         (const char *) &rh[1]);
+    LOG(GNUNET_ERROR_TYPE_DEBUG,
+        "Asked to cancel request to resolve hostname `%s'.\n",
+        (const char *)&rh[1]);
   if (NULL != rh->task)
-  {
-    GNUNET_SCHEDULER_cancel (rh->task);
-    rh->task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rh->task);
+      rh->task = NULL;
+    }
   if (GNUNET_NO == rh->was_transmitted)
-  {
-    if (GNUNET_YES == rh->was_queued)
-      GNUNET_CONTAINER_DLL_remove (req_head,
-                                   req_tail,
-                                   rh);
-    GNUNET_free (rh);
-    check_disconnect ();
-    return;
-  }
-  GNUNET_assert (GNUNET_YES == rh->was_transmitted);
+    {
+      if (GNUNET_YES == rh->was_queued)
+        GNUNET_CONTAINER_DLL_remove(req_head,
+                                    req_tail,
+                                    rh);
+      GNUNET_free(rh);
+      check_disconnect();
+      return;
+    }
+  GNUNET_assert(GNUNET_YES == rh->was_transmitted);
   rh->was_transmitted = GNUNET_SYSERR;  /* mark as cancelled */
-  check_disconnect ();
+  check_disconnect();
 }
 
 
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index c818e91ee..4bea5bd5d 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -11,7 +11,7 @@
       WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       Affero General Public License for more details.
-     
+
       You should have received a copy of the GNU Affero General Public License
       along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -28,9 +28,9 @@
 // DEBUG
 #include <inttypes.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-scheduler", __VA_ARGS__)
 
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-scheduler", syscall)
+#define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror(kind, "util-scheduler", syscall)
 
 
 #if HAVE_EXECINFO_H
@@ -76,8 +76,7 @@
  * #GNUNET_SCHEDULER_do_work().  Contains the
  * scheduler's internal state.
  */
-struct GNUNET_SCHEDULER_Handle
-{
+struct GNUNET_SCHEDULER_Handle {
   /**
    * Passed here to avoid constantly allocating/deallocating
    * this element, but generally we want to get rid of this.
@@ -131,8 +130,7 @@ struct GNUNET_SCHEDULER_Handle
 /**
  * Entry in list of pending tasks.
  */
-struct GNUNET_SCHEDULER_Task
-{
+struct GNUNET_SCHEDULER_Task {
   /**
    * This is a linked list.
    */
@@ -245,15 +243,13 @@ struct GNUNET_SCHEDULER_Task
    * Asynchronous scope of the task that scheduled this scope,
    */
   struct GNUNET_AsyncScopeSave scope;
-
 };
 
 
 /**
  * A struct representing an event the select driver is waiting for
  */
-struct Scheduled
-{
+struct Scheduled {
   struct Scheduled *prev;
 
   struct Scheduled *next;
@@ -280,8 +276,7 @@ struct Scheduled
 /**
  * Driver context used by GNUNET_SCHEDULER_run
  */
-struct DriverContext
-{
+struct DriverContext {
   /**
    * the head of a DLL containing information about the events the
    * select driver is waiting for
@@ -430,8 +425,8 @@ static void *scheduler_select_cls;
  * @return previously used select function, NULL for default
  */
 void
-GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
-                             void *new_select_cls)
+GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select,
+                            void *new_select_cls)
 {
   scheduler_select = new_select;
   scheduler_select_cls = new_select_cls;
@@ -445,11 +440,11 @@ GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
  * @return p on success, 0 on error
  */
 static enum GNUNET_SCHEDULER_Priority
-check_priority (enum GNUNET_SCHEDULER_Priority p)
+check_priority(enum GNUNET_SCHEDULER_Priority p)
 {
   if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT))
     return p;
-  GNUNET_assert (0);
+  GNUNET_assert(0);
   return 0;                     /* make compiler happy */
 }
 
@@ -460,38 +455,38 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
  * callback)
  */
 struct GNUNET_TIME_Absolute
-get_timeout ()
+get_timeout()
 {
   struct GNUNET_SCHEDULER_Task *pos;
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Absolute timeout;
 
   pos = pending_timeout_head;
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   if (NULL != pos)
-  {
-    if (0 != pos->reason)
     {
-      return now;
-    }
-    else
-    {
-      timeout = pos->timeout;
+      if (0 != pos->reason)
+        {
+          return now;
+        }
+      else
+        {
+          timeout = pos->timeout;
+        }
     }
-  }
   for (pos = pending_head; NULL != pos; pos = pos->next)
-  {
-    if (0 != pos->reason)
     {
-      return now;
-    }
-    else if ((pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) &&
-             (timeout.abs_value_us > pos->timeout.abs_value_us))
-    {
-      timeout = pos->timeout;
+      if (0 != pos->reason)
+        {
+          return now;
+        }
+      else if ((pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) &&
+               (timeout.abs_value_us > pos->timeout.abs_value_us))
+        {
+          timeout = pos->timeout;
+        }
     }
-  }
   return timeout;
 }
 
@@ -502,13 +497,13 @@ get_timeout ()
  * @param task task ready for execution
  */
 static void
-queue_ready_task (struct GNUNET_SCHEDULER_Task *task)
+queue_ready_task(struct GNUNET_SCHEDULER_Task *task)
 {
-  enum GNUNET_SCHEDULER_Priority p = check_priority (task->priority);
+  enum GNUNET_SCHEDULER_Priority p = check_priority(task->priority);
 
-  GNUNET_CONTAINER_DLL_insert (ready_head[p],
-                               ready_tail[p],
-                               task);
+  GNUNET_CONTAINER_DLL_insert(ready_head[p],
+                              ready_tail[p],
+                              task);
   task->in_ready_list = GNUNET_YES;
   ready_count++;
 }
@@ -521,30 +516,30 @@ queue_ready_task (struct GNUNET_SCHEDULER_Task *task)
  * will be delayed until the next shutdown signal.
  */
 void
-GNUNET_SCHEDULER_shutdown ()
+GNUNET_SCHEDULER_shutdown()
 {
   struct GNUNET_SCHEDULER_Task *pos;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "GNUNET_SCHEDULER_shutdown\n");
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "GNUNET_SCHEDULER_shutdown\n");
   if (NULL != install_parent_control_task)
-  {
-    GNUNET_SCHEDULER_cancel (install_parent_control_task);
-    install_parent_control_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(install_parent_control_task);
+      install_parent_control_task = NULL;
+    }
   if (NULL != shutdown_pipe_task)
-  {
-    GNUNET_SCHEDULER_cancel (shutdown_pipe_task);
-    shutdown_pipe_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(shutdown_pipe_task);
+      shutdown_pipe_task = NULL;
+    }
   while (NULL != (pos = shutdown_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (shutdown_head,
-                                 shutdown_tail,
-                                 pos);
-    pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
-    queue_ready_task (pos);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(shutdown_head,
+                                  shutdown_tail,
+                                  pos);
+      pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
+      queue_ready_task(pos);
+    }
 }
 
 
@@ -554,17 +549,17 @@ GNUNET_SCHEDULER_shutdown ()
  * @param t task to dump stack trace of
  */
 static void
-dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
+dump_backtrace(struct GNUNET_SCHEDULER_Task *t)
 {
 #if EXECINFO
   for (unsigned int i = 0; i < t->num_backtrace_strings; i++)
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "Task %p trace %u: %s\n",
-         t,
-         i,
-         t->backtrace_strings[i]);
+    LOG(GNUNET_ERROR_TYPE_WARNING,
+        "Task %p trace %u: %s\n",
+        t,
+        i,
+        t->backtrace_strings[i]);
 #else
-  (void) t;
+  (void)t;
 #endif
 }
 
@@ -575,40 +570,40 @@ dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
  * @param t task to destroy
  */
 static void
-destroy_task (struct GNUNET_SCHEDULER_Task *t)
+destroy_task(struct GNUNET_SCHEDULER_Task *t)
 {
   unsigned int i;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "destroying task %p\n",
-       t);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "destroying task %p\n",
+      t);
 
   if (GNUNET_YES == t->own_handles)
-  {
-    for (i = 0; i != t->fds_len; ++i)
     {
-      const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd;
-      const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh;
-      if (fd)
-      {
-        GNUNET_NETWORK_socket_free_memory_only_ ((struct GNUNET_NETWORK_Handle *) fd);
-      }
-      if (fh)
-      {
-        // FIXME: on WIN32 this is not enough! A function
-        // GNUNET_DISK_file_free_memory_only would be nice
-        GNUNET_free ((void *) fh);
-      }
+      for (i = 0; i != t->fds_len; ++i)
+        {
+          const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd;
+          const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh;
+          if (fd)
+            {
+              GNUNET_NETWORK_socket_free_memory_only_((struct GNUNET_NETWORK_Handle *)fd);
+            }
+          if (fh)
+            {
+              // FIXME: on WIN32 this is not enough! A function
+              // GNUNET_DISK_file_free_memory_only would be nice
+              GNUNET_free((void *)fh);
+            }
+        }
     }
-  }
   if (t->fds_len > 1)
-  {
-    GNUNET_array_grow (t->fds, t->fds_len, 0);
-  }
+    {
+      GNUNET_array_grow(t->fds, t->fds_len, 0);
+    }
 #if EXECINFO
-  GNUNET_free (t->backtrace_strings);
+  GNUNET_free(t->backtrace_strings);
 #endif
-  GNUNET_free (t);
+  GNUNET_free(t);
 }
 
 
@@ -628,7 +623,7 @@ static pid_t my_pid;
  */
 #ifndef MINGW
 static void
-sighandler_pipe ()
+sighandler_pipe()
 {
   return;
 }
@@ -657,23 +652,23 @@ sighandler_pipe ()
  * Signal handler called for signals that should cause us to shutdown.
  */
 static void
-sighandler_shutdown ()
+sighandler_shutdown()
 {
   static char c;
   int old_errno = errno;        /* backup errno */
 
-  if (getpid () != my_pid)
-    _exit (1);                   /* we have fork'ed since the signal handler was created,
+  if (getpid() != my_pid)
+    _exit(1);                    /* we have fork'ed since the signal handler was created,
                                   * ignore the signal, see https://gnunet.org/vfork discussion */
-  GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
-                          (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
-                          &c, sizeof (c));
+  GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle
+                           (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
+                         &c, sizeof(c));
   errno = old_errno;
 }
 
 
 static void
-shutdown_if_no_lifeness ()
+shutdown_if_no_lifeness()
 {
   struct GNUNET_SCHEDULER_Task *t;
 
@@ -689,13 +684,13 @@ shutdown_if_no_lifeness ()
     if (GNUNET_YES == t->lifeness)
       return;
   /* No lifeness! */
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static int
-select_loop (struct GNUNET_SCHEDULER_Handle *sh,
-             struct DriverContext *context);
+select_loop(struct GNUNET_SCHEDULER_Handle *sh,
+            struct DriverContext *context);
 
 
 /**
@@ -713,26 +708,26 @@ select_loop (struct GNUNET_SCHEDULER_Handle *sh,
  * @param task_cls closure of @a task
  */
 void
-GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
-                      void *task_cls)
+GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task,
+                     void *task_cls)
 {
   struct GNUNET_SCHEDULER_Handle *sh;
   struct GNUNET_SCHEDULER_Driver *driver;
-  struct DriverContext context = {.scheduled_head = NULL,
-                                  .scheduled_tail = NULL,
-                                  .timeout = GNUNET_TIME_absolute_get ()};
+  struct DriverContext context = { .scheduled_head = NULL,
+                                   .scheduled_tail = NULL,
+                                   .timeout = GNUNET_TIME_absolute_get() };
 
-  driver = GNUNET_SCHEDULER_driver_select ();
+  driver = GNUNET_SCHEDULER_driver_select();
   driver->cls = &context;
-  sh = GNUNET_SCHEDULER_driver_init (driver);
-  GNUNET_SCHEDULER_add_with_reason_and_priority (task,
-                                                 task_cls,
-                                                 GNUNET_SCHEDULER_REASON_STARTUP,
-                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT);
-  select_loop (sh,
-               &context);
-  GNUNET_SCHEDULER_driver_done (sh);
-  GNUNET_free (driver);
+  sh = GNUNET_SCHEDULER_driver_init(driver);
+  GNUNET_SCHEDULER_add_with_reason_and_priority(task,
+                                                task_cls,
+                                                GNUNET_SCHEDULER_REASON_STARTUP,
+                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  select_loop(sh,
+              &context);
+  GNUNET_SCHEDULER_driver_done(sh);
+  GNUNET_free(driver);
 }
 
 
@@ -743,9 +738,9 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
  * @return current tasks' scheduler context
  */
 const struct GNUNET_SCHEDULER_TaskContext *
-GNUNET_SCHEDULER_get_task_context ()
+GNUNET_SCHEDULER_get_task_context()
 {
-  GNUNET_assert (NULL != active_task);
+  GNUNET_assert(NULL != active_task);
   return &tc;
 }
 
@@ -760,33 +755,33 @@ GNUNET_SCHEDULER_get_task_context ()
  * @return number of tasks pending right now
  */
 unsigned int
-GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
+GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p)
 {
   struct GNUNET_SCHEDULER_Task *pos;
   unsigned int ret;
 
-  GNUNET_assert (NULL != active_task);
+  GNUNET_assert(NULL != active_task);
   if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
     return ready_count;
   if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
     p = current_priority;
   ret = 0;
-  for (pos = ready_head[check_priority (p)]; NULL != pos; pos = pos->next)
+  for (pos = ready_head[check_priority(p)]; NULL != pos; pos = pos->next)
     ret++;
   return ret;
 }
 
 
 void
-init_fd_info (struct GNUNET_SCHEDULER_Task *t,
-              const struct GNUNET_NETWORK_Handle *const *read_nh,
-              unsigned int read_nh_len,
-              const struct GNUNET_NETWORK_Handle *const *write_nh,
-              unsigned int write_nh_len,
-              const struct GNUNET_DISK_FileHandle *const *read_fh,
-              unsigned int read_fh_len,
-              const struct GNUNET_DISK_FileHandle *const *write_fh,
-              unsigned int write_fh_len)
+init_fd_info(struct GNUNET_SCHEDULER_Task *t,
+             const struct GNUNET_NETWORK_Handle *const *read_nh,
+             unsigned int read_nh_len,
+             const struct GNUNET_NETWORK_Handle *const *write_nh,
+             unsigned int write_nh_len,
+             const struct GNUNET_DISK_FileHandle *const *read_fh,
+             unsigned int read_fh_len,
+             const struct GNUNET_DISK_FileHandle *const *write_fh,
+             unsigned int write_fh_len)
 {
   // FIXME: if we have exactly two network handles / exactly two file handles
   // and they are equal, we can make one FdInfo with both
@@ -795,90 +790,90 @@ init_fd_info (struct GNUNET_SCHEDULER_Task *t,
 
   t->fds_len = read_nh_len + write_nh_len + read_fh_len + write_fh_len;
   if (1 == t->fds_len)
-  {
-    fdi = &t->fdx;
-    t->fds = fdi;
-    if (1 == read_nh_len)
     {
-      GNUNET_assert (NULL != read_nh);
-      GNUNET_assert (NULL != *read_nh);
-      fdi->fd = *read_nh;
-      fdi->et = GNUNET_SCHEDULER_ET_IN;
-      fdi->sock = GNUNET_NETWORK_get_fd (*read_nh);
-      t->read_fd = fdi->sock;
-      t->write_fd = -1;
+      fdi = &t->fdx;
+      t->fds = fdi;
+      if (1 == read_nh_len)
+        {
+          GNUNET_assert(NULL != read_nh);
+          GNUNET_assert(NULL != *read_nh);
+          fdi->fd = *read_nh;
+          fdi->et = GNUNET_SCHEDULER_ET_IN;
+          fdi->sock = GNUNET_NETWORK_get_fd(*read_nh);
+          t->read_fd = fdi->sock;
+          t->write_fd = -1;
+        }
+      else if (1 == write_nh_len)
+        {
+          GNUNET_assert(NULL != write_nh);
+          GNUNET_assert(NULL != *write_nh);
+          fdi->fd = *write_nh;
+          fdi->et = GNUNET_SCHEDULER_ET_OUT;
+          fdi->sock = GNUNET_NETWORK_get_fd(*write_nh);
+          t->read_fd = -1;
+          t->write_fd = fdi->sock;
+        }
+      else if (1 == read_fh_len)
+        {
+          GNUNET_assert(NULL != read_fh);
+          GNUNET_assert(NULL != *read_fh);
+          fdi->fh = *read_fh;
+          fdi->et = GNUNET_SCHEDULER_ET_IN;
+          fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32
+          t->read_fd = fdi->sock;
+          t->write_fd = -1;
+        }
+      else
+        {
+          GNUNET_assert(NULL != write_fh);
+          GNUNET_assert(NULL != *write_fh);
+          fdi->fh = *write_fh;
+          fdi->et = GNUNET_SCHEDULER_ET_OUT;
+          fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32
+          t->read_fd = -1;
+          t->write_fd = fdi->sock;
+        }
     }
-    else if (1 == write_nh_len)
+  else
     {
-      GNUNET_assert (NULL != write_nh);
-      GNUNET_assert (NULL != *write_nh);
-      fdi->fd = *write_nh;
-      fdi->et = GNUNET_SCHEDULER_ET_OUT;
-      fdi->sock = GNUNET_NETWORK_get_fd (*write_nh);
+      fdi = GNUNET_new_array(t->fds_len, struct GNUNET_SCHEDULER_FdInfo);
+      t->fds = fdi;
       t->read_fd = -1;
-      t->write_fd = fdi->sock;
-    }
-    else if (1 == read_fh_len)
-    {
-      GNUNET_assert (NULL != read_fh);
-      GNUNET_assert (NULL != *read_fh);
-      fdi->fh = *read_fh;
-      fdi->et = GNUNET_SCHEDULER_ET_IN;
-      fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32
-      t->read_fd = fdi->sock;
       t->write_fd = -1;
+      unsigned int i;
+      for (i = 0; i != read_nh_len; ++i)
+        {
+          fdi->fd = read_nh[i];
+          GNUNET_assert(NULL != fdi->fd);
+          fdi->et = GNUNET_SCHEDULER_ET_IN;
+          fdi->sock = GNUNET_NETWORK_get_fd(read_nh[i]);
+          ++fdi;
+        }
+      for (i = 0; i != write_nh_len; ++i)
+        {
+          fdi->fd = write_nh[i];
+          GNUNET_assert(NULL != fdi->fd);
+          fdi->et = GNUNET_SCHEDULER_ET_OUT;
+          fdi->sock = GNUNET_NETWORK_get_fd(write_nh[i]);
+          ++fdi;
+        }
+      for (i = 0; i != read_fh_len; ++i)
+        {
+          fdi->fh = read_fh[i];
+          GNUNET_assert(NULL != fdi->fh);
+          fdi->et = GNUNET_SCHEDULER_ET_IN;
+          fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32
+          ++fdi;
+        }
+      for (i = 0; i != write_fh_len; ++i)
+        {
+          fdi->fh = write_fh[i];
+          GNUNET_assert(NULL != fdi->fh);
+          fdi->et = GNUNET_SCHEDULER_ET_OUT;
+          fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32
+          ++fdi;
+        }
     }
-    else
-    {
-      GNUNET_assert (NULL != write_fh);
-      GNUNET_assert (NULL != *write_fh);
-      fdi->fh = *write_fh;
-      fdi->et = GNUNET_SCHEDULER_ET_OUT;
-      fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32
-      t->read_fd = -1;
-      t->write_fd = fdi->sock;
-    }
-  }
-  else
-  {
-    fdi = GNUNET_new_array (t->fds_len, struct GNUNET_SCHEDULER_FdInfo);
-    t->fds = fdi;
-    t->read_fd = -1;
-    t->write_fd = -1;
-    unsigned int i;
-    for (i = 0; i != read_nh_len; ++i)
-    {
-      fdi->fd = read_nh[i];
-      GNUNET_assert (NULL != fdi->fd);
-      fdi->et = GNUNET_SCHEDULER_ET_IN;
-      fdi->sock = GNUNET_NETWORK_get_fd (read_nh[i]);
-      ++fdi;
-    }
-    for (i = 0; i != write_nh_len; ++i)
-    {
-      fdi->fd = write_nh[i];
-      GNUNET_assert (NULL != fdi->fd);
-      fdi->et = GNUNET_SCHEDULER_ET_OUT;
-      fdi->sock = GNUNET_NETWORK_get_fd (write_nh[i]);
-      ++fdi;
-    }
-    for (i = 0; i != read_fh_len; ++i)
-    {
-      fdi->fh = read_fh[i];
-      GNUNET_assert (NULL != fdi->fh);
-      fdi->et = GNUNET_SCHEDULER_ET_IN;
-      fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32
-      ++fdi;
-    }
-    for (i = 0; i != write_fh_len; ++i)
-    {
-      fdi->fh = write_fh[i];
-      GNUNET_assert (NULL != fdi->fh);
-      fdi->et = GNUNET_SCHEDULER_ET_OUT;
-      fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32
-      ++fdi;
-    }
-  }
 }
 
 
@@ -896,56 +891,56 @@ init_fd_info (struct GNUNET_SCHEDULER_Task *t,
  *           @a driver_func on it, or -1 if no updating not desired.
  */
 static void
-driver_add_multiple (struct GNUNET_SCHEDULER_Task *t)
+driver_add_multiple(struct GNUNET_SCHEDULER_Task *t)
 {
   struct GNUNET_SCHEDULER_FdInfo *fdi;
   int success = GNUNET_YES;
 
   for (unsigned int i = 0; i != t->fds_len; ++i)
-  {
-    fdi = &t->fds[i];
-    success = scheduler_driver->add (scheduler_driver->cls,
-                                     t,
-                                     fdi) && success;
-    fdi->et = GNUNET_SCHEDULER_ET_NONE;
-  }
+    {
+      fdi = &t->fds[i];
+      success = scheduler_driver->add(scheduler_driver->cls,
+                                      t,
+                                      fdi) && success;
+      fdi->et = GNUNET_SCHEDULER_ET_NONE;
+    }
   if (GNUNET_YES != success)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         "driver could not add task\n");
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          "driver could not add task\n");
+    }
 }
 
 
 static void
-install_parent_control_handler (void *cls)
+install_parent_control_handler(void *cls)
 {
-  (void) cls;
+  (void)cls;
   install_parent_control_task = NULL;
-  GNUNET_OS_install_parent_control_handler (NULL);
+  GNUNET_OS_install_parent_control_handler(NULL);
 }
 
 
 static void
-shutdown_pipe_cb (void *cls)
+shutdown_pipe_cb(void *cls)
 {
   char c;
   const struct GNUNET_DISK_FileHandle *pr;
 
-  (void) cls;
+  (void)cls;
   shutdown_pipe_task = NULL;
-  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
-                                GNUNET_DISK_PIPE_END_READ);
-  GNUNET_assert (! GNUNET_DISK_handle_invalid (pr));
+  pr = GNUNET_DISK_pipe_handle(shutdown_pipe_handle,
+                               GNUNET_DISK_PIPE_END_READ);
+  GNUNET_assert(!GNUNET_DISK_handle_invalid(pr));
   /* consume the signal */
-  GNUNET_DISK_file_read (pr, &c, sizeof (c));
+  GNUNET_DISK_file_read(pr, &c, sizeof(c));
   /* mark all active tasks as ready due to shutdown */
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   shutdown_pipe_task =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    pr,
-                                    &shutdown_pipe_cb,
-                                    NULL);
+    GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                   pr,
+                                   &shutdown_pipe_cb,
+                                   NULL);
 }
 
 
@@ -962,62 +957,62 @@ shutdown_pipe_cb (void *cls)
  * @return original closure of the task
  */
 void *
-GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
+GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
 {
   enum GNUNET_SCHEDULER_Priority p;
   int is_fd_task;
   void *ret;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "canceling task %p\n",
-       task);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "canceling task %p\n",
+      task);
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
+  GNUNET_assert(NULL != scheduler_driver);
   is_fd_task = (NULL != task->fds);
   if (is_fd_task)
-  {
-    int del_result = scheduler_driver->del (scheduler_driver->cls, task);
-    if (GNUNET_OK != del_result)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "driver could not delete task\n");
-      GNUNET_assert (0);
-    }
-  }
-  if (! task->in_ready_list)
-  {
-    if (is_fd_task)
     {
-      GNUNET_CONTAINER_DLL_remove (pending_head,
-                                   pending_tail,
-                                   task);
+      int del_result = scheduler_driver->del(scheduler_driver->cls, task);
+      if (GNUNET_OK != del_result)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              "driver could not delete task\n");
+          GNUNET_assert(0);
+        }
     }
-    else if (GNUNET_YES == task->on_shutdown)
+  if (!task->in_ready_list)
     {
-      GNUNET_CONTAINER_DLL_remove (shutdown_head,
-                                   shutdown_tail,
-                                   task);
+      if (is_fd_task)
+        {
+          GNUNET_CONTAINER_DLL_remove(pending_head,
+                                      pending_tail,
+                                      task);
+        }
+      else if (GNUNET_YES == task->on_shutdown)
+        {
+          GNUNET_CONTAINER_DLL_remove(shutdown_head,
+                                      shutdown_tail,
+                                      task);
+        }
+      else
+        {
+          GNUNET_CONTAINER_DLL_remove(pending_timeout_head,
+                                      pending_timeout_tail,
+                                      task);
+          if (pending_timeout_last == task)
+            pending_timeout_last = NULL;
+        }
     }
-    else
+  else
     {
-      GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
-                                   pending_timeout_tail,
-                                   task);
-      if (pending_timeout_last == task)
-        pending_timeout_last = NULL;
+      p = check_priority(task->priority);
+      GNUNET_CONTAINER_DLL_remove(ready_head[p],
+                                  ready_tail[p],
+                                  task);
+      ready_count--;
     }
-  }
-  else
-  {
-    p = check_priority (task->priority);
-    GNUNET_CONTAINER_DLL_remove (ready_head[p],
-                                 ready_tail[p],
-                                 task);
-    ready_count--;
-  }
   ret = task->callback_cls;
-  destroy_task (task);
+  destroy_task(task);
   return ret;
 }
 
@@ -1028,19 +1023,19 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
  * @param t task to initialize
  */
 static void
-init_backtrace (struct GNUNET_SCHEDULER_Task *t)
+init_backtrace(struct GNUNET_SCHEDULER_Task *t)
 {
 #if EXECINFO
   void *backtrace_array[MAX_TRACE_DEPTH];
 
   t->num_backtrace_strings
-    = backtrace (backtrace_array, MAX_TRACE_DEPTH);
+    = backtrace(backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-      backtrace_symbols (backtrace_array,
-       t->num_backtrace_strings);
-  dump_backtrace (t);
+    backtrace_symbols(backtrace_array,
+                      t->num_backtrace_strings);
+  dump_backtrace(t);
 #else
-  (void) t;
+  (void)t;
 #endif
 }
 
@@ -1056,32 +1051,32 @@ init_backtrace (struct GNUNET_SCHEDULER_Task *t)
  * @param priority priority to use for the task
  */
 void
-GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback task,
-                                               void *task_cls,
-                                               enum GNUNET_SCHEDULER_Reason reason,
-                                               enum GNUNET_SCHEDULER_Priority priority)
+GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task,
+                                              void *task_cls,
+                                              enum GNUNET_SCHEDULER_Reason reason,
+                                              enum GNUNET_SCHEDULER_Priority priority)
 {
   struct GNUNET_SCHEDULER_Task *t;
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
-  GNUNET_assert (NULL != task);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+  GNUNET_assert(NULL != scheduler_driver);
+  GNUNET_assert(NULL != task);
+  t = GNUNET_new(struct GNUNET_SCHEDULER_Task);
   t->read_fd = -1;
   t->write_fd = -1;
   t->callback = task;
   t->callback_cls = task_cls;
 #if PROFILE_DELAYS
-  t->start_time = GNUNET_TIME_absolute_get ();
+  t->start_time = GNUNET_TIME_absolute_get();
 #endif
   t->reason = reason;
-  t->priority = check_priority (priority);
+  t->priority = check_priority(priority);
   t->lifeness = current_lifeness;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding continuation task %p\n",
-       t);
-  init_backtrace (t);
-  queue_ready_task (t);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Adding continuation task %p\n",
+      t);
+  init_backtrace(t);
+  queue_ready_task(t);
 }
 
 
@@ -1097,68 +1092,68 @@ GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback tas
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
-                                       enum GNUNET_SCHEDULER_Priority priority,
-                                       GNUNET_SCHEDULER_TaskCallback task,
-                                       void *task_cls)
+GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at,
+                                      enum GNUNET_SCHEDULER_Priority priority,
+                                      GNUNET_SCHEDULER_TaskCallback task,
+                                      void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
   struct GNUNET_SCHEDULER_Task *pos;
   struct GNUNET_SCHEDULER_Task *prev;
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
-  GNUNET_assert (NULL != task);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
-  GNUNET_async_scope_get (&t->scope);
+  GNUNET_assert(NULL != scheduler_driver);
+  GNUNET_assert(NULL != task);
+  t = GNUNET_new(struct GNUNET_SCHEDULER_Task);
+  GNUNET_async_scope_get(&t->scope);
   t->callback = task;
   t->callback_cls = task_cls;
   t->read_fd = -1;
   t->write_fd = -1;
 #if PROFILE_DELAYS
-  t->start_time = GNUNET_TIME_absolute_get ();
+  t->start_time = GNUNET_TIME_absolute_get();
 #endif
   t->timeout = at;
-  t->priority = check_priority (priority);
+  t->priority = check_priority(priority);
   t->lifeness = current_lifeness;
   /* try tail first (optimization in case we are
    * appending to a long list of tasks with timeouts) */
-  if ( (NULL == pending_timeout_head) ||
-       (at.abs_value_us < pending_timeout_head->timeout.abs_value_us) )
-  {
-    GNUNET_CONTAINER_DLL_insert (pending_timeout_head,
-                                 pending_timeout_tail,
-                                 t);
-  }
+  if ((NULL == pending_timeout_head) ||
+      (at.abs_value_us < pending_timeout_head->timeout.abs_value_us))
+    {
+      GNUNET_CONTAINER_DLL_insert(pending_timeout_head,
+                                  pending_timeout_tail,
+                                  t);
+    }
   else
-  {
-    /* first move from heuristic start backwards to before start time */
-    prev = pending_timeout_last;
-    while ( (NULL != prev) &&
-            (prev->timeout.abs_value_us > t->timeout.abs_value_us) )
-      prev = prev->prev;
-    /* now, move from heuristic start (or head of list) forward to insertion point */
-    if (NULL == prev)
-      pos = pending_timeout_head;
-    else
-      pos = prev->next;
-    while ((NULL != pos) && (pos->timeout.abs_value_us <= t->timeout.abs_value_us))
     {
-      prev = pos;
-      pos = pos->next;
+      /* first move from heuristic start backwards to before start time */
+      prev = pending_timeout_last;
+      while ((NULL != prev) &&
+             (prev->timeout.abs_value_us > t->timeout.abs_value_us))
+        prev = prev->prev;
+      /* now, move from heuristic start (or head of list) forward to insertion point */
+      if (NULL == prev)
+        pos = pending_timeout_head;
+      else
+        pos = prev->next;
+      while ((NULL != pos) && (pos->timeout.abs_value_us <= t->timeout.abs_value_us))
+        {
+          prev = pos;
+          pos = pos->next;
+        }
+      GNUNET_CONTAINER_DLL_insert_after(pending_timeout_head,
+                                        pending_timeout_tail,
+                                        prev,
+                                        t);
     }
-    GNUNET_CONTAINER_DLL_insert_after (pending_timeout_head,
-                                       pending_timeout_tail,
-                                       prev,
-                                       t);
-  }
   /* finally, update heuristic insertion point to last insertion... */
   pending_timeout_last = t;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task %p\n",
-       t);
-  init_backtrace (t);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Adding task %p\n",
+      t);
+  init_backtrace(t);
   return t;
 }
 
@@ -1175,15 +1170,15 @@ GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
-                                            enum GNUNET_SCHEDULER_Priority priority,
-                                            GNUNET_SCHEDULER_TaskCallback task,
-                                            void *task_cls)
+GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay,
+                                           enum GNUNET_SCHEDULER_Priority priority,
+                                           GNUNET_SCHEDULER_TaskCallback task,
+                                           void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
-                                                priority,
-                                                task,
-                                                task_cls);
+  return GNUNET_SCHEDULER_add_at_with_priority(GNUNET_TIME_relative_to_absolute(delay),
+                                               priority,
+                                               task,
+                                               task_cls);
 }
 
 
@@ -1197,14 +1192,14 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
-                                    GNUNET_SCHEDULER_TaskCallback task,
-                                    void *task_cls)
+GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio,
+                                   GNUNET_SCHEDULER_TaskCallback task,
+                                   void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_ZERO,
-                                                     prio,
-                                                     task,
-                                                     task_cls);
+  return GNUNET_SCHEDULER_add_delayed_with_priority(GNUNET_TIME_UNIT_ZERO,
+                                                    prio,
+                                                    task,
+                                                    task_cls);
 }
 
 
@@ -1220,14 +1215,14 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
-                         GNUNET_SCHEDULER_TaskCallback task,
-                         void *task_cls)
+GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at,
+                        GNUNET_SCHEDULER_TaskCallback task,
+                        void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_at_with_priority (at,
-                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                task,
-                                                task_cls);
+  return GNUNET_SCHEDULER_add_at_with_priority(at,
+                                               GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                               task,
+                                               task_cls);
 }
 
 
@@ -1243,14 +1238,14 @@ GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
-                              GNUNET_SCHEDULER_TaskCallback task,
-                              void *task_cls)
+GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay,
+                             GNUNET_SCHEDULER_TaskCallback task,
+                             void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
-                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                 task,
-                 task_cls);
+  return GNUNET_SCHEDULER_add_delayed_with_priority(delay,
+                                                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                    task,
+                                                    task_cls);
 }
 
 
@@ -1270,12 +1265,12 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
-                          void *task_cls)
+GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task,
+                         void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO,
-                                       task,
-                                       task_cls);
+  return GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_ZERO,
+                                      task,
+                                      task_cls);
 }
 
 
@@ -1290,34 +1285,34 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
-                               void *task_cls)
+GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task,
+                              void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
-  GNUNET_assert (NULL != task);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
-  GNUNET_async_scope_get (&t->scope);
+  GNUNET_assert(NULL != scheduler_driver);
+  GNUNET_assert(NULL != task);
+  t = GNUNET_new(struct GNUNET_SCHEDULER_Task);
+  GNUNET_async_scope_get(&t->scope);
   t->callback = task;
   t->callback_cls = task_cls;
   t->read_fd = -1;
   t->write_fd = -1;
 #if PROFILE_DELAYS
-  t->start_time = GNUNET_TIME_absolute_get ();
+  t->start_time = GNUNET_TIME_absolute_get();
 #endif
   t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
   t->on_shutdown = GNUNET_YES;
   t->lifeness = GNUNET_NO;
-  GNUNET_CONTAINER_DLL_insert (shutdown_head,
-                               shutdown_tail,
-                               t);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding shutdown task %p\n",
-       t);
-  init_backtrace (t);
+  GNUNET_CONTAINER_DLL_insert(shutdown_head,
+                              shutdown_tail,
+                              t);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Adding shutdown task %p\n",
+      t);
+  init_backtrace(t);
   return t;
 }
 
@@ -1337,13 +1332,13 @@ GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
-                                        GNUNET_SCHEDULER_TaskCallback task,
-                                        void *task_cls)
+GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness,
+                                       GNUNET_SCHEDULER_TaskCallback task,
+                                       void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *ret;
 
-  ret = GNUNET_SCHEDULER_add_now (task, task_cls);
+  ret = GNUNET_SCHEDULER_add_now(task, task_cls);
   ret->lifeness = lifeness;
   return ret;
 }
@@ -1357,21 +1352,21 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  * @param raw_fd the raw file descriptor to check
  */
 void
-check_fd (struct GNUNET_SCHEDULER_Task *t, int raw_fd)
+check_fd(struct GNUNET_SCHEDULER_Task *t, int raw_fd)
 {
   if (-1 != raw_fd)
-  {
-    int flags = fcntl (raw_fd, F_GETFD);
-
-    if ((flags == -1) && (errno == EBADF))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "Got invalid file descriptor %d!\n",
-           raw_fd);
-      init_backtrace (t);
-      GNUNET_assert (0);
+      int flags = fcntl(raw_fd, F_GETFD);
+
+      if ((flags == -1) && (errno == EBADF))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              "Got invalid file descriptor %d!\n",
+              raw_fd);
+          init_backtrace(t);
+          GNUNET_assert(0);
+        }
     }
-  }
 }
 #endif
 
@@ -1403,52 +1398,52 @@ check_fd (struct GNUNET_SCHEDULER_Task *t, int raw_fd)
  */
 #ifndef MINGW
 static struct GNUNET_SCHEDULER_Task *
-add_without_sets (struct GNUNET_TIME_Relative delay,
-                  enum GNUNET_SCHEDULER_Priority priority,
-                  const struct GNUNET_NETWORK_Handle *read_nh,
-                  const struct GNUNET_NETWORK_Handle *write_nh,
-                  const struct GNUNET_DISK_FileHandle *read_fh,
-                  const struct GNUNET_DISK_FileHandle *write_fh,
-                  GNUNET_SCHEDULER_TaskCallback task,
-                  void *task_cls)
+add_without_sets(struct GNUNET_TIME_Relative delay,
+                 enum GNUNET_SCHEDULER_Priority priority,
+                 const struct GNUNET_NETWORK_Handle *read_nh,
+                 const struct GNUNET_NETWORK_Handle *write_nh,
+                 const struct GNUNET_DISK_FileHandle *read_fh,
+                 const struct GNUNET_DISK_FileHandle *write_fh,
+                 GNUNET_SCHEDULER_TaskCallback task,
+                 void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
-  GNUNET_assert (NULL != task);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
-  GNUNET_async_scope_get (&t->scope);
-  init_fd_info (t,
-                &read_nh,
-                read_nh ? 1 : 0,
-                &write_nh,
-                write_nh ? 1 : 0,
-                &read_fh,
-                read_fh ? 1 : 0,
-                &write_fh,
-                write_fh ? 1 : 0);
+  GNUNET_assert(NULL != scheduler_driver);
+  GNUNET_assert(NULL != task);
+  t = GNUNET_new(struct GNUNET_SCHEDULER_Task);
+  GNUNET_async_scope_get(&t->scope);
+  init_fd_info(t,
+               &read_nh,
+               read_nh ? 1 : 0,
+               &write_nh,
+               write_nh ? 1 : 0,
+               &read_fh,
+               read_fh ? 1 : 0,
+               &write_fh,
+               write_fh ? 1 : 0);
   t->callback = task;
   t->callback_cls = task_cls;
 #if DEBUG_FDS
-  check_fd (t, NULL != read_nh ? GNUNET_NETWORK_get_fd (read_nh) : -1);
-  check_fd (t, NULL != write_nh ? GNUNET_NETWORK_get_fd (write_nh) : -1);
-  check_fd (t, NULL != read_fh ? read_fh->fd : -1);
-  check_fd (t, NULL != write_fh ? write_fh->fd : -1);
+  check_fd(t, NULL != read_nh ? GNUNET_NETWORK_get_fd(read_nh) : -1);
+  check_fd(t, NULL != write_nh ? GNUNET_NETWORK_get_fd(write_nh) : -1);
+  check_fd(t, NULL != read_fh ? read_fh->fd : -1);
+  check_fd(t, NULL != write_fh ? write_fh->fd : -1);
 #endif
 #if PROFILE_DELAYS
-  t->start_time = GNUNET_TIME_absolute_get ();
+  t->start_time = GNUNET_TIME_absolute_get();
 #endif
-  t->timeout = GNUNET_TIME_relative_to_absolute (delay);
-  t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);
+  t->timeout = GNUNET_TIME_relative_to_absolute(delay);
+  t->priority = check_priority((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);
   t->lifeness = current_lifeness;
-  GNUNET_CONTAINER_DLL_insert (pending_head,
-                               pending_tail,
-                               t);
-  driver_add_multiple (t);
-  max_priority_added = GNUNET_MAX (max_priority_added,
-                                   t->priority);
-  init_backtrace (t);
+  GNUNET_CONTAINER_DLL_insert(pending_head,
+                              pending_tail,
+                              t);
+  driver_add_multiple(t);
+  max_priority_added = GNUNET_MAX(max_priority_added,
+                                  t->priority);
+  init_backtrace(t);
   return t;
 }
 #endif
@@ -1475,14 +1470,14 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
-                               struct GNUNET_NETWORK_Handle *rfd,
-                               GNUNET_SCHEDULER_TaskCallback task,
-                               void *task_cls)
+GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay,
+                              struct GNUNET_NETWORK_Handle *rfd,
+                              GNUNET_SCHEDULER_TaskCallback task,
+                              void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
-                  GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                  rfd, task, task_cls);
+  return GNUNET_SCHEDULER_add_read_net_with_priority(delay,
+                                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                     rfd, task, task_cls);
 }
 
 
@@ -1509,17 +1504,17 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
-               enum GNUNET_SCHEDULER_Priority priority,
-               struct GNUNET_NETWORK_Handle *rfd,
-               GNUNET_SCHEDULER_TaskCallback task,
-                                             void *task_cls)
+GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay,
+                                            enum GNUNET_SCHEDULER_Priority priority,
+                                            struct GNUNET_NETWORK_Handle *rfd,
+                                            GNUNET_SCHEDULER_TaskCallback task,
+                                            void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
-                                                 rfd,
-                                                 GNUNET_YES,
-                                                 GNUNET_NO,
-                                                 task, task_cls);
+  return GNUNET_SCHEDULER_add_net_with_priority(delay, priority,
+                                                rfd,
+                                                GNUNET_YES,
+                                                GNUNET_NO,
+                                                task, task_cls);
 }
 
 
@@ -1545,16 +1540,16 @@ GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
-                                struct GNUNET_NETWORK_Handle *wfd,
-                                GNUNET_SCHEDULER_TaskCallback task,
-                                void *task_cls)
+GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay,
+                               struct GNUNET_NETWORK_Handle *wfd,
+                               GNUNET_SCHEDULER_TaskCallback task,
+                               void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_net_with_priority (delay,
-                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                 wfd,
-                                                 GNUNET_NO, GNUNET_YES,
-                                                 task, task_cls);
+  return GNUNET_SCHEDULER_add_net_with_priority(delay,
+                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                wfd,
+                                                GNUNET_NO, GNUNET_YES,
+                                                task, task_cls);
 }
 
 /**
@@ -1581,40 +1576,40 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  *         only valid until "task" is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
-                                         enum GNUNET_SCHEDULER_Priority priority,
-                                         struct GNUNET_NETWORK_Handle *fd,
-                                         int on_read,
-                                         int on_write,
-                                         GNUNET_SCHEDULER_TaskCallback task,
-                                         void *task_cls)
+GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay,
+                                       enum GNUNET_SCHEDULER_Priority priority,
+                                       struct GNUNET_NETWORK_Handle *fd,
+                                       int on_read,
+                                       int on_write,
+                                       GNUNET_SCHEDULER_TaskCallback task,
+                                       void *task_cls)
 {
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
+  GNUNET_assert(NULL != scheduler_driver);
 
 #if MINGW
   struct GNUNET_NETWORK_FDSet *s;
   struct GNUNET_SCHEDULER_Task * ret;
 
-  GNUNET_assert (NULL != fd);
-  s = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_set (s, fd);
-  ret = GNUNET_SCHEDULER_add_select (
-      priority, delay,
-      on_read  ? s : NULL,
-      on_write ? s : NULL,
-      task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (s);
+  GNUNET_assert(NULL != fd);
+  s = GNUNET_NETWORK_fdset_create();
+  GNUNET_NETWORK_fdset_set(s, fd);
+  ret = GNUNET_SCHEDULER_add_select(
+    priority, delay,
+    on_read  ? s : NULL,
+    on_write ? s : NULL,
+    task, task_cls);
+  GNUNET_NETWORK_fdset_destroy(s);
   return ret;
 #else
-  GNUNET_assert (on_read || on_write);
-  GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0);
-  return add_without_sets (delay, priority,
-                           on_read  ? fd : NULL,
-                           on_write ? fd : NULL,
-                           NULL,
-                           NULL,
-                           task, task_cls);
+  GNUNET_assert(on_read || on_write);
+  GNUNET_assert(GNUNET_NETWORK_get_fd(fd) >= 0);
+  return add_without_sets(delay, priority,
+                          on_read  ? fd : NULL,
+                          on_write ? fd : NULL,
+                          NULL,
+                          NULL,
+                          task, task_cls);
 #endif
 }
 
@@ -1640,14 +1635,14 @@ GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
-                                const struct GNUNET_DISK_FileHandle *rfd,
-                                GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay,
+                               const struct GNUNET_DISK_FileHandle *rfd,
+                               GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_file_with_priority (
-      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-      rfd, GNUNET_YES, GNUNET_NO,
-      task, task_cls);
+  return GNUNET_SCHEDULER_add_file_with_priority(
+    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+    rfd, GNUNET_YES, GNUNET_NO,
+    task, task_cls);
 }
 
 
@@ -1672,14 +1667,14 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
-                                 const struct GNUNET_DISK_FileHandle *wfd,
-                                 GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay,
+                                const struct GNUNET_DISK_FileHandle *wfd,
+                                GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_file_with_priority (
-      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-      wfd, GNUNET_NO, GNUNET_YES,
-      task, task_cls);
+  return GNUNET_SCHEDULER_add_file_with_priority(
+    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+    wfd, GNUNET_NO, GNUNET_YES,
+    task, task_cls);
 }
 
 
@@ -1707,48 +1702,48 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
-                                         enum GNUNET_SCHEDULER_Priority priority,
-                                         const struct GNUNET_DISK_FileHandle *fd,
-                                         int on_read, int on_write,
-                                         GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay,
+                                        enum GNUNET_SCHEDULER_Priority priority,
+                                        const struct GNUNET_DISK_FileHandle *fd,
+                                        int on_read, int on_write,
+                                        GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
 {
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
+  GNUNET_assert(NULL != scheduler_driver);
 
 #if MINGW
   struct GNUNET_NETWORK_FDSet *s;
   struct GNUNET_SCHEDULER_Task * ret;
 
-  GNUNET_assert (NULL != fd);
-  s = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_handle_set (s, fd);
-  ret = GNUNET_SCHEDULER_add_select (
-      priority, delay,
-      on_read  ? s : NULL,
-      on_write ? s : NULL,
-      task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (s);
+  GNUNET_assert(NULL != fd);
+  s = GNUNET_NETWORK_fdset_create();
+  GNUNET_NETWORK_fdset_handle_set(s, fd);
+  ret = GNUNET_SCHEDULER_add_select(
+    priority, delay,
+    on_read  ? s : NULL,
+    on_write ? s : NULL,
+    task, task_cls);
+  GNUNET_NETWORK_fdset_destroy(s);
   return ret;
 #else
-  GNUNET_assert (on_read || on_write);
-  GNUNET_assert (fd->fd >= 0);
-  return add_without_sets (delay, priority,
-                           NULL,
-                           NULL,
-                           on_read ? fd : NULL,
-                           on_write ? fd : NULL,
-                           task, task_cls);
+  GNUNET_assert(on_read || on_write);
+  GNUNET_assert(fd->fd >= 0);
+  return add_without_sets(delay, priority,
+                          NULL,
+                          NULL,
+                          on_read ? fd : NULL,
+                          on_write ? fd : NULL,
+                          task, task_cls);
 #endif
 }
 
 
 void
-extract_handles (const struct GNUNET_NETWORK_FDSet *fdset,
-                 const struct GNUNET_NETWORK_Handle ***ntarget,
-                 unsigned int *extracted_nhandles,
-                 const struct GNUNET_DISK_FileHandle ***ftarget,
-                 unsigned int *extracted_fhandles)
+extract_handles(const struct GNUNET_NETWORK_FDSet *fdset,
+                const struct GNUNET_NETWORK_Handle ***ntarget,
+                unsigned int *extracted_nhandles,
+                const struct GNUNET_DISK_FileHandle ***ftarget,
+                unsigned int *extracted_fhandles)
 {
   // FIXME: this implementation only works for unix, for WIN32 the file handles
   // in fdset must be handled separately
@@ -1762,31 +1757,31 @@ extract_handles (const struct GNUNET_NETWORK_FDSet *fdset,
   nhandles_len = 0;
   fhandles_len = 0;
   for (int sock = 0; sock != fdset->nsds; ++sock)
-  {
-    if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (fdset, sock))
     {
-      struct GNUNET_NETWORK_Handle *nhandle;
-      struct GNUNET_DISK_FileHandle *fhandle;
-
-      nhandle = GNUNET_NETWORK_socket_box_native (sock);
-      if (NULL != nhandle)
-      {
-        GNUNET_array_append (nhandles, nhandles_len, nhandle);
-      }
-      else
-      {
-        fhandle = GNUNET_DISK_get_handle_from_int_fd (sock);
-        if (NULL != fhandle)
+      if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native(fdset, sock))
         {
-          GNUNET_array_append (fhandles, fhandles_len, fhandle);
+          struct GNUNET_NETWORK_Handle *nhandle;
+          struct GNUNET_DISK_FileHandle *fhandle;
+
+          nhandle = GNUNET_NETWORK_socket_box_native(sock);
+          if (NULL != nhandle)
+            {
+              GNUNET_array_append(nhandles, nhandles_len, nhandle);
+            }
+          else
+            {
+              fhandle = GNUNET_DISK_get_handle_from_int_fd(sock);
+              if (NULL != fhandle)
+                {
+                  GNUNET_array_append(fhandles, fhandles_len, fhandle);
+                }
+              else
+                {
+                  GNUNET_assert(0);
+                }
+            }
         }
-        else
-        {
-          GNUNET_assert (0);
-        }
-      }
     }
-  }
   *ntarget = nhandles_len > 0 ? nhandles : NULL;
   *ftarget = fhandles_len > 0 ? fhandles : NULL;
   *extracted_nhandles = nhandles_len;
@@ -1826,12 +1821,12 @@ extract_handles (const struct GNUNET_NETWORK_FDSet *fdset,
  *         only valid until @a task is started!
  */
 struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
-                             struct GNUNET_TIME_Relative delay,
-                             const struct GNUNET_NETWORK_FDSet *rs,
-                             const struct GNUNET_NETWORK_FDSet *ws,
-                             GNUNET_SCHEDULER_TaskCallback task,
-                             void *task_cls)
+GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio,
+                            struct GNUNET_TIME_Relative delay,
+                            const struct GNUNET_NETWORK_FDSet *rs,
+                            const struct GNUNET_NETWORK_FDSet *ws,
+                            GNUNET_SCHEDULER_TaskCallback task,
+                            void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
   const struct GNUNET_NETWORK_Handle **read_nhandles = NULL;
@@ -1844,8 +1839,8 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   unsigned int write_fhandles_len = 0;
 
   /* scheduler must be running */
-  GNUNET_assert (NULL != scheduler_driver);
-  GNUNET_assert (NULL != task);
+  GNUNET_assert(NULL != scheduler_driver);
+  GNUNET_assert(NULL != task);
   int no_rs = (NULL == rs);
   int no_ws = (NULL == ws);
   int empty_rs = (NULL != rs) && (0 == rs->nsds);
@@ -1854,25 +1849,25 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                (empty_rs && empty_ws) ||
                (no_rs && empty_ws) ||
                (no_ws && empty_rs);
-  if (! no_fds)
-  {
-    if (NULL != rs)
+  if (!no_fds)
     {
-      extract_handles (rs,
-                       &read_nhandles,
-                       &read_nhandles_len,
-                       &read_fhandles,
-                       &read_fhandles_len);
-    }
-    if (NULL != ws)
-    {
-      extract_handles (ws,
-                       &write_nhandles,
-                       &write_nhandles_len,
-                       &write_fhandles,
-                       &write_fhandles_len);
+      if (NULL != rs)
+        {
+          extract_handles(rs,
+                          &read_nhandles,
+                          &read_nhandles_len,
+                          &read_fhandles,
+                          &read_fhandles_len);
+        }
+      if (NULL != ws)
+        {
+          extract_handles(ws,
+                          &write_nhandles,
+                          &write_nhandles_len,
+                          &write_fhandles,
+                          &write_fhandles_len);
+        }
     }
-  }
   /**
    * here we consider the case that a GNUNET_NETWORK_FDSet might be empty
    * although its maximum FD number (nsds) is greater than 0. We handle
@@ -1885,49 +1880,49 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                          (0 == write_nhandles_len) &&
                          (0 == write_fhandles_len);
   if (no_fds || no_fds_extracted)
-    return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
-                                                       prio,
-                                                       task,
-                                                       task_cls);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
-  GNUNET_async_scope_get (&t->scope);
-  init_fd_info (t,
-                read_nhandles,
-                read_nhandles_len,
-                write_nhandles,
-                write_nhandles_len,
-                read_fhandles,
-                read_fhandles_len,
-                write_fhandles,
-                write_fhandles_len);
+    return GNUNET_SCHEDULER_add_delayed_with_priority(delay,
+                                                      prio,
+                                                      task,
+                                                      task_cls);
+  t = GNUNET_new(struct GNUNET_SCHEDULER_Task);
+  GNUNET_async_scope_get(&t->scope);
+  init_fd_info(t,
+               read_nhandles,
+               read_nhandles_len,
+               write_nhandles,
+               write_nhandles_len,
+               read_fhandles,
+               read_fhandles_len,
+               write_fhandles,
+               write_fhandles_len);
   t->callback = task;
   t->callback_cls = task_cls;
   t->own_handles = GNUNET_YES;
   /* free the arrays of pointers to network / file handles, the actual
    * handles will be freed in destroy_task */
-  GNUNET_array_grow (read_nhandles, read_nhandles_len, 0);
-  GNUNET_array_grow (write_nhandles, write_nhandles_len, 0);
-  GNUNET_array_grow (read_fhandles, read_fhandles_len, 0);
-  GNUNET_array_grow (write_fhandles, write_fhandles_len, 0);
+  GNUNET_array_grow(read_nhandles, read_nhandles_len, 0);
+  GNUNET_array_grow(write_nhandles, write_nhandles_len, 0);
+  GNUNET_array_grow(read_fhandles, read_fhandles_len, 0);
+  GNUNET_array_grow(write_fhandles, write_fhandles_len, 0);
 #if PROFILE_DELAYS
-  t->start_time = GNUNET_TIME_absolute_get ();
+  t->start_time = GNUNET_TIME_absolute_get();
 #endif
-  t->timeout = GNUNET_TIME_relative_to_absolute (delay);
+  t->timeout = GNUNET_TIME_relative_to_absolute(delay);
   t->priority =
-      check_priority ((prio ==
-                       GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
-                      prio);
+    check_priority((prio ==
+                    GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
+                   prio);
   t->lifeness = current_lifeness;
-  GNUNET_CONTAINER_DLL_insert (pending_head,
-                               pending_tail,
-                               t);
-  driver_add_multiple (t);
-  max_priority_added = GNUNET_MAX (max_priority_added,
-           t->priority);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task %p\n",
-       t);
-  init_backtrace (t);
+  GNUNET_CONTAINER_DLL_insert(pending_head,
+                              pending_tail,
+                              t);
+  driver_add_multiple(t);
+  max_priority_added = GNUNET_MAX(max_priority_added,
+                                  t->priority);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Adding task %p\n",
+      t);
+  init_backtrace(t);
   return t;
 }
 
@@ -1944,27 +1939,27 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
  * @param fdi information about the related FD
  */
 void
-GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
-                             struct GNUNET_SCHEDULER_FdInfo *fdi)
+GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task,
+                            struct GNUNET_SCHEDULER_FdInfo *fdi)
 {
   enum GNUNET_SCHEDULER_Reason reason;
 
   reason = task->reason;
-  if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
-       (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)) )
+  if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
+      (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)))
     reason |= GNUNET_SCHEDULER_REASON_READ_READY;
-  if ( (0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
-       (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)) )
+  if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
+      (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)))
     reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
   reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
   task->reason = reason;
   if (GNUNET_NO == task->in_ready_list)
-  {
-    GNUNET_CONTAINER_DLL_remove (pending_head,
-                                 pending_tail,
-                                 task);
-    queue_ready_task (task);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(pending_head,
+                                  pending_tail,
+                                  task);
+      queue_ready_task(task);
+    }
 }
 
 
@@ -1989,173 +1984,173 @@ GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
  *         if we are done running tasks (yield to block)
  */
 int
-GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh)
+GNUNET_SCHEDULER_do_work(struct GNUNET_SCHEDULER_Handle *sh)
 {
   enum GNUNET_SCHEDULER_Priority p;
   struct GNUNET_SCHEDULER_Task *pos;
   struct GNUNET_TIME_Absolute now;
 
   /* check for tasks that reached the timeout! */
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   pos = pending_timeout_head;
   while (NULL != pos)
-  {
-    struct GNUNET_SCHEDULER_Task *next = pos->next;
-    if (now.abs_value_us >= pos->timeout.abs_value_us)
-      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-    if (0 == pos->reason)
-      break;
-    GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
-                                 pending_timeout_tail,
-                                 pos);
-    if (pending_timeout_last == pos)
-      pending_timeout_last = NULL;
-    queue_ready_task (pos);
-    pos = next;
-  }
+    {
+      struct GNUNET_SCHEDULER_Task *next = pos->next;
+      if (now.abs_value_us >= pos->timeout.abs_value_us)
+        pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+      if (0 == pos->reason)
+        break;
+      GNUNET_CONTAINER_DLL_remove(pending_timeout_head,
+                                  pending_timeout_tail,
+                                  pos);
+      if (pending_timeout_last == pos)
+        pending_timeout_last = NULL;
+      queue_ready_task(pos);
+      pos = next;
+    }
   pos = pending_head;
   while (NULL != pos)
-  {
-    struct GNUNET_SCHEDULER_Task *next = pos->next;
-    if (now.abs_value_us >= pos->timeout.abs_value_us)
     {
-      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-      GNUNET_CONTAINER_DLL_remove (pending_head,
-                                   pending_tail,
-                                   pos);
-      queue_ready_task (pos);
+      struct GNUNET_SCHEDULER_Task *next = pos->next;
+      if (now.abs_value_us >= pos->timeout.abs_value_us)
+        {
+          pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+          GNUNET_CONTAINER_DLL_remove(pending_head,
+                                      pending_tail,
+                                      pos);
+          queue_ready_task(pos);
+        }
+      pos = next;
     }
-    pos = next;
-  }
 
   if (0 == ready_count)
-  {
-    struct GNUNET_TIME_Absolute timeout = get_timeout ();
-
-    if (timeout.abs_value_us > now.abs_value_us)
-    {
-      /**
-       * The event loop called this function before the current timeout was
-       * reached (and no FD tasks are ready). This is acceptable if
-       *
-       * - the system time was changed while the driver was waiting for
-       *   the timeout
-       * - an external event loop called GNUnet API functions outside of
-       *   the callbacks called in GNUNET_SCHEDULER_do_work and thus 
-       *   wasn't notified about the new timeout
-       *
-       * It might also mean we are busy-waiting because of a programming
-       * error in the external event loop.
-       */
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "GNUNET_SCHEDULER_do_work did not find any ready "
-           "tasks and timeout has not been reached yet.\n");
-    }
-    else
-    {
-      /**
-       * the current timeout was reached but no ready tasks were found,
-       * internal scheduler error!
-       */
-      GNUNET_assert (0);
-    }
-  }
-  else
-  {
-    /* find out which task priority level we are going to
-       process this time */
-    max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
-    GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
-    /* yes, p>0 is correct, 0 is "KEEP" which should
-     * always be an empty queue (see assertion)! */
-    for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
     {
-      pos = ready_head[p];
-      if (NULL != pos)
-        break;
-    }
-    GNUNET_assert (NULL != pos);        /* ready_count wrong? */
+      struct GNUNET_TIME_Absolute timeout = get_timeout();
 
-    /* process all tasks at this priority level, then yield */
-    while (NULL != (pos = ready_head[p]))
-    {
-      GNUNET_CONTAINER_DLL_remove (ready_head[p],
-           ready_tail[p],
-           pos);
-      ready_count--;
-      current_priority = pos->priority;
-      current_lifeness = pos->lifeness;
-      active_task = pos;
-#if PROFILE_DELAYS
-      if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
-          DELAY_THRESHOLD.rel_value_us)
-      {
-        LOG (GNUNET_ERROR_TYPE_DEBUG,
-             "Task %p took %s to be scheduled\n",
-             pos,
-             GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
-                                                     GNUNET_YES));
-      }
-#endif
-      tc.reason = pos->reason;
-      GNUNET_NETWORK_fdset_zero (sh->rs);
-      GNUNET_NETWORK_fdset_zero (sh->ws);
-      // FIXME: do we have to remove FdInfos from fds if they are not ready?
-      tc.fds_len = pos->fds_len;
-      tc.fds = pos->fds;
-      for (unsigned int i = 0; i != pos->fds_len; ++i)
-      {
-        struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i];
-        if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et))
+      if (timeout.abs_value_us > now.abs_value_us)
         {
-          GNUNET_NETWORK_fdset_set_native (sh->rs,
-                                           fdi->sock);
+          /**
+           * The event loop called this function before the current timeout was
+           * reached (and no FD tasks are ready). This is acceptable if
+           *
+           * - the system time was changed while the driver was waiting for
+           *   the timeout
+           * - an external event loop called GNUnet API functions outside of
+           *   the callbacks called in GNUNET_SCHEDULER_do_work and thus
+           *   wasn't notified about the new timeout
+           *
+           * It might also mean we are busy-waiting because of a programming
+           * error in the external event loop.
+           */
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "GNUNET_SCHEDULER_do_work did not find any ready "
+              "tasks and timeout has not been reached yet.\n");
         }
-        if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et))
+      else
         {
-          GNUNET_NETWORK_fdset_set_native (sh->ws,
-                                           fdi->sock);
+          /**
+           * the current timeout was reached but no ready tasks were found,
+           * internal scheduler error!
+           */
+          GNUNET_assert(0);
         }
-      }
-      tc.read_ready = sh->rs;
-      tc.write_ready = sh->ws;
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Running task %p\n",
-           pos);
-      GNUNET_assert (NULL != pos->callback);
-      {
-        struct GNUNET_AsyncScopeSave old_scope;
-        if (pos->scope.have_scope)
-          GNUNET_async_scope_enter (&pos->scope.scope_id, &old_scope);
-        else
-          GNUNET_async_scope_get (&old_scope);
-        pos->callback (pos->callback_cls);
-        GNUNET_async_scope_restore (&old_scope);
-      }
-      if (NULL != pos->fds)
-      {
-        int del_result = scheduler_driver->del (scheduler_driver->cls, pos);
-        if (GNUNET_OK != del_result)
+    }
+  else
+    {
+      /* find out which task priority level we are going to
+         process this time */
+      max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
+      GNUNET_assert(NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
+      /* yes, p>0 is correct, 0 is "KEEP" which should
+       * always be an empty queue (see assertion)! */
+      for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
         {
-          LOG (GNUNET_ERROR_TYPE_ERROR,
-             "driver could not delete task %p\n", pos);
-          GNUNET_assert (0);
+          pos = ready_head[p];
+          if (NULL != pos)
+            break;
+        }
+      GNUNET_assert(NULL != pos);       /* ready_count wrong? */
+
+      /* process all tasks at this priority level, then yield */
+      while (NULL != (pos = ready_head[p]))
+        {
+          GNUNET_CONTAINER_DLL_remove(ready_head[p],
+                                      ready_tail[p],
+                                      pos);
+          ready_count--;
+          current_priority = pos->priority;
+          current_lifeness = pos->lifeness;
+          active_task = pos;
+#if PROFILE_DELAYS
+          if (GNUNET_TIME_absolute_get_duration(pos->start_time).rel_value_us >
+              DELAY_THRESHOLD.rel_value_us)
+            {
+              LOG(GNUNET_ERROR_TYPE_DEBUG,
+                  "Task %p took %s to be scheduled\n",
+                  pos,
+                  GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(pos->start_time),
+                                                         GNUNET_YES));
+            }
+#endif
+          tc.reason = pos->reason;
+          GNUNET_NETWORK_fdset_zero(sh->rs);
+          GNUNET_NETWORK_fdset_zero(sh->ws);
+          // FIXME: do we have to remove FdInfos from fds if they are not ready?
+          tc.fds_len = pos->fds_len;
+          tc.fds = pos->fds;
+          for (unsigned int i = 0; i != pos->fds_len; ++i)
+            {
+              struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i];
+              if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et))
+                {
+                  GNUNET_NETWORK_fdset_set_native(sh->rs,
+                                                  fdi->sock);
+                }
+              if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et))
+                {
+                  GNUNET_NETWORK_fdset_set_native(sh->ws,
+                                                  fdi->sock);
+                }
+            }
+          tc.read_ready = sh->rs;
+          tc.write_ready = sh->ws;
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Running task %p\n",
+              pos);
+          GNUNET_assert(NULL != pos->callback);
+          {
+            struct GNUNET_AsyncScopeSave old_scope;
+            if (pos->scope.have_scope)
+              GNUNET_async_scope_enter(&pos->scope.scope_id, &old_scope);
+            else
+              GNUNET_async_scope_get(&old_scope);
+            pos->callback(pos->callback_cls);
+            GNUNET_async_scope_restore(&old_scope);
+          }
+          if (NULL != pos->fds)
+            {
+              int del_result = scheduler_driver->del(scheduler_driver->cls, pos);
+              if (GNUNET_OK != del_result)
+                {
+                  LOG(GNUNET_ERROR_TYPE_ERROR,
+                      "driver could not delete task %p\n", pos);
+                  GNUNET_assert(0);
+                }
+            }
+          active_task = NULL;
+          dump_backtrace(pos);
+          destroy_task(pos);
         }
-      }
-      active_task = NULL;
-      dump_backtrace (pos);
-      destroy_task (pos);
     }
-  }
-  shutdown_if_no_lifeness ();
+  shutdown_if_no_lifeness();
   if (0 == ready_count)
-  {
-    scheduler_driver->set_wakeup (scheduler_driver->cls,
-                                  get_timeout ());
-    return GNUNET_NO;
-  }
-  scheduler_driver->set_wakeup (scheduler_driver->cls,
-                                GNUNET_TIME_absolute_get ());
+    {
+      scheduler_driver->set_wakeup(scheduler_driver->cls,
+                                   get_timeout());
+      return GNUNET_NO;
+    }
+  scheduler_driver->set_wakeup(scheduler_driver->cls,
+                               GNUNET_TIME_absolute_get());
   return GNUNET_YES;
 }
 
@@ -2192,64 +2187,64 @@ GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh)
  *         #GNUNET_SCHEDULER_driver_done
  */
 struct GNUNET_SCHEDULER_Handle *
-GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver)
+GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver)
 {
   struct GNUNET_SCHEDULER_Handle *sh;
   const struct GNUNET_DISK_FileHandle *pr;
 
   /* scheduler must not be running */
-  GNUNET_assert (NULL == scheduler_driver);
-  GNUNET_assert (NULL == shutdown_pipe_handle);
+  GNUNET_assert(NULL == scheduler_driver);
+  GNUNET_assert(NULL == shutdown_pipe_handle);
   /* general set-up */
-  sh = GNUNET_new (struct GNUNET_SCHEDULER_Handle);
-  shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
-                                           GNUNET_NO,
-                                           GNUNET_NO,
-                                           GNUNET_NO);
-  GNUNET_assert (NULL != shutdown_pipe_handle);
-  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
-                                GNUNET_DISK_PIPE_END_READ);
-  my_pid = getpid ();
+  sh = GNUNET_new(struct GNUNET_SCHEDULER_Handle);
+  shutdown_pipe_handle = GNUNET_DISK_pipe(GNUNET_NO,
+                                          GNUNET_NO,
+                                          GNUNET_NO,
+                                          GNUNET_NO);
+  GNUNET_assert(NULL != shutdown_pipe_handle);
+  pr = GNUNET_DISK_pipe_handle(shutdown_pipe_handle,
+                               GNUNET_DISK_PIPE_END_READ);
+  my_pid = getpid();
   scheduler_driver = driver;
 
   /* install signal handlers */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Registering signal handlers\n");
-  sh->shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Registering signal handlers\n");
+  sh->shc_int = GNUNET_SIGNAL_handler_install(SIGINT,
+                                              &sighandler_shutdown);
+  sh->shc_term = GNUNET_SIGNAL_handler_install(SIGTERM,
                                                &sighandler_shutdown);
-  sh->shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
-                                                &sighandler_shutdown);
 #if (SIGTERM != GNUNET_TERM_SIG)
-  sh->shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
-                                                 &sighandler_shutdown);
+  sh->shc_gterm = GNUNET_SIGNAL_handler_install(GNUNET_TERM_SIG,
+                                                &sighandler_shutdown);
 #endif
 #ifndef MINGW
-  sh->shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
-                                                &sighandler_pipe);
-  sh->shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
-                                                &sighandler_shutdown);
-  sh->shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
+  sh->shc_pipe = GNUNET_SIGNAL_handler_install(SIGPIPE,
+                                               &sighandler_pipe);
+  sh->shc_quit = GNUNET_SIGNAL_handler_install(SIGQUIT,
                                                &sighandler_shutdown);
+  sh->shc_hup = GNUNET_SIGNAL_handler_install(SIGHUP,
+                                              &sighandler_shutdown);
 #endif
 
   /* Setup initial tasks */
   current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
   current_lifeness = GNUNET_NO;
   install_parent_control_task =
-    GNUNET_SCHEDULER_add_now (&install_parent_control_handler,
-                              NULL);
+    GNUNET_SCHEDULER_add_now(&install_parent_control_handler,
+                             NULL);
   shutdown_pipe_task =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    pr,
-                                    &shutdown_pipe_cb,
-                                    NULL);
+    GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                   pr,
+                                   &shutdown_pipe_cb,
+                                   NULL);
   current_lifeness = GNUNET_YES;
-  scheduler_driver->set_wakeup (scheduler_driver->cls,
-                                get_timeout ());
+  scheduler_driver->set_wakeup(scheduler_driver->cls,
+                               get_timeout());
   /* begin main event loop */
-  sh->rs = GNUNET_NETWORK_fdset_create ();
-  sh->ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_handle_set (sh->rs, pr);
+  sh->rs = GNUNET_NETWORK_fdset_create();
+  sh->ws = GNUNET_NETWORK_fdset_create();
+  GNUNET_NETWORK_fdset_handle_set(sh->rs, pr);
   return sh;
 }
 
@@ -2269,244 +2264,245 @@ GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver)
  * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init
  */
 void
-GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh)
+GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh)
 {
-  GNUNET_assert (NULL == pending_head);
-  GNUNET_assert (NULL == pending_timeout_head);
-  GNUNET_assert (NULL == shutdown_head);
+  GNUNET_assert(NULL == pending_head);
+  GNUNET_assert(NULL == pending_timeout_head);
+  GNUNET_assert(NULL == shutdown_head);
   for (int i = 0; i != GNUNET_SCHEDULER_PRIORITY_COUNT; ++i)
-  {
-    GNUNET_assert (NULL == ready_head[i]);
-  }
-  GNUNET_NETWORK_fdset_destroy (sh->rs);
-  GNUNET_NETWORK_fdset_destroy (sh->ws);
+    {
+      GNUNET_assert(NULL == ready_head[i]);
+    }
+  GNUNET_NETWORK_fdset_destroy(sh->rs);
+  GNUNET_NETWORK_fdset_destroy(sh->ws);
 
   /* uninstall signal handlers */
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_int);
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_term);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_int);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_term);
 #if (SIGTERM != GNUNET_TERM_SIG)
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_gterm);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_gterm);
 #endif
 #ifndef MINGW
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_pipe);
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_quit);
-  GNUNET_SIGNAL_handler_uninstall (sh->shc_hup);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_pipe);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_quit);
+  GNUNET_SIGNAL_handler_uninstall(sh->shc_hup);
 #endif
-  GNUNET_DISK_pipe_close (shutdown_pipe_handle);
+  GNUNET_DISK_pipe_close(shutdown_pipe_handle);
   shutdown_pipe_handle = NULL;
   scheduler_driver = NULL;
-  GNUNET_free (sh);
+  GNUNET_free(sh);
 }
 
 
 static int
-select_loop (struct GNUNET_SCHEDULER_Handle *sh,
-             struct DriverContext *context)
+select_loop(struct GNUNET_SCHEDULER_Handle *sh,
+            struct DriverContext *context)
 {
   struct GNUNET_NETWORK_FDSet *rs;
   struct GNUNET_NETWORK_FDSet *ws;
   int select_result;
 
-  GNUNET_assert (NULL != context);
-  rs = GNUNET_NETWORK_fdset_create ();
-  ws = GNUNET_NETWORK_fdset_create ();
-  while ( (NULL != context->scheduled_head) ||
-          (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us != context->timeout.abs_value_us) )
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "select timeout = %s\n",
-         GNUNET_STRINGS_absolute_time_to_string (context->timeout));
-
-    GNUNET_NETWORK_fdset_zero (rs);
-    GNUNET_NETWORK_fdset_zero (ws);
-
-    for (struct Scheduled *pos = context->scheduled_head;
-         NULL != pos;
-         pos = pos->next)
+  GNUNET_assert(NULL != context);
+  rs = GNUNET_NETWORK_fdset_create();
+  ws = GNUNET_NETWORK_fdset_create();
+  while ((NULL != context->scheduled_head) ||
+         (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us != context->timeout.abs_value_us))
     {
-      if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et))
-      {
-        GNUNET_NETWORK_fdset_set_native (rs, pos->fdi->sock);
-      }
-      if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et))
-      {
-        GNUNET_NETWORK_fdset_set_native (ws, pos->fdi->sock);
-      }
-    }
-    struct GNUNET_TIME_Relative time_remaining =
-      GNUNET_TIME_absolute_get_remaining (context->timeout);
-    if (NULL == scheduler_select)
-    {
-      select_result = GNUNET_NETWORK_socket_select (rs,
-                                                    ws,
-                                                    NULL,
-                                                    time_remaining);
-    }
-    else
-    {
-      select_result = scheduler_select (scheduler_select_cls,
-                                        rs,
-                                        ws,
-                                        NULL,
-                                        time_remaining);
-    }
-    if (select_result == GNUNET_SYSERR)
-    {
-      if (errno == EINTR)
-        continue;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "select timeout = %s\n",
+          GNUNET_STRINGS_absolute_time_to_string(context->timeout));
+
+      GNUNET_NETWORK_fdset_zero(rs);
+      GNUNET_NETWORK_fdset_zero(ws);
 
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
-                    "select");
+      for (struct Scheduled *pos = context->scheduled_head;
+           NULL != pos;
+           pos = pos->next)
+        {
+          if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et))
+            {
+              GNUNET_NETWORK_fdset_set_native(rs, pos->fdi->sock);
+            }
+          if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et))
+            {
+              GNUNET_NETWORK_fdset_set_native(ws, pos->fdi->sock);
+            }
+        }
+      struct GNUNET_TIME_Relative time_remaining =
+        GNUNET_TIME_absolute_get_remaining(context->timeout);
+      if (NULL == scheduler_select)
+        {
+          select_result = GNUNET_NETWORK_socket_select(rs,
+                                                       ws,
+                                                       NULL,
+                                                       time_remaining);
+        }
+      else
+        {
+          select_result = scheduler_select(scheduler_select_cls,
+                                           rs,
+                                           ws,
+                                           NULL,
+                                           time_remaining);
+        }
+      if (select_result == GNUNET_SYSERR)
+        {
+          if (errno == EINTR)
+            continue;
+
+          LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR,
+                       "select");
 #ifndef MINGW
 #if USE_LSOF
-      char lsof[512];
-
-      snprintf (lsof,
-                sizeof (lsof),
-                "lsof -p %d",
-                getpid ());
-      (void) close (1);
-      (void) dup2 (2, 1);
-      if (0 != system (lsof))
-        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                      "system");
+          char lsof[512];
+
+          snprintf(lsof,
+                   sizeof(lsof),
+                   "lsof -p %d",
+                   getpid());
+          (void)close(1);
+          (void)dup2(2, 1);
+          if (0 != system(lsof))
+            LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING,
+                         "system");
 #endif
 #endif
 #if DEBUG_FDS
-      for (struct Scheduled *s = context->scheduled_head;
-           NULL != s;
-           s = s->next)
-      {
-        int flags = fcntl (s->fdi->sock,
-                           F_GETFD);
-
-        if ( (flags == -1) &&
-             (EBADF == errno) )
-        {
-          LOG (GNUNET_ERROR_TYPE_ERROR,
-               "Got invalid file descriptor %d!\n",
-               s->fdi->sock);
+          for (struct Scheduled *s = context->scheduled_head;
+               NULL != s;
+               s = s->next)
+            {
+              int flags = fcntl(s->fdi->sock,
+                                F_GETFD);
+
+              if ((flags == -1) &&
+                  (EBADF == errno))
+                {
+                  LOG(GNUNET_ERROR_TYPE_ERROR,
+                      "Got invalid file descriptor %d!\n",
+                      s->fdi->sock);
 #if EXECINFO
-          dump_backtrace (s->task);
+                  dump_backtrace(s->task);
 #endif
-        }
-      }
+                }
+            }
 #endif
-      GNUNET_assert (0);
-      GNUNET_NETWORK_fdset_destroy (rs);
-      GNUNET_NETWORK_fdset_destroy (ws);
-      return GNUNET_SYSERR;
-    }
-    if (select_result > 0)
-    {
-      for (struct Scheduled *pos = context->scheduled_head;
-           NULL != pos;
-           pos = pos->next)
-      {
-        int is_ready = GNUNET_NO;
-
-        if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) &&
-            GNUNET_YES ==
-            GNUNET_NETWORK_fdset_test_native (rs,
-                                              pos->fdi->sock))
-        {
-          pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
-          is_ready = GNUNET_YES;
+          GNUNET_assert(0);
+          GNUNET_NETWORK_fdset_destroy(rs);
+          GNUNET_NETWORK_fdset_destroy(ws);
+          return GNUNET_SYSERR;
         }
-        if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) &&
-            GNUNET_YES ==
-            GNUNET_NETWORK_fdset_test_native (ws,
-                                              pos->fdi->sock))
+      if (select_result > 0)
         {
-          pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
-          is_ready = GNUNET_YES;
+          for (struct Scheduled *pos = context->scheduled_head;
+               NULL != pos;
+               pos = pos->next)
+            {
+              int is_ready = GNUNET_NO;
+
+              if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) &&
+                  GNUNET_YES ==
+                  GNUNET_NETWORK_fdset_test_native(rs,
+                                                   pos->fdi->sock))
+                {
+                  pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
+                  is_ready = GNUNET_YES;
+                }
+              if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) &&
+                  GNUNET_YES ==
+                  GNUNET_NETWORK_fdset_test_native(ws,
+                                                   pos->fdi->sock))
+                {
+                  pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
+                  is_ready = GNUNET_YES;
+                }
+              if (GNUNET_YES == is_ready)
+                {
+                  GNUNET_SCHEDULER_task_ready(pos->task,
+                                              pos->fdi);
+                }
+            }
         }
-        if (GNUNET_YES == is_ready)
+      if (GNUNET_YES == GNUNET_SCHEDULER_do_work(sh))
         {
-          GNUNET_SCHEDULER_task_ready (pos->task,
-                                       pos->fdi);
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "scheduler has more tasks ready!\n");
         }
-      }
     }
-    if (GNUNET_YES == GNUNET_SCHEDULER_do_work (sh))
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "scheduler has more tasks ready!\n");
-    }
-  }
-  GNUNET_NETWORK_fdset_destroy (rs);
-  GNUNET_NETWORK_fdset_destroy (ws);
+  GNUNET_NETWORK_fdset_destroy(rs);
+  GNUNET_NETWORK_fdset_destroy(ws);
   return GNUNET_OK;
 }
 
 
 static int
-select_add (void *cls,
-            struct GNUNET_SCHEDULER_Task *task,
-            struct GNUNET_SCHEDULER_FdInfo *fdi)
+select_add(void *cls,
+           struct GNUNET_SCHEDULER_Task *task,
+           struct GNUNET_SCHEDULER_FdInfo *fdi)
 {
   struct DriverContext *context = cls;
-  GNUNET_assert (NULL != context);
-  GNUNET_assert (NULL != task);
-  GNUNET_assert (NULL != fdi);
-  GNUNET_assert (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) ||
-                 0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et));
+
+  GNUNET_assert(NULL != context);
+  GNUNET_assert(NULL != task);
+  GNUNET_assert(NULL != fdi);
+  GNUNET_assert(0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) ||
+                0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et));
 
   if (!((NULL != fdi->fd) ^ (NULL != fdi->fh)) || (fdi->sock < 0))
-  {
-    /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */
-    return GNUNET_SYSERR;
-  }
+    {
+      /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */
+      return GNUNET_SYSERR;
+    }
 
-  struct Scheduled *scheduled = GNUNET_new (struct Scheduled);
+  struct Scheduled *scheduled = GNUNET_new(struct Scheduled);
   scheduled->task = task;
   scheduled->fdi = fdi;
   scheduled->et = fdi->et;
 
-  GNUNET_CONTAINER_DLL_insert (context->scheduled_head,
-                               context->scheduled_tail,
-                               scheduled);
+  GNUNET_CONTAINER_DLL_insert(context->scheduled_head,
+                              context->scheduled_tail,
+                              scheduled);
   return GNUNET_OK;
 }
 
 
 static int
-select_del (void *cls,
-            struct GNUNET_SCHEDULER_Task *task)
+select_del(void *cls,
+           struct GNUNET_SCHEDULER_Task *task)
 {
   struct DriverContext *context;
   struct Scheduled *pos;
   int ret;
 
-  GNUNET_assert (NULL != cls);
+  GNUNET_assert(NULL != cls);
 
   context = cls;
   ret = GNUNET_SYSERR;
   pos = context->scheduled_head;
   while (NULL != pos)
-  {
-    struct Scheduled *next = pos->next;
-    if (pos->task == task)
     {
-      GNUNET_CONTAINER_DLL_remove (context->scheduled_head,
-                                   context->scheduled_tail,
-                                   pos);
-      GNUNET_free (pos);
-      ret = GNUNET_OK;
+      struct Scheduled *next = pos->next;
+      if (pos->task == task)
+        {
+          GNUNET_CONTAINER_DLL_remove(context->scheduled_head,
+                                      context->scheduled_tail,
+                                      pos);
+          GNUNET_free(pos);
+          ret = GNUNET_OK;
+        }
+      pos = next;
     }
-    pos = next;
-  }
   return ret;
 }
 
 
 static void
-select_set_wakeup (void *cls,
-                   struct GNUNET_TIME_Absolute dt)
+select_set_wakeup(void *cls,
+                  struct GNUNET_TIME_Absolute dt)
 {
   struct DriverContext *context = cls;
 
-  GNUNET_assert (NULL != context);
+  GNUNET_assert(NULL != context);
   context->timeout = dt;
 }
 
@@ -2517,10 +2513,11 @@ select_set_wakeup (void *cls,
  * @return NULL on error
  */
 struct GNUNET_SCHEDULER_Driver *
-GNUNET_SCHEDULER_driver_select ()
+GNUNET_SCHEDULER_driver_select()
 {
   struct GNUNET_SCHEDULER_Driver *select_driver;
-  select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver);
+
+  select_driver = GNUNET_new(struct GNUNET_SCHEDULER_Driver);
 
   select_driver->add = &select_add;
   select_driver->del = &select_del;
@@ -2543,14 +2540,14 @@ GNUNET_SCHEDULER_driver_select ()
  * @param aid the asynchronous scope id to enter
  */
 void
-GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid)
+GNUNET_SCHEDULER_begin_async_scope(struct GNUNET_AsyncScopeId *aid)
 {
   struct GNUNET_AsyncScopeSave dummy_old_scope;
 
-  GNUNET_assert (NULL != active_task);
+  GNUNET_assert(NULL != active_task);
   /* Since we're in a task, the context will be automatically
      restored by the scheduler. */
-  GNUNET_async_scope_enter (aid, &dummy_old_scope);
+  GNUNET_async_scope_enter(aid, &dummy_old_scope);
 }
 
 
diff --git a/src/util/service.c b/src/util/service.c
index 5986b0158..089d3ef35 100644
--- a/src/util/service.c
+++ b/src/util/service.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 util/service.c
@@ -37,21 +37,19 @@
 #endif
 
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-service", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-service", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-service", syscall)
+  GNUNET_log_from_strerror(kind, "util-service", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)
+  GNUNET_log_from_strerror_file(kind, "util-service", syscall, filename)
 
 
 /**
  * Information the service tracks per listen operation.
  */
-struct ServiceListenContext
-{
-
+struct ServiceListenContext {
   /**
    * Kept in a DLL.
    */
@@ -82,8 +80,7 @@ struct ServiceListenContext
 /**
  * Reasons why we might be suspended.
  */
-enum SuspendReason
-{
+enum SuspendReason {
   /**
    * We are running normally.
    */
@@ -114,8 +111,7 @@ enum SuspendReason
 /**
  * Handle to a service.
  */
-struct GNUNET_SERVICE_Handle
-{
+struct GNUNET_SERVICE_Handle {
   /**
    * Our configuration.
    */
@@ -247,9 +243,7 @@ struct GNUNET_SERVICE_Handle
 /**
  * Handle to a client that is connected to a service.
  */
-struct GNUNET_SERVICE_Client
-{
-
+struct GNUNET_SERVICE_Client {
   /**
    * Kept in a DLL.
    */
@@ -359,15 +353,15 @@ struct GNUNET_SERVICE_Client
  * @return #GNUNET_YES if we have non-monitoring clients left
  */
 static int
-have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
+have_non_monitor_clients(struct GNUNET_SERVICE_Handle *sh)
 {
   for (struct GNUNET_SERVICE_Client *client = sh->clients_head; NULL != client;
        client = client->next)
-  {
-    if (client->is_monitor)
-      continue;
-    return GNUNET_YES;
-  }
+    {
+      if (client->is_monitor)
+        continue;
+      return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -380,20 +374,20 @@ have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
  * @param sr reason for suspending accepting connections
  */
 static void
-do_suspend (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
+do_suspend(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
 {
   struct ServiceListenContext *slc;
 
-  GNUNET_assert (0 == (sh->suspend_state & sr));
+  GNUNET_assert(0 == (sh->suspend_state & sr));
   sh->suspend_state |= sr;
   for (slc = sh->slc_head; NULL != slc; slc = slc->next)
-  {
-    if (NULL != slc->listen_task)
     {
-      GNUNET_SCHEDULER_cancel (slc->listen_task);
-      slc->listen_task = NULL;
+      if (NULL != slc->listen_task)
+        {
+          GNUNET_SCHEDULER_cancel(slc->listen_task);
+          slc->listen_task = NULL;
+        }
     }
-  }
 }
 
 
@@ -406,27 +400,29 @@ do_suspend (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
  * @param cls our `struct GNUNET_SERVICE_Handle`
  */
 static void
-service_shutdown (void *cls)
+service_shutdown(void *cls)
 {
   struct GNUNET_SERVICE_Handle *sh = cls;
 
   switch (sh->options)
-  {
-  case GNUNET_SERVICE_OPTION_NONE:
-    GNUNET_SERVICE_shutdown (sh);
-    break;
-  case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN:
-    /* This task should never be run if we are using
-       the manual shutdown. */
-    GNUNET_assert (0);
-    break;
-  case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN:
-    if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
-      do_suspend (sh, SUSPEND_STATE_SHUTDOWN);
-    if (GNUNET_NO == have_non_monitor_clients (sh))
-      GNUNET_SERVICE_shutdown (sh);
-    break;
-  }
+    {
+    case GNUNET_SERVICE_OPTION_NONE:
+      GNUNET_SERVICE_shutdown(sh);
+      break;
+
+    case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN:
+      /* This task should never be run if we are using
+         the manual shutdown. */
+      GNUNET_assert(0);
+      break;
+
+    case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN:
+      if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
+        do_suspend(sh, SUSPEND_STATE_SHUTDOWN);
+      if (GNUNET_NO == have_non_monitor_clients(sh))
+        GNUNET_SERVICE_shutdown(sh);
+      break;
+    }
 }
 
 
@@ -438,8 +434,8 @@ service_shutdown (void *cls)
  * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
  */
 static int
-check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
-                   const struct in_addr *add)
+check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
+                  const struct in_addr *add)
 {
   unsigned int i;
 
@@ -447,12 +443,12 @@ check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
     return GNUNET_NO;
   i = 0;
   while ((0 != list[i].network.s_addr) || (0 != list[i].netmask.s_addr))
-  {
-    if ((add->s_addr & list[i].netmask.s_addr) ==
-        (list[i].network.s_addr & list[i].netmask.s_addr))
-      return GNUNET_YES;
-    i++;
-  }
+    {
+      if ((add->s_addr & list[i].netmask.s_addr) ==
+          (list[i].network.s_addr & list[i].netmask.s_addr))
+        return GNUNET_YES;
+      i++;
+    }
   return GNUNET_NO;
 }
 
@@ -465,8 +461,8 @@ check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
  * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
  */
 static int
-check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
-                   const struct in6_addr *ip)
+check_ipv6_listed(const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
+                  const struct in6_addr *ip)
 {
   unsigned int i;
   unsigned int j;
@@ -475,17 +471,17 @@ check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
     return GNUNET_NO;
   i = 0;
 NEXT:
-  while (0 != GNUNET_is_zero (&list[i].network))
-  {
-    for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
-      if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
-          (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
-      {
-        i++;
-        goto NEXT;
-      }
-    return GNUNET_YES;
-  }
+  while (0 != GNUNET_is_zero(&list[i].network))
+    {
+      for (j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++)
+        if (((((int *)ip)[j] & ((int *)&list[i].netmask)[j])) !=
+            (((int *)&list[i].network)[j] & ((int *)&list[i].netmask)[j]))
+          {
+            i++;
+            goto NEXT;
+          }
+      return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -497,63 +493,63 @@ NEXT:
  * @param cls the `struct GNUNET_SERVICE_Client *` to send to
  */
 static void
-do_send (void *cls)
+do_send(void *cls)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   ssize_t ret;
   size_t left;
   const char *buf;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "service: sending message with type %u\n",
-       ntohs (client->msg->type));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "service: sending message with type %u\n",
+      ntohs(client->msg->type));
 
 
   client->send_task = NULL;
-  buf = (const char *) client->msg;
-  left = ntohs (client->msg->size) - client->msg_pos;
-  ret = GNUNET_NETWORK_socket_send (client->sock, &buf[client->msg_pos], left);
-  GNUNET_assert (ret <= (ssize_t) left);
+  buf = (const char *)client->msg;
+  left = ntohs(client->msg->size) - client->msg_pos;
+  ret = GNUNET_NETWORK_socket_send(client->sock, &buf[client->msg_pos], left);
+  GNUNET_assert(ret <= (ssize_t)left);
   if (0 == ret)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "no data send");
-    GNUNET_MQ_inject_error (client->mq, GNUNET_MQ_ERROR_WRITE);
-    return;
-  }
-  if (-1 == ret)
-  {
-    if ((EAGAIN == errno) || (EINTR == errno))
     {
-      /* ignore */
-      ret = 0;
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "no data send");
+      GNUNET_MQ_inject_error(client->mq, GNUNET_MQ_ERROR_WRITE);
+      return;
     }
-    else
+  if (-1 == ret)
     {
-      if (EPIPE != errno)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "socket send returned with error code %i",
-           errno);
-      GNUNET_MQ_inject_error (client->mq, GNUNET_MQ_ERROR_WRITE);
-      return;
+      if ((EAGAIN == errno) || (EINTR == errno))
+        {
+          /* ignore */
+          ret = 0;
+        }
+      else
+        {
+          if (EPIPE != errno)
+            GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send");
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "socket send returned with error code %i",
+              errno);
+          GNUNET_MQ_inject_error(client->mq, GNUNET_MQ_ERROR_WRITE);
+          return;
+        }
     }
-  }
   if (0 == client->msg_pos)
-  {
-    GNUNET_MQ_impl_send_in_flight (client->mq);
-  }
+    {
+      GNUNET_MQ_impl_send_in_flight(client->mq);
+    }
   client->msg_pos += ret;
-  if (left > (size_t) ret)
-  {
-    GNUNET_assert (NULL == client->drop_task);
-    client->send_task =
-      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      client->sock,
-                                      &do_send,
-                                      client);
-    return;
-  }
-  GNUNET_MQ_impl_send_continue (client->mq);
+  if (left > (size_t)ret)
+    {
+      GNUNET_assert(NULL == client->drop_task);
+      client->send_task =
+        GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                       client->sock,
+                                       &do_send,
+                                       client);
+      return;
+    }
+  GNUNET_MQ_impl_send_continue(client->mq);
 }
 
 
@@ -566,27 +562,27 @@ do_send (void *cls)
  * @param impl_state our `struct GNUNET_SERVICE_Client *`
  */
 static void
-service_mq_send (struct GNUNET_MQ_Handle *mq,
-                 const struct GNUNET_MessageHeader *msg,
-                 void *impl_state)
+service_mq_send(struct GNUNET_MQ_Handle *mq,
+                const struct GNUNET_MessageHeader *msg,
+                void *impl_state)
 {
   struct GNUNET_SERVICE_Client *client = impl_state;
 
-  (void) mq;
+  (void)mq;
   if (NULL != client->drop_task)
     return; /* we're going down right now, do not try to send */
-  GNUNET_assert (NULL == client->send_task);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending message of type %u and size %u to client\n",
-       ntohs (msg->type),
-       ntohs (msg->size));
+  GNUNET_assert(NULL == client->send_task);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Sending message of type %u and size %u to client\n",
+      ntohs(msg->type),
+      ntohs(msg->size));
   client->msg = msg;
   client->msg_pos = 0;
   client->send_task =
-    GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    client->sock,
-                                    &do_send,
-                                    client);
+    GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                   client->sock,
+                                   &do_send,
+                                   client);
 }
 
 
@@ -597,14 +593,14 @@ service_mq_send (struct GNUNET_MQ_Handle *mq,
  * @param impl_state state specific to the implementation
  */
 static void
-service_mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+service_mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
 {
   struct GNUNET_SERVICE_Client *client = impl_state;
 
-  (void) mq;
-  GNUNET_assert (0 == client->msg_pos);
+  (void)mq;
+  GNUNET_assert(0 == client->msg_pos);
   client->msg = NULL;
-  GNUNET_SCHEDULER_cancel (client->send_task);
+  GNUNET_SCHEDULER_cancel(client->send_task);
   client->send_task = NULL;
 }
 
@@ -619,20 +615,20 @@ service_mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
  * @param error error code
  */
 static void
-service_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+service_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_SERVICE_Handle *sh = client->sh;
 
   if ((GNUNET_MQ_ERROR_NO_MATCH == error) && (GNUNET_NO == sh->require_found))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "No handler for message of type %u found\n",
-                (unsigned int) client->warn_type);
-    GNUNET_SERVICE_client_continue (client);
-    return; /* ignore error */
-  }
-  GNUNET_SERVICE_client_drop (client);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "No handler for message of type %u found\n",
+                 (unsigned int)client->warn_type);
+      GNUNET_SERVICE_client_continue(client);
+      return; /* ignore error */
+    }
+  GNUNET_SERVICE_client_drop(client);
 }
 
 
@@ -642,24 +638,24 @@ service_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from
  */
 static void
-warn_no_client_continue (void *cls)
+warn_no_client_continue(void *cls)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GNUNET_break (
+  GNUNET_break(
     0 !=
     client->warn_type); /* type should never be 0 here, as we don't use 0 */
-  client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                    &warn_no_client_continue,
-                                                    client);
-  LOG (
+  client->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
+                                                   &warn_no_client_continue,
+                                                   client);
+  LOG(
     GNUNET_ERROR_TYPE_WARNING,
-    _ (
+    _(
       "Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"),
-    (unsigned int) client->warn_type,
-    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (
-                                              client->warn_start),
-                                            GNUNET_YES));
+    (unsigned int)client->warn_type,
+    GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(
+                                             client->warn_start),
+                                           GNUNET_YES));
 }
 
 
@@ -675,23 +671,23 @@ warn_no_client_continue (void *cls)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped
  */
 static int
-service_client_mst_cb (void *cls, const struct GNUNET_MessageHeader *message)
+service_client_mst_cb(void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received message of type %u and size %u from client\n",
-       ntohs (message->type),
-       ntohs (message->size));
-  GNUNET_assert (GNUNET_NO == client->needs_continue);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received message of type %u and size %u from client\n",
+      ntohs(message->type),
+      ntohs(message->size));
+  GNUNET_assert(GNUNET_NO == client->needs_continue);
   client->needs_continue = GNUNET_YES;
-  client->warn_type = ntohs (message->type);
-  client->warn_start = GNUNET_TIME_absolute_get ();
-  GNUNET_assert (NULL == client->warn_task);
-  client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                    &warn_no_client_continue,
-                                                    client);
-  GNUNET_MQ_inject_message (client->mq, message);
+  client->warn_type = ntohs(message->type);
+  client->warn_start = GNUNET_TIME_absolute_get();
+  GNUNET_assert(NULL == client->warn_task);
+  client->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
+                                                   &warn_no_client_continue,
+                                                   client);
+  GNUNET_MQ_inject_message(client->mq, message);
   if (NULL != client->drop_task)
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -705,37 +701,37 @@ service_client_mst_cb (void *cls, const struct GNUNET_MessageHeader *message)
  * @param cls the `struct GNUNET_SERVICE_Client` that sent us data.
  */
 static void
-service_client_recv (void *cls)
+service_client_recv(void *cls)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   int ret;
 
   client->recv_task = NULL;
-  ret = GNUNET_MST_read (client->mst, client->sock, GNUNET_NO, GNUNET_YES);
+  ret = GNUNET_MST_read(client->mst, client->sock, GNUNET_NO, GNUNET_YES);
   if (GNUNET_SYSERR == ret)
-  {
-    /* client closed connection (or IO error) */
-    if (NULL == client->drop_task)
     {
-      GNUNET_assert (GNUNET_NO == client->needs_continue);
-      GNUNET_SERVICE_client_drop (client);
+      /* client closed connection (or IO error) */
+      if (NULL == client->drop_task)
+        {
+          GNUNET_assert(GNUNET_NO == client->needs_continue);
+          GNUNET_SERVICE_client_drop(client);
+        }
+      return;
     }
-    return;
-  }
   if (GNUNET_NO == ret)
     return; /* more messages in buffer, wait for application
-         to be done processing */
-  GNUNET_assert (GNUNET_OK == ret);
+               to be done processing */
+  GNUNET_assert(GNUNET_OK == ret);
   if (GNUNET_YES == client->needs_continue)
     return;
   if (NULL != client->recv_task)
     return;
   /* MST needs more data, re-schedule read job */
   client->recv_task =
-    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                   client->sock,
-                                   &service_client_recv,
-                                   client);
+    GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                  client->sock,
+                                  &service_client_recv,
+                                  client);
 }
 
 
@@ -747,31 +743,31 @@ service_client_recv (void *cls)
  * @param sock socket associated with the client
  */
 static void
-start_client (struct GNUNET_SERVICE_Handle *sh,
-              struct GNUNET_NETWORK_Handle *csock)
+start_client(struct GNUNET_SERVICE_Handle *sh,
+             struct GNUNET_NETWORK_Handle *csock)
 {
   struct GNUNET_SERVICE_Client *client;
 
-  client = GNUNET_new (struct GNUNET_SERVICE_Client);
-  GNUNET_CONTAINER_DLL_insert (sh->clients_head, sh->clients_tail, client);
+  client = GNUNET_new(struct GNUNET_SERVICE_Client);
+  GNUNET_CONTAINER_DLL_insert(sh->clients_head, sh->clients_tail, client);
   client->sh = sh;
   client->sock = csock;
-  client->mq = GNUNET_MQ_queue_for_callbacks (&service_mq_send,
-                                              NULL,
-                                              &service_mq_cancel,
-                                              client,
-                                              sh->handlers,
-                                              &service_mq_error_handler,
-                                              client);
-  client->mst = GNUNET_MST_create (&service_client_mst_cb, client);
+  client->mq = GNUNET_MQ_queue_for_callbacks(&service_mq_send,
+                                             NULL,
+                                             &service_mq_cancel,
+                                             client,
+                                             sh->handlers,
+                                             &service_mq_error_handler,
+                                             client);
+  client->mst = GNUNET_MST_create(&service_client_mst_cb, client);
   if (NULL != sh->connect_cb)
-    client->user_context = sh->connect_cb (sh->cb_cls, client, client->mq);
-  GNUNET_MQ_set_handlers_closure (client->mq, client->user_context);
+    client->user_context = sh->connect_cb(sh->cb_cls, client, client->mq);
+  GNUNET_MQ_set_handlers_closure(client->mq, client->user_context);
   client->recv_task =
-    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                   client->sock,
-                                   &service_client_recv,
-                                   client);
+    GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                  client->sock,
+                                  &service_client_recv,
+                                  client);
 }
 
 
@@ -782,82 +778,84 @@ start_client (struct GNUNET_SERVICE_Handle *sh,
  * @param cls the `struct ServiceListenContext` of the ready listen socket
  */
 static void
-accept_client (void *cls)
+accept_client(void *cls)
 {
   struct ServiceListenContext *slc = cls;
   struct GNUNET_SERVICE_Handle *sh = slc->sh;
 
   slc->listen_task = NULL;
   while (1)
-  {
-    struct GNUNET_NETWORK_Handle *sock;
-    const struct sockaddr_in *v4;
-    const struct sockaddr_in6 *v6;
-    struct sockaddr_storage sa;
-    socklen_t addrlen;
-    int ok;
-
-    addrlen = sizeof (sa);
-    sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
-                                         (struct sockaddr *) &sa,
-                                         &addrlen);
-    if (NULL == sock)
-    {
-      if (EMFILE == errno)
-        do_suspend (sh, SUSPEND_STATE_EMFILE);
-      else if (EAGAIN != errno)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
-      break;
-    }
-    switch (sa.ss_family)
     {
-    case AF_INET:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
-      v4 = (const struct sockaddr_in *) &sa;
-      ok = (((NULL == sh->v4_allowed) ||
-             (check_ipv4_listed (sh->v4_allowed, &v4->sin_addr))) &&
-            ((NULL == sh->v4_denied) ||
-             (! check_ipv4_listed (sh->v4_denied, &v4->sin_addr))));
-      break;
-    case AF_INET6:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
-      v6 = (const struct sockaddr_in6 *) &sa;
-      ok = (((NULL == sh->v6_allowed) ||
-             (check_ipv6_listed (sh->v6_allowed, &v6->sin6_addr))) &&
-            ((NULL == sh->v6_denied) ||
-             (! check_ipv6_listed (sh->v6_denied, &v6->sin6_addr))));
-      break;
+      struct GNUNET_NETWORK_Handle *sock;
+      const struct sockaddr_in *v4;
+      const struct sockaddr_in6 *v6;
+      struct sockaddr_storage sa;
+      socklen_t addrlen;
+      int ok;
+
+      addrlen = sizeof(sa);
+      sock = GNUNET_NETWORK_socket_accept(slc->listen_socket,
+                                          (struct sockaddr *)&sa,
+                                          &addrlen);
+      if (NULL == sock)
+        {
+          if (EMFILE == errno)
+            do_suspend(sh, SUSPEND_STATE_EMFILE);
+          else if (EAGAIN != errno)
+            GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "accept");
+          break;
+        }
+      switch (sa.ss_family)
+        {
+        case AF_INET:
+          GNUNET_assert(addrlen == sizeof(struct sockaddr_in));
+          v4 = (const struct sockaddr_in *)&sa;
+          ok = (((NULL == sh->v4_allowed) ||
+                 (check_ipv4_listed(sh->v4_allowed, &v4->sin_addr))) &&
+                ((NULL == sh->v4_denied) ||
+                 (!check_ipv4_listed(sh->v4_denied, &v4->sin_addr))));
+          break;
+
+        case AF_INET6:
+          GNUNET_assert(addrlen == sizeof(struct sockaddr_in6));
+          v6 = (const struct sockaddr_in6 *)&sa;
+          ok = (((NULL == sh->v6_allowed) ||
+                 (check_ipv6_listed(sh->v6_allowed, &v6->sin6_addr))) &&
+                ((NULL == sh->v6_denied) ||
+                 (!check_ipv6_listed(sh->v6_denied, &v6->sin6_addr))));
+          break;
+
 #ifndef WINDOWS
-    case AF_UNIX:
-      ok = GNUNET_OK; /* controlled using file-system ACL now */
-      break;
+        case AF_UNIX:
+          ok = GNUNET_OK; /* controlled using file-system ACL now */
+          break;
 #endif
-    default:
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _ ("Unknown address family %d\n"),
-           sa.ss_family);
-      return;
-    }
-    if (! ok)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Service rejected incoming connection from %s due to policy.\n",
-           GNUNET_a2s ((const struct sockaddr *) &sa, addrlen));
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
-      continue;
+        default:
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _("Unknown address family %d\n"),
+              sa.ss_family);
+          return;
+        }
+      if (!ok)
+        {
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Service rejected incoming connection from %s due to policy.\n",
+              GNUNET_a2s((const struct sockaddr *)&sa, addrlen));
+          GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock));
+          continue;
+        }
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Service accepted incoming connection from %s.\n",
+          GNUNET_a2s((const struct sockaddr *)&sa, addrlen));
+      start_client(slc->sh, sock);
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Service accepted incoming connection from %s.\n",
-         GNUNET_a2s ((const struct sockaddr *) &sa, addrlen));
-    start_client (slc->sh, sock);
-  }
   if (0 != sh->suspend_state)
     return;
   slc->listen_task =
-    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                   slc->listen_socket,
-                                   &accept_client,
-                                   slc);
+    GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                  slc->listen_socket,
+                                  &accept_client,
+                                  slc);
 }
 
 
@@ -869,23 +867,23 @@ accept_client (void *cls)
  *           or #SUSPEND_STATE_NONE on first startup
  */
 static void
-do_resume (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
+do_resume(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
 {
   struct ServiceListenContext *slc;
 
-  GNUNET_assert ((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr)));
+  GNUNET_assert((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr)));
   sh->suspend_state -= sr;
   if (SUSPEND_STATE_NONE != sh->suspend_state)
     return;
   for (slc = sh->slc_head; NULL != slc; slc = slc->next)
-  {
-    GNUNET_assert (NULL == slc->listen_task);
-    slc->listen_task =
-      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                     slc->listen_socket,
-                                     &accept_client,
-                                     slc);
-  }
+    {
+      GNUNET_assert(NULL == slc->listen_task);
+      slc->listen_task =
+        GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                      slc->listen_socket,
+                                      &accept_client,
+                                      slc);
+    }
 }
 
 
@@ -897,23 +895,23 @@ do_resume (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
  * @param cls our `struct GNUNET_SERVICE_Handle`
  */
 static void
-service_main (void *cls)
+service_main(void *cls)
 {
   struct GNUNET_SERVICE_Handle *sh = cls;
 
   if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options)
-    GNUNET_SCHEDULER_add_shutdown (&service_shutdown, sh);
-  do_resume (sh, SUSPEND_STATE_NONE);
+    GNUNET_SCHEDULER_add_shutdown(&service_shutdown, sh);
+  do_resume(sh, SUSPEND_STATE_NONE);
 
   if (-1 != sh->ready_confirm_fd)
-  {
-    GNUNET_break (1 == write (sh->ready_confirm_fd, ".", 1));
-    GNUNET_break (0 == close (sh->ready_confirm_fd));
-    sh->ready_confirm_fd = -1;
-  }
+    {
+      GNUNET_break(1 == write(sh->ready_confirm_fd, ".", 1));
+      GNUNET_break(0 == close(sh->ready_confirm_fd));
+      sh->ready_confirm_fd = -1;
+    }
 
   if (NULL != sh->service_init_cb)
-    sh->service_init_cb (sh->cb_cls, sh->cfg, sh);
+    sh->service_init_cb(sh->cb_cls, sh->cfg, sh);
 }
 
 
@@ -927,33 +925,33 @@ service_main (void *cls)
  *         no ACL configured)
  */
 static int
-process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
-              struct GNUNET_SERVICE_Handle *sh,
-              const char *option)
+process_acl4(struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
+             struct GNUNET_SERVICE_Handle *sh,
+             const char *option)
 {
   char *opt;
 
-  if (! GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option))
-  {
-    *ret = NULL;
-    return GNUNET_OK;
-  }
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_string (sh->cfg,
-                                                       sh->service_name,
-                                                       option,
-                                                       &opt));
-  if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
-         opt,
-         sh->service_name,
-         option);
-    GNUNET_free (opt);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (opt);
+  if (!GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, option))
+    {
+      *ret = NULL;
+      return GNUNET_OK;
+    }
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_CONFIGURATION_get_value_string(sh->cfg,
+                                                     sh->service_name,
+                                                     option,
+                                                     &opt));
+  if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy(opt)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
+          opt,
+          sh->service_name,
+          option);
+      GNUNET_free(opt);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(opt);
   return GNUNET_OK;
 }
 
@@ -968,33 +966,33 @@ process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
  *         no ACL configured)
  */
 static int
-process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
-              struct GNUNET_SERVICE_Handle *sh,
-              const char *option)
+process_acl6(struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
+             struct GNUNET_SERVICE_Handle *sh,
+             const char *option)
 {
   char *opt;
 
-  if (! GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option))
-  {
-    *ret = NULL;
-    return GNUNET_OK;
-  }
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_string (sh->cfg,
-                                                       sh->service_name,
-                                                       option,
-                                                       &opt));
-  if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
-         opt,
-         sh->service_name,
-         option);
-    GNUNET_free (opt);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (opt);
+  if (!GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, option))
+    {
+      *ret = NULL;
+      return GNUNET_OK;
+    }
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_CONFIGURATION_get_value_string(sh->cfg,
+                                                     sh->service_name,
+                                                     option,
+                                                     &opt));
+  if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy(opt)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
+          opt,
+          sh->service_name,
+          option);
+      GNUNET_free(opt);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(opt);
   return GNUNET_OK;
 }
 
@@ -1010,30 +1008,30 @@ process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
  *          parameter is ignore on systems other than LINUX
  */
 static void
-add_unixpath (struct sockaddr **saddrs,
-              socklen_t *saddrlens,
-              const char *unixpath,
-              int abstract)
+add_unixpath(struct sockaddr **saddrs,
+             socklen_t *saddrlens,
+             const char *unixpath,
+             int abstract)
 {
 #ifdef AF_UNIX
   struct sockaddr_un *un;
 
-  un = GNUNET_new (struct sockaddr_un);
+  un = GNUNET_new(struct sockaddr_un);
   un->sun_family = AF_UNIX;
-  GNUNET_strlcpy (un->sun_path, unixpath, sizeof (un->sun_path));
+  GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path));
 #ifdef LINUX
   if (GNUNET_YES == abstract)
     un->sun_path[0] = '\0';
 #endif
 #if HAVE_SOCKADDR_UN_SUN_LEN
-  un->sun_len = (u_char) sizeof (struct sockaddr_un);
+  un->sun_len = (u_char)sizeof(struct sockaddr_un);
 #endif
-  *saddrs = (struct sockaddr *) un;
-  *saddrlens = sizeof (struct sockaddr_un);
+  *saddrs = (struct sockaddr *)un;
+  *saddrlens = sizeof(struct sockaddr_un);
 #else
   /* this function should never be called
    * unless AF_UNIX is defined! */
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 #endif
 }
 
@@ -1059,10 +1057,10 @@ add_unixpath (struct sockaddr **saddrs,
  *              set to NULL).
  */
 static int
-get_server_addresses (const char *service_name,
-                      const struct GNUNET_CONFIGURATION_Handle *cfg,
-                      struct sockaddr ***addrs,
-                      socklen_t **addr_lens)
+get_server_addresses(const char *service_name,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg,
+                     struct sockaddr ***addrs,
+                     socklen_t **addr_lens)
 {
   int disablev6;
   struct GNUNET_NETWORK_Handle *desc;
@@ -1084,40 +1082,40 @@ get_server_addresses (const char *service_name,
   *addr_lens = NULL;
   desc = NULL;
   disablev6 = GNUNET_NO;
-  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
+  if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) ||
       (GNUNET_YES ==
-       GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6")))
+       GNUNET_CONFIGURATION_get_value_yesno(cfg, service_name, "DISABLEV6")))
     disablev6 = GNUNET_YES;
 
   port = 0;
-  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
-  {
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                            service_name,
-                                                            "PORT",
-                                                            &port))
+  if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT"))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Require valid port number for service `%s' in configuration!\n"),
-           service_name);
-    }
-    if (port > 65535)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Require valid port number for service `%s' in configuration!\n"),
-           service_name);
-      return GNUNET_SYSERR;
+      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
+                                                             service_name,
+                                                             "PORT",
+                                                             &port))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Require valid port number for service `%s' in configuration!\n"),
+              service_name);
+        }
+      if (port > 65535)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Require valid port number for service `%s' in configuration!\n"),
+              service_name);
+          return GNUNET_SYSERR;
+        }
     }
-  }
 
-  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
-  {
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONFIGURATION_get_value_string (cfg,
+  if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO"))
+    {
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string(cfg,
                                                          service_name,
                                                          "BINDTO",
                                                          &hostname));
-  }
+    }
   else
     hostname = NULL;
 
@@ -1125,232 +1123,232 @@ get_server_addresses (const char *service_name,
   abstract = GNUNET_NO;
 #ifdef AF_UNIX
   if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                             service_name,
-                                                             "UNIXPATH",
-                                                             &unixpath)) &&
-      (0 < strlen (unixpath)))
-  {
-    /* probe UNIX support */
-    struct sockaddr_un s_un;
-
-    if (strlen (unixpath) >= sizeof (s_un.sun_path))
+       GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) &&
+      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                            service_name,
+                                                            "UNIXPATH",
+                                                            &unixpath)) &&
+      (0 < strlen(unixpath)))
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
-           unixpath,
-           (unsigned long long) sizeof (s_un.sun_path));
-      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
-      LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath);
-    }
+      /* probe UNIX support */
+      struct sockaddr_un s_un;
+
+      if (strlen(unixpath) >= sizeof(s_un.sun_path))
+        {
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+              unixpath,
+              (unsigned long long)sizeof(s_un.sun_path));
+          unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath);
+          LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath);
+        }
 #ifdef LINUX
-    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                     "TESTING",
-                                                     "USE_ABSTRACT_SOCKETS");
-    if (GNUNET_SYSERR == abstract)
-      abstract = GNUNET_NO;
+      abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg,
+                                                      "TESTING",
+                                                      "USE_ABSTRACT_SOCKETS");
+      if (GNUNET_SYSERR == abstract)
+        abstract = GNUNET_NO;
 #endif
-    if ((GNUNET_YES != abstract) &&
-        (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath)))
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath);
-  }
-  if (NULL != unixpath)
-  {
-    desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
-    if (NULL == desc)
-    {
-      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
-          (EACCES == errno))
-      {
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
-        GNUNET_free_non_null (hostname);
-        GNUNET_free (unixpath);
-        return GNUNET_SYSERR;
-      }
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _ (
-             "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
-           service_name,
-           strerror (errno));
-      GNUNET_free (unixpath);
-      unixpath = NULL;
+      if ((GNUNET_YES != abstract) &&
+          (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath)))
+        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath);
     }
-    else
+  if (NULL != unixpath)
     {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
-      desc = NULL;
+      desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0);
+      if (NULL == desc)
+        {
+          if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
+              (EACCES == errno))
+            {
+              LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket");
+              GNUNET_free_non_null(hostname);
+              GNUNET_free(unixpath);
+              return GNUNET_SYSERR;
+            }
+          LOG(GNUNET_ERROR_TYPE_INFO,
+              _(
+                "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
+              service_name,
+              strerror(errno));
+          GNUNET_free(unixpath);
+          unixpath = NULL;
+        }
+      else
+        {
+          GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc));
+          desc = NULL;
+        }
     }
-  }
 #endif
 
   if ((0 == port) && (NULL == unixpath))
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ (
-           "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
-         service_name);
-    GNUNET_free_non_null (hostname);
-    return GNUNET_SYSERR;
-  }
-  if (0 == port)
-  {
-    saddrs = GNUNET_new_array (2, struct sockaddr *);
-    saddrlens = GNUNET_new_array (2, socklen_t);
-    add_unixpath (saddrs, saddrlens, unixpath, abstract);
-    GNUNET_free_non_null (unixpath);
-    GNUNET_free_non_null (hostname);
-    *addrs = saddrs;
-    *addr_lens = saddrlens;
-    return 1;
-  }
-
-  if (NULL != hostname)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Resolving `%s' since that is where `%s' will bind to.\n",
-         hostname,
-         service_name);
-    memset (&hints, 0, sizeof (struct addrinfo));
-    if (disablev6)
-      hints.ai_family = AF_INET;
-    hints.ai_protocol = IPPROTO_TCP;
-    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
-        (NULL == res))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to resolve `%s': %s\n"),
-           hostname,
-           gai_strerror (ret));
-      GNUNET_free (hostname);
-      GNUNET_free_non_null (unixpath);
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _(
+            "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
+          service_name);
+      GNUNET_free_non_null(hostname);
       return GNUNET_SYSERR;
     }
-    next = res;
-    i = 0;
-    while (NULL != (pos = next))
-    {
-      next = pos->ai_next;
-      if ((disablev6) && (pos->ai_family == AF_INET6))
-        continue;
-      i++;
-    }
-    if (0 == i)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to find %saddress for `%s'.\n"),
-           disablev6 ? "IPv4 " : "",
-           hostname);
-      freeaddrinfo (res);
-      GNUNET_free (hostname);
-      GNUNET_free_non_null (unixpath);
-      return GNUNET_SYSERR;
-    }
-    resi = i;
-    if (NULL != unixpath)
-      resi++;
-    saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
-    saddrlens = GNUNET_new_array (resi + 1, socklen_t);
-    i = 0;
-    if (NULL != unixpath)
+  if (0 == port)
     {
-      add_unixpath (saddrs, saddrlens, unixpath, abstract);
-      i++;
+      saddrs = GNUNET_new_array(2, struct sockaddr *);
+      saddrlens = GNUNET_new_array(2, socklen_t);
+      add_unixpath(saddrs, saddrlens, unixpath, abstract);
+      GNUNET_free_non_null(unixpath);
+      GNUNET_free_non_null(hostname);
+      *addrs = saddrs;
+      *addr_lens = saddrlens;
+      return 1;
     }
-    next = res;
-    while (NULL != (pos = next))
-    {
-      next = pos->ai_next;
-      if ((disablev6) && (AF_INET6 == pos->ai_family))
-        continue;
-      if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
-        continue; /* not TCP */
-      if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
-        continue; /* huh? */
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Service `%s' will bind to `%s'\n",
-           service_name,
-           GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
-      if (AF_INET == pos->ai_family)
-      {
-        GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen);
-        saddrlens[i] = pos->ai_addrlen;
-        saddrs[i] = GNUNET_malloc (saddrlens[i]);
-        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
-        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
-      }
-      else
-      {
-        GNUNET_assert (AF_INET6 == pos->ai_family);
-        GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen);
-        saddrlens[i] = pos->ai_addrlen;
-        saddrs[i] = GNUNET_malloc (saddrlens[i]);
-        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
-        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
-      }
-      i++;
-    }
-    GNUNET_free (hostname);
-    freeaddrinfo (res);
-    resi = i;
-  }
-  else
-  {
-    /* will bind against everything, just set port */
-    if (disablev6)
+
+  if (NULL != hostname)
     {
-      /* V4-only */
-      resi = 1;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Resolving `%s' since that is where `%s' will bind to.\n",
+          hostname,
+          service_name);
+      memset(&hints, 0, sizeof(struct addrinfo));
+      if (disablev6)
+        hints.ai_family = AF_INET;
+      hints.ai_protocol = IPPROTO_TCP;
+      if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) ||
+          (NULL == res))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Failed to resolve `%s': %s\n"),
+              hostname,
+              gai_strerror(ret));
+          GNUNET_free(hostname);
+          GNUNET_free_non_null(unixpath);
+          return GNUNET_SYSERR;
+        }
+      next = res;
+      i = 0;
+      while (NULL != (pos = next))
+        {
+          next = pos->ai_next;
+          if ((disablev6) && (pos->ai_family == AF_INET6))
+            continue;
+          i++;
+        }
+      if (0 == i)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Failed to find %saddress for `%s'.\n"),
+              disablev6 ? "IPv4 " : "",
+              hostname);
+          freeaddrinfo(res);
+          GNUNET_free(hostname);
+          GNUNET_free_non_null(unixpath);
+          return GNUNET_SYSERR;
+        }
+      resi = i;
       if (NULL != unixpath)
         resi++;
+      saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
+      saddrlens = GNUNET_new_array(resi + 1, socklen_t);
       i = 0;
-      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
-      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
       if (NULL != unixpath)
-      {
-        add_unixpath (saddrs, saddrlens, unixpath, abstract);
-        i++;
-      }
-      saddrlens[i] = sizeof (struct sockaddr_in);
-      saddrs[i] = GNUNET_malloc (saddrlens[i]);
-#if HAVE_SOCKADDR_IN_SIN_LEN
-      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
-#endif
-      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
-      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
+        {
+          add_unixpath(saddrs, saddrlens, unixpath, abstract);
+          i++;
+        }
+      next = res;
+      while (NULL != (pos = next))
+        {
+          next = pos->ai_next;
+          if ((disablev6) && (AF_INET6 == pos->ai_family))
+            continue;
+          if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
+            continue; /* not TCP */
+          if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
+            continue; /* huh? */
+          LOG(GNUNET_ERROR_TYPE_DEBUG,
+              "Service `%s' will bind to `%s'\n",
+              service_name,
+              GNUNET_a2s(pos->ai_addr, pos->ai_addrlen));
+          if (AF_INET == pos->ai_family)
+            {
+              GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen);
+              saddrlens[i] = pos->ai_addrlen;
+              saddrs[i] = GNUNET_malloc(saddrlens[i]);
+              GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]);
+              ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
+            }
+          else
+            {
+              GNUNET_assert(AF_INET6 == pos->ai_family);
+              GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen);
+              saddrlens[i] = pos->ai_addrlen;
+              saddrs[i] = GNUNET_malloc(saddrlens[i]);
+              GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]);
+              ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port);
+            }
+          i++;
+        }
+      GNUNET_free(hostname);
+      freeaddrinfo(res);
+      resi = i;
     }
-    else
+  else
     {
-      /* dual stack */
-      resi = 2;
-      if (NULL != unixpath)
-        resi++;
-      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
-      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
-      i = 0;
-      if (NULL != unixpath)
-      {
-        add_unixpath (saddrs, saddrlens, unixpath, abstract);
-        i++;
-      }
-      saddrlens[i] = sizeof (struct sockaddr_in6);
-      saddrs[i] = GNUNET_malloc (saddrlens[i]);
+      /* will bind against everything, just set port */
+      if (disablev6)
+        {
+          /* V4-only */
+          resi = 1;
+          if (NULL != unixpath)
+            resi++;
+          i = 0;
+          saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
+          saddrlens = GNUNET_new_array(resi + 1, socklen_t);
+          if (NULL != unixpath)
+            {
+              add_unixpath(saddrs, saddrlens, unixpath, abstract);
+              i++;
+            }
+          saddrlens[i] = sizeof(struct sockaddr_in);
+          saddrs[i] = GNUNET_malloc(saddrlens[i]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
+          ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i];
 #endif
-      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
-      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
-      i++;
-      saddrlens[i] = sizeof (struct sockaddr_in);
-      saddrs[i] = GNUNET_malloc (saddrlens[i]);
+          ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET;
+          ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
+        }
+      else
+        {
+          /* dual stack */
+          resi = 2;
+          if (NULL != unixpath)
+            resi++;
+          saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
+          saddrlens = GNUNET_new_array(resi + 1, socklen_t);
+          i = 0;
+          if (NULL != unixpath)
+            {
+              add_unixpath(saddrs, saddrlens, unixpath, abstract);
+              i++;
+            }
+          saddrlens[i] = sizeof(struct sockaddr_in6);
+          saddrs[i] = GNUNET_malloc(saddrlens[i]);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+          ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0];
+#endif
+          ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6;
+          ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port);
+          i++;
+          saddrlens[i] = sizeof(struct sockaddr_in);
+          saddrs[i] = GNUNET_malloc(saddrlens[i]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
+          ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1];
 #endif
-      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
-      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
+          ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET;
+          ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
+        }
     }
-  }
-  GNUNET_free_non_null (unixpath);
+  GNUNET_free_non_null(unixpath);
   *addrs = saddrs;
   *addr_lens = saddrlens;
   return resi;
@@ -1366,7 +1364,7 @@ get_server_addresses (const char *service_name,
  *         NULL if not ok (must bind yourself)
  */
 static struct GNUNET_NETWORK_Handle **
-receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
+receive_sockets_from_parent(struct GNUNET_SERVICE_Handle *sh)
 {
   static struct GNUNET_NETWORK_Handle **lsocks;
   const char *env_buf;
@@ -1375,69 +1373,70 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
   uint64_t i;
   HANDLE lsocks_pipe;
 
-  env_buf = getenv ("GNUNET_OS_READ_LSOCKS");
-  if ((NULL == env_buf) || (strlen (env_buf) <= 0))
+  env_buf = getenv("GNUNET_OS_READ_LSOCKS");
+  if ((NULL == env_buf) || (strlen(env_buf) <= 0))
     return NULL;
   /* Using W32 API directly here, because this pipe will
    * never be used outside of this function, and it's just too much of a bother
    * to create a GNUnet API that boxes a HANDLE (the way it is done with socks)
    */
-  lsocks_pipe = (HANDLE) strtoul (env_buf, NULL, 10);
+  lsocks_pipe = (HANDLE)strtoul(env_buf, NULL, 10);
   if ((0 == lsocks_pipe) || (INVALID_HANDLE_VALUE == lsocks_pipe))
     return NULL;
   fail = 1;
   do
-  {
-    int ret;
-    int fail2;
-    DWORD rd;
-
-    ret = ReadFile (lsocks_pipe, &count, sizeof (count), &rd, NULL);
-    if ((0 == ret) || (sizeof (count) != rd) || (0 == count))
-      break;
-    lsocks = GNUNET_new_array (count + 1, struct GNUNET_NETWORK_Handle *);
-
-    fail2 = 1;
-    for (i = 0; i < count; i++)
     {
-      WSAPROTOCOL_INFOA pi;
-      uint64_t size;
-      SOCKET s;
+      int ret;
+      int fail2;
+      DWORD rd;
 
-      ret = ReadFile (lsocks_pipe, &size, sizeof (size), &rd, NULL);
-      if ((0 == ret) || (sizeof (size) != rd) || (sizeof (pi) != size))
+      ret = ReadFile(lsocks_pipe, &count, sizeof(count), &rd, NULL);
+      if ((0 == ret) || (sizeof(count) != rd) || (0 == count))
         break;
-      ret = ReadFile (lsocks_pipe, &pi, sizeof (pi), &rd, NULL);
-      if ((0 == ret) || (sizeof (pi) != rd))
+      lsocks = GNUNET_new_array(count + 1, struct GNUNET_NETWORK_Handle *);
+
+      fail2 = 1;
+      for (i = 0; i < count; i++)
+        {
+          WSAPROTOCOL_INFOA pi;
+          uint64_t size;
+          SOCKET s;
+
+          ret = ReadFile(lsocks_pipe, &size, sizeof(size), &rd, NULL);
+          if ((0 == ret) || (sizeof(size) != rd) || (sizeof(pi) != size))
+            break;
+          ret = ReadFile(lsocks_pipe, &pi, sizeof(pi), &rd, NULL);
+          if ((0 == ret) || (sizeof(pi) != rd))
+            break;
+          s = WSASocketA(pi.iAddressFamily,
+                         pi.iSocketType,
+                         pi.iProtocol,
+                         &pi,
+                         0,
+                         WSA_FLAG_OVERLAPPED);
+          lsocks[i] = GNUNET_NETWORK_socket_box_native(s);
+          if (NULL == lsocks[i])
+            break;
+          else if (i == count - 1)
+            fail2 = 0;
+        }
+      if (fail2)
         break;
-      s = WSASocketA (pi.iAddressFamily,
-                      pi.iSocketType,
-                      pi.iProtocol,
-                      &pi,
-                      0,
-                      WSA_FLAG_OVERLAPPED);
-      lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
-      if (NULL == lsocks[i])
-        break;
-      else if (i == count - 1)
-        fail2 = 0;
+      lsocks[count] = NULL;
+      fail = 0;
     }
-    if (fail2)
-      break;
-    lsocks[count] = NULL;
-    fail = 0;
-  } while (fail);
-  CloseHandle (lsocks_pipe);
+  while (fail);
+  CloseHandle(lsocks_pipe);
 
   if (fail)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Could not access a pre-bound socket, will try to bind myself\n"));
-    for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (lsocks[i]));
-    GNUNET_free (lsocks);
-    return NULL;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Could not access a pre-bound socket, will try to bind myself\n"));
+      for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
+        GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(lsocks[i]));
+      GNUNET_free(lsocks);
+      return NULL;
+    }
   return lsocks;
 }
 #endif
@@ -1451,86 +1450,89 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
  * @return NULL on error, otherwise the listen socket
  */
 static struct GNUNET_NETWORK_Handle *
-open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
+open_listen_socket(const struct sockaddr *server_addr, socklen_t socklen)
 {
   struct GNUNET_NETWORK_Handle *sock;
   uint16_t port;
   int eno;
 
   switch (server_addr->sa_family)
-  {
-  case AF_INET:
-    port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port);
-    break;
-  case AF_INET6:
-    port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port);
-    break;
-  case AF_UNIX:
-    port = 0;
-    break;
-  default:
-    GNUNET_break (0);
-    port = 0;
-    break;
-  }
-  sock = GNUNET_NETWORK_socket_create (server_addr->sa_family, SOCK_STREAM, 0);
+    {
+    case AF_INET:
+      port = ntohs(((const struct sockaddr_in *)server_addr)->sin_port);
+      break;
+
+    case AF_INET6:
+      port = ntohs(((const struct sockaddr_in6 *)server_addr)->sin6_port);
+      break;
+
+    case AF_UNIX:
+      port = 0;
+      break;
+
+    default:
+      GNUNET_break(0);
+      port = 0;
+      break;
+    }
+  sock = GNUNET_NETWORK_socket_create(server_addr->sa_family, SOCK_STREAM, 0);
   if (NULL == sock)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
-    errno = 0;
-    return NULL;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket");
+      errno = 0;
+      return NULL;
+    }
   /* bind the socket */
-  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock, server_addr, socklen))
-  {
-    eno = errno;
-    if (EADDRINUSE != errno)
+  if (GNUNET_OK != GNUNET_NETWORK_socket_bind(sock, server_addr, socklen))
     {
-      /* we don't log 'EADDRINUSE' here since an IPv4 bind may
-       * fail if we already took the port on IPv6; if both IPv4 and
-       * IPv6 binds fail, then our caller will log using the
-       * errno preserved in 'eno' */
-      if (0 != port)
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ ("`%s' failed for port %d (%s).\n"),
-             "bind",
-             port,
-             (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
+      eno = errno;
+      if (EADDRINUSE != errno)
+        {
+          /* we don't log 'EADDRINUSE' here since an IPv4 bind may
+           * fail if we already took the port on IPv6; if both IPv4 and
+           * IPv6 binds fail, then our caller will log using the
+           * errno preserved in 'eno' */
+          if (0 != port)
+            LOG(GNUNET_ERROR_TYPE_ERROR,
+                _("`%s' failed for port %d (%s).\n"),
+                "bind",
+                port,
+                (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
+          else
+            LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "bind");
+          eno = 0;
+        }
       else
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
-      eno = 0;
+        {
+          if (0 != port)
+            LOG(GNUNET_ERROR_TYPE_WARNING,
+                _("`%s' failed for port %d (%s): address already in use\n"),
+                "bind",
+                port,
+                (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
+          else if (AF_UNIX == server_addr->sa_family)
+            {
+              LOG(GNUNET_ERROR_TYPE_WARNING,
+                  _("`%s' failed for `%s': address already in use\n"),
+                  "bind",
+                  GNUNET_a2s(server_addr, socklen));
+            }
+        }
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock));
+      errno = eno;
+      return NULL;
     }
-    else
+  if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5))
     {
-      if (0 != port)
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             _ ("`%s' failed for port %d (%s): address already in use\n"),
-             "bind",
-             port,
-             (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
-      else if (AF_UNIX == server_addr->sa_family)
-      {
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             _ ("`%s' failed for `%s': address already in use\n"),
-             "bind",
-             GNUNET_a2s (server_addr, socklen));
-      }
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "listen");
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock));
+      errno = 0;
+      return NULL;
     }
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
-    errno = eno;
-    return NULL;
-  }
-  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "listen");
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
-    errno = 0;
-    return NULL;
-  }
   if (0 != port)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Server starts to listen on port %u.\n",
-         port);
+    LOG(GNUNET_ERROR_TYPE_DEBUG,
+        "Server starts to listen on port %u.\n",
+        port);
   return sock;
 }
 
@@ -1552,10 +1554,11 @@ open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
  * @return #GNUNET_OK if configuration succeeded
  */
 static int
-setup_service (struct GNUNET_SERVICE_Handle *sh)
+setup_service(struct GNUNET_SERVICE_Handle *sh)
 {
   int tolerant;
   struct GNUNET_NETWORK_Handle **lsocks;
+
 #ifndef MINGW
   const char *nfds;
   unsigned int cnt;
@@ -1563,126 +1566,126 @@ setup_service (struct GNUNET_SERVICE_Handle *sh)
   char dummy[2];
 #endif
 
-  if (GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, "TOLERANT"))
-  {
-    if (GNUNET_SYSERR ==
-        (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
-                                                          sh->service_name,
-                                                          "TOLERANT")))
+  if (GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, "TOLERANT"))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Specified value for `%s' of service `%s' is invalid\n"),
-           "TOLERANT",
-           sh->service_name);
-      return GNUNET_SYSERR;
+      if (GNUNET_SYSERR ==
+          (tolerant = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg,
+                                                           sh->service_name,
+                                                           "TOLERANT")))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Specified value for `%s' of service `%s' is invalid\n"),
+              "TOLERANT",
+              sh->service_name);
+          return GNUNET_SYSERR;
+        }
     }
-  }
   else
     tolerant = GNUNET_NO;
 
   lsocks = NULL;
 #ifndef MINGW
   errno = 0;
-  if ((NULL != (nfds = getenv ("LISTEN_FDS"))) &&
-      (1 == sscanf (nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) &&
+  if ((NULL != (nfds = getenv("LISTEN_FDS"))) &&
+      (1 == sscanf(nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) &&
       (cnt < FD_SETSIZE) && (cnt + 4 < FD_SETSIZE))
-  {
-    lsocks = GNUNET_new_array (cnt + 1, struct GNUNET_NETWORK_Handle *);
-    while (0 < cnt--)
     {
-      flags = fcntl (3 + cnt, F_GETFD);
-      if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
-          (NULL == (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
-      {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _ (
-               "Could not access pre-bound socket %u, will try to bind myself\n"),
-             (unsigned int) 3 + cnt);
-        cnt++;
-        while (NULL != lsocks[cnt])
-          GNUNET_break (GNUNET_OK ==
-                        GNUNET_NETWORK_socket_close (lsocks[cnt++]));
-        GNUNET_free (lsocks);
-        lsocks = NULL;
-        break;
-      }
+      lsocks = GNUNET_new_array(cnt + 1, struct GNUNET_NETWORK_Handle *);
+      while (0 < cnt--)
+        {
+          flags = fcntl(3 + cnt, F_GETFD);
+          if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
+              (NULL == (lsocks[cnt] = GNUNET_NETWORK_socket_box_native(3 + cnt))))
+            {
+              LOG(GNUNET_ERROR_TYPE_ERROR,
+                  _(
+                    "Could not access pre-bound socket %u, will try to bind myself\n"),
+                  (unsigned int)3 + cnt);
+              cnt++;
+              while (NULL != lsocks[cnt])
+                GNUNET_break(GNUNET_OK ==
+                             GNUNET_NETWORK_socket_close(lsocks[cnt++]));
+              GNUNET_free(lsocks);
+              lsocks = NULL;
+              break;
+            }
+        }
+      unsetenv("LISTEN_FDS");
     }
-    unsetenv ("LISTEN_FDS");
-  }
 #else
-  if (NULL != getenv ("GNUNET_OS_READ_LSOCKS"))
-  {
-    lsocks = receive_sockets_from_parent (sh);
-    putenv ("GNUNET_OS_READ_LSOCKS=");
-  }
+  if (NULL != getenv("GNUNET_OS_READ_LSOCKS"))
+    {
+      lsocks = receive_sockets_from_parent(sh);
+      putenv("GNUNET_OS_READ_LSOCKS=");
+    }
 #endif
 
   if (NULL != lsocks)
-  {
-    /* listen only on inherited sockets if we have any */
-    struct GNUNET_NETWORK_Handle **ls;
-
-    for (ls = lsocks; NULL != *ls; ls++)
     {
-      struct ServiceListenContext *slc;
-
-      slc = GNUNET_new (struct ServiceListenContext);
-      slc->sh = sh;
-      slc->listen_socket = *ls;
-      GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc);
+      /* listen only on inherited sockets if we have any */
+      struct GNUNET_NETWORK_Handle **ls;
+
+      for (ls = lsocks; NULL != *ls; ls++)
+        {
+          struct ServiceListenContext *slc;
+
+          slc = GNUNET_new(struct ServiceListenContext);
+          slc->sh = sh;
+          slc->listen_socket = *ls;
+          GNUNET_CONTAINER_DLL_insert(sh->slc_head, sh->slc_tail, slc);
+        }
+      GNUNET_free(lsocks);
     }
-    GNUNET_free (lsocks);
-  }
   else
-  {
-    struct sockaddr **addrs;
-    socklen_t *addrlens;
-    int num;
-
-    num = get_server_addresses (sh->service_name, sh->cfg, &addrs, &addrlens);
-    if (GNUNET_SYSERR == num)
-      return GNUNET_SYSERR;
-
-    for (int i = 0; i < num; i++)
     {
-      struct ServiceListenContext *slc;
+      struct sockaddr **addrs;
+      socklen_t *addrlens;
+      int num;
 
-      slc = GNUNET_new (struct ServiceListenContext);
-      slc->sh = sh;
-      slc->listen_socket = open_listen_socket (addrs[i], addrlens[i]);
-      GNUNET_free (addrs[i]);
-      if (NULL == slc->listen_socket)
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
-        GNUNET_free (slc);
-        continue;
-      }
-      GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc);
-    }
-    GNUNET_free_non_null (addrlens);
-    GNUNET_free_non_null (addrs);
-    if ((0 != num) && (NULL == sh->slc_head))
-    {
-      /* All attempts to bind failed, hard failure */
-      GNUNET_log (
-        GNUNET_ERROR_TYPE_ERROR,
-        _ (
-          "Could not bind to any of the ports I was supposed to, refusing to run!\n"));
-      return GNUNET_SYSERR;
+      num = get_server_addresses(sh->service_name, sh->cfg, &addrs, &addrlens);
+      if (GNUNET_SYSERR == num)
+        return GNUNET_SYSERR;
+
+      for (int i = 0; i < num; i++)
+        {
+          struct ServiceListenContext *slc;
+
+          slc = GNUNET_new(struct ServiceListenContext);
+          slc->sh = sh;
+          slc->listen_socket = open_listen_socket(addrs[i], addrlens[i]);
+          GNUNET_free(addrs[i]);
+          if (NULL == slc->listen_socket)
+            {
+              GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind");
+              GNUNET_free(slc);
+              continue;
+            }
+          GNUNET_CONTAINER_DLL_insert(sh->slc_head, sh->slc_tail, slc);
+        }
+      GNUNET_free_non_null(addrlens);
+      GNUNET_free_non_null(addrs);
+      if ((0 != num) && (NULL == sh->slc_head))
+        {
+          /* All attempts to bind failed, hard failure */
+          GNUNET_log(
+            GNUNET_ERROR_TYPE_ERROR,
+            _(
+              "Could not bind to any of the ports I was supposed to, refusing to run!\n"));
+          return GNUNET_SYSERR;
+        }
     }
-  }
 
   sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
-  sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
-                                                        sh->service_name,
-                                                        "UNIX_MATCH_UID");
-  sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
-                                                        sh->service_name,
-                                                        "UNIX_MATCH_GID");
-  process_acl4 (&sh->v4_denied, sh, "REJECT_FROM");
-  process_acl4 (&sh->v4_allowed, sh, "ACCEPT_FROM");
-  process_acl6 (&sh->v6_denied, sh, "REJECT_FROM6");
-  process_acl6 (&sh->v6_allowed, sh, "ACCEPT_FROM6");
+  sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg,
+                                                       sh->service_name,
+                                                       "UNIX_MATCH_UID");
+  sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg,
+                                                       sh->service_name,
+                                                       "UNIX_MATCH_GID");
+  process_acl4(&sh->v4_denied, sh, "REJECT_FROM");
+  process_acl4(&sh->v4_allowed, sh, "ACCEPT_FROM");
+  process_acl6(&sh->v6_denied, sh, "REJECT_FROM6");
+  process_acl6(&sh->v6_allowed, sh, "ACCEPT_FROM6");
   return GNUNET_OK;
 }
 
@@ -1695,14 +1698,14 @@ setup_service (struct GNUNET_SERVICE_Handle *sh)
  * @return value of the 'USERNAME' option
  */
 static char *
-get_user_name (struct GNUNET_SERVICE_Handle *sh)
+get_user_name(struct GNUNET_SERVICE_Handle *sh)
 {
   char *un;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
-                                                            sh->service_name,
-                                                            "USERNAME",
-                                                            &un))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sh->cfg,
+                                                           sh->service_name,
+                                                           "USERNAME",
+                                                           &un))
     return NULL;
   return un;
 }
@@ -1715,45 +1718,45 @@ get_user_name (struct GNUNET_SERVICE_Handle *sh)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-set_user_id (struct GNUNET_SERVICE_Handle *sh)
+set_user_id(struct GNUNET_SERVICE_Handle *sh)
 {
   char *user;
 
-  if (NULL == (user = get_user_name (sh)))
+  if (NULL == (user = get_user_name(sh)))
     return GNUNET_OK; /* keep */
 #ifndef MINGW
   struct passwd *pws;
 
   errno = 0;
-  pws = getpwnam (user);
+  pws = getpwnam(user);
   if (NULL == pws)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Cannot obtain information about user `%s': %s\n"),
-         user,
-         errno == 0 ? _ ("No such user") : strerror (errno));
-    GNUNET_free (user);
-    return GNUNET_SYSERR;
-  }
-  if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) ||
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR,
+          _("Cannot obtain information about user `%s': %s\n"),
+          user,
+          errno == 0 ? _("No such user") : strerror(errno));
+      GNUNET_free(user);
+      return GNUNET_SYSERR;
+    }
+  if ((0 != setgid(pws->pw_gid)) || (0 != setegid(pws->pw_gid)) ||
 #if HAVE_INITGROUPS
-      (0 != initgroups (user, pws->pw_gid)) ||
+      (0 != initgroups(user, pws->pw_gid)) ||
 #endif
-      (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid)))
-  {
-    if ((0 != setregid (pws->pw_gid, pws->pw_gid)) ||
-        (0 != setreuid (pws->pw_uid, pws->pw_uid)))
+      (0 != setuid(pws->pw_uid)) || (0 != seteuid(pws->pw_uid)))
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Cannot change user/group to `%s': %s\n"),
-           user,
-           strerror (errno));
-      GNUNET_free (user);
-      return GNUNET_SYSERR;
+      if ((0 != setregid(pws->pw_gid, pws->pw_gid)) ||
+          (0 != setreuid(pws->pw_uid, pws->pw_uid)))
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              _("Cannot change user/group to `%s': %s\n"),
+              user,
+              strerror(errno));
+          GNUNET_free(user);
+          return GNUNET_SYSERR;
+        }
     }
-  }
 #endif
-  GNUNET_free (user);
+  GNUNET_free(user);
   return GNUNET_OK;
 }
 
@@ -1766,14 +1769,14 @@ set_user_id (struct GNUNET_SERVICE_Handle *sh)
  * @return name of the file for the process ID
  */
 static char *
-get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
+get_pid_file_name(struct GNUNET_SERVICE_Handle *sh)
 {
   char *pif;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
-                                                            sh->service_name,
-                                                            "PIDFILE",
-                                                            &pif))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sh->cfg,
+                                                           sh->service_name,
+                                                           "PIDFILE",
+                                                           &pif))
     return NULL;
   return pif;
 }
@@ -1785,15 +1788,15 @@ get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
  * @param sh service context
  */
 static void
-pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
+pid_file_delete(struct GNUNET_SERVICE_Handle *sh)
 {
-  char *pif = get_pid_file_name (sh);
+  char *pif = get_pid_file_name(sh);
 
   if (NULL == pif)
     return; /* no PID file */
-  if (0 != unlink (pif))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
-  GNUNET_free (pif);
+  if (0 != unlink(pif))
+    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
+  GNUNET_free(pif);
 }
 
 
@@ -1804,76 +1807,79 @@ pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-detach_terminal (struct GNUNET_SERVICE_Handle *sh)
+detach_terminal(struct GNUNET_SERVICE_Handle *sh)
 {
 #ifndef MINGW
   pid_t pid;
   int nullfd;
   int filedes[2];
 
-  if (0 != pipe (filedes))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe");
-    return GNUNET_SYSERR;
-  }
-  pid = fork ();
+  if (0 != pipe(filedes))
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "pipe");
+      return GNUNET_SYSERR;
+    }
+  pid = fork();
   if (pid < 0)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
-    return GNUNET_SYSERR;
-  }
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fork");
+      return GNUNET_SYSERR;
+    }
   if (0 != pid)
-  {
-    /* Parent */
-    char c;
-
-    GNUNET_break (0 == close (filedes[1]));
-    c = 'X';
-    if (1 != read (filedes[0], &c, sizeof (char)))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "read");
-    fflush (stdout);
-    switch (c)
     {
-    case '.':
-      exit (0);
-    case 'I':
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _ ("Service process failed to initialize\n"));
-      break;
-    case 'S':
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _ ("Service process could not initialize server function\n"));
-      break;
-    case 'X':
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _ ("Service process failed to report status\n"));
-      break;
+      /* Parent */
+      char c;
+
+      GNUNET_break(0 == close(filedes[1]));
+      c = 'X';
+      if (1 != read(filedes[0], &c, sizeof(char)))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "read");
+      fflush(stdout);
+      switch (c)
+        {
+        case '.':
+          exit(0);
+
+        case 'I':
+          LOG(GNUNET_ERROR_TYPE_INFO,
+              _("Service process failed to initialize\n"));
+          break;
+
+        case 'S':
+          LOG(GNUNET_ERROR_TYPE_INFO,
+              _("Service process could not initialize server function\n"));
+          break;
+
+        case 'X':
+          LOG(GNUNET_ERROR_TYPE_INFO,
+              _("Service process failed to report status\n"));
+          break;
+        }
+      exit(1); /* child reported error */
     }
-    exit (1); /* child reported error */
-  }
-  GNUNET_break (0 == close (0));
-  GNUNET_break (0 == close (1));
-  GNUNET_break (0 == close (filedes[0]));
-  nullfd = open ("/dev/null", O_RDWR | O_APPEND);
+  GNUNET_break(0 == close(0));
+  GNUNET_break(0 == close(1));
+  GNUNET_break(0 == close(filedes[0]));
+  nullfd = open("/dev/null", O_RDWR | O_APPEND);
   if (nullfd < 0)
     return GNUNET_SYSERR;
   /* set stdin/stdout to /dev/null */
-  if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0))
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-    (void) close (nullfd);
-    return GNUNET_SYSERR;
-  }
-  (void) close (nullfd);
+  if ((dup2(nullfd, 0) < 0) || (dup2(nullfd, 1) < 0))
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2");
+      (void)close(nullfd);
+      return GNUNET_SYSERR;
+    }
+  (void)close(nullfd);
   /* Detach from controlling terminal */
-  pid = setsid ();
+  pid = setsid();
   if (-1 == pid)
-    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "setsid");
+    LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "setsid");
   sh->ready_confirm_fd = filedes[1];
 #else
   /* FIXME: we probably need to do something else
    * elsewhere in order to fork the process itself... */
-  FreeConsole ();
+  FreeConsole();
 #endif
   return GNUNET_OK;
 }
@@ -1886,23 +1892,23 @@ detach_terminal (struct GNUNET_SERVICE_Handle *sh)
  * @param sh handle to the service to tear down.
  */
 static void
-teardown_service (struct GNUNET_SERVICE_Handle *sh)
+teardown_service(struct GNUNET_SERVICE_Handle *sh)
 {
   struct ServiceListenContext *slc;
 
-  GNUNET_free_non_null (sh->v4_denied);
-  GNUNET_free_non_null (sh->v6_denied);
-  GNUNET_free_non_null (sh->v4_allowed);
-  GNUNET_free_non_null (sh->v6_allowed);
+  GNUNET_free_non_null(sh->v4_denied);
+  GNUNET_free_non_null(sh->v6_denied);
+  GNUNET_free_non_null(sh->v4_allowed);
+  GNUNET_free_non_null(sh->v6_allowed);
   while (NULL != (slc = sh->slc_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (sh->slc_head, sh->slc_tail, slc);
-    if (NULL != slc->listen_task)
-      GNUNET_SCHEDULER_cancel (slc->listen_task);
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_NETWORK_socket_close (slc->listen_socket));
-    GNUNET_free (slc);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(sh->slc_head, sh->slc_tail, slc);
+      if (NULL != slc->listen_task)
+        GNUNET_SCHEDULER_cancel(slc->listen_task);
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_NETWORK_socket_close(slc->listen_socket));
+      GNUNET_free(slc);
+    }
 }
 
 
@@ -1913,7 +1919,7 @@ teardown_service (struct GNUNET_SERVICE_Handle *sh)
  * @param msg AGPL request
  */
 static void
-return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
+return_agpl(void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_MQ_Handle *mq;
@@ -1921,13 +1927,13 @@ return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
   struct GNUNET_MessageHeader *res;
   size_t slen;
 
-  (void) msg;
-  slen = strlen (GNUNET_AGPL_URL) + 1;
-  env = GNUNET_MQ_msg_extra (res, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, slen);
-  memcpy (&res[1], GNUNET_AGPL_URL, slen);
-  mq = GNUNET_SERVICE_client_get_mq (client);
-  GNUNET_MQ_send (mq, env);
-  GNUNET_SERVICE_client_continue (client);
+  (void)msg;
+  slen = strlen(GNUNET_AGPL_URL) + 1;
+  env = GNUNET_MQ_msg_extra(res, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, slen);
+  memcpy(&res[1], GNUNET_AGPL_URL, slen);
+  mq = GNUNET_SERVICE_client_get_mq(client);
+  GNUNET_MQ_send(mq, env);
+  GNUNET_SERVICE_client_continue(client);
 }
 
 
@@ -1968,29 +1974,29 @@ return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
  * @return NULL on error
  */
 struct GNUNET_SERVICE_Handle *
-GNUNET_SERVICE_start (const char *service_name,
-                      const struct GNUNET_CONFIGURATION_Handle *cfg,
-                      GNUNET_SERVICE_ConnectHandler connect_cb,
-                      GNUNET_SERVICE_DisconnectHandler disconnect_cb,
-                      void *cls,
-                      const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_SERVICE_start(const char *service_name,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg,
+                     GNUNET_SERVICE_ConnectHandler connect_cb,
+                     GNUNET_SERVICE_DisconnectHandler disconnect_cb,
+                     void *cls,
+                     const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_SERVICE_Handle *sh;
 
-  sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
+  sh = GNUNET_new(struct GNUNET_SERVICE_Handle);
   sh->service_name = service_name;
   sh->cfg = cfg;
   sh->connect_cb = connect_cb;
   sh->disconnect_cb = disconnect_cb;
   sh->cb_cls = cls;
-  sh->handlers = GNUNET_MQ_copy_handlers2 (handlers, &return_agpl, NULL);
-  if (GNUNET_OK != setup_service (sh))
-  {
-    GNUNET_free_non_null (sh->handlers);
-    GNUNET_free (sh);
-    return NULL;
-  }
-  do_resume (sh, SUSPEND_STATE_NONE);
+  sh->handlers = GNUNET_MQ_copy_handlers2(handlers, &return_agpl, NULL);
+  if (GNUNET_OK != setup_service(sh))
+    {
+      GNUNET_free_non_null(sh->handlers);
+      GNUNET_free(sh);
+      return NULL;
+    }
+  do_resume(sh, SUSPEND_STATE_NONE);
   return sh;
 }
 
@@ -2001,16 +2007,16 @@ GNUNET_SERVICE_start (const char *service_name,
  * @param srv service to stop
  */
 void
-GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
+GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv)
 {
   struct GNUNET_SERVICE_Client *client;
 
-  GNUNET_SERVICE_suspend (srv);
+  GNUNET_SERVICE_suspend(srv);
   while (NULL != (client = srv->clients_head))
-    GNUNET_SERVICE_client_drop (client);
-  teardown_service (srv);
-  GNUNET_free_non_null (srv->handlers);
-  GNUNET_free (srv);
+    GNUNET_SERVICE_client_drop(client);
+  teardown_service(srv);
+  GNUNET_free_non_null(srv->handlers);
+  GNUNET_free(srv);
 }
 
 
@@ -2056,17 +2062,18 @@ GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
  * @return 0 on success, non-zero on error
  */
 int
-GNUNET_SERVICE_run_ (int argc,
-                     char *const *argv,
-                     const char *service_name,
-                     enum GNUNET_SERVICE_Options options,
-                     GNUNET_SERVICE_InitCallback service_init_cb,
-                     GNUNET_SERVICE_ConnectHandler connect_cb,
-                     GNUNET_SERVICE_DisconnectHandler disconnect_cb,
-                     void *cls,
-                     const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_SERVICE_run_(int argc,
+                    char *const *argv,
+                    const char *service_name,
+                    enum GNUNET_SERVICE_Options options,
+                    GNUNET_SERVICE_InitCallback service_init_cb,
+                    GNUNET_SERVICE_ConnectHandler connect_cb,
+                    GNUNET_SERVICE_DisconnectHandler disconnect_cb,
+                    void *cls,
+                    const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_SERVICE_Handle sh;
+
 #if ENABLE_NLS
   char *path;
 #endif
@@ -2082,40 +2089,40 @@ GNUNET_SERVICE_run_ (int argc,
   struct GNUNET_CONFIGURATION_Handle *cfg;
   int ret;
   int err;
-  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
+  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get();
 
   struct GNUNET_GETOPT_CommandLineOption service_options[] =
-    {GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
-     GNUNET_GETOPT_option_flag ('d',
-                                "daemonize",
-                                gettext_noop (
-                                  "do daemonize (detach from terminal)"),
-                                &do_daemonize),
-     GNUNET_GETOPT_option_help (NULL),
-     GNUNET_GETOPT_option_loglevel (&loglev),
-     GNUNET_GETOPT_option_logfile (&logfile),
-     GNUNET_GETOPT_option_version (pd->version),
-     GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_cfgfile(&opt_cfg_filename),
+    GNUNET_GETOPT_option_flag('d',
+                              "daemonize",
+                              gettext_noop(
+                                "do daemonize (detach from terminal)"),
+                              &do_daemonize),
+    GNUNET_GETOPT_option_help(NULL),
+    GNUNET_GETOPT_option_loglevel(&loglev),
+    GNUNET_GETOPT_option_logfile(&logfile),
+    GNUNET_GETOPT_option_version(pd->version),
+    GNUNET_GETOPT_OPTION_END };
 
   err = 1;
-  memset (&sh, 0, sizeof (sh));
-  xdg = getenv ("XDG_CONFIG_HOME");
+  memset(&sh, 0, sizeof(sh));
+  xdg = getenv("XDG_CONFIG_HOME");
   if (NULL != xdg)
-    GNUNET_asprintf (&cfg_filename,
-                     "%s%s%s",
-                     xdg,
-                     DIR_SEPARATOR_STR,
-                     pd->config_file);
+    GNUNET_asprintf(&cfg_filename,
+                    "%s%s%s",
+                    xdg,
+                    DIR_SEPARATOR_STR,
+                    pd->config_file);
   else
-    cfg_filename = GNUNET_strdup (pd->user_config_file);
+    cfg_filename = GNUNET_strdup(pd->user_config_file);
   sh.ready_confirm_fd = -1;
   sh.options = options;
-  sh.cfg = cfg = GNUNET_CONFIGURATION_create ();
+  sh.cfg = cfg = GNUNET_CONFIGURATION_create();
   sh.service_init_cb = service_init_cb;
   sh.connect_cb = connect_cb;
   sh.disconnect_cb = disconnect_cb;
   sh.cb_cls = cls;
-  sh.handlers = GNUNET_MQ_copy_handlers (handlers);
+  sh.handlers = GNUNET_MQ_copy_handlers(handlers);
   sh.service_name = service_name;
   sh.ret = 0;
   /* setup subsystems */
@@ -2125,135 +2132,135 @@ GNUNET_SERVICE_run_ (int argc,
   do_daemonize = 0;
 #if ENABLE_NLS
   if (NULL != pd->gettext_domain)
-  {
-    setlocale (LC_ALL, "");
-    path = (NULL == pd->gettext_path) ?
-      GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR) :
-      GNUNET_strdup (pd->gettext_path);
-    if (NULL != path)
     {
-      bindtextdomain (pd->gettext_domain, path);
-      GNUNET_free (path);
+      setlocale(LC_ALL, "");
+      path = (NULL == pd->gettext_path) ?
+             GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR) :
+             GNUNET_strdup(pd->gettext_path);
+      if (NULL != path)
+        {
+          bindtextdomain(pd->gettext_domain, path);
+          GNUNET_free(path);
+        }
+      textdomain(pd->gettext_domain);
     }
-    textdomain (pd->gettext_domain);
-  }
 #endif
-  ret = GNUNET_GETOPT_run (service_name, service_options, argc, argv);
+  ret = GNUNET_GETOPT_run(service_name, service_options, argc, argv);
   if (GNUNET_SYSERR == ret)
     goto shutdown;
   if (GNUNET_NO == ret)
-  {
-    err = 0;
-    goto shutdown;
-  }
-  if (GNUNET_OK != GNUNET_log_setup (service_name, loglev, logfile))
-  {
-    GNUNET_break (0);
-    goto shutdown;
-  }
-  if (NULL != opt_cfg_filename)
-  {
-    if ((GNUNET_YES != GNUNET_DISK_file_test (opt_cfg_filename)) ||
-        (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, opt_cfg_filename)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Malformed configuration file `%s', exit ...\n"),
-                  opt_cfg_filename);
+      err = 0;
       goto shutdown;
     }
-  }
-  else
-  {
-    if (GNUNET_YES == GNUNET_DISK_file_test (cfg_filename))
+  if (GNUNET_OK != GNUNET_log_setup(service_name, loglev, logfile))
     {
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cfg_filename))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _ ("Malformed configuration file `%s', exit ...\n"),
-                    cfg_filename);
-        goto shutdown;
-      }
+      GNUNET_break(0);
+      goto shutdown;
     }
-    else
+  if (NULL != opt_cfg_filename)
     {
-      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _ ("Malformed configuration, exit ...\n"));
-        goto shutdown;
-      }
+      if ((GNUNET_YES != GNUNET_DISK_file_test(opt_cfg_filename)) ||
+          (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, opt_cfg_filename)))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     _("Malformed configuration file `%s', exit ...\n"),
+                     opt_cfg_filename);
+          goto shutdown;
+        }
     }
-  }
-  if (GNUNET_OK != setup_service (&sh))
-    goto shutdown;
-  if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal (&sh)))
-  {
-    GNUNET_break (0);
+  else
+    {
+      if (GNUNET_YES == GNUNET_DISK_file_test(cfg_filename))
+        {
+          if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cfg_filename))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         _("Malformed configuration file `%s', exit ...\n"),
+                         cfg_filename);
+              goto shutdown;
+            }
+        }
+      else
+        {
+          if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, NULL))
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         _("Malformed configuration, exit ...\n"));
+              goto shutdown;
+            }
+        }
+    }
+  if (GNUNET_OK != setup_service(&sh))
     goto shutdown;
-  }
-  if (GNUNET_OK != set_user_id (&sh))
+  if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal(&sh)))
+    {
+      GNUNET_break(0);
+      goto shutdown;
+    }
+  if (GNUNET_OK != set_user_id(&sh))
     goto shutdown;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Service `%s' runs with configuration from `%s'\n",
-       service_name,
-       (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
-  if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sh.cfg,
-                                                           "TESTING",
-                                                           "SKEW_OFFSET",
-                                                           &skew_offset)) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sh.cfg,
-                                                           "TESTING",
-                                                           "SKEW_VARIANCE",
-                                                           &skew_variance)))
-  {
-    clock_offset = skew_offset - skew_variance;
-    GNUNET_TIME_set_offset (clock_offset);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset);
-  }
-  GNUNET_RESOLVER_connect (sh.cfg);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Service `%s' runs with configuration from `%s'\n",
+      service_name,
+      (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
+  if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sh.cfg,
+                                                          "TESTING",
+                                                          "SKEW_OFFSET",
+                                                          &skew_offset)) &&
+      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sh.cfg,
+                                                          "TESTING",
+                                                          "SKEW_VARIANCE",
+                                                          &skew_variance)))
+    {
+      clock_offset = skew_offset - skew_variance;
+      GNUNET_TIME_set_offset(clock_offset);
+      LOG(GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset);
+    }
+  GNUNET_RESOLVER_connect(sh.cfg);
 
   /* actually run service */
   err = 0;
-  GNUNET_SCHEDULER_run (&service_main, &sh);
+  GNUNET_SCHEDULER_run(&service_main, &sh);
   /* shutdown */
   if (1 == do_daemonize)
-    pid_file_delete (&sh);
+    pid_file_delete(&sh);
 
 shutdown:
   if (-1 != sh.ready_confirm_fd)
-  {
-    if (1 != write (sh.ready_confirm_fd, err ? "I" : "S", 1))
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "write");
-    GNUNET_break (0 == close (sh.ready_confirm_fd));
-  }
+    {
+      if (1 != write(sh.ready_confirm_fd, err ? "I" : "S", 1))
+        LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "write");
+      GNUNET_break(0 == close(sh.ready_confirm_fd));
+    }
 #if HAVE_MALLINFO
   {
     char *counter;
 
-    if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (sh.cfg,
-                                                        service_name,
-                                                        "GAUGER_HEAP")) &&
-        (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (sh.cfg,
-                                                             service_name,
-                                                             "GAUGER_HEAP",
-                                                             &counter)))
-    {
-      struct mallinfo mi;
+    if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value(sh.cfg,
+                                                       service_name,
+                                                       "GAUGER_HEAP")) &&
+        (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(sh.cfg,
+                                                            service_name,
+                                                            "GAUGER_HEAP",
+                                                            &counter)))
+      {
+        struct mallinfo mi;
 
-      mi = mallinfo ();
-      GAUGER (service_name, counter, mi.usmblks, "blocks");
-      GNUNET_free (counter);
-    }
+        mi = mallinfo();
+        GAUGER(service_name, counter, mi.usmblks, "blocks");
+        GNUNET_free(counter);
+      }
   }
 #endif
-  teardown_service (&sh);
-  GNUNET_free_non_null (sh.handlers);
-  GNUNET_SPEEDUP_stop_ ();
-  GNUNET_CONFIGURATION_destroy (cfg);
-  GNUNET_free_non_null (logfile);
-  GNUNET_free_non_null (loglev);
-  GNUNET_free (cfg_filename);
-  GNUNET_free_non_null (opt_cfg_filename);
+  teardown_service(&sh);
+  GNUNET_free_non_null(sh.handlers);
+  GNUNET_SPEEDUP_stop_();
+  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_free_non_null(logfile);
+  GNUNET_free_non_null(loglev);
+  GNUNET_free(cfg_filename);
+  GNUNET_free_non_null(opt_cfg_filename);
 
   return err ? GNUNET_SYSERR : sh.ret;
 }
@@ -2266,9 +2273,9 @@ shutdown:
  * @param sh service to stop accepting connections.
  */
 void
-GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
+GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh)
 {
-  do_suspend (sh, SUSPEND_STATE_APP);
+  do_suspend(sh, SUSPEND_STATE_APP);
 }
 
 
@@ -2278,9 +2285,9 @@ GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
  * @param sh service to resume accepting connections.
  */
 void
-GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
+GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
 {
-  do_resume (sh, SUSPEND_STATE_APP);
+  do_resume(sh, SUSPEND_STATE_APP);
 }
 
 
@@ -2291,32 +2298,32 @@ GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
  * @param cls our `struct GNUNET_SERVICE_Client`
  */
 static void
-resume_client_receive (void *cls)
+resume_client_receive(void *cls)
 {
   struct GNUNET_SERVICE_Client *c = cls;
   int ret;
 
   c->recv_task = NULL;
   /* first, check if there is still something in the buffer */
-  ret = GNUNET_MST_next (c->mst, GNUNET_YES);
+  ret = GNUNET_MST_next(c->mst, GNUNET_YES);
   if (GNUNET_SYSERR == ret)
-  {
-    if (NULL == c->drop_task)
-      GNUNET_SERVICE_client_drop (c);
-    return;
-  }
+    {
+      if (NULL == c->drop_task)
+        GNUNET_SERVICE_client_drop(c);
+      return;
+    }
   if (GNUNET_NO == ret)
     return; /* done processing, wait for more later */
-  GNUNET_assert (GNUNET_OK == ret);
+  GNUNET_assert(GNUNET_OK == ret);
   if (GNUNET_YES == c->needs_continue)
     return; /* #GNUNET_MST_next() did give a message to the client */
   /* need to receive more data from the network first */
   if (NULL != c->recv_task)
     return;
-  c->recv_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                c->sock,
-                                                &service_client_recv,
-                                                c);
+  c->recv_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
+                                               c->sock,
+                                               &service_client_recv,
+                                               c);
 }
 
 
@@ -2327,18 +2334,18 @@ resume_client_receive (void *cls)
  * @param c the client to continue receiving from
  */
 void
-GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
 {
-  GNUNET_assert (NULL == c->drop_task);
-  GNUNET_assert (GNUNET_YES == c->needs_continue);
-  GNUNET_assert (NULL == c->recv_task);
+  GNUNET_assert(NULL == c->drop_task);
+  GNUNET_assert(GNUNET_YES == c->needs_continue);
+  GNUNET_assert(NULL == c->recv_task);
   c->needs_continue = GNUNET_NO;
   if (NULL != c->warn_task)
-  {
-    GNUNET_SCHEDULER_cancel (c->warn_task);
-    c->warn_task = NULL;
-  }
-  c->recv_task = GNUNET_SCHEDULER_add_now (&resume_client_receive, c);
+    {
+      GNUNET_SCHEDULER_cancel(c->warn_task);
+      c->warn_task = NULL;
+    }
+  c->recv_task = GNUNET_SCHEDULER_add_now(&resume_client_receive, c);
 }
 
 
@@ -2351,14 +2358,14 @@ GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
  * @param c client for which to disable the warning
  */
 void
-GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c)
 {
-  GNUNET_break (NULL != c->warn_task);
+  GNUNET_break(NULL != c->warn_task);
   if (NULL != c->warn_task)
-  {
-    GNUNET_SCHEDULER_cancel (c->warn_task);
-    c->warn_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(c->warn_task);
+      c->warn_task = NULL;
+    }
 }
 
 
@@ -2368,32 +2375,32 @@ GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
  * @param cls the `struct GNUNET_SERVICE_Client`.
  */
 static void
-finish_client_drop (void *cls)
+finish_client_drop(void *cls)
 {
   struct GNUNET_SERVICE_Client *c = cls;
   struct GNUNET_SERVICE_Handle *sh = c->sh;
 
   c->drop_task = NULL;
-  GNUNET_assert (NULL == c->send_task);
-  GNUNET_assert (NULL == c->recv_task);
-  GNUNET_assert (NULL == c->warn_task);
-  GNUNET_MST_destroy (c->mst);
-  GNUNET_MQ_destroy (c->mq);
+  GNUNET_assert(NULL == c->send_task);
+  GNUNET_assert(NULL == c->recv_task);
+  GNUNET_assert(NULL == c->warn_task);
+  GNUNET_MST_destroy(c->mst);
+  GNUNET_MQ_destroy(c->mq);
   if (GNUNET_NO == c->persist)
-  {
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (c->sock));
-    if ((0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
-        (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)))
-      do_resume (sh, SUSPEND_STATE_EMFILE);
-  }
+    {
+      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(c->sock));
+      if ((0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
+          (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)))
+        do_resume(sh, SUSPEND_STATE_EMFILE);
+    }
   else
-  {
-    GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
-  }
-  GNUNET_free (c);
+    {
+      GNUNET_NETWORK_socket_free_memory_only_(c->sock);
+    }
+  GNUNET_free(c);
   if ((0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) &&
-      (GNUNET_NO == have_non_monitor_clients (sh)))
-    GNUNET_SERVICE_shutdown (sh);
+      (GNUNET_NO == have_non_monitor_clients(sh)))
+    GNUNET_SERVICE_shutdown(sh);
 }
 
 
@@ -2408,52 +2415,52 @@ finish_client_drop (void *cls)
  * @param c client to disconnect now
  */
 void
-GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
 {
   struct GNUNET_SERVICE_Handle *sh = c->sh;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client dropped: %p (MQ: %p)\n",
-              c,
-              c->mq);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Client dropped: %p (MQ: %p)\n",
+             c,
+             c->mq);
 #if EXECINFO
   {
     void *backtrace_array[MAX_TRACE_DEPTH];
-    int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
+    int num_backtrace_strings = backtrace(backtrace_array, MAX_TRACE_DEPTH);
     char **backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+      backtrace_symbols(backtrace_array, t->num_backtrace_strings);
     for (unsigned int i = 0; i < num_backtrace_strings; i++)
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "client drop trace %u: %s\n",
-           i,
-           backtrace_strings[i]);
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "client drop trace %u: %s\n",
+          i,
+          backtrace_strings[i]);
   }
 #endif
   if (NULL != c->drop_task)
-  {
-    /* asked to drop twice! */
-    GNUNET_assert (0);
-    return;
-  }
-  GNUNET_CONTAINER_DLL_remove (sh->clients_head, sh->clients_tail, c);
+    {
+      /* asked to drop twice! */
+      GNUNET_assert(0);
+      return;
+    }
+  GNUNET_CONTAINER_DLL_remove(sh->clients_head, sh->clients_tail, c);
   if (NULL != sh->disconnect_cb)
-    sh->disconnect_cb (sh->cb_cls, c, c->user_context);
+    sh->disconnect_cb(sh->cb_cls, c, c->user_context);
   if (NULL != c->warn_task)
-  {
-    GNUNET_SCHEDULER_cancel (c->warn_task);
-    c->warn_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(c->warn_task);
+      c->warn_task = NULL;
+    }
   if (NULL != c->recv_task)
-  {
-    GNUNET_SCHEDULER_cancel (c->recv_task);
-    c->recv_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(c->recv_task);
+      c->recv_task = NULL;
+    }
   if (NULL != c->send_task)
-  {
-    GNUNET_SCHEDULER_cancel (c->send_task);
-    c->send_task = NULL;
-  }
-  c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop, c);
+    {
+      GNUNET_SCHEDULER_cancel(c->send_task);
+      c->send_task = NULL;
+    }
+  c->drop_task = GNUNET_SCHEDULER_add_now(&finish_client_drop, c);
 }
 
 
@@ -2463,14 +2470,14 @@ GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
  * @param sh server to shutdown
  */
 void
-GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
+GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh)
 {
   struct GNUNET_SERVICE_Client *client;
 
   if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
-    do_suspend (sh, SUSPEND_STATE_SHUTDOWN);
+    do_suspend(sh, SUSPEND_STATE_SHUTDOWN);
   while (NULL != (client = sh->clients_head))
-    GNUNET_SERVICE_client_drop (client);
+    GNUNET_SERVICE_client_drop(client);
 }
 
 
@@ -2487,12 +2494,12 @@ GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
  * @param c client to mark as a monitor
  */
 void
-GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
 {
   c->is_monitor = GNUNET_YES;
   if (((0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state)) &&
-       (GNUNET_NO == have_non_monitor_clients (c->sh))))
-    GNUNET_SERVICE_shutdown (c->sh);
+       (GNUNET_NO == have_non_monitor_clients(c->sh))))
+    GNUNET_SERVICE_shutdown(c->sh);
 }
 
 
@@ -2504,7 +2511,7 @@ GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
  * @param c client to persist the socket (never to be closed)
  */
 void
-GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_persist(struct GNUNET_SERVICE_Client *c)
 {
   c->persist = GNUNET_YES;
 }
@@ -2517,7 +2524,7 @@ GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
  * @return the message queue of @a c
  */
 struct GNUNET_MQ_Handle *
-GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
+GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
 {
   return c->mq;
 }
diff --git a/src/util/signal.c b/src/util/signal.c
index 3e23f4a59..96e40ba7f 100644
--- a/src/util/signal.c
+++ b/src/util/signal.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 util/signal.c
@@ -27,12 +27,10 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-signal", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-signal", __VA_ARGS__)
 
 
-struct GNUNET_SIGNAL_Context
-{
-
+struct GNUNET_SIGNAL_Context {
   struct GNUNET_SIGNAL_Context *next;
 
   struct GNUNET_SIGNAL_Context *prev;
@@ -56,7 +54,7 @@ GNUNET_SIGNAL_Handler w32_sigchld_handler = NULL;
 #endif
 
 struct GNUNET_SIGNAL_Context *
-GNUNET_SIGNAL_handler_install (int signum, GNUNET_SIGNAL_Handler handler)
+GNUNET_SIGNAL_handler_install(int signum, GNUNET_SIGNAL_Handler handler)
 {
   struct GNUNET_SIGNAL_Context *ret;
 
@@ -64,48 +62,48 @@ GNUNET_SIGNAL_handler_install (int signum, GNUNET_SIGNAL_Handler handler)
   struct sigaction sig;
 #endif
 
-  ret = GNUNET_new (struct GNUNET_SIGNAL_Context);
+  ret = GNUNET_new(struct GNUNET_SIGNAL_Context);
   ret->sig = signum;
   ret->method = handler;
 #ifndef MINGW
-  memset (&sig, 0, sizeof (sig));
-  sig.sa_handler = (void *) handler;
-  sigemptyset (&sig.sa_mask);
+  memset(&sig, 0, sizeof(sig));
+  sig.sa_handler = (void *)handler;
+  sigemptyset(&sig.sa_mask);
 #ifdef SA_INTERRUPT
   sig.sa_flags = SA_INTERRUPT;  /* SunOS */
 #else
   sig.sa_flags = SA_RESTART;
 #endif
-  sigaction (signum, &sig, &ret->oldsig);
+  sigaction(signum, &sig, &ret->oldsig);
 #else
   if (signum == GNUNET_SIGCHLD)
     w32_sigchld_handler = handler;
   else
-  {
-    __p_sig_fn_t sigret = signal (signum, (__p_sig_fn_t) handler);
-
-    if (sigret == SIG_ERR)
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING, _("signal (%d, %p) returned %d.\n"),
-           signum, handler, sigret);
+      __p_sig_fn_t sigret = signal(signum, (__p_sig_fn_t)handler);
+
+      if (sigret == SIG_ERR)
+        {
+          LOG(GNUNET_ERROR_TYPE_WARNING, _("signal (%d, %p) returned %d.\n"),
+              signum, handler, sigret);
+        }
     }
-  }
 #endif
-  GNUNET_CONTAINER_DLL_insert_tail (sc_head, sc_tail, ret);
+  GNUNET_CONTAINER_DLL_insert_tail(sc_head, sc_tail, ret);
   return ret;
 }
 
 void
-GNUNET_SIGNAL_handler_uninstall (struct GNUNET_SIGNAL_Context *ctx)
+GNUNET_SIGNAL_handler_uninstall(struct GNUNET_SIGNAL_Context *ctx)
 {
 #ifndef MINGW
   struct sigaction sig;
 
-  sigemptyset (&sig.sa_mask);
-  sigaction (ctx->sig, &ctx->oldsig, &sig);
+  sigemptyset(&sig.sa_mask);
+  sigaction(ctx->sig, &ctx->oldsig, &sig);
 #endif
-  GNUNET_CONTAINER_DLL_remove (sc_head, sc_tail, ctx);
-  GNUNET_free (ctx);
+  GNUNET_CONTAINER_DLL_remove(sc_head, sc_tail, ctx);
+  GNUNET_free(ctx);
 }
 
 
@@ -117,16 +115,16 @@ GNUNET_SIGNAL_handler_uninstall (struct GNUNET_SIGNAL_Context *ctx)
  * @param sig the signal to raise
  */
 void
-GNUNET_SIGNAL_raise (const int sig)
+GNUNET_SIGNAL_raise(const int sig)
 {
   struct GNUNET_SIGNAL_Context *ctx;
 
   for (ctx = sc_head; NULL != ctx; ctx = ctx->next)
-  {
-    if (sig != ctx->sig)
-      continue;
-    if (NULL == ctx->method)
-      continue;
-    ctx->method ();
-  }
+    {
+      if (sig != ctx->sig)
+        continue;
+      if (NULL == ctx->method)
+        continue;
+      ctx->method();
+    }
 }
diff --git a/src/util/socks.c b/src/util/socks.c
index 66b7bf7df..ca3d1e8c4 100644
--- a/src/util/socks.c
+++ b/src/util/socks.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 util/socks.c
@@ -29,10 +29,10 @@
 #include "gnunet_util_lib.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-socks", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-socks", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-socks", syscall)
+  GNUNET_log_from_strerror(kind, "util-socks", syscall)
 
 
 /* SOCKS5 authentication methods */
@@ -58,33 +58,43 @@
 #define SOCKS5_REP_INVADDR 0x09 /* Inalid address */
 
 const char *
-SOCKS5_REP_names (int rep)
+SOCKS5_REP_names(int rep)
 {
   switch (rep)
-  {
-  case SOCKS5_REP_SUCCEEDED:
-    return "succeeded";
-  case SOCKS5_REP_FAIL:
-    return "general SOCKS server failure";
-  case SOCKS5_REP_NALLOWED:
-    return "connection not allowed by ruleset";
-  case SOCKS5_REP_NUNREACH:
-    return "Network unreachable";
-  case SOCKS5_REP_HUNREACH:
-    return "Host unreachable";
-  case SOCKS5_REP_REFUSED:
-    return "connection refused";
-  case SOCKS5_REP_EXPIRED:
-    return "TTL expired";
-  case SOCKS5_REP_CNOTSUP:
-    return "Command not supported";
-  case SOCKS5_REP_ANOTSUP:
-    return "Address not supported";
-  case SOCKS5_REP_INVADDR:
-    return "Invalid address";
-  default:
-    return NULL;
-  }
+    {
+    case SOCKS5_REP_SUCCEEDED:
+      return "succeeded";
+
+    case SOCKS5_REP_FAIL:
+      return "general SOCKS server failure";
+
+    case SOCKS5_REP_NALLOWED:
+      return "connection not allowed by ruleset";
+
+    case SOCKS5_REP_NUNREACH:
+      return "Network unreachable";
+
+    case SOCKS5_REP_HUNREACH:
+      return "Host unreachable";
+
+    case SOCKS5_REP_REFUSED:
+      return "connection refused";
+
+    case SOCKS5_REP_EXPIRED:
+      return "TTL expired";
+
+    case SOCKS5_REP_CNOTSUP:
+      return "Command not supported";
+
+    case SOCKS5_REP_ANOTSUP:
+      return "Address not supported";
+
+    case SOCKS5_REP_INVADDR:
+      return "Invalid address";
+
+    default:
+      return NULL;
+    }
 };
 
 
@@ -98,18 +108,18 @@ SOCKS5_REP_names (int rep)
  * @return pointer to the end of the encoded string in the buffer
  */
 unsigned char *
-SOCK5_proto_string (unsigned char *b, const char *s)
+SOCK5_proto_string(unsigned char *b, const char *s)
 {
-  size_t l = strlen (s);
+  size_t l = strlen(s);
 
   if (l > 255)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "SOCKS5 cannot handle hostnames, usernames, or passwords over 255 bytes, truncating.\n");
-    l = 255;
-  }
-  *(b++) = (unsigned char) l;
-  memcpy (b, s, l);
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          "SOCKS5 cannot handle hostnames, usernames, or passwords over 255 bytes, truncating.\n");
+      l = 255;
+    }
+  *(b++) = (unsigned char)l;
+  memcpy(b, s, l);
   return b + l;
 }
 
@@ -122,9 +132,7 @@ SOCK5_proto_string (unsigned char *b, const char *s)
 /**
  * State of the SOCKS5 handshake.
  */
-struct GNUNET_SOCKS_Handshake
-{
-
+struct GNUNET_SOCKS_Handshake {
   /**
    * Connection handle used for SOCKS5
    */
@@ -171,16 +179,16 @@ struct GNUNET_SOCKS_Handshake
 /* Regitering prototypes */
 
 void
-register_reciever (struct GNUNET_SOCKS_Handshake *ih, int want);
+register_reciever(struct GNUNET_SOCKS_Handshake *ih, int want);
 
 /* In fact, the client sends first rule in GNUnet suggests one could take
-   * large mac read sizes without fear of screwing up the proxied protocol,
-   * but we make a proper SOCKS5 client. */
+ * large mac read sizes without fear of screwing up the proxied protocol,
+ * but we make a proper SOCKS5 client. */
 #define register_reciever_wants(ih) ((SOCKS5_step_cmd == ih->step) ? 10 : 2)
 
 
 struct GNUNET_CONNECTION_TransmitHandle *
-register_sender (struct GNUNET_SOCKS_Handshake *ih);
+register_sender(struct GNUNET_SOCKS_Handshake *ih);
 
 
 /**
@@ -191,9 +199,9 @@ register_sender (struct GNUNET_SOCKS_Handshake *ih);
  * @return Connection handle that becomes usable when the handshake completes.
  */
 void
-SOCKS5_handshake_done (struct GNUNET_SOCKS_Handshake *ih)
+SOCKS5_handshake_done(struct GNUNET_SOCKS_Handshake *ih)
 {
-  GNUNET_CONNECTION_acivate_proxied (ih->target_connection);
+  GNUNET_CONNECTION_acivate_proxied(ih->target_connection);
 }
 
 
@@ -203,100 +211,109 @@ SOCKS5_handshake_done (struct GNUNET_SOCKS_Handshake *ih)
  * @param ih SOCKS5 Handshake
  */
 void
-SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
+SOCKS5_handshake_step(struct GNUNET_SOCKS_Handshake *ih)
 {
   unsigned char *b = ih->instart;
   size_t available = ih->inend - b;
 
-  int want = register_reciever_wants (ih);
+  int want = register_reciever_wants(ih);
+
   if (available < want)
-  {
-    register_reciever (ih, want - available);
-    return;
-  }
-  GNUNET_assert (SOCKS5_step_done > ih->step && ih->step >= 0);
-  switch (ih->step)
-  {
-  case SOCKS5_step_greet: /* SOCKS5 server's greeting */
-    if (b[0] != 5)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR, "Not a SOCKS5 server\n");
-      GNUNET_assert (0);
-    }
-    switch (b[1])
     {
-    case SOCKS5_AUTH_NOAUTH:
-      ih->step = SOCKS5_step_cmd; /* no authentication to do */
-      break;
-    case SOCKS5_AUTH_USERPASS:
-      ih->step = SOCKS5_step_auth;
-      break;
-    case SOCKS5_AUTH_REJECT:
-      LOG (GNUNET_ERROR_TYPE_ERROR, "No authentication method accepted\n");
-      return;
-    default:
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "Not a SOCKS5 server / Nonsensical authentication\n");
+      register_reciever(ih, want - available);
       return;
     }
-    b += 2;
-    break;
-  case SOCKS5_step_auth: /* SOCKS5 server's responce to authentication */
-    if (b[1] != 0)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 authentication failed\n");
-      GNUNET_assert (0);
-    }
-    ih->step = SOCKS5_step_cmd;
-    b += 2;
-    break;
-  case SOCKS5_step_cmd: /* SOCKS5 server's responce to command */
-    if (b[0] != 5)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 protocol error\n");
-      GNUNET_assert (0);
-    }
-    if (0 != b[1])
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "SOCKS5 connection error : %s\n",
-           SOCKS5_REP_names (b[1]));
-      return;
-    }
-    b += 3;
-    /* There is no reason to verify host and port afaik. */
-    switch (*(b++))
+  GNUNET_assert(SOCKS5_step_done > ih->step && ih->step >= 0);
+  switch (ih->step)
     {
-    case 1: /* IPv4 */
-      b += sizeof (struct in_addr); /* 4 */
+    case SOCKS5_step_greet: /* SOCKS5 server's greeting */
+      if (b[0] != 5)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR, "Not a SOCKS5 server\n");
+          GNUNET_assert(0);
+        }
+      switch (b[1])
+        {
+        case SOCKS5_AUTH_NOAUTH:
+          ih->step = SOCKS5_step_cmd; /* no authentication to do */
+          break;
+
+        case SOCKS5_AUTH_USERPASS:
+          ih->step = SOCKS5_step_auth;
+          break;
+
+        case SOCKS5_AUTH_REJECT:
+          LOG(GNUNET_ERROR_TYPE_ERROR, "No authentication method accepted\n");
+          return;
+
+        default:
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              "Not a SOCKS5 server / Nonsensical authentication\n");
+          return;
+        }
+      b += 2;
       break;
-    case 4: /* IPv6 */
-      b += sizeof (struct in6_addr); /* 16 */
-      break;
-    case 3: /* hostname */
-      b += *b;
+
+    case SOCKS5_step_auth: /* SOCKS5 server's responce to authentication */
+      if (b[1] != 0)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR, "SOCKS5 authentication failed\n");
+          GNUNET_assert(0);
+        }
+      ih->step = SOCKS5_step_cmd;
+      b += 2;
       break;
-    }
-    b += 2; /* port */
-    if (b > ih->inend)
-    {
-      register_reciever (ih, b - ih->inend);
+
+    case SOCKS5_step_cmd: /* SOCKS5 server's responce to command */
+      if (b[0] != 5)
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR, "SOCKS5 protocol error\n");
+          GNUNET_assert(0);
+        }
+      if (0 != b[1])
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              "SOCKS5 connection error : %s\n",
+              SOCKS5_REP_names(b[1]));
+          return;
+        }
+      b += 3;
+      /* There is no reason to verify host and port afaik. */
+      switch (*(b++))
+        {
+        case 1: /* IPv4 */
+          b += sizeof(struct in_addr); /* 4 */
+          break;
+
+        case 4: /* IPv6 */
+          b += sizeof(struct in6_addr); /* 16 */
+          break;
+
+        case 3: /* hostname */
+          b += *b;
+          break;
+        }
+      b += 2; /* port */
+      if (b > ih->inend)
+        {
+          register_reciever(ih, b - ih->inend);
+          return;
+        }
+      ih->step = SOCKS5_step_done;
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "SOCKS5 server : %s\n",
+          SOCKS5_REP_names(b[1]));
+      ih->instart = b;
+      SOCKS5_handshake_done(ih);
       return;
+
+    case SOCKS5_step_done:
+      GNUNET_assert(0);
     }
-    ih->step = SOCKS5_step_done;
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "SOCKS5 server : %s\n",
-         SOCKS5_REP_names (b[1]));
-    ih->instart = b;
-    SOCKS5_handshake_done (ih);
-    return;
-  case SOCKS5_step_done:
-    GNUNET_assert (0);
-  }
   ih->instart = b;
   /* Do not reschedule the sender unless we're done reading.
    * I imagine this lets us avoid ever cancelling the transmit handle. */
-  register_sender (ih);
+  register_sender(ih);
 }
 
 
@@ -308,18 +325,19 @@ SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
  * @param handler_cls closure for @a handler
  */
 void
-reciever (void *cls,
-          const void *buf,
-          size_t available,
-          const struct sockaddr *addr,
-          socklen_t addrlen,
-          int errCode)
+reciever(void *cls,
+         const void *buf,
+         size_t available,
+         const struct sockaddr *addr,
+         socklen_t addrlen,
+         int errCode)
 {
   struct GNUNET_SOCKS_Handshake *ih = cls;
-  GNUNET_assert (&ih->inend[available] < &ih->inbuf[1024]);
-  GNUNET_memcpy (ih->inend, buf, available);
+
+  GNUNET_assert(&ih->inend[available] < &ih->inbuf[1024]);
+  GNUNET_memcpy(ih->inend, buf, available);
   ih->inend += available;
-  SOCKS5_handshake_step (ih);
+  SOCKS5_handshake_step(ih);
 }
 
 
@@ -331,13 +349,13 @@ reciever (void *cls,
  * @param handler_cls closure for @a handler
  */
 void
-register_reciever (struct GNUNET_SOCKS_Handshake *ih, int want)
+register_reciever(struct GNUNET_SOCKS_Handshake *ih, int want)
 {
-  GNUNET_CONNECTION_receive (ih->socks5_connection,
-                             want,
-                             GNUNET_TIME_relative_get_minute_ (),
-                             &reciever,
-                             ih);
+  GNUNET_CONNECTION_receive(ih->socks5_connection,
+                            want,
+                            GNUNET_TIME_relative_get_minute_(),
+                            &reciever,
+                            ih);
 }
 
 
@@ -350,7 +368,7 @@ register_reciever (struct GNUNET_SOCKS_Handshake *ih, int want)
  * @return number of bytes written to @a buf
  */
 size_t
-transmit_ready (void *cls, size_t size, void *buf)
+transmit_ready(void *cls, size_t size, void *buf)
 {
   struct GNUNET_SOCKS_Handshake *ih = cls;
 
@@ -370,32 +388,32 @@ transmit_ready (void *cls, size_t size, void *buf)
    * maybe that should change for error handling pruposes.  It appears that
    * successful operations, including DNS resolution, do not use this.  */
   if (NULL == buf)
-  {
-    if (0 == ih->step)
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Timeout contacting SOCKS server, retrying indefinitely, but probably hopeless.\n");
-      register_sender (ih);
-    }
-    else
     {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "Timeout during mid SOCKS handshake (step %u), probably not a SOCKS server.\n",
-           ih->step);
-      GNUNET_break (0);
+      if (0 == ih->step)
+        {
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              "Timeout contacting SOCKS server, retrying indefinitely, but probably hopeless.\n");
+          register_sender(ih);
+        }
+      else
+        {
+          LOG(GNUNET_ERROR_TYPE_ERROR,
+              "Timeout during mid SOCKS handshake (step %u), probably not a SOCKS server.\n",
+              ih->step);
+          GNUNET_break(0);
+        }
+      return 0;
     }
-    return 0;
-  }
 
-  GNUNET_assert ((1024 >= size) && (size > 0));
-  GNUNET_assert ((SOCKS5_step_done > ih->step) && (ih->step >= 0));
+  GNUNET_assert((1024 >= size) && (size > 0));
+  GNUNET_assert((SOCKS5_step_done > ih->step) && (ih->step >= 0));
   unsigned char *b = ih->outstep[ih->step];
   unsigned char *e = ih->outstep[ih->step + 1];
-  GNUNET_assert (e <= &ih->outbuf[1024]);
+  GNUNET_assert(e <= &ih->outbuf[1024]);
   unsigned int l = e - b;
-  GNUNET_assert (size >= l);
-  GNUNET_memcpy (buf, b, l);
-  register_reciever (ih, register_reciever_wants (ih));
+  GNUNET_assert(size >= l);
+  GNUNET_memcpy(buf, b, l);
+  register_reciever(ih, register_reciever_wants(ih));
   return l;
 }
 
@@ -408,22 +426,22 @@ transmit_ready (void *cls, size_t size, void *buf)
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_CONNECTION_TransmitHandle *
-register_sender (struct GNUNET_SOCKS_Handshake *ih)
+register_sender(struct GNUNET_SOCKS_Handshake *ih)
 {
   struct GNUNET_TIME_Relative timeout = GNUNET_TIME_UNIT_MINUTES;
 
-  GNUNET_assert (SOCKS5_step_done > ih->step);
-  GNUNET_assert (ih->step >= 0);
+  GNUNET_assert(SOCKS5_step_done > ih->step);
+  GNUNET_assert(ih->step >= 0);
   if (0 == ih->step)
-    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 3);
+    timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 3);
   unsigned char *b = ih->outstep[ih->step];
   unsigned char *e = ih->outstep[ih->step + 1];
-  GNUNET_assert (ih->outbuf <= b && b < e && e < &ih->outbuf[1024]);
-  ih->th = GNUNET_CONNECTION_notify_transmit_ready (ih->socks5_connection,
-                                                    e - b,
-                                                    timeout,
-                                                    &transmit_ready,
-                                                    ih);
+  GNUNET_assert(ih->outbuf <= b && b < e && e < &ih->outbuf[1024]);
+  ih->th = GNUNET_CONNECTION_notify_transmit_ready(ih->socks5_connection,
+                                                   e - b,
+                                                   timeout,
+                                                   &transmit_ready,
+                                                   ih);
   return ih->th;
 }
 
@@ -438,10 +456,10 @@ register_sender (struct GNUNET_SOCKS_Handshake *ih)
  * @return Valid SOCKS5 hanbdshake handle
  */
 struct GNUNET_SOCKS_Handshake *
-GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
+GNUNET_SOCKS_init_handshake(const char *user, const char *pass)
 {
   struct GNUNET_SOCKS_Handshake *ih =
-    GNUNET_new (struct GNUNET_SOCKS_Handshake);
+    GNUNET_new(struct GNUNET_SOCKS_Handshake);
   unsigned char *b = ih->outbuf;
 
   ih->outstep[SOCKS5_step_greet] = b;
@@ -453,10 +471,10 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
    * And some SOCKS5 servers might require this.  */
   *(b++) = SOCKS5_AUTH_NOAUTH;
   if (NULL != user)
-  {
-    *(b++) = SOCKS5_AUTH_USERPASS;
-    (*n)++;
-  }
+    {
+      *(b++) = SOCKS5_AUTH_USERPASS;
+      (*n)++;
+    }
   /* There is no apperent reason to support authentication methods beyond
    * username and password since afaik Tor does not support them. */
 
@@ -469,8 +487,8 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
 
   ih->outstep[SOCKS5_step_auth] = b;
   *(b++) = 1; /* subnegotiation ver.: 1 */
-  b = SOCK5_proto_string (b, user);
-  b = SOCK5_proto_string (b, pass);
+  b = SOCK5_proto_string(b, user);
+  b = SOCK5_proto_string(b, pass);
 
   ih->outstep[SOCKS5_step_cmd] = b;
 
@@ -487,9 +505,9 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
  * @return Valid SOCKS5 hanbdshake handle
  */
 struct GNUNET_SOCKS_Handshake *
-GNUNET_SOCKS_init_handshake_noauth ()
+GNUNET_SOCKS_init_handshake_noauth()
 {
-  return GNUNET_SOCKS_init_handshake (NULL, NULL);
+  return GNUNET_SOCKS_init_handshake(NULL, NULL);
 }
 
 
@@ -502,12 +520,11 @@ GNUNET_SOCKS_init_handshake_noauth ()
  * @param port
  */
 void
-GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih,
-                                        const char *host,
-                                        uint16_t port)
+GNUNET_SOCKS_set_handshake_destination(struct GNUNET_SOCKS_Handshake *ih,
+                                       const char *host,
+                                       uint16_t port)
 {
-  union
-  {
+  union {
     struct in_addr in4;
     struct in6_addr in6;
   } ia;
@@ -518,26 +535,26 @@ GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih,
   *(b++) = 0; /* reserved */
 
   /* Specify destination */
-  if (1 == inet_pton (AF_INET, host, &ia.in4))
-  {
-    *(b++) = 1; /* IPv4 */
-    GNUNET_memcpy (b, &ia.in4, sizeof (struct in_addr));
-    b += sizeof (struct in_addr); /* 4 */
-  }
-  else if (1 == inet_pton (AF_INET6, host, &ia.in6))
-  {
-    *(b++) = 4; /* IPv6 */
-    GNUNET_memcpy (b, &ia.in6, sizeof (struct in6_addr));
-    b += sizeof (struct in6_addr); /* 16 */
-  }
+  if (1 == inet_pton(AF_INET, host, &ia.in4))
+    {
+      *(b++) = 1; /* IPv4 */
+      GNUNET_memcpy(b, &ia.in4, sizeof(struct in_addr));
+      b += sizeof(struct in_addr); /* 4 */
+    }
+  else if (1 == inet_pton(AF_INET6, host, &ia.in6))
+    {
+      *(b++) = 4; /* IPv6 */
+      GNUNET_memcpy(b, &ia.in6, sizeof(struct in6_addr));
+      b += sizeof(struct in6_addr); /* 16 */
+    }
   else
-  {
-    *(b++) = 3; /* hostname */
-    b = SOCK5_proto_string (b, host);
-  }
+    {
+      *(b++) = 3; /* hostname */
+      b = SOCK5_proto_string(b, host);
+    }
 
   /* Specify port */
-  *(uint16_t *) b = htons (port);
+  *(uint16_t *)b = htons(port);
   b += 2;
 
   ih->outstep[SOCKS5_step_done] = b;
@@ -552,12 +569,12 @@ GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih,
  * @return Connection handle that becomes usable when the SOCKS5 handshake completes.
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_SOCKS_run_handshake (struct GNUNET_SOCKS_Handshake *ih,
-                            struct GNUNET_CONNECTION_Handle *c)
+GNUNET_SOCKS_run_handshake(struct GNUNET_SOCKS_Handshake *ih,
+                           struct GNUNET_CONNECTION_Handle *c)
 {
   ih->socks5_connection = c;
-  ih->target_connection = GNUNET_CONNECTION_create_proxied_from_handshake (c);
-  register_sender (ih);
+  ih->target_connection = GNUNET_CONNECTION_create_proxied_from_handshake(c);
+  register_sender(ih);
 
   return ih->target_connection;
 }
@@ -572,11 +589,11 @@ GNUNET_SOCKS_run_handshake (struct GNUNET_SOCKS_Handshake *ih,
  * @return GNUNET_YES if so, GNUNET_NO if not
  */
 int
-GNUNET_SOCKS_check_service (const char *service_name,
-                            const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_SOCKS_check_service(const char *service_name,
+                           const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_CONFIGURATION_have_value (cfg, service_name, "SOCKSPORT") ||
-         GNUNET_CONFIGURATION_have_value (cfg, service_name, "SOCKSHOST");
+  return GNUNET_CONFIGURATION_have_value(cfg, service_name, "SOCKSPORT") ||
+         GNUNET_CONFIGURATION_have_value(cfg, service_name, "SOCKSHOST");
 }
 
 
@@ -589,8 +606,8 @@ GNUNET_SOCKS_check_service (const char *service_name,
  *         NULL if SOCKS not configured or not configured properly
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_SOCKS_do_connect (const char *service_name,
-                         const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_SOCKS_do_connect(const char *service_name,
+                        const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_SOCKS_Handshake *ih;
   struct GNUNET_CONNECTION_Handle *socks5; /* *proxied */
@@ -601,70 +618,70 @@ GNUNET_SOCKS_do_connect (const char *service_name,
   unsigned long long port0;
   unsigned long long port1;
 
-  if (GNUNET_YES != GNUNET_SOCKS_check_service (service_name, cfg))
+  if (GNUNET_YES != GNUNET_SOCKS_check_service(service_name, cfg))
     return NULL;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                          service_name,
-                                                          "SOCKSPORT",
-                                                          &port0))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
+                                                         service_name,
+                                                         "SOCKSPORT",
+                                                         &port0))
     port0 = 9050;
   /* A typical Tor client should usually try port 9150 for the TBB too, but
    * GNUnet can probably assume a system Tor installation. */
   if (port0 > 65535 || port0 <= 0)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ (
-           "Attempting to use invalid port %d as SOCKS proxy for service `%s'.\n"),
-         port0,
-         service_name);
-    return NULL;
-  }
-  if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
-                                                           service_name,
-                                                           "PORT",
-                                                           &port1)) ||
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _(
+            "Attempting to use invalid port %d as SOCKS proxy for service `%s'.\n"),
+          port0,
+          service_name);
+      return NULL;
+    }
+  if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
+                                                          service_name,
+                                                          "PORT",
+                                                          &port1)) ||
       (port1 > 65535) || (port1 <= 0) ||
-      (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                           service_name,
-                                                           "HOSTNAME",
-                                                           &host1)))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ (
-           "Attempting to proxy service `%s' to invalid port %d or hostname.\n"),
-         service_name,
-         port1);
-    return NULL;
-  }
+      (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                          service_name,
+                                                          "HOSTNAME",
+                                                          &host1)))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _(
+            "Attempting to proxy service `%s' to invalid port %d or hostname.\n"),
+          service_name,
+          port1);
+      return NULL;
+    }
   /* Appeared to still work after host0 corrupted, so either test case is broken, or
      this whole routine is not being called. */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                          service_name,
-                                                          "SOCKSHOST",
-                                                          &host0))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
+                                                         service_name,
+                                                         "SOCKSHOST",
+                                                         &host0))
     host0 = NULL;
-  socks5 = GNUNET_CONNECTION_create_from_connect (cfg,
-                                                  (host0 != NULL) ? host0
-                                                                  : "127.0.0.1",
-                                                  port0);
-  GNUNET_free_non_null (host0);
+  socks5 = GNUNET_CONNECTION_create_from_connect(cfg,
+                                                 (host0 != NULL) ? host0
+                                                 : "127.0.0.1",
+                                                 port0);
+  GNUNET_free_non_null(host0);
 
   /* Sets to NULL if they do not exist */
-  (void) GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                service_name,
-                                                "SOCKSUSER",
-                                                &user);
-  (void) GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                service_name,
-                                                "SOCKSPASS",
-                                                &pass);
-  ih = GNUNET_SOCKS_init_handshake (user, pass);
-  GNUNET_free_non_null (user);
-  GNUNET_free_non_null (pass);
-
-  GNUNET_SOCKS_set_handshake_destination (ih, host1, port1);
-  GNUNET_free (host1);
-  return GNUNET_SOCKS_run_handshake (ih, socks5);
+  (void)GNUNET_CONFIGURATION_get_value_string(cfg,
+                                              service_name,
+                                              "SOCKSUSER",
+                                              &user);
+  (void)GNUNET_CONFIGURATION_get_value_string(cfg,
+                                              service_name,
+                                              "SOCKSPASS",
+                                              &pass);
+  ih = GNUNET_SOCKS_init_handshake(user, pass);
+  GNUNET_free_non_null(user);
+  GNUNET_free_non_null(pass);
+
+  GNUNET_SOCKS_set_handshake_destination(ih, host1, port1);
+  GNUNET_free(host1);
+  return GNUNET_SOCKS_run_handshake(ih, socks5);
 }
 
 /* socks.c */
diff --git a/src/util/speedup.c b/src/util/speedup.c
index c5c1f6a53..735da18c3 100644
--- a/src/util/speedup.c
+++ b/src/util/speedup.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 util/speedup.c
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 #include "speedup.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-speedup", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-speedup", __VA_ARGS__)
 
 
 static struct GNUNET_TIME_Relative interval;
@@ -38,20 +38,20 @@ static struct GNUNET_SCHEDULER_Task *speedup_task;
 
 
 static void
-do_speedup (void *cls)
+do_speedup(void *cls)
 {
   static long long current_offset;
 
-  (void) cls;
+  (void)cls;
   speedup_task = NULL;
   current_offset += delta.rel_value_us;
-  GNUNET_TIME_set_offset (current_offset);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Speeding up execution time by %s\n",
-       GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_NO));
-  speedup_task = GNUNET_SCHEDULER_add_delayed (interval,
-                                               &do_speedup,
-                                               NULL);
+  GNUNET_TIME_set_offset(current_offset);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Speeding up execution time by %s\n",
+      GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_NO));
+  speedup_task = GNUNET_SCHEDULER_add_delayed(interval,
+                                              &do_speedup,
+                                              NULL);
 }
 
 
@@ -62,38 +62,38 @@ do_speedup (void *cls)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the speedup was not configured
  */
 int
-GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_SPEEDUP_start_(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_assert (NULL == speedup_task);
+  GNUNET_assert(NULL == speedup_task);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "testing",
-                                           "SPEEDUP_INTERVAL",
-                                           &interval))
+      GNUNET_CONFIGURATION_get_value_time(cfg,
+                                          "testing",
+                                          "SPEEDUP_INTERVAL",
+                                          &interval))
     return GNUNET_SYSERR;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "testing",
-                                           "SPEEDUP_DELTA",
-                                           &delta))
+      GNUNET_CONFIGURATION_get_value_time(cfg,
+                                          "testing",
+                                          "SPEEDUP_DELTA",
+                                          &delta))
     return GNUNET_SYSERR;
 
-  if ( (0 == interval.rel_value_us) ||
-       (0 == delta.rel_value_us) )
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Speed up disabled\n");
-    return GNUNET_OK;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Speed up execution by %s\n",
-       GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_NO));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Speed up executed every %s\n",
-       GNUNET_STRINGS_relative_time_to_string (interval, GNUNET_NO));
-  speedup_task = GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
-                                                         &do_speedup,
-                                                         NULL);
+  if ((0 == interval.rel_value_us) ||
+      (0 == delta.rel_value_us))
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Speed up disabled\n");
+      return GNUNET_OK;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Speed up execution by %s\n",
+      GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_NO));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Speed up executed every %s\n",
+      GNUNET_STRINGS_relative_time_to_string(interval, GNUNET_NO));
+  speedup_task = GNUNET_SCHEDULER_add_now_with_lifeness(GNUNET_NO,
+                                                        &do_speedup,
+                                                        NULL);
   return GNUNET_OK;
 }
 
@@ -102,17 +102,17 @@ GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * Stop tasks that modify clock behavior.
  */
 void
-GNUNET_SPEEDUP_stop_ ()
+GNUNET_SPEEDUP_stop_()
 {
   if (NULL != speedup_task)
-  {
-    GNUNET_SCHEDULER_cancel (speedup_task);
-    speedup_task = NULL;
-  }
-  if ( (0 != interval.rel_value_us) &&
-       (0 != delta.rel_value_us) )
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Stopped execution speed up\n");
+    {
+      GNUNET_SCHEDULER_cancel(speedup_task);
+      speedup_task = NULL;
+    }
+  if ((0 != interval.rel_value_us) &&
+      (0 != delta.rel_value_us))
+    LOG(GNUNET_ERROR_TYPE_DEBUG,
+        "Stopped execution speed up\n");
 }
 
 /* end of speedup.c */
diff --git a/src/util/speedup.h b/src/util/speedup.h
index 5b665133e..232d74f7d 100644
--- a/src/util/speedup.h
+++ b/src/util/speedup.h
@@ -11,17 +11,17 @@
      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 util/speedup.c
  * @brief Interface for speedup routinues
- * @author Sree Harsha Totakura <sreeharsha@totakura.in> 
+ * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  */
 
 #ifndef SPEEDUP_H_
@@ -34,12 +34,12 @@
  * @return GNUNET_OK on success, GNUNET_SYSERR if the speedup was not configured
  */
 int
-GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg);
+GNUNET_SPEEDUP_start_(const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 /**
  * Stop tasks that modify clock behavior.
  */
 void
-GNUNET_SPEEDUP_stop_ (void);
+GNUNET_SPEEDUP_stop_(void);
 
 #endif  /* SPEEDUP_H_ */
diff --git a/src/util/strings.c b/src/util/strings.c
index ef9fdd693..1b4f75ab0 100644
--- a/src/util/strings.c
+++ b/src/util/strings.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 util/strings.c
  * @brief string functions
@@ -34,10 +34,10 @@
 #include <unistr.h>
 #include <uniconv.h>
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-strings", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-strings", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror (kind, "util-strings", syscall)
+  GNUNET_log_from_strerror(kind, "util-strings", syscall)
 
 
 /**
@@ -62,7 +62,7 @@
  *         (or number of bytes that would have been written)
  */
 size_t
-GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...)
+GNUNET_STRINGS_buffer_fill(char *buffer, size_t size, unsigned int count, ...)
 {
   size_t needed;
   size_t slen;
@@ -70,21 +70,21 @@ GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...)
   va_list ap;
 
   needed = 0;
-  va_start (ap, count);
+  va_start(ap, count);
   while (count > 0)
-  {
-    s = va_arg (ap, const char *);
-
-    slen = strlen (s) + 1;
-    if (buffer != NULL)
     {
-      GNUNET_assert (needed + slen <= size);
-      GNUNET_memcpy (&buffer[needed], s, slen);
+      s = va_arg(ap, const char *);
+
+      slen = strlen(s) + 1;
+      if (buffer != NULL)
+        {
+          GNUNET_assert(needed + slen <= size);
+          GNUNET_memcpy(&buffer[needed], s, slen);
+        }
+      needed += slen;
+      count--;
     }
-    needed += slen;
-    count--;
-  }
-  va_end (ap);
+  va_end(ap);
   return needed;
 }
 
@@ -97,23 +97,23 @@ GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...)
  * @return string representing the array of @a pids
  */
 char *
-GNUNET_STRINGS_pp2s (const struct GNUNET_PeerIdentity *pids,
-                     unsigned int num_pids)
+GNUNET_STRINGS_pp2s(const struct GNUNET_PeerIdentity *pids,
+                    unsigned int num_pids)
 {
   char *buf;
   size_t off;
   size_t plen = num_pids * 5 + 1;
 
   off = 0;
-  buf = GNUNET_malloc (plen);
+  buf = GNUNET_malloc(plen);
   for (unsigned int i = 0; i < num_pids; i++)
-  {
-    off += GNUNET_snprintf (&buf[off],
-                            plen - off,
-                            "%s%s",
-                            GNUNET_i2s (&pids[i]),
-                            (i == num_pids - 1) ? "" : "-");
-  }
+    {
+      off += GNUNET_snprintf(&buf[off],
+                             plen - off,
+                             "%s%s",
+                             GNUNET_i2s(&pids[i]),
+                             (i == num_pids - 1) ? "" : "-");
+    }
   return buf;
 }
 
@@ -132,10 +132,10 @@ GNUNET_STRINGS_pp2s (const struct GNUNET_PeerIdentity *pids,
  *         in the buffer, or 0 on error.
  */
 unsigned int
-GNUNET_STRINGS_buffer_tokenize (const char *buffer,
-                                size_t size,
-                                unsigned int count,
-                                ...)
+GNUNET_STRINGS_buffer_tokenize(const char *buffer,
+                               size_t size,
+                               unsigned int count,
+                               ...)
 {
   unsigned int start;
   unsigned int needed;
@@ -143,24 +143,24 @@ GNUNET_STRINGS_buffer_tokenize (const char *buffer,
   va_list ap;
 
   needed = 0;
-  va_start (ap, count);
+  va_start(ap, count);
   while (count > 0)
-  {
-    r = va_arg (ap, const char **);
-
-    start = needed;
-    while ((needed < size) && (buffer[needed] != '\0'))
-      needed++;
-    if (needed == size)
     {
-      va_end (ap);
-      return 0; /* error */
+      r = va_arg(ap, const char **);
+
+      start = needed;
+      while ((needed < size) && (buffer[needed] != '\0'))
+        needed++;
+      if (needed == size)
+        {
+          va_end(ap);
+          return 0; /* error */
+        }
+      *r = &buffer[start];
+      needed++; /* skip 0-termination */
+      count--;
     }
-    *r = &buffer[start];
-    needed++; /* skip 0-termination */
-    count--;
-  }
-  va_end (ap);
+  va_end(ap);
   return needed;
 }
 
@@ -172,33 +172,33 @@ GNUNET_STRINGS_buffer_tokenize (const char *buffer,
  * @return fancy representation of the size (possibly rounded) for humans
  */
 char *
-GNUNET_STRINGS_byte_size_fancy (unsigned long long size)
+GNUNET_STRINGS_byte_size_fancy(unsigned long long size)
 {
-  const char *unit = _ (/* size unit */ "b");
+  const char *unit = _(/* size unit */ "b");
   char *ret;
 
   if (size > 5 * 1024)
-  {
-    size = size / 1024;
-    unit = "KiB";
-    if (size > 5 * 1024)
     {
       size = size / 1024;
-      unit = "MiB";
+      unit = "KiB";
       if (size > 5 * 1024)
-      {
-        size = size / 1024;
-        unit = "GiB";
-        if (size > 5 * 1024)
         {
           size = size / 1024;
-          unit = "TiB";
+          unit = "MiB";
+          if (size > 5 * 1024)
+            {
+              size = size / 1024;
+              unit = "GiB";
+              if (size > 5 * 1024)
+                {
+                  size = size / 1024;
+                  unit = "TiB";
+                }
+            }
         }
-      }
     }
-  }
-  ret = GNUNET_malloc (32);
-  GNUNET_snprintf (ret, 32, "%llu %s", size, unit);
+  ret = GNUNET_malloc(32);
+  GNUNET_snprintf(ret, 32, "%llu %s", size, unit);
   return ret;
 }
 
@@ -213,16 +213,16 @@ GNUNET_STRINGS_byte_size_fancy (unsigned long long size)
  * @param n the length of the string to copy, including its terminating null
  *          byte
  * @return the length of the string that was copied, excluding the terminating
- *         null byte
+ *         null byte
  */
 size_t
-GNUNET_strlcpy (char *dst, const char *src, size_t n)
+GNUNET_strlcpy(char *dst, const char *src, size_t n)
 {
   size_t slen;
 
-  GNUNET_assert (0 != n);
-  slen = strnlen (src, n - 1);
-  memcpy (dst, src, slen);
+  GNUNET_assert(0 != n);
+  slen = strnlen(src, n - 1);
+  memcpy(dst, src, slen);
   dst[slen] = '\0';
   return slen;
 }
@@ -231,8 +231,7 @@ GNUNET_strlcpy (char *dst, const char *src, size_t n)
 /**
  * Unit conversion table entry for 'convert_with_table'.
  */
-struct ConversionTable
-{
+struct ConversionTable {
   /**
    * Name of the unit (or NULL for end of table).
    */
@@ -257,9 +256,9 @@ struct ConversionTable
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-convert_with_table (const char *input,
-                    const struct ConversionTable *table,
-                    unsigned long long *output)
+convert_with_table(const char *input,
+                   const struct ConversionTable *table,
+                   unsigned long long *output)
 {
   unsigned long long ret;
   char *in;
@@ -269,40 +268,41 @@ convert_with_table (const char *input,
 
   ret = 0;
   last = 0;
-  in = GNUNET_strdup (input);
-  for (tok = strtok (in, " "); tok != NULL; tok = strtok (NULL, " "))
-  {
-    do
+  in = GNUNET_strdup(input);
+  for (tok = strtok(in, " "); tok != NULL; tok = strtok(NULL, " "))
     {
-      i = 0;
-      while ((table[i].name != NULL) && (0 != strcasecmp (table[i].name, tok)))
-        i++;
-      if (table[i].name != NULL)
-      {
-        last *= table[i].value;
-        break; /* next tok */
-      }
-      else
-      {
-        char *endptr;
-        ret += last;
-        errno = 0;
-        last = strtoull (tok, &endptr, 10);
-        if ((0 != errno) || (endptr == tok))
+      do
         {
-          GNUNET_free (in);
-          return GNUNET_SYSERR; /* expected number */
+          i = 0;
+          while ((table[i].name != NULL) && (0 != strcasecmp(table[i].name, tok)))
+            i++;
+          if (table[i].name != NULL)
+            {
+              last *= table[i].value;
+              break; /* next tok */
+            }
+          else
+            {
+              char *endptr;
+              ret += last;
+              errno = 0;
+              last = strtoull(tok, &endptr, 10);
+              if ((0 != errno) || (endptr == tok))
+                {
+                  GNUNET_free(in);
+                  return GNUNET_SYSERR; /* expected number */
+                }
+              if ('\0' == endptr[0])
+                break; /* next tok */
+              else
+                tok = endptr; /* and re-check (handles times like "10s") */
+            }
         }
-        if ('\0' == endptr[0])
-          break; /* next tok */
-        else
-          tok = endptr; /* and re-check (handles times like "10s") */
-      }
-    } while (GNUNET_YES);
-  }
+      while (GNUNET_YES);
+    }
   ret += last;
   *output = ret;
-  GNUNET_free (in);
+  GNUNET_free(in);
   return GNUNET_OK;
 }
 
@@ -315,26 +315,26 @@ convert_with_table (const char *input,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size,
-                                    unsigned long long *size)
+GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size,
+                                   unsigned long long *size)
 {
   static const struct ConversionTable table[] =
-    {{"B", 1},
-     {"KiB", 1024},
-     {"kB", 1000},
-     {"MiB", 1024 * 1024},
-     {"MB", 1000 * 1000},
-     {"GiB", 1024 * 1024 * 1024},
-     {"GB", 1000 * 1000 * 1000},
-     {"TiB", 1024LL * 1024LL * 1024LL * 1024LL},
-     {"TB", 1000LL * 1000LL * 1000LL * 1024LL},
-     {"PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL},
-     {"PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL},
-     {"EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL},
-     {"EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL},
-     {NULL, 0}};
-
-  return convert_with_table (fancy_size, table, size);
+  { { "B", 1 },
+    { "KiB", 1024 },
+    { "kB", 1000 },
+    { "MiB", 1024 * 1024 },
+    { "MB", 1000 * 1000 },
+    { "GiB", 1024 * 1024 * 1024 },
+    { "GB", 1000 * 1000 * 1000 },
+    { "TiB", 1024LL * 1024LL * 1024LL * 1024LL },
+    { "TB", 1000LL * 1000LL * 1000LL * 1024LL },
+    { "PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
+    { "PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
+    { "EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
+    { "EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
+    { NULL, 0 } };
+
+  return convert_with_table(fancy_size, table, size);
 }
 
 
@@ -347,43 +347,43 @@ GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
-                                       struct GNUNET_TIME_Relative *rtime)
+GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time,
+                                      struct GNUNET_TIME_Relative *rtime)
 {
   static const struct ConversionTable table[] =
-    {{"us", 1},
-     {"ms", 1000},
-     {"s", 1000 * 1000LL},
-     {"second", 1000 * 1000LL},
-     {"seconds", 1000 * 1000LL},
-     {"\"", 1000 * 1000LL},
-     {"m", 60 * 1000 * 1000LL},
-     {"min", 60 * 1000 * 1000LL},
-     {"minute", 60 * 1000 * 1000LL},
-     {"minutes", 60 * 1000 * 1000LL},
-     {"'", 60 * 1000 * 1000LL},
-     {"h", 60 * 60 * 1000 * 1000LL},
-     {"hour", 60 * 60 * 1000 * 1000LL},
-     {"hours", 60 * 60 * 1000 * 1000LL},
-     {"d", 24 * 60 * 60 * 1000LL * 1000LL},
-     {"day", 24 * 60 * 60 * 1000LL * 1000LL},
-     {"days", 24 * 60 * 60 * 1000LL * 1000LL},
-     {"week", 7 * 24 * 60 * 60 * 1000LL * 1000LL},
-     {"weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL},
-     {"year", 31536000000000LL /* year */},
-     {"years", 31536000000000LL /* year */},
-     {"a", 31536000000000LL /* year */},
-     {NULL, 0}};
+  { { "us", 1 },
+    { "ms", 1000 },
+    { "s", 1000 * 1000LL },
+    { "second", 1000 * 1000LL },
+    { "seconds", 1000 * 1000LL },
+    { "\"", 1000 * 1000LL },
+    { "m", 60 * 1000 * 1000LL },
+    { "min", 60 * 1000 * 1000LL },
+    { "minute", 60 * 1000 * 1000LL },
+    { "minutes", 60 * 1000 * 1000LL },
+    { "'", 60 * 1000 * 1000LL },
+    { "h", 60 * 60 * 1000 * 1000LL },
+    { "hour", 60 * 60 * 1000 * 1000LL },
+    { "hours", 60 * 60 * 1000 * 1000LL },
+    { "d", 24 * 60 * 60 * 1000LL * 1000LL },
+    { "day", 24 * 60 * 60 * 1000LL * 1000LL },
+    { "days", 24 * 60 * 60 * 1000LL * 1000LL },
+    { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
+    { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
+    { "year", 31536000000000LL /* year */ },
+    { "years", 31536000000000LL /* year */ },
+    { "a", 31536000000000LL /* year */ },
+    { NULL, 0 } };
   int ret;
   unsigned long long val;
 
-  if (0 == strcasecmp ("forever", fancy_time))
-  {
-    *rtime = GNUNET_TIME_UNIT_FOREVER_REL;
-    return GNUNET_OK;
-  }
-  ret = convert_with_table (fancy_time, table, &val);
-  rtime->rel_value_us = (uint64_t) val;
+  if (0 == strcasecmp("forever", fancy_time))
+    {
+      *rtime = GNUNET_TIME_UNIT_FOREVER_REL;
+      return GNUNET_OK;
+    }
+  ret = convert_with_table(fancy_time, table, &val);
+  rtime->rel_value_us = (uint64_t)val;
   return ret;
 }
 
@@ -398,33 +398,33 @@ GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
-                                       struct GNUNET_TIME_Absolute *atime)
+GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time,
+                                      struct GNUNET_TIME_Absolute *atime)
 {
   struct tm tv;
   time_t t;
   const char *eos;
 
-  if (0 == strcasecmp ("end of time", fancy_time))
-  {
-    *atime = GNUNET_TIME_UNIT_FOREVER_ABS;
-    return GNUNET_OK;
-  }
-  eos = &fancy_time[strlen (fancy_time)];
-  memset (&tv, 0, sizeof (tv));
-  if ((eos != strptime (fancy_time, "%a %b %d %H:%M:%S %Y", &tv)) &&
-      (eos != strptime (fancy_time, "%c", &tv)) &&
-      (eos != strptime (fancy_time, "%Ec", &tv)) &&
-      (eos != strptime (fancy_time, "%Y-%m-%d %H:%M:%S", &tv)) &&
-      (eos != strptime (fancy_time, "%Y-%m-%d %H:%M", &tv)) &&
-      (eos != strptime (fancy_time, "%x", &tv)) &&
-      (eos != strptime (fancy_time, "%Ex", &tv)) &&
-      (eos != strptime (fancy_time, "%Y-%m-%d", &tv)) &&
-      (eos != strptime (fancy_time, "%Y-%m", &tv)) &&
-      (eos != strptime (fancy_time, "%Y", &tv)))
+  if (0 == strcasecmp("end of time", fancy_time))
+    {
+      *atime = GNUNET_TIME_UNIT_FOREVER_ABS;
+      return GNUNET_OK;
+    }
+  eos = &fancy_time[strlen(fancy_time)];
+  memset(&tv, 0, sizeof(tv));
+  if ((eos != strptime(fancy_time, "%a %b %d %H:%M:%S %Y", &tv)) &&
+      (eos != strptime(fancy_time, "%c", &tv)) &&
+      (eos != strptime(fancy_time, "%Ec", &tv)) &&
+      (eos != strptime(fancy_time, "%Y-%m-%d %H:%M:%S", &tv)) &&
+      (eos != strptime(fancy_time, "%Y-%m-%d %H:%M", &tv)) &&
+      (eos != strptime(fancy_time, "%x", &tv)) &&
+      (eos != strptime(fancy_time, "%Ex", &tv)) &&
+      (eos != strptime(fancy_time, "%Y-%m-%d", &tv)) &&
+      (eos != strptime(fancy_time, "%Y-%m", &tv)) &&
+      (eos != strptime(fancy_time, "%Y", &tv)))
     return GNUNET_SYSERR;
-  t = mktime (&tv);
-  atime->abs_value_us = (uint64_t) ((uint64_t) t * 1000LL * 1000LL);
+  t = mktime(&tv);
+  atime->abs_value_us = (uint64_t)((uint64_t)t * 1000LL * 1000LL);
   return GNUNET_OK;
 }
 
@@ -443,10 +443,10 @@ GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
  *  string is returned.
  */
 char *
-GNUNET_STRINGS_conv (const char *input,
-                     size_t len,
-                     const char *input_charset,
-                     const char *output_charset)
+GNUNET_STRINGS_conv(const char *input,
+                    size_t len,
+                    const char *input_charset,
+                    const char *output_charset)
 {
   char *ret;
   uint8_t *u8_string;
@@ -454,51 +454,51 @@ GNUNET_STRINGS_conv (const char *input,
   size_t u8_string_length;
   size_t encoded_string_length;
 
-  u8_string = u8_conv_from_encoding (input_charset,
-                                     iconveh_error,
-                                     input,
-                                     len,
-                                     NULL,
-                                     NULL,
-                                     &u8_string_length);
+  u8_string = u8_conv_from_encoding(input_charset,
+                                    iconveh_error,
+                                    input,
+                                    len,
+                                    NULL,
+                                    NULL,
+                                    &u8_string_length);
   if (NULL == u8_string)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
-    goto fail;
-  }
-  if (0 == strcmp (output_charset, "UTF-8"))
-  {
-    ret = GNUNET_malloc (u8_string_length + 1);
-    GNUNET_memcpy (ret, u8_string, u8_string_length);
-    ret[u8_string_length] = '\0';
-    free (u8_string);
-    return ret;
-  }
-  encoded_string = u8_conv_to_encoding (output_charset,
-                                        iconveh_error,
-                                        u8_string,
-                                        u8_string_length,
-                                        NULL,
-                                        NULL,
-                                        &encoded_string_length);
-  free (u8_string);
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
+      goto fail;
+    }
+  if (0 == strcmp(output_charset, "UTF-8"))
+    {
+      ret = GNUNET_malloc(u8_string_length + 1);
+      GNUNET_memcpy(ret, u8_string, u8_string_length);
+      ret[u8_string_length] = '\0';
+      free(u8_string);
+      return ret;
+    }
+  encoded_string = u8_conv_to_encoding(output_charset,
+                                       iconveh_error,
+                                       u8_string,
+                                       u8_string_length,
+                                       NULL,
+                                       NULL,
+                                       &encoded_string_length);
+  free(u8_string);
   if (NULL == encoded_string)
-  {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
-    goto fail;
-  }
-  ret = GNUNET_malloc (encoded_string_length + 1);
-  GNUNET_memcpy (ret, encoded_string, encoded_string_length);
+    {
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
+      goto fail;
+    }
+  ret = GNUNET_malloc(encoded_string_length + 1);
+  GNUNET_memcpy(ret, encoded_string, encoded_string_length);
   ret[encoded_string_length] = '\0';
-  free (encoded_string);
+  free(encoded_string);
   return ret;
 fail:
-  LOG (GNUNET_ERROR_TYPE_WARNING,
-       _ ("Character sets requested were `%s'->`%s'\n"),
-       "UTF-8",
-       output_charset);
-  ret = GNUNET_malloc (len + 1);
-  GNUNET_memcpy (ret, input, len);
+  LOG(GNUNET_ERROR_TYPE_WARNING,
+      _("Character sets requested were `%s'->`%s'\n"),
+      "UTF-8",
+      output_charset);
+  ret = GNUNET_malloc(len + 1);
+  GNUNET_memcpy(ret, input, len);
   ret[len] = '\0';
   return ret;
 }
@@ -517,9 +517,9 @@ fail:
  *  string is returned.
  */
 char *
-GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset)
+GNUNET_STRINGS_to_utf8(const char *input, size_t len, const char *charset)
 {
-  return GNUNET_STRINGS_conv (input, len, charset, "UTF-8");
+  return GNUNET_STRINGS_conv(input, len, charset, "UTF-8");
 }
 
 
@@ -535,9 +535,9 @@ GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset)
  *  string is returned.
  */
 char *
-GNUNET_STRINGS_from_utf8 (const char *input, size_t len, const char *charset)
+GNUNET_STRINGS_from_utf8(const char *input, size_t len, const char *charset)
 {
-  return GNUNET_STRINGS_conv (input, len, "UTF-8", charset);
+  return GNUNET_STRINGS_conv(input, len, "UTF-8", charset);
 }
 
 
@@ -549,20 +549,20 @@ GNUNET_STRINGS_from_utf8 (const char *input, size_t len, const char *charset)
  * @param output output buffer
  */
 void
-GNUNET_STRINGS_utf8_tolower (const char *input, char *output)
+GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
 {
   uint8_t *tmp_in;
   size_t len;
 
-  tmp_in = u8_tolower ((uint8_t *) input,
-                       strlen ((char *) input),
-                       NULL,
-                       UNINORM_NFD,
-                       NULL,
-                       &len);
-  GNUNET_memcpy (output, tmp_in, len);
+  tmp_in = u8_tolower((uint8_t *)input,
+                      strlen((char *)input),
+                      NULL,
+                      UNINORM_NFD,
+                      NULL,
+                      &len);
+  GNUNET_memcpy(output, tmp_in, len);
   output[len] = '\0';
-  free (tmp_in);
+  free(tmp_in);
 }
 
 
@@ -574,20 +574,20 @@ GNUNET_STRINGS_utf8_tolower (const char *input, char *output)
  * @param output output buffer
  */
 void
-GNUNET_STRINGS_utf8_toupper (const char *input, char *output)
+GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
 {
   uint8_t *tmp_in;
   size_t len;
 
-  tmp_in = u8_toupper ((uint8_t *) input,
-                       strlen ((char *) input),
-                       NULL,
-                       UNINORM_NFD,
-                       NULL,
-                       &len);
-  GNUNET_memcpy (output, tmp_in, len);
+  tmp_in = u8_toupper((uint8_t *)input,
+                      strlen((char *)input),
+                      NULL,
+                      UNINORM_NFD,
+                      NULL,
+                      &len);
+  GNUNET_memcpy(output, tmp_in, len);
   output[len] = '\0';
-  free (tmp_in);
+  free(tmp_in);
 }
 
 
@@ -599,9 +599,10 @@ GNUNET_STRINGS_utf8_toupper (const char *input, char *output)
  *          NULL is returned on error
  */
 char *
-GNUNET_STRINGS_filename_expand (const char *fil)
+GNUNET_STRINGS_filename_expand(const char *fil)
 {
   char *buffer;
+
 #ifndef MINGW
   size_t len;
   char *fm;
@@ -617,90 +618,90 @@ GNUNET_STRINGS_filename_expand (const char *fil)
 #ifndef MINGW
   if (fil[0] == DIR_SEPARATOR)
     /* absolute path, just copy */
-    return GNUNET_strdup (fil);
+    return GNUNET_strdup(fil);
   if (fil[0] == '~')
-  {
-    fm = getenv ("HOME");
-    if (fm == NULL)
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           _ ("Failed to expand `$HOME': environment variable `HOME' not set"));
-      return NULL;
-    }
-    fm = GNUNET_strdup (fm);
-    /* do not copy '~' */
-    fil_ptr = fil + 1;
+      fm = getenv("HOME");
+      if (fm == NULL)
+        {
+          LOG(GNUNET_ERROR_TYPE_WARNING,
+              _("Failed to expand `$HOME': environment variable `HOME' not set"));
+          return NULL;
+        }
+      fm = GNUNET_strdup(fm);
+      /* do not copy '~' */
+      fil_ptr = fil + 1;
 
-    /* skip over dir seperator to be consistent */
-    if (fil_ptr[0] == DIR_SEPARATOR)
-      fil_ptr++;
-  }
-  else
-  {
-    /* relative path */
-    fil_ptr = fil;
-    len = 512;
-    fm = NULL;
-    while (1)
-    {
-      buffer = GNUNET_malloc (len);
-      if (getcwd (buffer, len) != NULL)
-      {
-        fm = buffer;
-        break;
-      }
-      if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
-      {
-        len *= 2;
-        GNUNET_free (buffer);
-        continue;
-      }
-      GNUNET_free (buffer);
-      break;
+      /* skip over dir seperator to be consistent */
+      if (fil_ptr[0] == DIR_SEPARATOR)
+        fil_ptr++;
     }
-    if (fm == NULL)
+  else
     {
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "getcwd");
-      buffer = getenv ("PWD"); /* alternative */
-      if (buffer != NULL)
-        fm = GNUNET_strdup (buffer);
+      /* relative path */
+      fil_ptr = fil;
+      len = 512;
+      fm = NULL;
+      while (1)
+        {
+          buffer = GNUNET_malloc(len);
+          if (getcwd(buffer, len) != NULL)
+            {
+              fm = buffer;
+              break;
+            }
+          if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
+            {
+              len *= 2;
+              GNUNET_free(buffer);
+              continue;
+            }
+          GNUNET_free(buffer);
+          break;
+        }
+      if (fm == NULL)
+        {
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "getcwd");
+          buffer = getenv("PWD"); /* alternative */
+          if (buffer != NULL)
+            fm = GNUNET_strdup(buffer);
+        }
+      if (fm == NULL)
+        fm = GNUNET_strdup("./"); /* give up */
     }
-    if (fm == NULL)
-      fm = GNUNET_strdup ("./"); /* give up */
-  }
-  GNUNET_asprintf (&buffer,
-                   "%s%s%s",
-                   fm,
-                   (fm[strlen (fm) - 1] == DIR_SEPARATOR) ? ""
-                                                          : DIR_SEPARATOR_STR,
-                   fil_ptr);
-  GNUNET_free (fm);
+  GNUNET_asprintf(&buffer,
+                  "%s%s%s",
+                  fm,
+                  (fm[strlen(fm) - 1] == DIR_SEPARATOR) ? ""
+                  : DIR_SEPARATOR_STR,
+                  fil_ptr);
+  GNUNET_free(fm);
   return buffer;
 #else
-  fn = GNUNET_malloc (MAX_PATH + 1);
-
-  if ((lRet = plibc_conv_to_win_path (fil, fn)) != ERROR_SUCCESS)
-  {
-    SetErrnoFromWinError (lRet);
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "plibc_conv_to_win_path");
-    return NULL;
-  }
-  /* is the path relative? */
-  if ((0 != strncmp (fn + 1, ":\\", 2)) && (0 != strncmp (fn, "\\\\", 2)))
-  {
-    char szCurDir[MAX_PATH + 1];
+  fn = GNUNET_malloc(MAX_PATH + 1);
 
-    lRet = GetCurrentDirectory (MAX_PATH + 1, szCurDir);
-    if (lRet + strlen (fn) + 1 > (MAX_PATH + 1))
+  if ((lRet = plibc_conv_to_win_path(fil, fn)) != ERROR_SUCCESS)
     {
-      SetErrnoFromWinError (ERROR_BUFFER_OVERFLOW);
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetCurrentDirectory");
+      SetErrnoFromWinError(lRet);
+      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "plibc_conv_to_win_path");
       return NULL;
     }
-    GNUNET_asprintf (&buffer, "%s\\%s", szCurDir, fn);
-    GNUNET_free (fn);
-    fn = buffer;
-  }
+  /* is the path relative? */
+  if ((0 != strncmp(fn + 1, ":\\", 2)) && (0 != strncmp(fn, "\\\\", 2)))
+    {
+      char szCurDir[MAX_PATH + 1];
+
+      lRet = GetCurrentDirectory(MAX_PATH + 1, szCurDir);
+      if (lRet + strlen(fn) + 1 > (MAX_PATH + 1))
+        {
+          SetErrnoFromWinError(ERROR_BUFFER_OVERFLOW);
+          LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "GetCurrentDirectory");
+          return NULL;
+        }
+      GNUNET_asprintf(&buffer, "%s\\%s", szCurDir, fn);
+      GNUNET_free(fn);
+      fn = buffer;
+    }
 
   return fn;
 #endif
@@ -717,47 +718,47 @@ GNUNET_STRINGS_filename_expand (const char *fil)
  * @return time as human-readable string
  */
 const char *
-GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta,
-                                        int do_round)
+GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta,
+                                       int do_round)
 {
   static char buf[128];
-  const char *unit = _ (/* time unit */ "µs");
+  const char *unit = _(/* time unit */ "µs");
   uint64_t dval = delta.rel_value_us;
 
   if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == delta.rel_value_us)
-    return _ ("forever");
+    return _("forever");
   if (0 == delta.rel_value_us)
-    return _ ("0 ms");
+    return _("0 ms");
   if (((GNUNET_YES == do_round) && (dval > 5 * 1000)) || (0 == (dval % 1000)))
-  {
-    dval = dval / 1000;
-    unit = _ (/* time unit */ "ms");
-    if (((GNUNET_YES == do_round) && (dval > 5 * 1000)) || (0 == (dval % 1000)))
     {
       dval = dval / 1000;
-      unit = _ (/* time unit */ "s");
-      if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
-      {
-        dval = dval / 60;
-        unit = _ (/* time unit */ "m");
-        if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
+      unit = _(/* time unit */ "ms");
+      if (((GNUNET_YES == do_round) && (dval > 5 * 1000)) || (0 == (dval % 1000)))
         {
-          dval = dval / 60;
-          unit = _ (/* time unit */ "h");
-          if (((GNUNET_YES == do_round) && (dval > 5 * 24)) ||
-              (0 == (dval % 24)))
-          {
-            dval = dval / 24;
-            if (1 == dval)
-              unit = _ (/* time unit */ "day");
-            else
-              unit = _ (/* time unit */ "days");
-          }
+          dval = dval / 1000;
+          unit = _(/* time unit */ "s");
+          if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
+            {
+              dval = dval / 60;
+              unit = _(/* time unit */ "m");
+              if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
+                {
+                  dval = dval / 60;
+                  unit = _(/* time unit */ "h");
+                  if (((GNUNET_YES == do_round) && (dval > 5 * 24)) ||
+                      (0 == (dval % 24)))
+                    {
+                      dval = dval / 24;
+                      if (1 == dval)
+                        unit = _(/* time unit */ "day");
+                      else
+                        unit = _(/* time unit */ "days");
+                    }
+                }
+            }
         }
-      }
     }
-  }
-  GNUNET_snprintf (buf, sizeof (buf), "%llu %s", dval, unit);
+  GNUNET_snprintf(buf, sizeof(buf), "%llu %s", dval, unit);
   return buf;
 }
 
@@ -772,16 +773,16 @@ GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta,
  * @return timestamp in human-readable form in local time
  */
 const char *
-GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
+GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
 {
   static char buf[255];
   time_t tt;
   struct tm *tp;
 
   if (t.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
-    return _ ("end of time");
+    return _("end of time");
   tt = t.abs_value_us / 1000LL / 1000LL;
-  tp = localtime (&tt);
+  tp = localtime(&tt);
   /* This is hacky, but i don't know a way to detect libc character encoding.
    * Just expect utf8 from glibc these days.
    * As for msvcrt, use the wide variant, which always returns utf16
@@ -789,28 +790,28 @@ GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
    * set conversion routines to convert to UTF8).
    */
 #ifndef WINDOWS
-  strftime (buf, sizeof (buf), "%a %b %d %H:%M:%S %Y", tp);
+  strftime(buf, sizeof(buf), "%a %b %d %H:%M:%S %Y", tp);
 #else
   {
     static wchar_t wbuf[255];
     uint8_t *conved;
     size_t ssize;
 
-    wcsftime (wbuf,
-              sizeof (wbuf) / sizeof (wchar_t),
-              L"%a %b %d %H:%M:%S %Y",
-              tp);
-
-    ssize = sizeof (buf);
-    conved = u16_to_u8 (wbuf,
-                        sizeof (wbuf) / sizeof (wchar_t),
-                        (uint8_t *) buf,
-                        &ssize);
-    if (conved != (uint8_t *) buf)
-    {
-      GNUNET_strlcpy (buf, (char *) conved, sizeof (buf));
-      free (conved);
-    }
+    wcsftime(wbuf,
+             sizeof(wbuf) / sizeof(wchar_t),
+             L"%a %b %d %H:%M:%S %Y",
+             tp);
+
+    ssize = sizeof(buf);
+    conved = u16_to_u8(wbuf,
+                       sizeof(wbuf) / sizeof(wchar_t),
+                       (uint8_t *)buf,
+                       &ssize);
+    if (conved != (uint8_t *)buf)
+      {
+        GNUNET_strlcpy(buf, (char *)conved, sizeof(buf));
+        free(conved);
+      }
   }
 #endif
   return buf;
@@ -829,12 +830,12 @@ GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
  *         itself.
  */
 const char *
-GNUNET_STRINGS_get_short_name (const char *filename)
+GNUNET_STRINGS_get_short_name(const char *filename)
 {
   const char *short_fn = filename;
   const char *ss;
 
-  while (NULL != (ss = strstr (short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
+  while (NULL != (ss = strstr(short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
     short_fn = 1 + ss;
   return short_fn;
 }
@@ -848,48 +849,51 @@ GNUNET_STRINGS_get_short_name (const char *filename)
  * @return corresponding numeric value
  */
 static unsigned int
-getValue__ (unsigned char a)
+getValue__(unsigned char a)
 {
   unsigned int dec;
 
   switch (a)
-  {
-  case 'O':
-  case 'o':
-    a = '0';
-    break;
-  case 'i':
-  case 'I':
-  case 'l':
-  case 'L':
-    a = '1';
-    break;
+    {
+    case 'O':
+    case 'o':
+      a = '0';
+      break;
+
+    case 'i':
+    case 'I':
+    case 'l':
+    case 'L':
+      a = '1';
+      break;
+
     /* also consider U to be V */
-  case 'u':
-  case 'U':
-    a = 'V';
-    break;
-  default:
-    break;
-  }
+    case 'u':
+    case 'U':
+      a = 'V';
+      break;
+
+    default:
+      break;
+    }
   if ((a >= '0') && (a <= '9'))
     return a - '0';
   if ((a >= 'a') && (a <= 'z'))
-    a = toupper (a);
+    a = toupper(a);
   /* return (a - 'a' + 10); */
   dec = 0;
   if ((a >= 'A') && (a <= 'Z'))
-  {
-    if ('I' < a)
-      dec++;
-    if ('L' < a)
-      dec++;
-    if ('O' < a)
-      dec++;
-    if ('U' < a)
-      dec++;
-    return (a - 'A' + 10 - dec);
-  }
+    {
+      if ('I' < a)
+        dec++;
+      if ('L' < a)
+        dec++;
+      if ('O' < a)
+        dec++;
+      if ('U' < a)
+        dec++;
+      return(a - 'A' + 10 - dec);
+    }
   return -1;
 }
 
@@ -907,10 +911,10 @@ getValue__ (unsigned char a)
  * @return pointer to the next byte in @a out or NULL on error.
  */
 char *
-GNUNET_STRINGS_data_to_string (const void *data,
-                               size_t size,
-                               char *out,
-                               size_t out_size)
+GNUNET_STRINGS_data_to_string(const void *data,
+                              size_t size,
+                              char *out,
+                              size_t out_size)
 {
   /**
    * 32 characters for encoding
@@ -924,36 +928,36 @@ GNUNET_STRINGS_data_to_string (const void *data,
 
   udata = data;
   if (out_size < (size * 8 + 4) / 5)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
   vbit = 0;
   wpos = 0;
   rpos = 0;
   bits = 0;
   while ((rpos < size) || (vbit > 0))
-  {
-    if ((rpos < size) && (vbit < 5))
-    {
-      bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
-      vbit += 8;
-    }
-    if (vbit < 5)
-    {
-      bits <<= (5 - vbit); /* zero-padding */
-      GNUNET_assert (vbit == ((size * 8) % 5));
-      vbit = 5;
-    }
-    if (wpos >= out_size)
     {
-      GNUNET_break (0);
-      return NULL;
+      if ((rpos < size) && (vbit < 5))
+        {
+          bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
+          vbit += 8;
+        }
+      if (vbit < 5)
+        {
+          bits <<= (5 - vbit); /* zero-padding */
+          GNUNET_assert(vbit == ((size * 8) % 5));
+          vbit = 5;
+        }
+      if (wpos >= out_size)
+        {
+          GNUNET_break(0);
+          return NULL;
+        }
+      out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
+      vbit -= 5;
     }
-    out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
-    vbit -= 5;
-  }
-  GNUNET_assert (0 == vbit);
+  GNUNET_assert(0 == vbit);
   if (wpos < out_size)
     out[wpos] = '\0';
   return &out[wpos];
@@ -971,7 +975,7 @@ GNUNET_STRINGS_data_to_string (const void *data,
  * @return freshly allocated, null-terminated string
  */
 char *
-GNUNET_STRINGS_data_to_string_alloc (const void *buf, size_t size)
+GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
 {
   char *str_buf;
   size_t len = size * 8;
@@ -980,13 +984,13 @@ GNUNET_STRINGS_data_to_string_alloc (const void *buf, size_t size)
   if (len % 5 > 0)
     len += 5 - len % 5;
   len /= 5;
-  str_buf = GNUNET_malloc (len + 1);
-  end = GNUNET_STRINGS_data_to_string (buf, size, str_buf, len);
+  str_buf = GNUNET_malloc(len + 1);
+  end = GNUNET_STRINGS_data_to_string(buf, size, str_buf, len);
   if (NULL == end)
-  {
-    GNUNET_free (str_buf);
-    return NULL;
-  }
+    {
+      GNUNET_free(str_buf);
+      return NULL;
+    }
   *end = '\0';
   return str_buf;
 }
@@ -1003,10 +1007,10 @@ GNUNET_STRINGS_data_to_string_alloc (const void *buf, size_t size)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
  */
 int
-GNUNET_STRINGS_string_to_data (const char *enc,
-                               size_t enclen,
-                               void *out,
-                               size_t out_size)
+GNUNET_STRINGS_string_to_data(const char *enc,
+                              size_t enclen,
+                              void *out,
+                              size_t out_size)
 {
   unsigned int rpos;
   unsigned int wpos;
@@ -1018,48 +1022,48 @@ GNUNET_STRINGS_string_to_data (const char *enc,
   unsigned int encoded_len = out_size * 8;
 
   if (0 == enclen)
-  {
-    if (0 == out_size)
-      return GNUNET_OK;
-    return GNUNET_SYSERR;
-  }
+    {
+      if (0 == out_size)
+        return GNUNET_OK;
+      return GNUNET_SYSERR;
+    }
   uout = out;
   wpos = out_size;
   rpos = enclen;
   if ((encoded_len % 5) > 0)
-  {
-    vbit = encoded_len % 5; /* padding! */
-    shift = 5 - vbit;
-    bits = (ret = getValue__ (enc[--rpos])) >> shift;
-  }
+    {
+      vbit = encoded_len % 5; /* padding! */
+      shift = 5 - vbit;
+      bits = (ret = getValue__(enc[--rpos])) >> shift;
+    }
   else
-  {
-    vbit = 5;
-    shift = 0;
-    bits = (ret = getValue__ (enc[--rpos]));
-  }
+    {
+      vbit = 5;
+      shift = 0;
+      bits = (ret = getValue__(enc[--rpos]));
+    }
   if ((encoded_len + shift) / 5 != enclen)
     return GNUNET_SYSERR;
   if (-1 == ret)
     return GNUNET_SYSERR;
   while (wpos > 0)
-  {
-    if (0 == rpos)
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
-    if (-1 == ret)
-      return GNUNET_SYSERR;
-    vbit += 5;
-    if (vbit >= 8)
-    {
-      uout[--wpos] = (unsigned char) bits;
-      bits >>= 8;
-      vbit -= 8;
+      if (0 == rpos)
+        {
+          GNUNET_break(0);
+          return GNUNET_SYSERR;
+        }
+      bits = ((ret = getValue__(enc[--rpos])) << vbit) | bits;
+      if (-1 == ret)
+        return GNUNET_SYSERR;
+      vbit += 5;
+      if (vbit >= 8)
+        {
+          uout[--wpos] = (unsigned char)bits;
+          bits >>= 8;
+          vbit -= 8;
+        }
     }
-  }
   if ((0 != rpos) || (0 != vbit))
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -1083,57 +1087,61 @@ GNUNET_STRINGS_string_to_data (const char *enc,
  *         (if they weren't NULL).
  */
 int
-GNUNET_STRINGS_parse_uri (const char *path,
-                          char **scheme_part,
-                          const char **path_part)
+GNUNET_STRINGS_parse_uri(const char *path,
+                         char **scheme_part,
+                         const char **path_part)
 {
   size_t len;
   size_t i;
   int end;
   int pp_state = 0;
   const char *post_scheme_part = NULL;
-  len = strlen (path);
-  for (end = 0, i = 0; ! end && i < len; i++)
-  {
-    switch (pp_state)
+
+  len = strlen(path);
+  for (end = 0, i = 0; !end && i < len; i++)
     {
-    case 0:
-      if ((path[i] == ':') && (i > 0))
-      {
-        pp_state += 1;
-        continue;
-      }
-      if (! ((path[i] >= 'A' && path[i] <= 'Z') ||
-             (path[i] >= 'a' && path[i] <= 'z') ||
-             (path[i] >= '0' && path[i] <= '9') || path[i] == '+' ||
-             path[i] == '-' || (path[i] == '.')))
-        end = 1;
-      break;
-    case 1:
-    case 2:
-      if (path[i] == '/')
-      {
-        pp_state += 1;
-        continue;
-      }
-      end = 1;
-      break;
-    case 3:
-      post_scheme_part = &path[i];
-      end = 1;
-      break;
-    default:
-      end = 1;
+      switch (pp_state)
+        {
+        case 0:
+          if ((path[i] == ':') && (i > 0))
+            {
+              pp_state += 1;
+              continue;
+            }
+          if (!((path[i] >= 'A' && path[i] <= 'Z') ||
+                (path[i] >= 'a' && path[i] <= 'z') ||
+                (path[i] >= '0' && path[i] <= '9') || path[i] == '+' ||
+                path[i] == '-' || (path[i] == '.')))
+            end = 1;
+          break;
+
+        case 1:
+        case 2:
+          if (path[i] == '/')
+            {
+              pp_state += 1;
+              continue;
+            }
+          end = 1;
+          break;
+
+        case 3:
+          post_scheme_part = &path[i];
+          end = 1;
+          break;
+
+        default:
+          end = 1;
+        }
     }
-  }
   if (post_scheme_part == NULL)
     return GNUNET_NO;
   if (scheme_part)
-  {
-    *scheme_part = GNUNET_malloc (post_scheme_part - path + 1);
-    GNUNET_memcpy (*scheme_part, path, post_scheme_part - path);
-    (*scheme_part)[post_scheme_part - path] = '\0';
-  }
+    {
+      *scheme_part = GNUNET_malloc(post_scheme_part - path + 1);
+      GNUNET_memcpy(*scheme_part, path, post_scheme_part - path);
+      (*scheme_part)[post_scheme_part - path] = '\0';
+    }
   if (path_part)
     *path_part = post_scheme_part;
   return GNUNET_YES;
@@ -1155,10 +1163,10 @@ GNUNET_STRINGS_parse_uri (const char *path,
  * @return #GNUNET_YES if @a filename is absolute, #GNUNET_NO otherwise.
  */
 int
-GNUNET_STRINGS_path_is_absolute (const char *filename,
-                                 int can_be_uri,
-                                 int *r_is_uri,
-                                 char **r_uri_scheme)
+GNUNET_STRINGS_path_is_absolute(const char *filename,
+                                int can_be_uri,
+                                int *r_is_uri,
+                                char **r_uri_scheme)
 {
 #if WINDOWS
   size_t len;
@@ -1172,37 +1180,37 @@ GNUNET_STRINGS_path_is_absolute (const char *filename,
   if (filename[0] == '/')
     return GNUNET_YES;
   if (can_be_uri)
-  {
-    is_uri = GNUNET_STRINGS_parse_uri (filename, &uri, &post_scheme_path);
-    if (r_is_uri)
-      *r_is_uri = is_uri;
-    if (is_uri)
     {
-      if (r_uri_scheme)
-        *r_uri_scheme = uri;
-      else
-        GNUNET_free_non_null (uri);
+      is_uri = GNUNET_STRINGS_parse_uri(filename, &uri, &post_scheme_path);
+      if (r_is_uri)
+        *r_is_uri = is_uri;
+      if (is_uri)
+        {
+          if (r_uri_scheme)
+            *r_uri_scheme = uri;
+          else
+            GNUNET_free_non_null(uri);
 #if WINDOWS
-      len = strlen (post_scheme_path);
-      /* Special check for file:///c:/blah
-       * We want to parse 'c:/', not '/c:/'
-       */
-      if (post_scheme_path[0] == '/' && len >= 3 && post_scheme_path[2] == ':')
-        post_scheme_path = &post_scheme_path[1];
+          len = strlen(post_scheme_path);
+          /* Special check for file:///c:/blah
+           * We want to parse 'c:/', not '/c:/'
+           */
+          if (post_scheme_path[0] == '/' && len >= 3 && post_scheme_path[2] == ':')
+            post_scheme_path = &post_scheme_path[1];
 #endif
-      return GNUNET_STRINGS_path_is_absolute (post_scheme_path,
-                                              GNUNET_NO,
-                                              NULL,
-                                              NULL);
+          return GNUNET_STRINGS_path_is_absolute(post_scheme_path,
+                                                 GNUNET_NO,
+                                                 NULL,
+                                                 NULL);
+        }
     }
-  }
   else
-  {
-    if (r_is_uri)
-      *r_is_uri = GNUNET_NO;
-  }
+    {
+      if (r_is_uri)
+        *r_is_uri = GNUNET_NO;
+    }
 #if WINDOWS
-  len = strlen (filename);
+  len = strlen(filename);
   if (len >= 3 &&
       ((filename[0] >= 'A' && filename[0] <= 'Z') ||
        (filename[0] >= 'a' && filename[0] <= 'z')) &&
@@ -1215,7 +1223,7 @@ GNUNET_STRINGS_path_is_absolute (const char *filename,
 #if MINGW
 #define _IFMT 0170000 /* type of file */
 #define _IFLNK 0120000 /* symbolic link */
-#define S_ISLNK(m) (((m) &_IFMT) == _IFLNK)
+#define S_ISLNK(m) (((m) & _IFMT) == _IFLNK)
 #endif
 
 
@@ -1228,32 +1236,33 @@ GNUNET_STRINGS_path_is_absolute (const char *filename,
  *         fails, #GNUNET_SYSERR when a check can't be performed
  */
 int
-GNUNET_STRINGS_check_filename (const char *filename,
-                               enum GNUNET_STRINGS_FilenameCheck checks)
+GNUNET_STRINGS_check_filename(const char *filename,
+                              enum GNUNET_STRINGS_FilenameCheck checks)
 {
   struct stat st;
+
   if ((NULL == filename) || (filename[0] == '\0'))
     return GNUNET_SYSERR;
   if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
-    if (! GNUNET_STRINGS_path_is_absolute (filename, GNUNET_NO, NULL, NULL))
+    if (!GNUNET_STRINGS_path_is_absolute(filename, GNUNET_NO, NULL, NULL))
       return GNUNET_NO;
   if (0 != (checks &
             (GNUNET_STRINGS_CHECK_EXISTS | GNUNET_STRINGS_CHECK_IS_DIRECTORY |
              GNUNET_STRINGS_CHECK_IS_LINK)))
-  {
-    if (0 != stat (filename, &st))
     {
-      if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
-        return GNUNET_NO;
-      else
-        return GNUNET_SYSERR;
+      if (0 != stat(filename, &st))
+        {
+          if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
+            return GNUNET_NO;
+          else
+            return GNUNET_SYSERR;
+        }
     }
-  }
   if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
-    if (! S_ISDIR (st.st_mode))
+    if (!S_ISDIR(st.st_mode))
       return GNUNET_NO;
   if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
-    if (! S_ISLNK (st.st_mode))
+    if (!S_ISLNK(st.st_mode))
       return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -1272,9 +1281,9 @@ GNUNET_STRINGS_check_filename (const char *filename,
  *         case the contents of @a r_buf are undefined.
  */
 int
-GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
-                                uint16_t addrlen,
-                                struct sockaddr_in6 *r_buf)
+GNUNET_STRINGS_to_address_ipv6(const char *zt_addr,
+                               uint16_t addrlen,
+                               struct sockaddr_in6 *r_buf)
 {
   char zbuf[addrlen + 1];
   int ret;
@@ -1284,51 +1293,51 @@ GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
 
   if (addrlen < 6)
     return GNUNET_SYSERR;
-  GNUNET_memcpy (zbuf, zt_addr, addrlen);
+  GNUNET_memcpy(zbuf, zt_addr, addrlen);
   if ('[' != zbuf[0])
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("IPv6 address did not start with `['\n"));
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("IPv6 address did not start with `['\n"));
+      return GNUNET_SYSERR;
+    }
   zbuf[addrlen] = '\0';
-  port_colon = strrchr (zbuf, ':');
+  port_colon = strrchr(zbuf, ':');
   if (NULL == port_colon)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("IPv6 address did contain ':' to separate port number\n"));
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("IPv6 address did contain ':' to separate port number\n"));
+      return GNUNET_SYSERR;
+    }
   if (']' != *(port_colon - 1))
-  {
-    GNUNET_log (
-      GNUNET_ERROR_TYPE_WARNING,
-      _ ("IPv6 address did contain ']' before ':' to separate port number\n"));
-    return GNUNET_SYSERR;
-  }
-  ret = sscanf (port_colon, ":%u%1s", &port, dummy);
+    {
+      GNUNET_log(
+        GNUNET_ERROR_TYPE_WARNING,
+        _("IPv6 address did contain ']' before ':' to separate port number\n"));
+      return GNUNET_SYSERR;
+    }
+  ret = sscanf(port_colon, ":%u%1s", &port, dummy);
   if ((1 != ret) || (port > 65535))
-  {
-    GNUNET_log (
-      GNUNET_ERROR_TYPE_WARNING,
-      _ ("IPv6 address did contain a valid port number after the last ':'\n"));
-    return GNUNET_SYSERR;
-  }
+    {
+      GNUNET_log(
+        GNUNET_ERROR_TYPE_WARNING,
+        _("IPv6 address did contain a valid port number after the last ':'\n"));
+      return GNUNET_SYSERR;
+    }
   *(port_colon - 1) = '\0';
-  memset (r_buf, 0, sizeof (struct sockaddr_in6));
-  ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
+  memset(r_buf, 0, sizeof(struct sockaddr_in6));
+  ret = inet_pton(AF_INET6, &zbuf[1], &r_buf->sin6_addr);
   if (ret <= 0)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Invalid IPv6 address `%s': %s\n"),
-                &zbuf[1],
-                strerror (errno));
-    return GNUNET_SYSERR;
-  }
-  r_buf->sin6_port = htons (port);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 _("Invalid IPv6 address `%s': %s\n"),
+                 &zbuf[1],
+                 strerror(errno));
+      return GNUNET_SYSERR;
+    }
+  r_buf->sin6_port = htons(port);
   r_buf->sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  r_buf->sin6_len = (u_char) sizeof (struct sockaddr_in6);
+  r_buf->sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
   return GNUNET_OK;
 }
@@ -1346,9 +1355,9 @@ GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
  *         the contents of @a r_buf are undefined.
  */
 int
-GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr,
-                                uint16_t addrlen,
-                                struct sockaddr_in *r_buf)
+GNUNET_STRINGS_to_address_ipv4(const char *zt_addr,
+                               uint16_t addrlen,
+                               struct sockaddr_in *r_buf)
 {
   unsigned int temps[4];
   unsigned int port;
@@ -1357,14 +1366,14 @@ GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr,
 
   if (addrlen < 9)
     return GNUNET_SYSERR;
-  cnt = sscanf (zt_addr,
-                "%u.%u.%u.%u:%u%1s",
-                &temps[0],
-                &temps[1],
-                &temps[2],
-                &temps[3],
-                &port,
-                dummy);
+  cnt = sscanf(zt_addr,
+               "%u.%u.%u.%u:%u%1s",
+               &temps[0],
+               &temps[1],
+               &temps[2],
+               &temps[3],
+               &port,
+               dummy);
   if (5 != cnt)
     return GNUNET_SYSERR;
   for (cnt = 0; cnt < 4; cnt++)
@@ -1373,11 +1382,11 @@ GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr,
   if (port > 65535)
     return GNUNET_SYSERR;
   r_buf->sin_family = AF_INET;
-  r_buf->sin_port = htons (port);
+  r_buf->sin_port = htons(port);
   r_buf->sin_addr.s_addr =
-    htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
+    htonl((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  r_buf->sin_len = (u_char) sizeof (struct sockaddr_in);
+  r_buf->sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
   return GNUNET_OK;
 }
@@ -1395,17 +1404,17 @@ GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr,
  *         case the contents of @a r_buf are undefined.
  */
 int
-GNUNET_STRINGS_to_address_ip (const char *addr,
-                              uint16_t addrlen,
-                              struct sockaddr_storage *r_buf)
+GNUNET_STRINGS_to_address_ip(const char *addr,
+                             uint16_t addrlen,
+                             struct sockaddr_storage *r_buf)
 {
   if (addr[0] == '[')
-    return GNUNET_STRINGS_to_address_ipv6 (addr,
-                                           addrlen,
-                                           (struct sockaddr_in6 *) r_buf);
-  return GNUNET_STRINGS_to_address_ipv4 (addr,
-                                         addrlen,
-                                         (struct sockaddr_in *) r_buf);
+    return GNUNET_STRINGS_to_address_ipv6(addr,
+                                          addrlen,
+                                          (struct sockaddr_in6 *)r_buf);
+  return GNUNET_STRINGS_to_address_ipv4(addr,
+                                        addrlen,
+                                        (struct sockaddr_in *)r_buf);
 }
 
 
@@ -1419,49 +1428,49 @@ GNUNET_STRINGS_to_address_ip (const char *addr,
  * @return 0 on error, otherwise number of bytes in @a sa
  */
 size_t
-GNUNET_STRINGS_parse_socket_addr (const char *addr,
-                                  uint8_t *af,
-                                  struct sockaddr **sa)
+GNUNET_STRINGS_parse_socket_addr(const char *addr,
+                                 uint8_t *af,
+                                 struct sockaddr **sa)
 {
-  char *cp = GNUNET_strdup (addr);
+  char *cp = GNUNET_strdup(addr);
 
   *af = AF_UNSPEC;
   if ('[' == *addr)
-  {
-    /* IPv6 */
-    *sa = GNUNET_malloc (sizeof (struct sockaddr_in6));
-    if (GNUNET_OK !=
-        GNUNET_STRINGS_to_address_ipv6 (cp,
-                                        strlen (cp),
-                                        (struct sockaddr_in6 *) *sa))
     {
-      GNUNET_free (*sa);
-      *sa = NULL;
-      GNUNET_free (cp);
-      return 0;
+      /* IPv6 */
+      *sa = GNUNET_malloc(sizeof(struct sockaddr_in6));
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_to_address_ipv6(cp,
+                                         strlen(cp),
+                                         (struct sockaddr_in6 *)*sa))
+        {
+          GNUNET_free(*sa);
+          *sa = NULL;
+          GNUNET_free(cp);
+          return 0;
+        }
+      *af = AF_INET6;
+      GNUNET_free(cp);
+      return sizeof(struct sockaddr_in6);
     }
-    *af = AF_INET6;
-    GNUNET_free (cp);
-    return sizeof (struct sockaddr_in6);
-  }
   else
-  {
-    /* IPv4 */
-    *sa = GNUNET_malloc (sizeof (struct sockaddr_in));
-    if (GNUNET_OK !=
-        GNUNET_STRINGS_to_address_ipv4 (cp,
-                                        strlen (cp),
-                                        (struct sockaddr_in *) *sa))
     {
-      GNUNET_free (*sa);
-      *sa = NULL;
-      GNUNET_free (cp);
-      return 0;
+      /* IPv4 */
+      *sa = GNUNET_malloc(sizeof(struct sockaddr_in));
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_to_address_ipv4(cp,
+                                         strlen(cp),
+                                         (struct sockaddr_in *)*sa))
+        {
+          GNUNET_free(*sa);
+          *sa = NULL;
+          GNUNET_free(cp);
+          return 0;
+        }
+      *af = AF_INET;
+      GNUNET_free(cp);
+      return sizeof(struct sockaddr_in);
     }
-    *af = AF_INET;
-    GNUNET_free (cp);
-    return sizeof (struct sockaddr_in);
-  }
 }
 
 
@@ -1470,24 +1479,25 @@ GNUNET_STRINGS_parse_socket_addr (const char *addr,
  * freed with a single call to GNUNET_free();
  */
 static char *const *
-_make_continuous_arg_copy (int argc, char *const *argv)
+_make_continuous_arg_copy(int argc, char *const *argv)
 {
   size_t argvsize = 0;
   int i;
   char **new_argv;
   char *p;
+
   for (i = 0; i < argc; i++)
-    argvsize += strlen (argv[i]) + 1 + sizeof (char *);
-  new_argv = GNUNET_malloc (argvsize + sizeof (char *));
-  p = (char *) &new_argv[argc + 1];
+    argvsize += strlen(argv[i]) + 1 + sizeof(char *);
+  new_argv = GNUNET_malloc(argvsize + sizeof(char *));
+  p = (char *)&new_argv[argc + 1];
   for (i = 0; i < argc; i++)
-  {
-    new_argv[i] = p;
-    strcpy (p, argv[i]);
-    p += strlen (argv[i]) + 1;
-  }
+    {
+      new_argv[i] = p;
+      strcpy(p, argv[i]);
+      p += strlen(argv[i]) + 1;
+    }
   new_argv[argc] = NULL;
-  return (char *const *) new_argv;
+  return (char *const *)new_argv;
 }
 
 
@@ -1506,10 +1516,10 @@ _make_continuous_arg_copy (int argc, char *const *argv)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_STRINGS_get_utf8_args (int argc,
-                              char *const *argv,
-                              int *u8argc,
-                              char *const **u8argv)
+GNUNET_STRINGS_get_utf8_args(int argc,
+                             char *const *argv,
+                             int *u8argc,
+                             char *const **u8argv)
 {
 #if WINDOWS
   wchar_t *wcmd;
@@ -1518,42 +1528,42 @@ GNUNET_STRINGS_get_utf8_args (int argc,
   int i;
   char **split_u8argv;
 
-  wcmd = GetCommandLineW ();
+  wcmd = GetCommandLineW();
   if (NULL == wcmd)
     return GNUNET_SYSERR;
-  wargv = CommandLineToArgvW (wcmd, &wargc);
+  wargv = CommandLineToArgvW(wcmd, &wargc);
   if (NULL == wargv)
     return GNUNET_SYSERR;
 
-  split_u8argv = GNUNET_malloc (argc * sizeof (char *));
+  split_u8argv = GNUNET_malloc(argc * sizeof(char *));
 
   for (i = 0; i < wargc; i++)
-  {
-    size_t strl;
-    /* Hopefully it will allocate us NUL-terminated strings... */
-    split_u8argv[i] =
-      (char *) u16_to_u8 (wargv[i], wcslen (wargv[i]) + 1, NULL, &strl);
-    if (NULL == split_u8argv[i])
     {
-      int j;
-      for (j = 0; j < i; j++)
-        free (split_u8argv[j]);
-      GNUNET_free (split_u8argv);
-      LocalFree (wargv);
-      return GNUNET_SYSERR;
+      size_t strl;
+      /* Hopefully it will allocate us NUL-terminated strings... */
+      split_u8argv[i] =
+        (char *)u16_to_u8(wargv[i], wcslen(wargv[i]) + 1, NULL, &strl);
+      if (NULL == split_u8argv[i])
+        {
+          int j;
+          for (j = 0; j < i; j++)
+            free(split_u8argv[j]);
+          GNUNET_free(split_u8argv);
+          LocalFree(wargv);
+          return GNUNET_SYSERR;
+        }
     }
-  }
 
-  *u8argv = _make_continuous_arg_copy (wargc, split_u8argv);
+  *u8argv = _make_continuous_arg_copy(wargc, split_u8argv);
   *u8argc = wargc;
 
   for (i = 0; i < wargc; i++)
-    free (split_u8argv[i]);
-  free (split_u8argv);
+    free(split_u8argv[i]);
+  free(split_u8argv);
   return GNUNET_OK;
 #else
   char *const *new_argv =
-    (char *const *) _make_continuous_arg_copy (argc, argv);
+    (char *const *)_make_continuous_arg_copy(argc, argv);
   *u8argv = new_argv;
   *u8argc = argc;
   return GNUNET_OK;
@@ -1571,8 +1581,8 @@ GNUNET_STRINGS_get_utf8_args (int argc,
  *         @a port_policy is malformed
  */
 static int
-parse_port_policy (const char *port_policy,
-                   struct GNUNET_STRINGS_PortPolicy *pp)
+parse_port_policy(const char *port_policy,
+                  struct GNUNET_STRINGS_PortPolicy *pp)
 {
   const char *pos;
   int s;
@@ -1581,36 +1591,36 @@ parse_port_policy (const char *port_policy,
 
   pos = port_policy;
   if ('!' == *pos)
-  {
-    pp->negate_portrange = GNUNET_YES;
-    pos++;
-  }
-  if (2 == sscanf (pos, "%u-%u%1s", &s, &e, eol))
-  {
-    if ((0 == s) || (s > 0xFFFF) || (e < s) || (e > 0xFFFF))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Port not in range\n"));
-      return GNUNET_SYSERR;
+      pp->negate_portrange = GNUNET_YES;
+      pos++;
     }
-    pp->start_port = (uint16_t) s;
-    pp->end_port = (uint16_t) e;
-    return GNUNET_OK;
-  }
-  if (1 == sscanf (pos, "%u%1s", &s, eol))
-  {
-    if ((0 == s) || (s > 0xFFFF))
+  if (2 == sscanf(pos, "%u-%u%1s", &s, &e, eol))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Port not in range\n"));
-      return GNUNET_SYSERR;
+      if ((0 == s) || (s > 0xFFFF) || (e < s) || (e > 0xFFFF))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, _("Port not in range\n"));
+          return GNUNET_SYSERR;
+        }
+      pp->start_port = (uint16_t)s;
+      pp->end_port = (uint16_t)e;
+      return GNUNET_OK;
     }
+  if (1 == sscanf(pos, "%u%1s", &s, eol))
+    {
+      if ((0 == s) || (s > 0xFFFF))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, _("Port not in range\n"));
+          return GNUNET_SYSERR;
+        }
 
-    pp->start_port = (uint16_t) s;
-    pp->end_port = (uint16_t) s;
-    return GNUNET_OK;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _ ("Malformed port policy `%s'\n"),
-              port_policy);
+      pp->start_port = (uint16_t)s;
+      pp->end_port = (uint16_t)s;
+      return GNUNET_OK;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+             _("Malformed port policy `%s'\n"),
+             port_policy);
   return GNUNET_SYSERR;
 }
 
@@ -1628,7 +1638,7 @@ parse_port_policy (const char *port_policy,
  *         NULL if the synatx is flawed
  */
 struct GNUNET_STRINGS_IPv4NetworkPolicy *
-GNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
+GNUNET_STRINGS_parse_ipv4_policy(const char *routeListX)
 {
   unsigned int count;
   unsigned int i;
@@ -1646,164 +1656,164 @@ GNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
 
   if (NULL == routeListX)
     return NULL;
-  len = strlen (routeListX);
+  len = strlen(routeListX);
   if (0 == len)
     return NULL;
-  routeList = GNUNET_strdup (routeListX);
+  routeList = GNUNET_strdup(routeListX);
   count = 0;
   for (i = 0; i < len; i++)
     if (routeList[i] == ';')
       count++;
-  result = GNUNET_malloc (sizeof (struct GNUNET_STRINGS_IPv4NetworkPolicy) *
-                          (count + 1));
+  result = GNUNET_malloc(sizeof(struct GNUNET_STRINGS_IPv4NetworkPolicy) *
+                         (count + 1));
   i = 0;
   pos = 0;
   while (i < count)
-  {
-    for (colon = pos; ':' != routeList[colon]; colon++)
-      if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
-        break;
-    for (end = colon; ';' != routeList[end]; end++)
-      if ('\0' == routeList[end])
-        break;
-    if ('\0' == routeList[end])
-      break;
-    routeList[end] = '\0';
-    if (':' == routeList[colon])
     {
-      routeList[colon] = '\0';
-      if (GNUNET_OK != parse_port_policy (&routeList[colon + 1], &result[i].pp))
+      for (colon = pos; ':' != routeList[colon]; colon++)
+        if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
+          break;
+      for (end = colon; ';' != routeList[end]; end++)
+        if ('\0' == routeList[end])
+          break;
+      if ('\0' == routeList[end])
         break;
-    }
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u/%u.%u.%u.%u%1s",
-                  &temps[0],
-                  &temps[1],
-                  &temps[2],
-                  &temps[3],
-                  &temps[4],
-                  &temps[5],
-                  &temps[6],
-                  &temps[7],
-                  dummy);
-    if (8 == cnt)
-    {
-      for (j = 0; j < 8; j++)
-        if (temps[j] > 0xFF)
+      routeList[end] = '\0';
+      if (':' == routeList[colon])
         {
-          LOG (GNUNET_ERROR_TYPE_WARNING,
-               _ ("Invalid format for IP: `%s'\n"),
-               &routeList[pos]);
-          GNUNET_free (result);
-          GNUNET_free (routeList);
-          return NULL;
+          routeList[colon] = '\0';
+          if (GNUNET_OK != parse_port_policy(&routeList[colon + 1], &result[i].pp))
+            break;
         }
-      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16) +
-                                        (temps[2] << 8) + temps[3]);
-      result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16) +
-                                        (temps[6] << 8) + temps[7]);
-      pos = end + 1;
-      i++;
-      continue;
-    }
-    /* try second notation */
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u/%u%1s",
-                  &temps[0],
-                  &temps[1],
-                  &temps[2],
-                  &temps[3],
-                  &slash,
-                  dummy);
-    if (5 == cnt)
-    {
-      for (j = 0; j < 4; j++)
-        if (temps[j] > 0xFF)
+      cnt = sscanf(&routeList[pos],
+                   "%u.%u.%u.%u/%u.%u.%u.%u%1s",
+                   &temps[0],
+                   &temps[1],
+                   &temps[2],
+                   &temps[3],
+                   &temps[4],
+                   &temps[5],
+                   &temps[6],
+                   &temps[7],
+                   dummy);
+      if (8 == cnt)
         {
-          LOG (GNUNET_ERROR_TYPE_WARNING,
-               _ ("Invalid format for IP: `%s'\n"),
-               &routeList[pos]);
-          GNUNET_free (result);
-          GNUNET_free (routeList);
-          return NULL;
+          for (j = 0; j < 8; j++)
+            if (temps[j] > 0xFF)
+              {
+                LOG(GNUNET_ERROR_TYPE_WARNING,
+                    _("Invalid format for IP: `%s'\n"),
+                    &routeList[pos]);
+                GNUNET_free(result);
+                GNUNET_free(routeList);
+                return NULL;
+              }
+          result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
+                                           (temps[2] << 8) + temps[3]);
+          result[i].netmask.s_addr = htonl((temps[4] << 24) + (temps[5] << 16) +
+                                           (temps[6] << 8) + temps[7]);
+          pos = end + 1;
+          i++;
+          continue;
         }
-      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16) +
-                                        (temps[2] << 8) + temps[3]);
-      if ((slash <= 32) && (slash >= 0))
-      {
-        result[i].netmask.s_addr = 0;
-        while (slash > 0)
+      /* try second notation */
+      cnt = sscanf(&routeList[pos],
+                   "%u.%u.%u.%u/%u%1s",
+                   &temps[0],
+                   &temps[1],
+                   &temps[2],
+                   &temps[3],
+                   &slash,
+                   dummy);
+      if (5 == cnt)
         {
-          result[i].netmask.s_addr =
-            (result[i].netmask.s_addr >> 1) + 0x80000000;
-          slash--;
+          for (j = 0; j < 4; j++)
+            if (temps[j] > 0xFF)
+              {
+                LOG(GNUNET_ERROR_TYPE_WARNING,
+                    _("Invalid format for IP: `%s'\n"),
+                    &routeList[pos]);
+                GNUNET_free(result);
+                GNUNET_free(routeList);
+                return NULL;
+              }
+          result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
+                                           (temps[2] << 8) + temps[3]);
+          if ((slash <= 32) && (slash >= 0))
+            {
+              result[i].netmask.s_addr = 0;
+              while (slash > 0)
+                {
+                  result[i].netmask.s_addr =
+                    (result[i].netmask.s_addr >> 1) + 0x80000000;
+                  slash--;
+                }
+              result[i].netmask.s_addr = htonl(result[i].netmask.s_addr);
+              pos = end + 1;
+              i++;
+              continue;
+            }
+          else
+            {
+              LOG(GNUNET_ERROR_TYPE_WARNING,
+                  _("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
+                  slash);
+              GNUNET_free(result);
+              GNUNET_free(routeList);
+              return NULL; /* error */
+            }
         }
-        result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
-        pos = end + 1;
-        i++;
-        continue;
-      }
-      else
-      {
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             _ ("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
-             slash);
-        GNUNET_free (result);
-        GNUNET_free (routeList);
-        return NULL; /* error */
-      }
-    }
-    /* try third notation */
-    slash = 32;
-    cnt = sscanf (&routeList[pos],
-                  "%u.%u.%u.%u%1s",
-                  &temps[0],
-                  &temps[1],
-                  &temps[2],
-                  &temps[3],
-                  dummy);
-    if (4 == cnt)
-    {
-      for (j = 0; j < 4; j++)
-        if (temps[j] > 0xFF)
+      /* try third notation */
+      slash = 32;
+      cnt = sscanf(&routeList[pos],
+                   "%u.%u.%u.%u%1s",
+                   &temps[0],
+                   &temps[1],
+                   &temps[2],
+                   &temps[3],
+                   dummy);
+      if (4 == cnt)
         {
-          LOG (GNUNET_ERROR_TYPE_WARNING,
-               _ ("Invalid format for IP: `%s'\n"),
-               &routeList[pos]);
-          GNUNET_free (result);
-          GNUNET_free (routeList);
-          return NULL;
+          for (j = 0; j < 4; j++)
+            if (temps[j] > 0xFF)
+              {
+                LOG(GNUNET_ERROR_TYPE_WARNING,
+                    _("Invalid format for IP: `%s'\n"),
+                    &routeList[pos]);
+                GNUNET_free(result);
+                GNUNET_free(routeList);
+                return NULL;
+              }
+          result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
+                                           (temps[2] << 8) + temps[3]);
+          result[i].netmask.s_addr = 0;
+          while (slash > 0)
+            {
+              result[i].netmask.s_addr = (result[i].netmask.s_addr >> 1) + 0x80000000;
+              slash--;
+            }
+          result[i].netmask.s_addr = htonl(result[i].netmask.s_addr);
+          pos = end + 1;
+          i++;
+          continue;
         }
-      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16) +
-                                        (temps[2] << 8) + temps[3]);
-      result[i].netmask.s_addr = 0;
-      while (slash > 0)
-      {
-        result[i].netmask.s_addr = (result[i].netmask.s_addr >> 1) + 0x80000000;
-        slash--;
-      }
-      result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
-      pos = end + 1;
-      i++;
-      continue;
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Invalid format for IP: `%s'\n"),
+          &routeList[pos]);
+      GNUNET_free(result);
+      GNUNET_free(routeList);
+      return NULL; /* error */
     }
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Invalid format for IP: `%s'\n"),
-         &routeList[pos]);
-    GNUNET_free (result);
-    GNUNET_free (routeList);
-    return NULL; /* error */
-  }
-  if (pos < strlen (routeList))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Invalid format: `%s'\n"),
-         &routeListX[pos]);
-    GNUNET_free (result);
-    GNUNET_free (routeList);
-    return NULL; /* oops */
-  }
-  GNUNET_free (routeList);
+  if (pos < strlen(routeList))
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Invalid format: `%s'\n"),
+          &routeListX[pos]);
+      GNUNET_free(result);
+      GNUNET_free(routeList);
+      return NULL; /* oops */
+    }
+  GNUNET_free(routeList);
   return result; /* ok */
 }
 
@@ -1820,7 +1830,7 @@ GNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
  * @return the converted list, 0-terminated, NULL if the synatx is flawed
  */
 struct GNUNET_STRINGS_IPv6NetworkPolicy *
-GNUNET_STRINGS_parse_ipv6_policy (const char *routeListX)
+GNUNET_STRINGS_parse_ipv6_policy(const char *routeListX)
 {
   unsigned int count;
   unsigned int i;
@@ -1839,110 +1849,110 @@ GNUNET_STRINGS_parse_ipv6_policy (const char *routeListX)
 
   if (NULL == routeListX)
     return NULL;
-  len = strlen (routeListX);
+  len = strlen(routeListX);
   if (0 == len)
     return NULL;
-  routeList = GNUNET_strdup (routeListX);
+  routeList = GNUNET_strdup(routeListX);
   count = 0;
   for (i = 0; i < len; i++)
     if (';' == routeList[i])
       count++;
   if (';' != routeList[len - 1])
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Invalid network notation (does not end with ';': `%s')\n"),
-         routeList);
-    GNUNET_free (routeList);
-    return NULL;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_WARNING,
+          _("Invalid network notation (does not end with ';': `%s')\n"),
+          routeList);
+      GNUNET_free(routeList);
+      return NULL;
+    }
 
-  result = GNUNET_malloc (sizeof (struct GNUNET_STRINGS_IPv6NetworkPolicy) *
-                          (count + 1));
+  result = GNUNET_malloc(sizeof(struct GNUNET_STRINGS_IPv6NetworkPolicy) *
+                         (count + 1));
   i = 0;
   pos = 0;
   while (i < count)
-  {
-    start = pos;
-    while (';' != routeList[pos])
-      pos++;
-    slash = pos;
-    while ((slash >= start) && (routeList[slash] != '/'))
-      slash--;
-
-    if (slash < start)
     {
-      memset (&result[i].netmask, 0xFF, sizeof (struct in6_addr));
+      start = pos;
+      while (';' != routeList[pos])
+        pos++;
       slash = pos;
-    }
-    else
-    {
-      routeList[pos] = '\0';
-      for (colon = pos; ':' != routeList[colon]; colon--)
-        if ('/' == routeList[colon])
-          break;
-      if (':' == routeList[colon])
-      {
-        routeList[colon] = '\0';
-        if (GNUNET_OK !=
-            parse_port_policy (&routeList[colon + 1], &result[i].pp))
+      while ((slash >= start) && (routeList[slash] != '/'))
+        slash--;
+
+      if (slash < start)
         {
-          GNUNET_free (result);
-          GNUNET_free (routeList);
-          return NULL;
+          memset(&result[i].netmask, 0xFF, sizeof(struct in6_addr));
+          slash = pos;
         }
-      }
-      ret = inet_pton (AF_INET6, &routeList[slash + 1], &result[i].netmask);
+      else
+        {
+          routeList[pos] = '\0';
+          for (colon = pos; ':' != routeList[colon]; colon--)
+            if ('/' == routeList[colon])
+              break;
+          if (':' == routeList[colon])
+            {
+              routeList[colon] = '\0';
+              if (GNUNET_OK !=
+                  parse_port_policy(&routeList[colon + 1], &result[i].pp))
+                {
+                  GNUNET_free(result);
+                  GNUNET_free(routeList);
+                  return NULL;
+                }
+            }
+          ret = inet_pton(AF_INET6, &routeList[slash + 1], &result[i].netmask);
+          if (ret <= 0)
+            {
+              save = errno;
+              if ((1 != sscanf(&routeList[slash + 1], "%u%1s", &bits, dummy)) ||
+                  (bits > 128))
+                {
+                  if (0 == ret)
+                    LOG(GNUNET_ERROR_TYPE_WARNING,
+                        _("Wrong format `%s' for netmask\n"),
+                        &routeList[slash + 1]);
+                  else
+                    {
+                      errno = save;
+                      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "inet_pton");
+                    }
+                  GNUNET_free(result);
+                  GNUNET_free(routeList);
+                  return NULL;
+                }
+              off = 0;
+              while (bits > 8)
+                {
+                  result[i].netmask.s6_addr[off++] = 0xFF;
+                  bits -= 8;
+                }
+              while (bits > 0)
+                {
+                  result[i].netmask.s6_addr[off] =
+                    (result[i].netmask.s6_addr[off] >> 1) + 0x80;
+                  bits--;
+                }
+            }
+        }
+      routeList[slash] = '\0';
+      ret = inet_pton(AF_INET6, &routeList[start], &result[i].network);
       if (ret <= 0)
-      {
-        save = errno;
-        if ((1 != sscanf (&routeList[slash + 1], "%u%1s", &bits, dummy)) ||
-            (bits > 128))
         {
           if (0 == ret)
-            LOG (GNUNET_ERROR_TYPE_WARNING,
-                 _ ("Wrong format `%s' for netmask\n"),
-                 &routeList[slash + 1]);
+            LOG(GNUNET_ERROR_TYPE_WARNING,
+                _("Wrong format `%s' for network\n"),
+                &routeList[slash + 1]);
           else
-          {
-            errno = save;
-            LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_pton");
-          }
-          GNUNET_free (result);
-          GNUNET_free (routeList);
+            LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "inet_pton");
+          GNUNET_free(result);
+          GNUNET_free(routeList);
           return NULL;
         }
-        off = 0;
-        while (bits > 8)
-        {
-          result[i].netmask.s6_addr[off++] = 0xFF;
-          bits -= 8;
-        }
-        while (bits > 0)
-        {
-          result[i].netmask.s6_addr[off] =
-            (result[i].netmask.s6_addr[off] >> 1) + 0x80;
-          bits--;
-        }
-      }
-    }
-    routeList[slash] = '\0';
-    ret = inet_pton (AF_INET6, &routeList[start], &result[i].network);
-    if (ret <= 0)
-    {
-      if (0 == ret)
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             _ ("Wrong format `%s' for network\n"),
-             &routeList[slash + 1]);
-      else
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "inet_pton");
-      GNUNET_free (result);
-      GNUNET_free (routeList);
-      return NULL;
+      pos++;
+      i++;
     }
-    pos++;
-    i++;
-  }
-  GNUNET_free (routeList);
+  GNUNET_free(routeList);
   return result;
 }
 
@@ -1965,58 +1975,58 @@ static char *cvt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  * @return the size of the output
  */
 size_t
-GNUNET_STRINGS_base64_encode (const void *in, size_t len, char **output)
+GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
 {
   const char *data = in;
   size_t ret;
   char *opt;
 
   ret = 0;
-  opt = GNUNET_malloc (2 + (len * 4 / 3) + 8);
+  opt = GNUNET_malloc(2 + (len * 4 / 3) + 8);
   for (size_t i = 0; i < len; ++i)
-  {
-    char c;
-
-    c = (data[i] >> 2) & 0x3f;
-    opt[ret++] = cvt[(int) c];
-    c = (data[i] << 4) & 0x3f;
-    if (++i < len)
-      c |= (data[i] >> 4) & 0x0f;
-    opt[ret++] = cvt[(int) c];
-    if (i < len)
     {
-      c = (data[i] << 2) & 0x3f;
+      char c;
+
+      c = (data[i] >> 2) & 0x3f;
+      opt[ret++] = cvt[(int)c];
+      c = (data[i] << 4) & 0x3f;
       if (++i < len)
-        c |= (data[i] >> 6) & 0x03;
-      opt[ret++] = cvt[(int) c];
-    }
-    else
-    {
-      ++i;
-      opt[ret++] = FILLCHAR;
-    }
-    if (i < len)
-    {
-      c = data[i] & 0x3f;
-      opt[ret++] = cvt[(int) c];
-    }
-    else
-    {
-      opt[ret++] = FILLCHAR;
+        c |= (data[i] >> 4) & 0x0f;
+      opt[ret++] = cvt[(int)c];
+      if (i < len)
+        {
+          c = (data[i] << 2) & 0x3f;
+          if (++i < len)
+            c |= (data[i] >> 6) & 0x03;
+          opt[ret++] = cvt[(int)c];
+        }
+      else
+        {
+          ++i;
+          opt[ret++] = FILLCHAR;
+        }
+      if (i < len)
+        {
+          c = data[i] & 0x3f;
+          opt[ret++] = cvt[(int)c];
+        }
+      else
+        {
+          opt[ret++] = FILLCHAR;
+        }
     }
-  }
   *output = opt;
   return ret;
 }
 
 #define cvtfind(a)                        \
   ((((a) >= 'A') && ((a) <= 'Z'))         \
-     ? (a) - 'A'                          \
-     : (((a) >= 'a') && ((a) <= 'z'))     \
-         ? (a) - 'a' + 26                 \
-         : (((a) >= '0') && ((a) <= '9')) \
-             ? (a) - '0' + 52             \
-             : ((a) == '+') ? 62 : ((a) == '/') ? 63 : -1)
+   ? (a) - 'A'                          \
+   : (((a) >= 'a') && ((a) <= 'z'))     \
+   ? (a) - 'a' + 26                 \
+   : (((a) >= '0') && ((a) <= '9')) \
+   ? (a) - '0' + 52             \
+   : ((a) == '+') ? 62 : ((a) == '/') ? 63 : -1)
 
 
 /**
@@ -2029,61 +2039,61 @@ GNUNET_STRINGS_base64_encode (const void *in, size_t len, char **output)
  * @return the size of the output
  */
 size_t
-GNUNET_STRINGS_base64_decode (const char *data, size_t len, void **out)
+GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **out)
 {
   char *output;
   size_t ret = 0;
 
 #define CHECK_CRLF                                                \
   while (data[i] == '\r' || data[i] == '\n')                      \
-  {                                                               \
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
-                "ignoring CR/LF\n");                              \
-    i++;                                                          \
-    if (i >= len)                                                 \
+    {                                                               \
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
+                 "ignoring CR/LF\n");                              \
+      i++;                                                          \
+      if (i >= len)                                                 \
       goto END;                                                   \
-  }
+    }
 
-  output = GNUNET_malloc ((len * 3 / 4) + 8);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "base64_decode decoding len=%d\n",
-              (int) len);
+  output = GNUNET_malloc((len * 3 / 4) + 8);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "base64_decode decoding len=%d\n",
+             (int)len);
   for (size_t i = 0; i < len; ++i)
-  {
-    char c;
-    char c1;
-
-    CHECK_CRLF;
-    if (FILLCHAR == data[i])
-      break;
-    c = (char) cvtfind (data[i]);
-    ++i;
-    CHECK_CRLF;
-    c1 = (char) cvtfind (data[i]);
-    c = (c << 2) | ((c1 >> 4) & 0x3);
-    output[ret++] = c;
-    if (++i < len)
     {
+      char c;
+      char c1;
+
       CHECK_CRLF;
-      c = data[i];
-      if (FILLCHAR == c)
+      if (FILLCHAR == data[i])
         break;
-      c = (char) cvtfind (c);
-      c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
-      output[ret++] = c1;
-    }
-    if (++i < len)
-    {
+      c = (char)cvtfind(data[i]);
+      ++i;
       CHECK_CRLF;
-      c1 = data[i];
-      if (FILLCHAR == c1)
-        break;
-
-      c1 = (char) cvtfind (c1);
-      c = ((c << 6) & 0xc0) | c1;
+      c1 = (char)cvtfind(data[i]);
+      c = (c << 2) | ((c1 >> 4) & 0x3);
       output[ret++] = c;
+      if (++i < len)
+        {
+          CHECK_CRLF;
+          c = data[i];
+          if (FILLCHAR == c)
+            break;
+          c = (char)cvtfind(c);
+          c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
+          output[ret++] = c1;
+        }
+      if (++i < len)
+        {
+          CHECK_CRLF;
+          c1 = data[i];
+          if (FILLCHAR == c1)
+            break;
+
+          c1 = (char)cvtfind(c1);
+          c = ((c << 6) & 0xc0) | c1;
+          output[ret++] = c;
+        }
     }
-  }
 END:
   *out = output;
   return ret;
diff --git a/src/util/test_bio.c b/src/util/test_bio.c
index 719f622ba..c8887e246 100644
--- a/src/util/test_bio.c
+++ b/src/util/test_bio.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 util/test_bio.c
@@ -31,212 +31,212 @@
 #define TESTNUMBER64 ((int64_t)100000L)
 
 static int
-test_normal_rw ()
+test_normal_rw()
 {
   char *msg;
   int64_t testNum;
   char *readResultString;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
   struct GNUNET_CONTAINER_MetaData *metaDataW;
   struct GNUNET_CONTAINER_MetaData *metaDataR;
 
-  metaDataW = GNUNET_CONTAINER_meta_data_create ();
+  metaDataW = GNUNET_CONTAINER_meta_data_create();
   metaDataR = NULL;
-  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+  GNUNET_CONTAINER_meta_data_add_publication_date(metaDataW);
 
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, TESTNUMBER64));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, TESTSTRING));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_meta_data(fileW, metaDataW));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int64(fileW, TESTNUMBER64));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   readResultString = NULL;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResultString, 200));
-  GNUNET_assert (NULL != readResultString);
-  GNUNET_assert (0 == strcmp (TESTSTRING, readResultString));
-  GNUNET_free (readResultString);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
-                                            &metaDataR));
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_CONTAINER_meta_data_destroy (metaDataW);
-  GNUNET_CONTAINER_meta_data_destroy (metaDataR);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResultString, 200));
+  GNUNET_assert(NULL != readResultString);
+  GNUNET_assert(0 == strcmp(TESTSTRING, readResultString));
+  GNUNET_free(readResultString);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_BIO_read_meta_data(fileR, "Read meta error",
+                                          &metaDataR));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_meta_data_test_equal(metaDataR, metaDataW));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_int64(fileR, &testNum));
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_CONTAINER_meta_data_destroy(metaDataW);
+  GNUNET_CONTAINER_meta_data_destroy(metaDataR);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_nullstring_rw ()
+test_nullstring_rw()
 {
   char *msg;
-  char *readResultString = (char *) "not null";
+  char *readResultString = (char *)"not null";
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResultString, 200));
-  GNUNET_assert (NULL == readResultString);
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, NULL));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
+
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResultString, 200));
+  GNUNET_assert(NULL == readResultString);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
 
   return 0;
 }
 
 static int
-test_emptystring_rw ()
+test_emptystring_rw()
 {
   char *msg;
   char *readResultString;
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
 
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, ""));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   readResultString = NULL;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResultString, 200));
-  GNUNET_free (readResultString);
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResultString, 200));
+  GNUNET_free(readResultString);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_bigstring_rw ()
+test_bigstring_rw()
 {
   char *msg;
   char *readResultString;
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
 
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, TESTSTRING));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   readResultString = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResultString, 1));
-  GNUNET_assert (NULL == readResultString);
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResultString, 1));
+  GNUNET_assert(NULL == readResultString);
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_bigmeta_rw ()
+test_bigmeta_rw()
 {
   char *msg;
   static char meta[1024 * 1024 * 10];
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
   struct GNUNET_CONTAINER_MetaData *metaDataR;
 
-  memset (meta, 'b', sizeof (meta));
-  meta[sizeof (meta) - 1] = '\0';
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof (meta)));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof (meta)));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  memset(meta, 'b', sizeof(meta));
+  meta[sizeof(meta) - 1] = '\0';
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, sizeof(meta)));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write(fileW, meta, sizeof(meta)));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   metaDataR = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
-                                            &metaDataR));
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_meta_data(fileR, "Read meta error",
+                                          &metaDataR));
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_assert (NULL == metaDataR);
-  GNUNET_free (fileName);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_assert(NULL == metaDataR);
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_directory_r ()
+test_directory_r()
 {
 #if LINUX
   char *msg;
   char readResult[200];
   struct GNUNET_BIO_ReadHandle *fileR;
 
-  fileR = GNUNET_BIO_read_open ("/dev");
-  GNUNET_assert (NULL != fileR);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read (fileR, "Read error", readResult,
-                                  sizeof (readResult)));
+  fileR = GNUNET_BIO_read_open("/dev");
+  GNUNET_assert(NULL != fileR);
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read(fileR, "Read error", readResult,
+                                sizeof(readResult)));
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
 #endif
   return 0;
 }
 
 static int
-test_nullfile_rw ()
+test_nullfile_rw()
 {
   static char fileNameNO[102401];
   struct GNUNET_BIO_WriteHandle *fileWNO;
   struct GNUNET_BIO_ReadHandle *fileRNO;
 
-  memset (fileNameNO, 'a', sizeof (fileNameNO));
-  fileNameNO[sizeof (fileNameNO) - 1] = '\0';
+  memset(fileNameNO, 'a', sizeof(fileNameNO));
+  fileNameNO[sizeof(fileNameNO) - 1] = '\0';
 
-  GNUNET_log_skip (1, GNUNET_NO);
-  fileWNO = GNUNET_BIO_write_open (fileNameNO);
-  GNUNET_log_skip (0, GNUNET_YES);
-  GNUNET_assert (NULL == fileWNO);
+  GNUNET_log_skip(1, GNUNET_NO);
+  fileWNO = GNUNET_BIO_write_open(fileNameNO);
+  GNUNET_log_skip(0, GNUNET_YES);
+  GNUNET_assert(NULL == fileWNO);
 
-  GNUNET_log_skip (1, GNUNET_NO);
-  fileRNO = GNUNET_BIO_read_open (fileNameNO);
-  GNUNET_log_skip (0, GNUNET_YES);
-  GNUNET_assert (NULL == fileRNO);
+  GNUNET_log_skip(1, GNUNET_NO);
+  fileRNO = GNUNET_BIO_read_open(fileNameNO);
+  GNUNET_log_skip(0, GNUNET_YES);
+  GNUNET_assert(NULL == fileRNO);
   return 0;
 }
 
 
 static int
-test_fullfile_rw ()
+test_fullfile_rw()
 {
 #ifdef LINUX
   /* /dev/full only seems to exist on Linux */
@@ -249,168 +249,168 @@ test_fullfile_rw ()
   struct GNUNET_CONTAINER_MetaData *metaDataW;
   struct GNUNET_CONTAINER_MetaData *metaDataR;
 
-  metaDataW = GNUNET_CONTAINER_meta_data_create ();
-  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
-
-  fileW = GNUNET_BIO_write_open ("/dev/full");
-  GNUNET_assert (NULL != fileW);
-  (void) GNUNET_BIO_write (fileW, TESTSTRING, strlen (TESTSTRING));
-  (void) GNUNET_BIO_write_string (fileW, TESTSTRING);
-  (void) GNUNET_BIO_write_meta_data (fileW, metaDataW);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
-  GNUNET_CONTAINER_meta_data_destroy (metaDataW);
-
-  fileW = GNUNET_BIO_write_open ("/dev/full");
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
-
-  fileR = GNUNET_BIO_read_open ("/dev/null");
-  GNUNET_assert (NULL != fileR);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read (fileR, "Read error", readResult,
-                                  sizeof (readResult)));
+  metaDataW = GNUNET_CONTAINER_meta_data_create();
+  GNUNET_CONTAINER_meta_data_add_publication_date(metaDataW);
+
+  fileW = GNUNET_BIO_write_open("/dev/full");
+  GNUNET_assert(NULL != fileW);
+  (void)GNUNET_BIO_write(fileW, TESTSTRING, strlen(TESTSTRING));
+  (void)GNUNET_BIO_write_string(fileW, TESTSTRING);
+  (void)GNUNET_BIO_write_meta_data(fileW, metaDataW);
+  GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_close(fileW));
+  GNUNET_CONTAINER_meta_data_destroy(metaDataW);
+
+  fileW = GNUNET_BIO_write_open("/dev/full");
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_close(fileW));
+
+  fileR = GNUNET_BIO_read_open("/dev/null");
+  GNUNET_assert(NULL != fileR);
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read(fileR, "Read error", readResult,
+                                sizeof(readResult)));
   readResultString = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResultString, 200));
-  GNUNET_assert (NULL == readResultString);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResultString, 200));
+  GNUNET_assert(NULL == readResultString);
+  GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_int64(fileR, &testNum));
   metaDataR = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
-                                            &metaDataR));
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_meta_data(fileR, "Read meta error",
+                                          &metaDataR));
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (NULL == metaDataR);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(NULL == metaDataR);
 #endif
   return 0;
 }
 
 static int
-test_fakestring_rw ()
+test_fakestring_rw()
 {
   char *msg;
   int32_t tmpInt = 2;
   char *readResult;
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_string (fileR, "Read string error",
-                                         &readResult, 200));
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
+
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_string(fileR, "Read string error",
+                                       &readResult, 200));
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_fakemeta_rw ()
+test_fakemeta_rw()
 {
   char *msg;
   int32_t tmpInt = 2;
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
   struct GNUNET_CONTAINER_MetaData *metaDataR;
 
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   metaDataR = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
-                                            &metaDataR));
-  GNUNET_assert (NULL == metaDataR);
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_meta_data(fileR, "Read meta error",
+                                          &metaDataR));
+  GNUNET_assert(NULL == metaDataR);
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_free (fileName);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-test_fakebigmeta_rw ()
+test_fakebigmeta_rw()
 {
   char *msg;
   int32_t tmpInt = 1024 * 1024 * 10;
   struct GNUNET_BIO_WriteHandle *fileW;
   struct GNUNET_BIO_ReadHandle *fileR;
-  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
   struct GNUNET_CONTAINER_MetaData *metaDataR;
 
-  fileW = GNUNET_BIO_write_open (fileName);
-  GNUNET_assert (NULL != fileW);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open(fileName);
+  GNUNET_assert(NULL != fileW);
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
+  GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
 
-  fileR = GNUNET_BIO_read_open (fileName);
-  GNUNET_assert (NULL != fileR);
+  fileR = GNUNET_BIO_read_open(fileName);
+  GNUNET_assert(NULL != fileR);
   metaDataR = NULL;
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
-                                            &metaDataR));
+  GNUNET_assert(GNUNET_SYSERR ==
+                GNUNET_BIO_read_meta_data(fileR, "Read meta error",
+                                          &metaDataR));
   msg = NULL;
-  GNUNET_BIO_read_close (fileR, &msg);
-  GNUNET_free (msg);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-  GNUNET_assert (NULL == metaDataR);
-  GNUNET_free (fileName);
+  GNUNET_BIO_read_close(fileR, &msg);
+  GNUNET_free(msg);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
+  GNUNET_assert(NULL == metaDataR);
+  GNUNET_free(fileName);
   return 0;
 }
 
 static int
-check_string_rw ()
+check_string_rw()
 {
-  GNUNET_assert (0 == test_nullstring_rw ());
-  GNUNET_assert (0 == test_emptystring_rw ());
-  GNUNET_assert (0 == test_bigstring_rw ());
-  GNUNET_assert (0 == test_fakestring_rw ());
+  GNUNET_assert(0 == test_nullstring_rw());
+  GNUNET_assert(0 == test_emptystring_rw());
+  GNUNET_assert(0 == test_bigstring_rw());
+  GNUNET_assert(0 == test_fakestring_rw());
   return 0;
 }
 
 static int
-check_metadata_rw ()
+check_metadata_rw()
 {
-  GNUNET_assert (0 == test_fakebigmeta_rw ());
-  GNUNET_assert (0 == test_fakemeta_rw ());
-  GNUNET_assert (0 == test_bigmeta_rw ());
+  GNUNET_assert(0 == test_fakebigmeta_rw());
+  GNUNET_assert(0 == test_fakemeta_rw());
+  GNUNET_assert(0 == test_bigmeta_rw());
   return 0;
 }
 
 static int
-check_file_rw ()
+check_file_rw()
 {
-  GNUNET_assert (0 == test_normal_rw ());
-  GNUNET_assert (0 == test_nullfile_rw ());
-  GNUNET_assert (0 == test_fullfile_rw ());
-  GNUNET_assert (0 == test_directory_r ());
+  GNUNET_assert(0 == test_normal_rw());
+  GNUNET_assert(0 == test_nullfile_rw());
+  GNUNET_assert(0 == test_fullfile_rw());
+  GNUNET_assert(0 == test_directory_r());
   return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-bio", "WARNING", NULL);
-  GNUNET_assert (0 == check_file_rw ());
-  GNUNET_assert (0 == check_metadata_rw ());
-  GNUNET_assert (0 == check_string_rw ());
+  GNUNET_log_setup("test-bio", "WARNING", NULL);
+  GNUNET_assert(0 == check_file_rw());
+  GNUNET_assert(0 == check_metadata_rw());
+  GNUNET_assert(0 == check_string_rw());
   return 0;
 }
 
diff --git a/src/util/test_client.c b/src/util/test_client.c
index 365b8663f..b49fbcd25 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.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 util/test_client.c
  * @brief tests for client.c
@@ -36,31 +36,31 @@ static struct GNUNET_MQ_Handle *client_mq;
  * Callback that just bounces the message back to the sender.
  */
 static void
-handle_echo (void *cls,
-             const struct GNUNET_MessageHeader *message)
+handle_echo(void *cls,
+            const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *c = cls;
-  struct GNUNET_MQ_Handle *mq = GNUNET_SERVICE_client_get_mq (c);
+  struct GNUNET_MQ_Handle *mq = GNUNET_SERVICE_client_get_mq(c);
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving message from client, bouncing back\n");
-  env = GNUNET_MQ_msg_copy (message);
-  GNUNET_MQ_send (mq,
-                  env);
-  GNUNET_SERVICE_client_continue (c);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving message from client, bouncing back\n");
+  env = GNUNET_MQ_msg_copy(message);
+  GNUNET_MQ_send(mq,
+                 env);
+  GNUNET_SERVICE_client_continue(c);
 }
 
 
 static void
-handle_bounce (void *cls,
-               const struct GNUNET_MessageHeader *got)
+handle_bounce(void *cls,
+              const struct GNUNET_MessageHeader *got)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving bounce, checking content\n");
-  GNUNET_assert (NULL != got);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving bounce, checking content\n");
+  GNUNET_assert(NULL != got);
   global_ret = 2;
-  GNUNET_MQ_destroy (client_mq);
+  GNUNET_MQ_destroy(client_mq);
   client_mq = NULL;
 }
 
@@ -74,45 +74,45 @@ handle_bounce (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)
 {
-  GNUNET_assert (0); /* should never happen */
+  GNUNET_assert(0);  /* should never happen */
 }
 
 
 static void
-task (void *cls,
-      const struct GNUNET_CONFIGURATION_Handle *cfg,
-      struct GNUNET_SERVICE_Handle *sh)
+task(void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_SERVICE_Handle *sh)
 {
   struct GNUNET_MQ_MessageHandler chandlers[] = {
-    GNUNET_MQ_hd_fixed_size (bounce,
-                             MY_TYPE,
-                             struct GNUNET_MessageHeader,
-                             cls),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_fixed_size(bounce,
+                            MY_TYPE,
+                            struct GNUNET_MessageHeader,
+                            cls),
+    GNUNET_MQ_handler_end()
   };
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
   /* test that ill-configured client fails instantly */
-  GNUNET_assert (NULL ==
-                 GNUNET_CLIENT_connect (cfg,
-                                        "invalid-service",
-                                        NULL,
-                                        &mq_error_handler,
-                                        NULL));
-  client_mq = GNUNET_CLIENT_connect (cfg,
-                                     "test_client",
-                                     chandlers,
-                                     &mq_error_handler,
-                                     NULL);
-  GNUNET_assert (NULL != client_mq);
-  env = GNUNET_MQ_msg (msg,
-                       MY_TYPE);
-  GNUNET_MQ_send (client_mq,
-                  env);
+  GNUNET_assert(NULL ==
+                GNUNET_CLIENT_connect(cfg,
+                                      "invalid-service",
+                                      NULL,
+                                      &mq_error_handler,
+                                      NULL));
+  client_mq = GNUNET_CLIENT_connect(cfg,
+                                    "test_client",
+                                    chandlers,
+                                    &mq_error_handler,
+                                    NULL);
+  GNUNET_assert(NULL != client_mq);
+  env = GNUNET_MQ_msg(msg,
+                      MY_TYPE);
+  GNUNET_MQ_send(client_mq,
+                 env);
 }
 
 
@@ -125,9 +125,9 @@ task (void *cls,
  * @return @a c
  */
 static void *
-connect_cb (void *cls,
-            struct GNUNET_SERVICE_Client *c,
-            struct GNUNET_MQ_Handle *mq)
+connect_cb(void *cls,
+           struct GNUNET_SERVICE_Client *c,
+           struct GNUNET_MQ_Handle *mq)
 {
   return c;
 }
@@ -139,55 +139,55 @@ connect_cb (void *cls,
  * @param cls our service name
  * @param c disconnecting client
  * @param internal_cls must match @a c
- */ 
+ */
 static void
-disconnect_cb (void *cls,
-               struct GNUNET_SERVICE_Client *c,
-               void *internal_cls)
+disconnect_cb(void *cls,
+              struct GNUNET_SERVICE_Client *c,
+              void *internal_cls)
 {
   if (2 == global_ret)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    global_ret = 0;
-  }
+    {
+      GNUNET_SCHEDULER_shutdown();
+      global_ret = 0;
+    }
 }
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   struct GNUNET_MQ_MessageHandler shandlers[] = {
-    GNUNET_MQ_hd_fixed_size (echo,
-                             MY_TYPE,
-                             struct GNUNET_MessageHeader,
-                             NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_fixed_size(echo,
+                            MY_TYPE,
+                            struct GNUNET_MessageHeader,
+                            NULL),
+    GNUNET_MQ_handler_end()
   };
   char * test_argv[] = {
-    (char *) "test_client",
+    (char *)"test_client",
     "-c",
     "test_client_data.conf",
     NULL
   };
 
-  GNUNET_log_setup ("test_client",
-                    "WARNING",
-                    NULL);
-  if (0 != strstr (argv[0],
-                   "unix"))
+  GNUNET_log_setup("test_client",
+                   "WARNING",
+                   NULL);
+  if (0 != strstr(argv[0],
+                  "unix"))
     test_argv[2] = "test_client_unix.conf";
   global_ret = 1;
   if (0 !=
-      GNUNET_SERVICE_run_ (3,
-                           test_argv,
-                           "test_client",
-                           GNUNET_SERVICE_OPTION_NONE,
-                           &task,
-                           &connect_cb,
-                           &disconnect_cb,
-                           NULL,
-                           shandlers))
+      GNUNET_SERVICE_run_(3,
+                          test_argv,
+                          "test_client",
+                          GNUNET_SERVICE_OPTION_NONE,
+                          &task,
+                          &connect_cb,
+                          &disconnect_cb,
+                          NULL,
+                          shandlers))
     global_ret = 3;
   return global_ret;
 }
diff --git a/src/util/test_common_allocation.c b/src/util/test_common_allocation.c
index fcc453d6b..e67360044 100644
--- a/src/util/test_common_allocation.c
+++ b/src/util/test_common_allocation.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 util/test_common_allocation.c
@@ -27,7 +27,7 @@
 
 
 static int
-check ()
+check()
 {
 #define MAX_TESTVAL 1024
   char *ptrs[MAX_TESTVAL];
@@ -41,112 +41,112 @@ check ()
   /* GNUNET_malloc/GNUNET_free test */
   k = 352;                      /* random start value */
   for (i = 1; i < MAX_TESTVAL; i++)
-  {
-    ptrs[i] = GNUNET_malloc (i);
-    for (j = 0; j < i; j++)
-      ptrs[i][j] = k++;
-  }
+    {
+      ptrs[i] = GNUNET_malloc(i);
+      for (j = 0; j < i; j++)
+        ptrs[i][j] = k++;
+    }
 
   for (i = MAX_TESTVAL - 1; i >= 1; i--)
-  {
-    for (j = i - 1; j >= 0; j--)
-      if (ptrs[i][j] != (char) --k)
-        return 1;
-    GNUNET_free (ptrs[i]);
-  }
+    {
+      for (j = i - 1; j >= 0; j--)
+        if (ptrs[i][j] != (char)--k)
+          return 1;
+      GNUNET_free(ptrs[i]);
+    }
 
   /* GNUNET_free_non_null test */
-  GNUNET_free_non_null (NULL);
-  GNUNET_free_non_null (GNUNET_malloc (4));
+  GNUNET_free_non_null(NULL);
+  GNUNET_free_non_null(GNUNET_malloc(4));
 
   /* GNUNET_strdup tests */
-  ptrs[0] = GNUNET_strdup ("bar");
-  if (0 != strcmp (ptrs[0], "bar"))
+  ptrs[0] = GNUNET_strdup("bar");
+  if (0 != strcmp(ptrs[0], "bar"))
     return 3;
   /* now realloc */
-  ptrs[0] = GNUNET_realloc (ptrs[0], 12);
-  strcpy (ptrs[0], "Hello World");
+  ptrs[0] = GNUNET_realloc(ptrs[0], 12);
+  strcpy(ptrs[0], "Hello World");
 
-  GNUNET_free (ptrs[0]);
-  GNUNET_asprintf (&ptrs[0], "%s %s", "Hello", "World");
-  GNUNET_assert (strlen (ptrs[0]) == 11);
-  GNUNET_free (ptrs[0]);
+  GNUNET_free(ptrs[0]);
+  GNUNET_asprintf(&ptrs[0], "%s %s", "Hello", "World");
+  GNUNET_assert(strlen(ptrs[0]) == 11);
+  GNUNET_free(ptrs[0]);
 
   /* GNUNET_array_grow tests */
   ptrs[0] = NULL;
   ui = 0;
-  GNUNET_array_grow (ptrs[0], ui, 42);
+  GNUNET_array_grow(ptrs[0], ui, 42);
   if (ui != 42)
     return 4;
-  GNUNET_array_grow (ptrs[0], ui, 22);
+  GNUNET_array_grow(ptrs[0], ui, 22);
   if (ui != 22)
     return 5;
   for (j = 0; j < 22; j++)
     ptrs[0][j] = j;
-  GNUNET_array_grow (ptrs[0], ui, 32);
+  GNUNET_array_grow(ptrs[0], ui, 32);
   for (j = 0; j < 22; j++)
     if (ptrs[0][j] != j)
       return 6;
   for (j = 22; j < 32; j++)
     if (ptrs[0][j] != 0)
       return 7;
-  GNUNET_array_grow (ptrs[0], ui, 0);
+  GNUNET_array_grow(ptrs[0], ui, 0);
   if (i != 0)
     return 8;
   if (ptrs[0] != NULL)
     return 9;
 
   /* GNUNET_new_array_2d tests */
-  a2 = GNUNET_new_array_2d (17, 22, unsigned int);
+  a2 = GNUNET_new_array_2d(17, 22, unsigned int);
   for (i = 0; i < 17; i++)
-  {
-    for (j = 0; j < 22; j++)
     {
-      if (0 != a2[i][j])
-      {
-        GNUNET_free (a2);
-        return 10;
-      }
-      a2[i][j] = i * 100 + j;
+      for (j = 0; j < 22; j++)
+        {
+          if (0 != a2[i][j])
+            {
+              GNUNET_free(a2);
+              return 10;
+            }
+          a2[i][j] = i * 100 + j;
+        }
     }
-  }
-  GNUNET_free (a2);
+  GNUNET_free(a2);
 
   /* GNUNET_new_array_3d tests */
-  a3 = GNUNET_new_array_3d (2, 3, 4, char);
+  a3 = GNUNET_new_array_3d(2, 3, 4, char);
   for (i = 0; i < 2; i++)
-  {
-    for (j = 0; j < 3; j++)
     {
-      for (k = 0; k < 4; k++)
-      {
-        if (0 != a3[i][j][k])
+      for (j = 0; j < 3; j++)
         {
-          GNUNET_free (a3);
-          return 11;
+          for (k = 0; k < 4; k++)
+            {
+              if (0 != a3[i][j][k])
+                {
+                  GNUNET_free(a3);
+                  return 11;
+                }
+              a3[i][j][k] = i * 100 + j * 10 + k;
+            }
         }
-        a3[i][j][k] = i * 100 + j * 10 + k;
-      }
     }
-  }
-  GNUNET_free (a3);
+  GNUNET_free(a3);
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ret;
 
-  GNUNET_log_setup ("test-common-allocation",
-                    "WARNING",
-                    NULL);
-  ret = check ();
+  GNUNET_log_setup("test-common-allocation",
+                   "WARNING",
+                   NULL);
+  ret = check();
   if (ret != 0)
-    fprintf (stderr,
-             "ERROR %d.\n",
-             ret);
+    fprintf(stderr,
+            "ERROR %d.\n",
+            ret);
   return ret;
 }
 
diff --git a/src/util/test_common_endian.c b/src/util/test_common_endian.c
index 6e08b4f07..02de4b5c6 100644
--- a/src/util/test_common_endian.c
+++ b/src/util/test_common_endian.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 util/test_common_endian.c
  * @brief testcase for common_endian.c
@@ -27,14 +27,14 @@
 #define CHECK(n) if (n != GNUNET_htonll(GNUNET_ntohll(n))) return 1;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-common-endian", "WARNING", NULL);
-  CHECK (1);
-  CHECK (0x12345678);
-  CHECK (123456789012345LL);
-  if ((0x1234567890ABCDEFLL != GNUNET_htonll (0xEFCDAB9078563412LL)) &&
-      42 != htonl (42))
+  GNUNET_log_setup("test-common-endian", "WARNING", NULL);
+  CHECK(1);
+  CHECK(0x12345678);
+  CHECK(123456789012345LL);
+  if ((0x1234567890ABCDEFLL != GNUNET_htonll(0xEFCDAB9078563412LL)) &&
+      42 != htonl(42))
     return 1;
   return 0;
 }
diff --git a/src/util/test_common_logging.c b/src/util/test_common_logging.c
index 6ae50b36b..8492d3c35 100644
--- a/src/util/test_common_logging.c
+++ b/src/util/test_common_logging.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 util/test_common_logging.c
@@ -27,8 +27,8 @@
 #include "gnunet_util_lib.h"
 
 static void
-my_log (void *ctx, enum GNUNET_ErrorType kind, const char *component,
-        const char *date, const char *msg)
+my_log(void *ctx, enum GNUNET_ErrorType kind, const char *component,
+       const char *date, const char *msg)
 {
   unsigned int *c = ctx;
 
@@ -38,61 +38,61 @@ my_log (void *ctx, enum GNUNET_ErrorType kind, const char *component,
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   unsigned int failureCount = 0;
   unsigned int logs = 0;
 
-  if (0 != putenv ("GNUNET_FORCE_LOG="))
-    fprintf (stderr, "Failed to putenv: %s\n", strerror (errno));
-  GNUNET_log_setup ("test-common-logging", "DEBUG", "/dev/null");
-  GNUNET_logger_add (&my_log, &logs);
-  GNUNET_logger_add (&my_log, &logs);
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
-  GNUNET_logger_remove (&my_log, &logs);
-  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Flusher...\n");
+  if (0 != putenv("GNUNET_FORCE_LOG="))
+    fprintf(stderr, "Failed to putenv: %s\n", strerror(errno));
+  GNUNET_log_setup("test-common-logging", "DEBUG", "/dev/null");
+  GNUNET_logger_add(&my_log, &logs);
+  GNUNET_logger_add(&my_log, &logs);
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_logger_remove(&my_log, &logs);
+  GNUNET_log(GNUNET_ERROR_TYPE_BULK, "Flusher...\n");
   /* the last 6 calls should be merged (repated bulk messages!) */
-  GNUNET_logger_remove (&my_log, &logs);
+  GNUNET_logger_remove(&my_log, &logs);
   if (logs != 4)
-  {
-    fprintf (stdout, "Expected 4 log calls, got %u\n", logs);
-    failureCount++;
-  }
-  GNUNET_break (0 ==
-                strcmp (_("ERROR"),
-                        GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_ERROR)));
-  GNUNET_break (0 ==
-                strcmp (_("WARNING"),
-                        GNUNET_error_type_to_string
+    {
+      fprintf(stdout, "Expected 4 log calls, got %u\n", logs);
+      failureCount++;
+    }
+  GNUNET_break(0 ==
+               strcmp(_("ERROR"),
+                      GNUNET_error_type_to_string(GNUNET_ERROR_TYPE_ERROR)));
+  GNUNET_break(0 ==
+               strcmp(_("WARNING"),
+                      GNUNET_error_type_to_string
                         (GNUNET_ERROR_TYPE_WARNING)));
-  GNUNET_break (0 ==
-                strcmp (_("INFO"),
-                        GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_INFO)));
-  GNUNET_break (0 ==
-                strcmp (_("DEBUG"),
-                        GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG)));
-  GNUNET_log_setup ("test_common_logging", "WARNING", "/dev/null");
+  GNUNET_break(0 ==
+               strcmp(_("INFO"),
+                      GNUNET_error_type_to_string(GNUNET_ERROR_TYPE_INFO)));
+  GNUNET_break(0 ==
+               strcmp(_("DEBUG"),
+                      GNUNET_error_type_to_string(GNUNET_ERROR_TYPE_DEBUG)));
+  GNUNET_log_setup("test_common_logging", "WARNING", "/dev/null");
   logs = 0;
-  GNUNET_logger_add (&my_log, &logs);
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Checker...\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Drop me...\n");
-  GNUNET_logger_remove (&my_log, &logs);
+  GNUNET_logger_add(&my_log, &logs);
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Checker...\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Drop me...\n");
+  GNUNET_logger_remove(&my_log, &logs);
   if (logs != 1)
-  {
-    fprintf (stdout, "Expected 1 log call, got %u\n", logs);
-    failureCount++;
-  }
+    {
+      fprintf(stdout, "Expected 1 log call, got %u\n", logs);
+      failureCount++;
+    }
 
   if (failureCount != 0)
-  {
-    fprintf (stdout, "%u TESTS FAILED!\n", failureCount);
-    return -1;
-  }
+    {
+      fprintf(stdout, "%u TESTS FAILED!\n", failureCount);
+      return -1;
+    }
   return 0;
 }                               /* end of main */
 
diff --git a/src/util/test_common_logging_dummy.c b/src/util/test_common_logging_dummy.c
index d3c6e3452..dc80eeccd 100644
--- a/src/util/test_common_logging_dummy.c
+++ b/src/util/test_common_logging_dummy.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 util/test_common_logging_dummy.c
@@ -36,31 +36,31 @@
  * on a slow machine for a non-skipped one.
  */
 #define OUTPUT_DELAY \
-  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 1000)
+  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 1000)
 
 static void
-my_log (void *ctx,
-        enum GNUNET_ErrorType kind,
-        const char *component,
-        const char *date,
-        const char *msg)
+my_log(void *ctx,
+       enum GNUNET_ErrorType kind,
+       const char *component,
+       const char *date,
+       const char *msg)
 {
-  (void) ctx;
-  (void) kind;
-  (void) component;
-  (void) date;
-  if (strncmp ("test-common-logging-dummy", component, 25) != 0)
+  (void)ctx;
+  (void)kind;
+  (void)component;
+  (void)date;
+  if (strncmp("test-common-logging-dummy", component, 25) != 0)
     return;
-  fprintf (stdout, "%s", msg);
-  fflush (stdout);
+  fprintf(stdout, "%s", msg);
+  fflush(stdout);
 }
 
 
-#if ! defined(GNUNET_CULL_LOGGING)
+#if !defined(GNUNET_CULL_LOGGING)
 static int
-expensive_func ()
+expensive_func()
 {
-  return GNUNET_NETWORK_socket_select (NULL, NULL, NULL, OUTPUT_DELAY);
+  return GNUNET_NETWORK_socket_select(NULL, NULL, NULL, OUTPUT_DELAY);
 }
 #endif
 
@@ -68,51 +68,51 @@ expensive_func ()
 #define pr(kind, lvl)                                                         \
   {                                                                           \
     struct GNUNET_TIME_Absolute t1, t2;                                       \
-    t1 = GNUNET_TIME_absolute_get ();                                         \
-    GNUNET_log (kind, "L%s %d\n", lvl, expensive_func ());                    \
-    t2 = GNUNET_TIME_absolute_get ();                                         \
-    printf ("1%s %llu\n",                                                     \
-            lvl,                                                              \
-            (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2) \
-              .rel_value_us);                                                 \
+    t1 = GNUNET_TIME_absolute_get();                                         \
+    GNUNET_log(kind, "L%s %d\n", lvl, expensive_func());                    \
+    t2 = GNUNET_TIME_absolute_get();                                         \
+    printf("1%s %llu\n",                                                     \
+           lvl,                                                              \
+           (unsigned long long)GNUNET_TIME_absolute_get_difference(t1, t2) \
+           .rel_value_us);                                                 \
   }
 
 #define pr2(kind, lvl)                                                        \
   {                                                                           \
     struct GNUNET_TIME_Absolute t1, t2;                                       \
-    t1 = GNUNET_TIME_absolute_get ();                                         \
-    GNUNET_log (kind, "L%s %d\n", lvl, expensive_func ());                    \
-    t2 = GNUNET_TIME_absolute_get ();                                         \
-    printf ("2%s %llu\n",                                                     \
-            lvl,                                                              \
-            (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2) \
-              .rel_value_us);                                                 \
+    t1 = GNUNET_TIME_absolute_get();                                         \
+    GNUNET_log(kind, "L%s %d\n", lvl, expensive_func());                    \
+    t2 = GNUNET_TIME_absolute_get();                                         \
+    printf("2%s %llu\n",                                                     \
+           lvl,                                                              \
+           (unsigned long long)GNUNET_TIME_absolute_get_difference(t1, t2) \
+           .rel_value_us);                                                 \
   }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  (void) argc;
-  (void) argv;
+  (void)argc;
+  (void)argv;
   /* We set up logging with NULL level - will be overrided by
    * GNUNET_LOG or GNUNET_FORCE_LOG at runtime.
    */
-  GNUNET_log_setup ("test-common-logging-dummy", NULL, "/dev/null");
-  GNUNET_logger_add (&my_log, NULL);
-  pr (GNUNET_ERROR_TYPE_ERROR, "ERROR");
-  pr (GNUNET_ERROR_TYPE_WARNING, "WARNING");
-  pr (GNUNET_ERROR_TYPE_INFO, "INFO");
-  pr (GNUNET_ERROR_TYPE_DEBUG, "DEBUG");
+  GNUNET_log_setup("test-common-logging-dummy", NULL, "/dev/null");
+  GNUNET_logger_add(&my_log, NULL);
+  pr(GNUNET_ERROR_TYPE_ERROR, "ERROR");
+  pr(GNUNET_ERROR_TYPE_WARNING, "WARNING");
+  pr(GNUNET_ERROR_TYPE_INFO, "INFO");
+  pr(GNUNET_ERROR_TYPE_DEBUG, "DEBUG");
 
   /* We set up logging with WARNING level - will onle be overrided by
    * GNUNET_FORCE_LOG at runtime.
    */
-  GNUNET_log_setup ("test-common-logging-dummy", "WARNING", "/dev/null");
-  pr2 (GNUNET_ERROR_TYPE_ERROR, "ERROR");
-  pr2 (GNUNET_ERROR_TYPE_WARNING, "WARNING");
-  pr2 (GNUNET_ERROR_TYPE_INFO, "INFO");
-  pr2 (GNUNET_ERROR_TYPE_DEBUG, "DEBUG");
+  GNUNET_log_setup("test-common-logging-dummy", "WARNING", "/dev/null");
+  pr2(GNUNET_ERROR_TYPE_ERROR, "ERROR");
+  pr2(GNUNET_ERROR_TYPE_WARNING, "WARNING");
+  pr2(GNUNET_ERROR_TYPE_INFO, "INFO");
+  pr2(GNUNET_ERROR_TYPE_DEBUG, "DEBUG");
   return 0;
 } /* end of main */
 
diff --git a/src/util/test_common_logging_runtime_loglevels.c b/src/util/test_common_logging_runtime_loglevels.c
index 8da808760..f46776c8f 100644
--- a/src/util/test_common_logging_runtime_loglevels.c
+++ b/src/util/test_common_logging_runtime_loglevels.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 util/test_common_logging_runtime_loglevels.c
@@ -32,13 +32,13 @@
  * How much time the child is allowed to waste on skipped log calls, at most.
  * Raspberry Pi takes 113 microseconds tops, this is 3x that value.
  */
-#define MAX_SKIP_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 400).rel_value_us
+#define MAX_SKIP_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 400).rel_value_us
 
 /**
  * How much time non-skipped log call should take, at least.
  * Keep in sync with the value in the dummy!
  */
-#define OUTPUT_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us
+#define OUTPUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us
 
 static int ok;
 
@@ -54,51 +54,51 @@ static struct GNUNET_SCHEDULER_Task * die_task;
 static struct GNUNET_SCHEDULER_Task * read_task;
 
 static void
-runone (void);
+runone(void);
 
 
 static void
-end_task (void *cls)
+end_task(void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase,
-              ok);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase,
+             ok);
   if (NULL != proc)
-  {
-    if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+      if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+        }
+      GNUNET_OS_process_wait(proc);
+      GNUNET_OS_process_destroy(proc);
+      proc = NULL;
     }
-    GNUNET_OS_process_wait (proc);
-    GNUNET_OS_process_destroy (proc);
-    proc = NULL;
-  }
   if (NULL != read_task)
-  {
-    GNUNET_SCHEDULER_cancel (read_task);
-    read_task = NULL;
-  }
-  GNUNET_DISK_pipe_close (pipe_stdout);
+    {
+      GNUNET_SCHEDULER_cancel(read_task);
+      read_task = NULL;
+    }
+  GNUNET_DISK_pipe_close(pipe_stdout);
   if (ok == 1)
-  {
-    if (phase < 9)
     {
-      phase += 1;
-      runone ();
+      if (phase < 9)
+        {
+          phase += 1;
+          runone();
+        }
+      else
+        ok = 0;
     }
-    else
-      ok = 0;
-  }
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "failing\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "failing\n");
 }
 
 
 static char *
-read_output_line (int phase_from1, int phase_to1, int phase_from2,
-                  int phase_to2, char c, const char *expect_level,
-                  long delay_morethan, long delay_lessthan, int phase,
-                  char *p,
-                  int *len, long *delay, char level[8])
+read_output_line(int phase_from1, int phase_to1, int phase_from2,
+                 int phase_to2, char c, const char *expect_level,
+                 long delay_morethan, long delay_lessthan, int phase,
+                 char *p,
+                 int *len, long *delay, char level[8])
 {
   char *r = p;
   char t[7];
@@ -115,61 +115,63 @@ read_output_line (int phase_from1, int phase_to1, int phase_from2,
       !(phase >= phase_from2 && phase <= phase_to2))
     return p;
 #if 0
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p);
 #endif
   for (i = 0; i < *len && !stop; i++)
-  {
-    switch (stage)
     {
-    case 0:                    /* read first char */
-      if (r[i] != c)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c,
-                    r[i]);
-        GNUNET_break (0);
-        return NULL;
-      }
-      stage += 1;
-      break;
-    case 1:                    /* read at most 7 char-long error level string, finished by ' ' */
-      if (r[i] == ' ')
-      {
-        level[j] = '\0';
-        stage += 1;
-        j = 0;
-      }
-      else if (i == 8)
-      {
-        GNUNET_break (0);
-        ok = 2;
-        return NULL;
-      }
-      else
-        level[j++] = r[i];
-      break;
-    case 2:                    /* read the delay, finished by '\n' */
-      t[j++] = r[i];
+      switch (stage)
+        {
+        case 0:                /* read first char */
+          if (r[i] != c)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c,
+                         r[i]);
+              GNUNET_break(0);
+              return NULL;
+            }
+          stage += 1;
+          break;
+
+        case 1:                /* read at most 7 char-long error level string, finished by ' ' */
+          if (r[i] == ' ')
+            {
+              level[j] = '\0';
+              stage += 1;
+              j = 0;
+            }
+          else if (i == 8)
+            {
+              GNUNET_break(0);
+              ok = 2;
+              return NULL;
+            }
+          else
+            level[j++] = r[i];
+          break;
+
+        case 2:                /* read the delay, finished by '\n' */
+          t[j++] = r[i];
 #if WINDOWS
-      if (r[i] == '\r' && r[i + 1] == '\n')
-      {
-        i += 1;
-        t[j - 1] = '\0';
-        *delay = strtol (t, NULL, 10);
-        stop = 1;
-      }
+          if (r[i] == '\r' && r[i + 1] == '\n')
+            {
+              i += 1;
+              t[j - 1] = '\0';
+              *delay = strtol(t, NULL, 10);
+              stop = 1;
+            }
 #else
-      if (r[i] == '\n')
-      {
-        t[j - 1] = '\0';
-        *delay = strtol (t, NULL, 10);
-        stop = 1;
-      }
+          if (r[i] == '\n')
+            {
+              t[j - 1] = '\0';
+              *delay = strtol(t, NULL, 10);
+              stop = 1;
+            }
 #endif
-      break;
+          break;
+        }
     }
-  }
-  level_matches = (strcmp (expect_level, level) == 0);
+  level_matches = (strcmp(expect_level, level) == 0);
   delay_is_sane = (*delay >= 0) && (*delay <= 1000000);
   delay_is_a_dummy = (c == 'L');
   /* Delay must be either less than 'lessthan' (log call is skipped)
@@ -179,22 +181,22 @@ read_output_line (int phase_from1, int phase_to1, int phase_from2,
   if (delay_is_a_dummy)
     delay_outside_of_range = 1;
 
-  if (! stop)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Wrong log format?\n");
-  if (! level_matches)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Wrong log level\n");
-  if (! delay_is_sane)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Delay %ld is insane\n",
-                *delay);
-  if (! delay_outside_of_range)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Delay %ld is not outside of range (%ld ; %ld)\n",
-                *delay,
-                delay_lessthan,
-                delay_morethan);
+  if (!stop)
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Wrong log format?\n");
+  if (!level_matches)
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Wrong log level\n");
+  if (!delay_is_sane)
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Delay %ld is insane\n",
+               *delay);
+  if (!delay_outside_of_range)
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Delay %ld is not outside of range (%ld ; %ld)\n",
+               *delay,
+               delay_lessthan,
+               delay_morethan);
   if (!stop || !level_matches || !delay_is_sane || !delay_outside_of_range)
     return NULL;
   *len = *len - i;
@@ -221,7 +223,7 @@ static int bytes;
 
 
 static void
-read_call (void *cls)
+read_call(void *cls)
 {
   const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls;
   char level[8];
@@ -230,24 +232,24 @@ read_call (void *cls)
   int rd;
 
   read_task = NULL;
-  rd = GNUNET_DISK_file_read (stdout_read_handle, buf_ptr,
-                              sizeof (buf) - bytes);
+  rd = GNUNET_DISK_file_read(stdout_read_handle, buf_ptr,
+                             sizeof(buf) - bytes);
   if (rd > 0)
-  {
-    buf_ptr += rd;
-    bytes += rd;
+    {
+      buf_ptr += rd;
+      bytes += rd;
 #if VERBOSE
-    fprintf (stderr, "got %d bytes, reading more\n", rd);
+      fprintf(stderr, "got %d bytes, reading more\n", rd);
 #endif
-    read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                stdout_read_handle,
-                                                &read_call,
-                                                (void*) stdout_read_handle);
-    return;
-  }
+      read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 stdout_read_handle,
+                                                 &read_call,
+                                                 (void*)stdout_read_handle);
+      return;
+    }
 
 #if VERBOSE
-  fprintf (stderr, "bytes is %d:%s\n", bytes, buf);
+  fprintf(stderr, "bytes is %d:%s\n", bytes, buf);
 #endif
 
   /* +------CHILD OUTPUT--
@@ -269,186 +271,195 @@ read_call (void *cls)
 
   if (bytes == LOG_BUFFER_SIZE ||
       !(p =
-        read_output_line (0, 3, 4, 9, 'L', "ERROR", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(0, 3, 4, 9, 'L', "ERROR", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[0], level)) ||
+          read_output_line(0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[0], level)) ||
       !(p =
-        read_output_line (1, 3, 5, 9, 'L', "WARNING", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(1, 3, 5, 9, 'L', "WARNING", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[1], level)) ||
+          read_output_line(0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[1], level)) ||
       !(p =
-        read_output_line (2, 3, 6, 7, 'L', "INFO", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(2, 3, 6, 7, 'L', "INFO", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[2], level)) ||
+          read_output_line(0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[2], level)) ||
       !(p =
-        read_output_line (3, 3, 7, 7, 'L', "DEBUG", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(3, 3, 7, 7, 'L', "DEBUG", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[3], level)) ||
+          read_output_line(0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[3], level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, 'L', "ERROR", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(0, 3, 4, 9, 'L', "ERROR", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[4], level)) ||
+          read_output_line(0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[4], level)) ||
       !(p =
-        read_output_line (0, 3, 5, 9, 'L', "WARNING", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(0, 3, 5, 9, 'L', "WARNING", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[5], level)) ||
+          read_output_line(0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[5], level)) ||
       !(p =
-        read_output_line (-1, -1, 6, 7, 'L', "INFO", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(-1, -1, 6, 7, 'L', "INFO", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[6], level)) ||
+          read_output_line(0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[6], level)) ||
       !(p =
-        read_output_line (-1, -1, 7, 7, 'L', "DEBUG", -1,
-                          1, phase, p,
-                          &bytes, &delay, level)) ||
+          read_output_line(-1, -1, 7, 7, 'L', "DEBUG", -1,
+                           1, phase, p,
+                           &bytes, &delay, level)) ||
       !(p =
-        read_output_line (0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY,
-                          MAX_SKIP_DELAY, phase, p,
-                          &bytes, &delays[7], level)))
-  {
-    if (bytes == LOG_BUFFER_SIZE)
-      fprintf (stderr, "%s",  "Ran out of buffer space!\n");
-    GNUNET_break (0);
-    ok = 2;
-    GNUNET_SCHEDULER_cancel (die_task);
-    GNUNET_SCHEDULER_add_now (&end_task, NULL);
-    return;
-  }
-
-  GNUNET_SCHEDULER_cancel (die_task);
-  GNUNET_SCHEDULER_add_now (&end_task, NULL);
+          read_output_line(0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY,
+                           MAX_SKIP_DELAY, phase, p,
+                           &bytes, &delays[7], level)))
+    {
+      if (bytes == LOG_BUFFER_SIZE)
+        fprintf(stderr, "%s", "Ran out of buffer space!\n");
+      GNUNET_break(0);
+      ok = 2;
+      GNUNET_SCHEDULER_cancel(die_task);
+      GNUNET_SCHEDULER_add_now(&end_task, NULL);
+      return;
+    }
+
+  GNUNET_SCHEDULER_cancel(die_task);
+  GNUNET_SCHEDULER_add_now(&end_task, NULL);
 }
 
 
 static void
-runone ()
+runone()
 {
   const struct GNUNET_DISK_FileHandle *stdout_read_handle;
 
-  pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
 
   if (pipe_stdout == NULL)
-  {
-    GNUNET_break (0);
-    ok = 2;
-    return;
-  }
-
-  putenv ("GNUNET_LOG=");
-  putenv ("GNUNET_FORCE_LOG=");
-  putenv ("GNUNET_FORCE_LOGFILE=");
+    {
+      GNUNET_break(0);
+      ok = 2;
+      return;
+    }
+
+  putenv("GNUNET_LOG=");
+  putenv("GNUNET_FORCE_LOG=");
+  putenv("GNUNET_FORCE_LOGFILE=");
   switch (phase)
-  {
-  case 0:
-    putenv ("GNUNET_LOG=;;;;ERROR");
-    break;
-  case 1:
-    putenv ("GNUNET_LOG=;;;;WARNING");
-    break;
-  case 2:
-    putenv ("GNUNET_LOG=;;;;INFO");
-    break;
-  case 3:
-    putenv ("GNUNET_LOG=;;;;DEBUG");
-    break;
-  case 4:
-    putenv ("GNUNET_FORCE_LOG=;;;;ERROR");
-    break;
-  case 5:
-    putenv ("GNUNET_FORCE_LOG=;;;;WARNING");
-    break;
-  case 6:
-    putenv ("GNUNET_FORCE_LOG=;;;;INFO");
-    break;
-  case 7:
-    putenv ("GNUNET_FORCE_LOG=;;;;DEBUG");
-    break;
-  case 8:
-    putenv ("GNUNET_LOG=blah;;;;ERROR");
-    break;
-  case 9:
-    putenv ("GNUNET_FORCE_LOG=blah;;;;ERROR");
-    break;
-  }
-
-  proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                  NULL, pipe_stdout, NULL,
+    {
+    case 0:
+      putenv("GNUNET_LOG=;;;;ERROR");
+      break;
+
+    case 1:
+      putenv("GNUNET_LOG=;;;;WARNING");
+      break;
+
+    case 2:
+      putenv("GNUNET_LOG=;;;;INFO");
+      break;
+
+    case 3:
+      putenv("GNUNET_LOG=;;;;DEBUG");
+      break;
+
+    case 4:
+      putenv("GNUNET_FORCE_LOG=;;;;ERROR");
+      break;
+
+    case 5:
+      putenv("GNUNET_FORCE_LOG=;;;;WARNING");
+      break;
+
+    case 6:
+      putenv("GNUNET_FORCE_LOG=;;;;INFO");
+      break;
+
+    case 7:
+      putenv("GNUNET_FORCE_LOG=;;;;DEBUG");
+      break;
+
+    case 8:
+      putenv("GNUNET_LOG=blah;;;;ERROR");
+      break;
+
+    case 9:
+      putenv("GNUNET_FORCE_LOG=blah;;;;ERROR");
+      break;
+    }
+
+  proc = GNUNET_OS_start_process(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                 NULL, pipe_stdout, NULL,
 #if MINGW
-                                  "test_common_logging_dummy",
+                                 "test_common_logging_dummy",
 #else
-                                  "./test_common_logging_dummy",
+                                 "./test_common_logging_dummy",
 #endif
-                                  "test_common_logging_dummy", NULL);
-  GNUNET_assert (NULL != proc);
-  putenv ("GNUNET_FORCE_LOG=");
-  putenv ("GNUNET_LOG=");
+                                 "test_common_logging_dummy", NULL);
+  GNUNET_assert(NULL != proc);
+  putenv("GNUNET_FORCE_LOG=");
+  putenv("GNUNET_LOG=");
 
   /* Close the write end of the read pipe */
-  GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_DISK_pipe_close_end(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
 
   stdout_read_handle =
-      GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ);
+    GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_READ);
 
   die_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_SECONDS, 10),
-                                    &end_task,
-                                    NULL);
+    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_SECONDS, 10),
+                                 &end_task,
+                                 NULL);
 
   bytes = 0;
   buf_ptr = buf;
-  memset (&buf, 0, sizeof (buf));
+  memset(&buf, 0, sizeof(buf));
 
-  read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              stdout_read_handle,
-                                              &read_call,
-                                              (void*) stdout_read_handle);
+  read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                             stdout_read_handle,
+                                             &read_call,
+                                             (void*)stdout_read_handle);
 }
 
 
 static void
-task (void *cls)
+task(void *cls)
 {
   phase = 0;
-  runone ();
+  runone();
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-common-logging-runtime-loglevels",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("test-common-logging-runtime-loglevels",
+                   "WARNING",
+                   NULL);
   ok = 1;
-  GNUNET_SCHEDULER_run (&task, &ok);
+  GNUNET_SCHEDULER_run(&task, &ok);
   return ok;
 }
 
diff --git a/src/util/test_configuration.c b/src/util/test_configuration.c
index 67e532f40..71a1ae5bd 100644
--- a/src/util/test_configuration.c
+++ b/src/util/test_configuration.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 util/test_configuration.c
  * @brief Test that the configuration module works.
@@ -28,8 +28,7 @@
 
 
 /* Test Configuration Diffs Options */
-enum
-{
+enum {
   EDIT_NOTHING,
   EDIT_SECTION,
   EDIT_ALL,
@@ -44,8 +43,7 @@ enum
 static struct GNUNET_CONFIGURATION_Handle *cfg;
 static struct GNUNET_CONFIGURATION_Handle *cfg_default;
 
-struct DiffsCBData
-{
+struct DiffsCBData {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CONFIGURATION_Handle *cfgDiffs;
   const char *section;
@@ -55,7 +53,7 @@ struct DiffsCBData
 
 
 static void
-initDiffsCBData (struct DiffsCBData *cbData)
+initDiffsCBData(struct DiffsCBData *cbData)
 {
   cbData->section = NULL;
   cbData->cfg = NULL;
@@ -68,129 +66,138 @@ initDiffsCBData (struct DiffsCBData *cbData)
 /**
  * callback function for modifying
  * and comparing configuration
-*/
+ */
 static void
-diffsCallBack (void *cls, const char *section, const char *option,
-               const char *value)
+diffsCallBack(void *cls, const char *section, const char *option,
+              const char *value)
 {
   struct DiffsCBData *cbData = cls;
   int cbOption = cbData->callBackOption;
 
   switch (cbOption)
-  {
-  case EDIT_SECTION:
-    if (NULL == cbData->section)
-      cbData->section = section;
-    if (strcmp (cbData->section, section) == 0)
-    {
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
-                                             "new-value");
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
-                                             "new-value");
-    }
-    break;
-  case EDIT_ALL:
-    GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
-                                           "new-value");
-    GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
-                                           "new-value");
-    break;
-  case ADD_NEW_ENTRY:
-  {
-    static int hit = 0;
-
-    if (hit == 0)
-    {
-      hit = 1;
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, "new-key",
-                                             "new-value");
-      GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section,
-                                             "new-key", "new-value");
-    }
-    break;
-  }
-  case COMPARE:
-  {
-    int ret;
-    char *diffValue;
-
-    diffValue = NULL;
-    ret =
-        GNUNET_CONFIGURATION_get_value_string (cbData->cfgDiffs, section,
-                                               option, &diffValue);
-    if (NULL != diffValue)
-    {
-      if (ret == GNUNET_SYSERR || strcmp (diffValue, value) != 0)
-        cbData->status = 1;
-    }
-    else
-      cbData->status = 1;
-    GNUNET_free_non_null (diffValue);
-    break;
-  }
-#if 0
-  case PRINT:
-    if (NULL == cbData->section)
     {
-      cbData->section = section;
-      printf ("\nSection: %s\n", section);
+    case EDIT_SECTION:
+      if (NULL == cbData->section)
+        cbData->section = section;
+      if (strcmp(cbData->section, section) == 0)
+        {
+          GNUNET_CONFIGURATION_set_value_string(cbData->cfg, section, option,
+                                                "new-value");
+          GNUNET_CONFIGURATION_set_value_string(cbData->cfgDiffs, section, option,
+                                                "new-value");
+        }
+      break;
+
+    case EDIT_ALL:
+      GNUNET_CONFIGURATION_set_value_string(cbData->cfg, section, option,
+                                            "new-value");
+      GNUNET_CONFIGURATION_set_value_string(cbData->cfgDiffs, section, option,
+                                            "new-value");
+      break;
+
+    case ADD_NEW_ENTRY:
+    {
+      static int hit = 0;
+
+      if (hit == 0)
+        {
+          hit = 1;
+          GNUNET_CONFIGURATION_set_value_string(cbData->cfg, section, "new-key",
+                                                "new-value");
+          GNUNET_CONFIGURATION_set_value_string(cbData->cfgDiffs, section,
+                                                "new-key", "new-value");
+        }
+      break;
     }
-    else if (strcmp (cbData->section, section) != 0)
+
+    case COMPARE:
     {
-      cbData->section = section;
-      printf ("\nSection: %s\n", section);
+      int ret;
+      char *diffValue;
+
+      diffValue = NULL;
+      ret =
+        GNUNET_CONFIGURATION_get_value_string(cbData->cfgDiffs, section,
+                                              option, &diffValue);
+      if (NULL != diffValue)
+        {
+          if (ret == GNUNET_SYSERR || strcmp(diffValue, value) != 0)
+            cbData->status = 1;
+        }
+      else
+        cbData->status = 1;
+      GNUNET_free_non_null(diffValue);
+      break;
     }
-    printf ("%s = %s\n", option, value);
+
+#if 0
+    case PRINT:
+      if (NULL == cbData->section)
+        {
+          cbData->section = section;
+          printf("\nSection: %s\n", section);
+        }
+      else if (strcmp(cbData->section, section) != 0)
+        {
+          cbData->section = section;
+          printf("\nSection: %s\n", section);
+        }
+      printf("%s = %s\n", option, value);
 #endif
-  default:
-    break;
-  }
+    default:
+      break;
+    }
 }
 
 
 static struct GNUNET_CONFIGURATION_Handle *
-editConfiguration (struct GNUNET_CONFIGURATION_Handle *cfg, int option)
+editConfiguration(struct GNUNET_CONFIGURATION_Handle *cfg, int option)
 {
   struct DiffsCBData diffsCB;
 
-  initDiffsCBData (&diffsCB);
-  diffsCB.cfgDiffs = GNUNET_CONFIGURATION_create ();
+  initDiffsCBData(&diffsCB);
+  diffsCB.cfgDiffs = GNUNET_CONFIGURATION_create();
 
   switch (option)
-  {
-  case EDIT_SECTION:
-  case EDIT_ALL:
-  case ADD_NEW_ENTRY:
-    diffsCB.callBackOption = option;
-    diffsCB.cfg = cfg;
-    GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &diffsCB);
-    break;
-  case EDIT_NOTHING:
-    /* Do nothing */
-    break;
-  case ADD_NEW_SECTION:
-  {
-    int i;
-    char *key;
-
-    for (i = 0; i < 5; i++)
-    {
-      GNUNET_asprintf (&key, "key%d", i);
-      GNUNET_CONFIGURATION_set_value_string (cfg, "new-section", key,
-                                             "new-value");
-      GNUNET_CONFIGURATION_set_value_string (diffsCB.cfgDiffs, "new-section",
-                                             key, "new-value");
-      GNUNET_free (key);
-    }
-    break;
-  }
-  case REMOVE_SECTION:
-    break;
-  case REMOVE_ENTRY:
-    break;
-  default:
-    break;
-  }
+    {
+    case EDIT_SECTION:
+    case EDIT_ALL:
+    case ADD_NEW_ENTRY:
+      diffsCB.callBackOption = option;
+      diffsCB.cfg = cfg;
+      GNUNET_CONFIGURATION_iterate(cfg, diffsCallBack, &diffsCB);
+      break;
+
+    case EDIT_NOTHING:
+      /* Do nothing */
+      break;
+
+    case ADD_NEW_SECTION:
+    {
+      int i;
+      char *key;
+
+      for (i = 0; i < 5; i++)
+        {
+          GNUNET_asprintf(&key, "key%d", i);
+          GNUNET_CONFIGURATION_set_value_string(cfg, "new-section", key,
+                                                "new-value");
+          GNUNET_CONFIGURATION_set_value_string(diffsCB.cfgDiffs, "new-section",
+                                                key, "new-value");
+          GNUNET_free(key);
+        }
+      break;
+    }
+
+    case REMOVE_SECTION:
+      break;
+
+    case REMOVE_ENTRY:
+      break;
+
+    default:
+      break;
+    }
 
   return diffsCB.cfgDiffs;
 }
@@ -199,7 +206,7 @@ editConfiguration (struct GNUNET_CONFIGURATION_Handle *cfg, int option)
  * Checking configuration diffs
  */
 static int
-checkDiffs (struct GNUNET_CONFIGURATION_Handle *cfg_default, int option)
+checkDiffs(struct GNUNET_CONFIGURATION_Handle *cfg_default, int option)
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CONFIGURATION_Handle *cfgDiffs;
@@ -207,139 +214,139 @@ checkDiffs (struct GNUNET_CONFIGURATION_Handle *cfg_default, int option)
   int ret;
   char *diffsFileName;
 
-  initDiffsCBData (&cbData);
+  initDiffsCBData(&cbData);
 
-  cfg = GNUNET_CONFIGURATION_create ();
+  cfg = GNUNET_CONFIGURATION_create();
   /* load defaults */
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, NULL));
+  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(cfg, NULL));
 
   /* Modify configuration and save it */
-  cfgDiffs = editConfiguration (cfg, option);
-  diffsFileName = GNUNET_DISK_mktemp ("gnunet-test-configurations-diffs.conf");
+  cfgDiffs = editConfiguration(cfg, option);
+  diffsFileName = GNUNET_DISK_mktemp("gnunet-test-configurations-diffs.conf");
   if (diffsFileName == NULL)
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    GNUNET_CONFIGURATION_destroy (cfgDiffs);
-    return 1;
-  }
-  GNUNET_CONFIGURATION_write_diffs (cfg_default, cfg, diffsFileName);
-  GNUNET_CONFIGURATION_destroy (cfg);
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      GNUNET_CONFIGURATION_destroy(cfgDiffs);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_write_diffs(cfg_default, cfg, diffsFileName);
+  GNUNET_CONFIGURATION_destroy(cfg);
 
   /* Compare the dumped configuration with modifications done */
-  cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, diffsFileName));
-  if (0 != remove (diffsFileName))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "remove", diffsFileName);
+  cfg = GNUNET_CONFIGURATION_create();
+  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_parse(cfg, diffsFileName));
+  if (0 != remove(diffsFileName))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "remove", diffsFileName);
   cbData.callBackOption = COMPARE;
   cbData.cfgDiffs = cfgDiffs;
-  GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
+  GNUNET_CONFIGURATION_iterate(cfg, diffsCallBack, &cbData);
   if (1 == (ret = cbData.status))
-  {
-    fprintf (stderr, "%s",
-             "Incorrect Configuration Diffs: Diffs may contain data not actually edited\n");
-    goto housekeeping;
-  }
+    {
+      fprintf(stderr, "%s",
+              "Incorrect Configuration Diffs: Diffs may contain data not actually edited\n");
+      goto housekeeping;
+    }
   cbData.cfgDiffs = cfg;
-  GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
+  GNUNET_CONFIGURATION_iterate(cfgDiffs, diffsCallBack, &cbData);
   if ((ret = cbData.status) == 1)
-    fprintf (stderr, "%s",
-             "Incorrect Configuration Diffs: Data may be missing in diffs\n");
+    fprintf(stderr, "%s",
+            "Incorrect Configuration Diffs: Data may be missing in diffs\n");
 
 housekeeping:
 #if 0
   cbData.section = NULL;
   cbData.callBackOption = PRINT;
-  printf ("\nExpected Diffs:\n");
-  GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
+  printf("\nExpected Diffs:\n");
+  GNUNET_CONFIGURATION_iterate(cfgDiffs, diffsCallBack, &cbData);
   cbData.section = NULL;
-  printf ("\nActual Diffs:\n");
-  GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
+  printf("\nActual Diffs:\n");
+  GNUNET_CONFIGURATION_iterate(cfg, diffsCallBack, &cbData);
 #endif
-  GNUNET_CONFIGURATION_destroy (cfg);
-  GNUNET_CONFIGURATION_destroy (cfgDiffs);
-  GNUNET_free (diffsFileName);
+  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_CONFIGURATION_destroy(cfgDiffs);
+  GNUNET_free(diffsFileName);
   return ret;
 }
 
 
 static int
-testConfig ()
+testConfig()
 {
   char *c;
   unsigned long long l;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "test", "b", &c))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "test", "b", &c))
     return 1;
-  if (0 != strcmp ("b", c))
-  {
-    fprintf (stderr, "Got `%s'\n", c);
-    GNUNET_free (c);
-    return 2;
-  }
-  GNUNET_free (c);
+  if (0 != strcmp("b", c))
+    {
+      fprintf(stderr, "Got `%s'\n", c);
+      GNUNET_free(c);
+      return 2;
+    }
+  GNUNET_free(c);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (cfg, "test", "five", &l))
-  {
-    GNUNET_break (0);
-    return 3;
-  }
+      GNUNET_CONFIGURATION_get_value_number(cfg, "test", "five", &l))
+    {
+      GNUNET_break(0);
+      return 3;
+    }
   if (5 != l)
-  {
-    GNUNET_break (0);
-    return 4;
-  }
-  GNUNET_CONFIGURATION_set_value_string (cfg, "more", "c", "YES");
-  if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno (cfg, "more", "c"))
-  {
-    GNUNET_break (0);
-    return 5;
-  }
-  GNUNET_CONFIGURATION_set_value_number (cfg, "NUMBERS", "TEN", 10);
+    {
+      GNUNET_break(0);
+      return 4;
+    }
+  GNUNET_CONFIGURATION_set_value_string(cfg, "more", "c", "YES");
+  if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno(cfg, "more", "c"))
+    {
+      GNUNET_break(0);
+      return 5;
+    }
+  GNUNET_CONFIGURATION_set_value_number(cfg, "NUMBERS", "TEN", 10);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, "NUMBERS", "TEN", &c))
-  {
-    GNUNET_break (0);
-    return 6;
-  }
-  if (0 != strcmp (c, "10"))
-  {
-    GNUNET_free (c);
-    GNUNET_break (0);
-    return 7;
-  }
-  GNUNET_free (c);
+      GNUNET_CONFIGURATION_get_value_string(cfg, "NUMBERS", "TEN", &c))
+    {
+      GNUNET_break(0);
+      return 6;
+    }
+  if (0 != strcmp(c, "10"))
+    {
+      GNUNET_free(c);
+      GNUNET_break(0);
+      return 7;
+    }
+  GNUNET_free(c);
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "last", "test", &c))
-  {
-    GNUNET_break (0);
-    return 8;
-  }
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "last", "test", &c))
+    {
+      GNUNET_break(0);
+      return 8;
+    }
 #ifndef MINGW
-  if (0 != strcmp (c, "/hello/world"))
+  if (0 != strcmp(c, "/hello/world"))
 #else
 #define HI "\\hello\\world"
-  if (strstr (c, HI) != c + strlen (c) - strlen (HI))
+  if (strstr(c, HI) != c + strlen(c) - strlen(HI))
 #endif
-  {
-    GNUNET_break (0);
-    GNUNET_free (c);
-    return 9;
-  }
-  GNUNET_free (c);
+    {
+      GNUNET_break(0);
+      GNUNET_free(c);
+      return 9;
+    }
+  GNUNET_free(c);
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_size (cfg, "last", "size", &l))
-  {
-    GNUNET_break (0);
-    return 10;
-  }
+      GNUNET_CONFIGURATION_get_value_size(cfg, "last", "size", &l))
+    {
+      GNUNET_break(0);
+      return 10;
+    }
   if (l != 512 * 1024)
-  {
-    GNUNET_break (0);
-    return 11;
-  }
+    {
+      GNUNET_break(0);
+      return 11;
+    }
   return 0;
 }
 
@@ -352,198 +359,198 @@ static const char *want[] = {
 };
 
 static int
-check (void *data, const char *fn)
+check(void *data, const char *fn)
 {
   int *idx = data;
 
-  if (0 == strcmp (want[*idx], fn))
-  {
-    (*idx)++;
-    return GNUNET_OK;
-  }
-  GNUNET_break (0);
+  if (0 == strcmp(want[*idx], fn))
+    {
+      (*idx)++;
+      return GNUNET_OK;
+    }
+  GNUNET_break(0);
   return GNUNET_SYSERR;
 }
 
 static int
-testConfigFilenames ()
+testConfigFilenames()
 {
   int idx;
 
   idx = 0;
   if (3 !=
-      GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
-                                                    &check, &idx))
-  {
-    GNUNET_break (0);
-    return 8;
-  }
+      GNUNET_CONFIGURATION_iterate_value_filenames(cfg, "FILENAMES", "test",
+                                                   &check, &idx))
+    {
+      GNUNET_break(0);
+      return 8;
+    }
   if (idx != 3)
     return 16;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
-                                                  "/File Name"))
-  {
-    GNUNET_break (0);
-    return 24;
-  }
+      GNUNET_CONFIGURATION_remove_value_filename(cfg, "FILENAMES", "test",
+                                                 "/File Name"))
+    {
+      GNUNET_break(0);
+      return 24;
+    }
 
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
-                                                  "/File Name"))
-  {
-    GNUNET_break (0);
-    return 32;
-  }
+      GNUNET_CONFIGURATION_remove_value_filename(cfg, "FILENAMES", "test",
+                                                 "/File Name"))
+    {
+      GNUNET_break(0);
+      return 32;
+    }
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
-                                                  "Stuff"))
-  {
-    GNUNET_break (0);
-    return 40;
-  }
+      GNUNET_CONFIGURATION_remove_value_filename(cfg, "FILENAMES", "test",
+                                                 "Stuff"))
+    {
+      GNUNET_break(0);
+      return 40;
+    }
 
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
-                                                  "/Hello"))
-  {
-    GNUNET_break (0);
-    return 48;
-  }
+      GNUNET_CONFIGURATION_append_value_filename(cfg, "FILENAMES", "test",
+                                                 "/Hello"))
+    {
+      GNUNET_break(0);
+      return 48;
+    }
   if (GNUNET_NO !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
-                                                  "/World"))
-  {
-    GNUNET_break (0);
-    return 56;
-  }
+      GNUNET_CONFIGURATION_append_value_filename(cfg, "FILENAMES", "test",
+                                                 "/World"))
+    {
+      GNUNET_break(0);
+      return 56;
+    }
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
-                                                  "/File 1"))
-  {
-    GNUNET_break (0);
-    return 64;
-  }
+      GNUNET_CONFIGURATION_append_value_filename(cfg, "FILENAMES", "test",
+                                                 "/File 1"))
+    {
+      GNUNET_break(0);
+      return 64;
+    }
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
-                                                  "/File 2"))
-  {
-    GNUNET_break (0);
-    return 72;
-  }
+      GNUNET_CONFIGURATION_append_value_filename(cfg, "FILENAMES", "test",
+                                                 "/File 2"))
+    {
+      GNUNET_break(0);
+      return 72;
+    }
 
   idx = 0;
   want[1] = "/World";
   want[2] = "/File 1";
   want[3] = "/File 2";
   if (4 !=
-      GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
-                                                    &check, &idx))
-  {
-    GNUNET_break (0);
-    return 80;
-  }
+      GNUNET_CONFIGURATION_iterate_value_filenames(cfg, "FILENAMES", "test",
+                                                   &check, &idx))
+    {
+      GNUNET_break(0);
+      return 80;
+    }
   if (idx != 4)
-  {
-    GNUNET_break (0);
-    return 88;
-  }
+    {
+      GNUNET_break(0);
+      return 88;
+    }
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   char *c;
 
-  GNUNET_log_setup ("test_configuration", "WARNING", NULL);
-  cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_assert (cfg != NULL);
+  GNUNET_log_setup("test_configuration", "WARNING", NULL);
+  cfg = GNUNET_CONFIGURATION_create();
+  GNUNET_assert(cfg != NULL);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_parse (cfg, "test_configuration_data.conf"))
-  {
-    fprintf (stderr, "%s",  "Failed to parse configuration file\n");
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
-  failureCount += testConfig ();
+      GNUNET_CONFIGURATION_parse(cfg, "test_configuration_data.conf"))
+    {
+      fprintf(stderr, "%s", "Failed to parse configuration file\n");
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return 1;
+    }
+  failureCount += testConfig();
   if (failureCount > 0)
     goto error;
 
-  failureCount = testConfigFilenames ();
+  failureCount = testConfigFilenames();
   if (failureCount > 0)
     goto error;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, "/tmp/gnunet-test.conf"))
-  {
-    fprintf (stderr, "%s",  "Failed to write configuration file\n");
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
-  GNUNET_CONFIGURATION_destroy (cfg);
-  GNUNET_assert (0 == unlink ("/tmp/gnunet-test.conf"));
+  if (GNUNET_OK != GNUNET_CONFIGURATION_write(cfg, "/tmp/gnunet-test.conf"))
+    {
+      fprintf(stderr, "%s", "Failed to write configuration file\n");
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_assert(0 == unlink("/tmp/gnunet-test.conf"));
 
-  cfg = GNUNET_CONFIGURATION_create ();
+  cfg = GNUNET_CONFIGURATION_create();
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_load (cfg, "test_configuration_data.conf"))
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
+      GNUNET_CONFIGURATION_load(cfg, "test_configuration_data.conf"))
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return 1;
+    }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg, "TESTING", "WEAKRANDOM", &c))
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
-  if (0 != strcmp (c, "YES"))
-  {
-    GNUNET_break (0);
-    GNUNET_free (c);
-    GNUNET_CONFIGURATION_destroy (cfg);
-    return 1;
-  }
+      GNUNET_CONFIGURATION_get_value_string(cfg, "TESTING", "WEAKRANDOM", &c))
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return 1;
+    }
+  if (0 != strcmp(c, "YES"))
+    {
+      GNUNET_break(0);
+      GNUNET_free(c);
+      GNUNET_CONFIGURATION_destroy(cfg);
+      return 1;
+    }
 
-  GNUNET_free (c);
-  GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_free(c);
+  GNUNET_CONFIGURATION_destroy(cfg);
 
   /* Testing configuration diffs */
-  cfg_default = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg_default, NULL))
-  {
-    GNUNET_break (0);
-    GNUNET_CONFIGURATION_destroy (cfg_default);
-    return 1;
-  }
+  cfg_default = GNUNET_CONFIGURATION_create();
+  if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg_default, NULL))
+    {
+      GNUNET_break(0);
+      GNUNET_CONFIGURATION_destroy(cfg_default);
+      return 1;
+    }
 
   /* Nothing changed in the new configuration */
-  failureCount += checkDiffs (cfg_default, EDIT_NOTHING);
+  failureCount += checkDiffs(cfg_default, EDIT_NOTHING);
 
   /* Modify all entries of the last section */
-  failureCount += checkDiffs (cfg_default, EDIT_SECTION);
+  failureCount += checkDiffs(cfg_default, EDIT_SECTION);
 
   /* Add a new section */
-  failureCount += checkDiffs (cfg_default, ADD_NEW_SECTION);
+  failureCount += checkDiffs(cfg_default, ADD_NEW_SECTION);
 
   /* Add a new entry to the last section */
-  failureCount += checkDiffs (cfg_default, ADD_NEW_ENTRY);
+  failureCount += checkDiffs(cfg_default, ADD_NEW_ENTRY);
 
   /* Modify all entries in the configuration */
-  failureCount += checkDiffs (cfg_default, EDIT_ALL);
+  failureCount += checkDiffs(cfg_default, EDIT_ALL);
 
-  GNUNET_CONFIGURATION_destroy (cfg_default);
+  GNUNET_CONFIGURATION_destroy(cfg_default);
 
 error:
   if (failureCount != 0)
-  {
-    fprintf (stderr, "Test failed: %u\n", failureCount);
-    return 1;
-  }
+    {
+      fprintf(stderr, "Test failed: %u\n", failureCount);
+      return 1;
+    }
   return 0;
 }
diff --git a/src/util/test_container_bloomfilter.c b/src/util/test_container_bloomfilter.c
index 043eacafd..d295f465b 100644
--- a/src/util/test_container_bloomfilter.c
+++ b/src/util/test_container_bloomfilter.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 util/test_container_bloomfilter.c
  * @brief Testcase for the bloomfilter.
@@ -35,26 +35,26 @@
  * Generate a random hashcode.
  */
 static void
-nextHC (struct GNUNET_HashCode *hc)
+nextHC(struct GNUNET_HashCode *hc)
 {
-  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, hc);
+  GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, hc);
 }
 
 static int
-add_iterator (void *cls, struct GNUNET_HashCode *next)
+add_iterator(void *cls, struct GNUNET_HashCode *next)
 {
   int *ret = cls;
   struct GNUNET_HashCode pos;
 
   if (0 == (*ret)--)
     return GNUNET_NO;
-  nextHC (&pos);
+  nextHC(&pos);
   *next = pos;
   return GNUNET_YES;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
   struct GNUNET_CONTAINER_BloomFilter *bfi;
@@ -66,186 +66,186 @@ main (int argc, char *argv[])
   char buf[SIZE];
   struct stat sbuf;
 
-  GNUNET_log_setup ("test-container-bloomfilter", "WARNING", NULL);
-  GNUNET_CRYPTO_seed_weak_random (1);
-  if (0 == stat (TESTFILE, &sbuf))
-    if (0 != unlink (TESTFILE))
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "unlink", TESTFILE);
-  bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K);
+  GNUNET_log_setup("test-container-bloomfilter", "WARNING", NULL);
+  GNUNET_CRYPTO_seed_weak_random(1);
+  if (0 == stat(TESTFILE, &sbuf))
+    if (0 != unlink(TESTFILE))
+      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "unlink", TESTFILE);
+  bf = GNUNET_CONTAINER_bloomfilter_load(TESTFILE, SIZE, K);
 
   for (i = 0; i < 200; i++)
-  {
-    nextHC (&tmp);
-    GNUNET_CONTAINER_bloomfilter_add (bf, &tmp);
-  }
-  GNUNET_CRYPTO_seed_weak_random (1);
+    {
+      nextHC(&tmp);
+      GNUNET_CONTAINER_bloomfilter_add(bf, &tmp);
+    }
+  GNUNET_CRYPTO_seed_weak_random(1);
   ok1 = 0;
   for (i = 0; i < 200; i++)
-  {
-    nextHC (&tmp);
-    if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
-      ok1++;
-  }
+    {
+      nextHC(&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES)
+        ok1++;
+    }
   if (ok1 != 200)
-  {
-    printf ("Got %d elements out of"
-            "200 expected after insertion.\n",
-            ok1);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    return -1;
-  }
-  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_get_raw_data (bf, buf, SIZE))
-  {
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    return -1;
-  }
-
-  GNUNET_CONTAINER_bloomfilter_free (bf);
-
-  bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K);
-  GNUNET_assert (bf != NULL);
-  bfi = GNUNET_CONTAINER_bloomfilter_init (buf, SIZE, K);
-  GNUNET_assert (bfi != NULL);
-
-  GNUNET_CRYPTO_seed_weak_random (1);
+    {
+      printf("Got %d elements out of"
+             "200 expected after insertion.\n",
+             ok1);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      return -1;
+    }
+  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_get_raw_data(bf, buf, SIZE))
+    {
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      return -1;
+    }
+
+  GNUNET_CONTAINER_bloomfilter_free(bf);
+
+  bf = GNUNET_CONTAINER_bloomfilter_load(TESTFILE, SIZE, K);
+  GNUNET_assert(bf != NULL);
+  bfi = GNUNET_CONTAINER_bloomfilter_init(buf, SIZE, K);
+  GNUNET_assert(bfi != NULL);
+
+  GNUNET_CRYPTO_seed_weak_random(1);
   ok1 = 0;
   ok2 = 0;
   for (i = 0; i < 200; i++)
-  {
-    nextHC (&tmp);
-    if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
-      ok1++;
-    if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
-      ok2++;
-  }
+    {
+      nextHC(&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
   if (ok1 != 200)
-  {
-    printf ("Got %d elements out of 200 "
-            "expected after reloading.\n",
-            ok1);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
+    {
+      printf("Got %d elements out of 200 "
+             "expected after reloading.\n",
+             ok1);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
 
   if (ok2 != 200)
-  {
-    printf ("Got %d elements out of 200 "
-            "expected after initialization.\n",
-            ok2);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
-
-  GNUNET_CRYPTO_seed_weak_random (1);
+    {
+      printf("Got %d elements out of 200 "
+             "expected after initialization.\n",
+             ok2);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
+
+  GNUNET_CRYPTO_seed_weak_random(1);
   for (i = 0; i < 100; i++)
-  {
-    nextHC (&tmp);
-    GNUNET_CONTAINER_bloomfilter_remove (bf, &tmp);
-    GNUNET_CONTAINER_bloomfilter_remove (bfi, &tmp);
-  }
+    {
+      nextHC(&tmp);
+      GNUNET_CONTAINER_bloomfilter_remove(bf, &tmp);
+      GNUNET_CONTAINER_bloomfilter_remove(bfi, &tmp);
+    }
 
-  GNUNET_CRYPTO_seed_weak_random (1);
+  GNUNET_CRYPTO_seed_weak_random(1);
 
   ok1 = 0;
   ok2 = 0;
   for (i = 0; i < 200; i++)
-  {
-    nextHC (&tmp);
-    if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
-      ok1++;
-    if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
-      ok2++;
-  }
+    {
+      nextHC(&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
 
   if (ok1 != 100)
-  {
-    printf ("Expected 100 elements in loaded filter"
-            " after adding 200 and deleting 100, got %d\n",
-            ok1);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
+    {
+      printf("Expected 100 elements in loaded filter"
+             " after adding 200 and deleting 100, got %d\n",
+             ok1);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
   if (ok2 != 200)
-  {
-    printf ("Expected 200 elements in initialized filter"
-            " after adding 200 and deleting 100 "
-            "(which should do nothing for a filter not backed by a file), got %d\n",
-            ok2);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
-
-  GNUNET_CRYPTO_seed_weak_random (3);
-
-  GNUNET_CONTAINER_bloomfilter_clear (bf);
+    {
+      printf("Expected 200 elements in initialized filter"
+             " after adding 200 and deleting 100 "
+             "(which should do nothing for a filter not backed by a file), got %d\n",
+             ok2);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
+
+  GNUNET_CRYPTO_seed_weak_random(3);
+
+  GNUNET_CONTAINER_bloomfilter_clear(bf);
   falseok = 0;
   for (i = 0; i < 1000; i++)
-  {
-    nextHC (&tmp);
-    if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
-      falseok++;
-  }
+    {
+      nextHC(&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES)
+        falseok++;
+    }
   if (falseok > 0)
-  {
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
-
-  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_or (bf, buf, SIZE))
-  {
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
-
-  GNUNET_CRYPTO_seed_weak_random (2);
+    {
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
+
+  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_or(bf, buf, SIZE))
+    {
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
+
+  GNUNET_CRYPTO_seed_weak_random(2);
   i = 20;
-  GNUNET_CONTAINER_bloomfilter_resize (bfi, &add_iterator, &i, SIZE * 2, K);
+  GNUNET_CONTAINER_bloomfilter_resize(bfi, &add_iterator, &i, SIZE * 2, K);
 
-  GNUNET_CRYPTO_seed_weak_random (2);
+  GNUNET_CRYPTO_seed_weak_random(2);
   i = 20;
-  GNUNET_CONTAINER_bloomfilter_resize (bf, &add_iterator, &i, SIZE * 2, K);
-  GNUNET_CRYPTO_seed_weak_random (2);
+  GNUNET_CONTAINER_bloomfilter_resize(bf, &add_iterator, &i, SIZE * 2, K);
+  GNUNET_CRYPTO_seed_weak_random(2);
 
   ok1 = 0;
   ok2 = 0;
   for (i = 0; i < 20; i++)
-  {
-    nextHC (&tmp);
-    if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
-      ok1++;
-    if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
-      ok2++;
-  }
+    {
+      nextHC(&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
 
   if (ok1 != 20)
-  {
-    printf ("Expected 20 elements in resized file-backed filter"
-            " after adding 20, got %d\n",
-            ok1);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
+    {
+      printf("Expected 20 elements in resized file-backed filter"
+             " after adding 20, got %d\n",
+             ok1);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
   if (ok2 != 20)
-  {
-    printf ("Expected 20 elements in resized filter"
-            " after adding 20, got %d\n",
-            ok2);
-    GNUNET_CONTAINER_bloomfilter_free (bf);
-    GNUNET_CONTAINER_bloomfilter_free (bfi);
-    return -1;
-  }
+    {
+      printf("Expected 20 elements in resized filter"
+             " after adding 20, got %d\n",
+             ok2);
+      GNUNET_CONTAINER_bloomfilter_free(bf);
+      GNUNET_CONTAINER_bloomfilter_free(bfi);
+      return -1;
+    }
 
 
-  GNUNET_CONTAINER_bloomfilter_free (bf);
-  GNUNET_CONTAINER_bloomfilter_free (bfi);
+  GNUNET_CONTAINER_bloomfilter_free(bf);
+  GNUNET_CONTAINER_bloomfilter_free(bfi);
 
-  GNUNET_break (0 == unlink (TESTFILE));
+  GNUNET_break(0 == unlink(TESTFILE));
   return 0;
 }
diff --git a/src/util/test_container_dll.c b/src/util/test_container_dll.c
index f1c0e9446..7203cde22 100644
--- a/src/util/test_container_dll.c
+++ b/src/util/test_container_dll.c
@@ -1,19 +1,19 @@
 /*
- This file is part of GNUnet.
- Copyright (C) 2017 GNUnet e.V.
+   This file is part of GNUnet.
+   Copyright (C) 2017 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 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.
+   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/>.
+   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
  */
@@ -30,8 +30,7 @@
 /**
  * Element in the DLL.
  */
-struct Element
-{
+struct Element {
   /**
    * Required pointer to previous element.
    */
@@ -58,9 +57,9 @@ struct Element
  * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO
  */
 static int
-cmp_elem (void *cls,
-          struct Element *e1,
-          struct Element *e2)
+cmp_elem(void *cls,
+         struct Element *e1,
+         struct Element *e2)
 {
   if (e1->value == e2->value)
     return 0;
@@ -69,7 +68,7 @@ cmp_elem (void *cls,
 
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   unsigned int values[] = {
     4, 5, 8, 6, 9, 3, 7, 2, 1, 0
@@ -79,33 +78,33 @@ main (int argc, char **argv)
   struct Element *e;
   unsigned int want;
 
-  GNUNET_log_setup ("test-container-dll",
-                    "WARNING",
-                    NULL);
-  for (unsigned int off=0;
+  GNUNET_log_setup("test-container-dll",
+                   "WARNING",
+                   NULL);
+  for (unsigned int off = 0;
        0 != values[off];
        off++)
-  {
-    e = GNUNET_new (struct Element);
-    e->value = values[off];
-    GNUNET_CONTAINER_DLL_insert_sorted (struct Element,
-                                        cmp_elem,
-                                        NULL,
-                                        head,
-                                        tail,
-                                        e);
-  }
+    {
+      e = GNUNET_new(struct Element);
+      e->value = values[off];
+      GNUNET_CONTAINER_DLL_insert_sorted(struct Element,
+                                         cmp_elem,
+                                         NULL,
+                                         head,
+                                         tail,
+                                         e);
+    }
 
   want = 1;
   while (NULL != (e = head))
-  {
-    GNUNET_assert (e->value == want);
-    GNUNET_CONTAINER_DLL_remove (head,
-                                 tail,
-                                 e);
-    GNUNET_free (e);
-    want++;
-  }
+    {
+      GNUNET_assert(e->value == want);
+      GNUNET_CONTAINER_DLL_remove(head,
+                                  tail,
+                                  e);
+      GNUNET_free(e);
+      want++;
+    }
   return 0;
 }
 
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c
index f95032ca0..8df6553b6 100644
--- a/src/util/test_container_heap.c
+++ b/src/util/test_container_heap.c
@@ -1,19 +1,19 @@
 /*
- This file is part of GNUnet.
- Copyright (C) 2008 GNUnet e.V.
+   This file is part of GNUnet.
+   Copyright (C) 2008 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 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.
+   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/>.
+   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
  */
@@ -28,23 +28,23 @@
 #include "gnunet_util_lib.h"
 
 static int
-iterator_callback (void *cls,
-                   struct GNUNET_CONTAINER_HeapNode *node,
-                   void *element, GNUNET_CONTAINER_HeapCostType cost)
+iterator_callback(void *cls,
+                  struct GNUNET_CONTAINER_HeapNode *node,
+                  void *element, GNUNET_CONTAINER_HeapCostType cost)
 {
   return GNUNET_OK;
 }
 
 static int
-nstrcmp (const char *a, const char *b)
+nstrcmp(const char *a, const char *b)
 {
-  GNUNET_assert (a != NULL);
-  GNUNET_assert (b != NULL);
-  return strcmp (a, b);
+  GNUNET_assert(a != NULL);
+  GNUNET_assert(b != NULL);
+  return strcmp(a, b);
 }
 
 static int
-check ()
+check()
 {
   struct GNUNET_CONTAINER_Heap *myHeap;
   struct GNUNET_CONTAINER_HeapNode *n1;
@@ -57,234 +57,234 @@ check ()
   struct GNUNET_CONTAINER_HeapNode *n8;
   const char *r;
 
-  myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
 
   // GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch
-  n1 = GNUNET_CONTAINER_heap_remove_root (myHeap);
-  GNUNET_assert (NULL == n1);
+  n1 = GNUNET_CONTAINER_heap_remove_root(myHeap);
+  GNUNET_assert(NULL == n1);
 
   // GNUNET_CONTAINER_heap_peek heap empty, taking if-branch
-  n1 = GNUNET_CONTAINER_heap_peek (myHeap);
-  GNUNET_assert (NULL == n1);
+  n1 = GNUNET_CONTAINER_heap_peek(myHeap);
+  GNUNET_assert(NULL == n1);
 
   // GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch
-  n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_assert (NULL == n1);
+  n1 = GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_assert(NULL == n1);
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "11", 11);
-  GNUNET_assert (NULL != n1);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "11", 11);
+  GNUNET_assert(NULL != n1);
 
 
   // GNUNET_CONTAINER_heap_peek not empty, taking if-branch
   n2 = NULL;
-  n2 = GNUNET_CONTAINER_heap_peek (myHeap);
-  GNUNET_assert (NULL != n2);
+  n2 = GNUNET_CONTAINER_heap_peek(myHeap);
+  GNUNET_assert(NULL != n2);
 
   // GNUNET_CONTAINER_heap_walk_get_next: 1 element
   n1 = NULL;
-  n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_assert (NULL != n1);
-
-  GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
-  GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78);
-  GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_assert (0 == strcmp ("78", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
-
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "15", 5);
-  GNUNET_CONTAINER_heap_update_cost (n3, 15);
-  GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
-
-  n4 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
-  GNUNET_CONTAINER_heap_update_cost (n4, 50);
-  GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
-
-  n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100);
-  n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30);
-  GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_CONTAINER_heap_remove_node (n5);
-  r = GNUNET_CONTAINER_heap_remove_root (myHeap);       /* n1 */
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("11", r));
-  GNUNET_CONTAINER_heap_update_cost (n6, 200);
-  GNUNET_CONTAINER_heap_remove_node (n3);
-  r = GNUNET_CONTAINER_heap_remove_root (myHeap);       /* n4 */
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("50", r));
-  r = GNUNET_CONTAINER_heap_remove_root (myHeap);       /* n6 */
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("30/200", r));
-  GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (myHeap));
-
-  GNUNET_CONTAINER_heap_destroy (myHeap);
+  n1 = GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_assert(NULL != n1);
+
+  GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
+  GNUNET_assert(1 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "78", 78);
+  GNUNET_assert(2 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  GNUNET_assert(0 == strcmp("78", GNUNET_CONTAINER_heap_remove_node(n2)));
+  GNUNET_assert(1 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
+
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "15", 5);
+  GNUNET_CONTAINER_heap_update_cost(n3, 15);
+  GNUNET_assert(2 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
+
+  n4 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
+  GNUNET_CONTAINER_heap_update_cost(n4, 50);
+  GNUNET_assert(3 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
+
+  n5 = GNUNET_CONTAINER_heap_insert(myHeap, "100", 100);
+  n6 = GNUNET_CONTAINER_heap_insert(myHeap, "30/200", 30);
+  GNUNET_assert(5 == GNUNET_CONTAINER_heap_get_size(myHeap));
+  GNUNET_CONTAINER_heap_remove_node(n5);
+  r = GNUNET_CONTAINER_heap_remove_root(myHeap);        /* n1 */
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("11", r));
+  GNUNET_CONTAINER_heap_update_cost(n6, 200);
+  GNUNET_CONTAINER_heap_remove_node(n3);
+  r = GNUNET_CONTAINER_heap_remove_root(myHeap);        /* n4 */
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("50", r));
+  r = GNUNET_CONTAINER_heap_remove_root(myHeap);        /* n6 */
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("30/200", r));
+  GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(myHeap));
+
+  GNUNET_CONTAINER_heap_destroy(myHeap);
 
   // My additions to a complete testcase
   // Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN
   // Testing remove_node
 
-  myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  GNUNET_CONTAINER_heap_update_cost (n1, 15);
-
-  r = GNUNET_CONTAINER_heap_remove_node (n1);
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("10", r));
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
-
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  r = GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("20", r));
-  r = GNUNET_CONTAINER_heap_remove_node (n1);
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("10", r));
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
-
-  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (n1);
-  r = GNUNET_CONTAINER_heap_remove_root (myHeap);
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("30", r));
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
-
-  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (n1);
-  r = GNUNET_CONTAINER_heap_remove_node (n3);
-  GNUNET_assert (NULL != r);
-  GNUNET_assert (0 == strcmp ("30", r));
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
-
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (0 ==
-                 nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap)));
-  GNUNET_assert (0 ==
-                 nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
-
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
-  n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40);
-  n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
-  n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60);
+  myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  GNUNET_CONTAINER_heap_update_cost(n1, 15);
+
+  r = GNUNET_CONTAINER_heap_remove_node(n1);
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("10", r));
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
+
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  r = GNUNET_CONTAINER_heap_remove_node(n2);
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("20", r));
+  r = GNUNET_CONTAINER_heap_remove_node(n1);
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("10", r));
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
+
+  GNUNET_CONTAINER_heap_remove_node(n2);
+  GNUNET_CONTAINER_heap_remove_node(n1);
+  r = GNUNET_CONTAINER_heap_remove_root(myHeap);
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("30", r));
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
+
+  GNUNET_CONTAINER_heap_remove_node(n2);
+  GNUNET_CONTAINER_heap_remove_node(n1);
+  r = GNUNET_CONTAINER_heap_remove_node(n3);
+  GNUNET_assert(NULL != r);
+  GNUNET_assert(0 == strcmp("30", r));
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
+
+  GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
+  GNUNET_assert(0 ==
+                nstrcmp("10", GNUNET_CONTAINER_heap_remove_root(myHeap)));
+  GNUNET_assert(0 ==
+                nstrcmp("30", GNUNET_CONTAINER_heap_remove_root(myHeap)));
+
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
+  n4 = GNUNET_CONTAINER_heap_insert(myHeap, "40", 40);
+  n5 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
+  n6 = GNUNET_CONTAINER_heap_insert(myHeap, "60", 60);
 
   // Inserting nodes deeper in the tree with lower costs
-  n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
-  n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
+  n7 = GNUNET_CONTAINER_heap_insert(myHeap, "70", 10);
+  n8 = GNUNET_CONTAINER_heap_insert(myHeap, "80", 10);
 
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
+  GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
 
   // Cleaning up...
-  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
-  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
+  GNUNET_assert(0 == nstrcmp("60", GNUNET_CONTAINER_heap_remove_node(n6)));
+  GNUNET_assert(0 == nstrcmp("50", GNUNET_CONTAINER_heap_remove_node(n5)));
 
   // Testing heap_walk_get_next
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);;
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
-  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
-  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);;
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+
+  GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
+  GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
+  GNUNET_assert(0 == nstrcmp("40", GNUNET_CONTAINER_heap_remove_node(n4)));
+  GNUNET_assert(0 == nstrcmp("70", GNUNET_CONTAINER_heap_remove_node(n7)));
+  GNUNET_assert(0 == nstrcmp("80", GNUNET_CONTAINER_heap_remove_node(n8)));
 
   // End Testing remove_node
 
   // Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX
-  GNUNET_CONTAINER_heap_destroy (myHeap);
+  GNUNET_CONTAINER_heap_destroy(myHeap);
 
-  myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
+  myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MAX);
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  GNUNET_CONTAINER_heap_update_cost (n1, 15);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  GNUNET_CONTAINER_heap_update_cost(n1, 15);
 
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
+  GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
 
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
+  GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
 
-  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (n1);
-  GNUNET_assert (0 ==
-                 nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
+  GNUNET_CONTAINER_heap_remove_node(n2);
+  GNUNET_CONTAINER_heap_remove_node(n1);
+  GNUNET_assert(0 ==
+                nstrcmp("30", GNUNET_CONTAINER_heap_remove_root(myHeap)));
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
 
-  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (n1);
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
+  GNUNET_CONTAINER_heap_remove_node(n2);
+  GNUNET_CONTAINER_heap_remove_node(n1);
+  GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
 
-  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
-  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
-  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
-  n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40);
-  n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
-  n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60);
+  n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
+  n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
+  n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
+  n4 = GNUNET_CONTAINER_heap_insert(myHeap, "40", 40);
+  n5 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
+  n6 = GNUNET_CONTAINER_heap_insert(myHeap, "60", 60);
 
   // Inserting nodes deeper in the tree with lower costs
-  n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
-  n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
+  n7 = GNUNET_CONTAINER_heap_insert(myHeap, "70", 10);
+  n8 = GNUNET_CONTAINER_heap_insert(myHeap, "80", 10);
 
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
+  GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
 
   // Cleaning up...
-  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
-  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
+  GNUNET_assert(0 == nstrcmp("60", GNUNET_CONTAINER_heap_remove_node(n6)));
+  GNUNET_assert(0 == nstrcmp("50", GNUNET_CONTAINER_heap_remove_node(n5)));
 
   // Testing heap_walk_get_next
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);;
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
-  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
-  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);;
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+  GNUNET_CONTAINER_heap_walk_get_next(myHeap);
+
+  GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
+  GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
+  GNUNET_assert(0 == nstrcmp("40", GNUNET_CONTAINER_heap_remove_node(n4)));
+  GNUNET_assert(0 == nstrcmp("70", GNUNET_CONTAINER_heap_remove_node(n7)));
+  GNUNET_assert(0 == nstrcmp("80", GNUNET_CONTAINER_heap_remove_node(n8)));
 
   // End Testing remove_node
 
-  GNUNET_CONTAINER_heap_destroy (myHeap);
+  GNUNET_CONTAINER_heap_destroy(myHeap);
 
   return 0;
 }
 
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-  GNUNET_log_setup ("test-container-heap", "WARNING", NULL);
-  return check ();
+  GNUNET_log_setup("test-container-heap", "WARNING", NULL);
+  return check();
 }
 
 /* end of test_container_heap.c */
diff --git a/src/util/test_container_meta_data.c b/src/util/test_container_meta_data.c
index 416ea7db9..854498f28 100644
--- a/src/util/test_container_meta_data.c
+++ b/src/util/test_container_meta_data.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 util/test_container_meta_data.c
@@ -27,11 +27,11 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
+#define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy (m); return 1; }
 
 
 static int
-testMeta (int i)
+testMeta(int i)
 {
   struct GNUNET_CONTAINER_MetaData *m;
   char val[256];
@@ -39,95 +39,95 @@ testMeta (int i)
   int j;
   unsigned int size;
 
-  m = GNUNET_CONTAINER_meta_data_create ();
+  m = GNUNET_CONTAINER_meta_data_create();
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain", "TestTitle",
-                                         strlen ("TestTitle") + 1))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_insert(m, "<test>", EXTRACTOR_METATYPE_TITLE,
+                                        EXTRACTOR_METAFORMAT_UTF8,
+                                        "text/plain", "TestTitle",
+                                        strlen("TestTitle") + 1))
+    ABORT(m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
-                                         EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain", "TestTitle",
-                                         strlen ("TestTitle") + 1))
-    ABORT (m);
-  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))   /* dup! */
-    ABORT (m);
-  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))     /* dup! */
-    ABORT (m);
-  if (2 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_insert(m, "<test>",
+                                        EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                        EXTRACTOR_METAFORMAT_UTF8,
+                                        "text/plain", "TestTitle",
+                                        strlen("TestTitle") + 1))
+    ABORT(m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert(m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen("TestTitle") + 1))     /* dup! */
+    ABORT(m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert(m, "<test>", EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen("TestTitle") + 1))       /* dup! */
+    ABORT(m);
+  if (2 != GNUNET_CONTAINER_meta_data_iterate(m, NULL, NULL))
+    ABORT(m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                         "TestTitle", strlen ("TestTitle") + 1))
-    ABORT (m);
-  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen ("TestTitle") + 1))        /* already gone */
-    ABORT (m);
-  if (1 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_delete(m, EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                        "TestTitle", strlen("TestTitle") + 1))
+    ABORT(m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete(m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen("TestTitle") + 1))          /* already gone */
+    ABORT(m);
+  if (1 != GNUNET_CONTAINER_meta_data_iterate(m, NULL, NULL))
+    ABORT(m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
-                                         "TestTitle", strlen ("TestTitle") + 1))
-    ABORT (m);
-  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen ("TestTitle") + 1))      /* already gone */
-    ABORT (m);
-  if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_delete(m, EXTRACTOR_METATYPE_TITLE,
+                                        "TestTitle", strlen("TestTitle") + 1))
+    ABORT(m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete(m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen("TestTitle") + 1))        /* already gone */
+    ABORT(m);
+  if (0 != GNUNET_CONTAINER_meta_data_iterate(m, NULL, NULL))
+    ABORT(m);
   for (j = 0; j < i; j++)
-  {
-    GNUNET_snprintf (val, sizeof (val), "%s.%d",
-                     "A teststring that should compress well.", j);
-    if (GNUNET_OK !=
-        GNUNET_CONTAINER_meta_data_insert (m, "<test>",
-                                           EXTRACTOR_METATYPE_UNKNOWN,
-                                           EXTRACTOR_METAFORMAT_UTF8,
-                                           "text/plain", val, strlen (val) + 1))
-      ABORT (m);
-  }
-  if (i != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
-    ABORT (m);
-
-  size = GNUNET_CONTAINER_meta_data_get_serialized_size (m);
+    {
+      GNUNET_snprintf(val, sizeof(val), "%s.%d",
+                      "A teststring that should compress well.", j);
+      if (GNUNET_OK !=
+          GNUNET_CONTAINER_meta_data_insert(m, "<test>",
+                                            EXTRACTOR_METATYPE_UNKNOWN,
+                                            EXTRACTOR_METAFORMAT_UTF8,
+                                            "text/plain", val, strlen(val) + 1))
+        ABORT(m);
+    }
+  if (i != GNUNET_CONTAINER_meta_data_iterate(m, NULL, NULL))
+    ABORT(m);
+
+  size = GNUNET_CONTAINER_meta_data_get_serialized_size(m);
   sval = NULL;
   if (size !=
-      GNUNET_CONTAINER_meta_data_serialize (m, &sval, size,
-                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
-  {
-    GNUNET_free_non_null (sval);
-    ABORT (m);
-  }
-  GNUNET_CONTAINER_meta_data_destroy (m);
-  m = GNUNET_CONTAINER_meta_data_deserialize (sval, size);
-  GNUNET_free (sval);
+      GNUNET_CONTAINER_meta_data_serialize(m, &sval, size,
+                                           GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+    {
+      GNUNET_free_non_null(sval);
+      ABORT(m);
+    }
+  GNUNET_CONTAINER_meta_data_destroy(m);
+  m = GNUNET_CONTAINER_meta_data_deserialize(sval, size);
+  GNUNET_free(sval);
   if (m == NULL)
-    ABORT (m);
+    ABORT(m);
   for (j = 0; j < i; j++)
-  {
-    GNUNET_snprintf (val,
-                     sizeof (val),
-                     "%s.%d",
-                     "A teststring that should compress well.",
-                     j);
-    if (GNUNET_OK !=
-        GNUNET_CONTAINER_meta_data_delete (m,
-                                           EXTRACTOR_METATYPE_UNKNOWN,
-                                           val,
-                                           strlen (val) + 1))
     {
-      ABORT (m);
+      GNUNET_snprintf(val,
+                      sizeof(val),
+                      "%s.%d",
+                      "A teststring that should compress well.",
+                      j);
+      if (GNUNET_OK !=
+          GNUNET_CONTAINER_meta_data_delete(m,
+                                            EXTRACTOR_METATYPE_UNKNOWN,
+                                            val,
+                                            strlen(val) + 1))
+        {
+          ABORT(m);
+        }
     }
-  }
-  if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
-    ABORT (m);
-  GNUNET_CONTAINER_meta_data_destroy (m);
+  if (0 != GNUNET_CONTAINER_meta_data_iterate(m, NULL, NULL))
+    ABORT(m);
+  GNUNET_CONTAINER_meta_data_destroy(m);
   return 0;
 }
 
 
 static int
-testMetaMore (int i)
+testMetaMore(int i)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   int q;
@@ -135,68 +135,68 @@ testMetaMore (int i)
   char *data;
   unsigned long long size;
 
-  meta = GNUNET_CONTAINER_meta_data_create ();
+  meta = GNUNET_CONTAINER_meta_data_create();
   for (q = 0; q <= i; q++)
-  {
-    GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
-    GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
-                                       q % 42 /* EXTRACTOR_metatype_get_max () */,
-                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                       txt, strlen (txt) + 1);
-  }
-  size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
-  data = GNUNET_malloc (size * 4);
+    {
+      GNUNET_snprintf(txt, 128, "%u -- %u\n", i, q);
+      GNUNET_CONTAINER_meta_data_insert(meta, "<test>",
+                                        q % 42 /* EXTRACTOR_metatype_get_max () */,
+                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                        txt, strlen(txt) + 1);
+    }
+  size = GNUNET_CONTAINER_meta_data_get_serialized_size(meta);
+  data = GNUNET_malloc(size * 4);
   if (size !=
-      GNUNET_CONTAINER_meta_data_serialize (meta, &data, size * 4,
-                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
-  {
-    GNUNET_free (data);
-    ABORT (meta);
-  }
-  GNUNET_CONTAINER_meta_data_destroy (meta);
-  GNUNET_free (data);
+      GNUNET_CONTAINER_meta_data_serialize(meta, &data, size * 4,
+                                           GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+    {
+      GNUNET_free(data);
+      ABORT(meta);
+    }
+  GNUNET_CONTAINER_meta_data_destroy(meta);
+  GNUNET_free(data);
   return 0;
 }
 
 
 static int
-testMetaLink ()
+testMetaLink()
 {
   struct GNUNET_CONTAINER_MetaData *m;
   char *val;
   unsigned int size;
 
-  m = GNUNET_CONTAINER_meta_data_create ();
+  m = GNUNET_CONTAINER_meta_data_create();
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
-                                         EXTRACTOR_METATYPE_UNKNOWN,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain", "link",
-                                         strlen ("link") + 1))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_insert(m, "<test>",
+                                        EXTRACTOR_METATYPE_UNKNOWN,
+                                        EXTRACTOR_METAFORMAT_UTF8,
+                                        "text/plain", "link",
+                                        strlen("link") + 1))
+    ABORT(m);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_meta_data_insert (m, "<test>",
-                                         EXTRACTOR_METATYPE_FILENAME,
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain", "lib-link.m4",
-                                         strlen ("lib-link.m4") + 1))
-    ABORT (m);
+      GNUNET_CONTAINER_meta_data_insert(m, "<test>",
+                                        EXTRACTOR_METATYPE_FILENAME,
+                                        EXTRACTOR_METAFORMAT_UTF8,
+                                        "text/plain", "lib-link.m4",
+                                        strlen("lib-link.m4") + 1))
+    ABORT(m);
   val = NULL;
   size =
-      GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
-                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
-  GNUNET_CONTAINER_meta_data_destroy (m);
-  m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
-  GNUNET_free (val);
+    GNUNET_CONTAINER_meta_data_serialize(m, &val, (size_t)-1,
+                                         GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  GNUNET_CONTAINER_meta_data_destroy(m);
+  m = GNUNET_CONTAINER_meta_data_deserialize(val, size);
+  GNUNET_free(val);
   if (m == NULL)
-    ABORT (m);
-  GNUNET_CONTAINER_meta_data_destroy (m);
+    ABORT(m);
+  GNUNET_CONTAINER_meta_data_destroy(m);
   return 0;
 }
 
 
 static int
-check ()
+check()
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_CONTAINER_MetaData *meta2;
@@ -206,143 +206,143 @@ check ()
   char *str;
   unsigned char *thumb;
 
-  meta = GNUNET_CONTAINER_meta_data_create ();
-  meta2 = GNUNET_CONTAINER_meta_data_create ();
+  meta = GNUNET_CONTAINER_meta_data_create();
+  meta2 = GNUNET_CONTAINER_meta_data_create();
   for (q = 0; q <= i; q++)
-  {
-    GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
-    GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
-                                       EXTRACTOR_METATYPE_UNKNOWN,
-                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                       "TestTitle", strlen ("TestTitle") + 1);
-    GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
-                                       EXTRACTOR_METATYPE_UNKNOWN,
-                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                       "TestTitle", strlen ("TestTitle") + 1);
-  }
+    {
+      GNUNET_snprintf(txt, 128, "%u -- %u\n", i, q);
+      GNUNET_CONTAINER_meta_data_insert(meta, "<test>",
+                                        EXTRACTOR_METATYPE_UNKNOWN,
+                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                        "TestTitle", strlen("TestTitle") + 1);
+      GNUNET_CONTAINER_meta_data_insert(meta2, "<test>",
+                                        EXTRACTOR_METATYPE_UNKNOWN,
+                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                        "TestTitle", strlen("TestTitle") + 1);
+    }
 
   //check meta_data_test_equal
-  if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+  if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal(meta, meta2))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
 
   //check meta_data_clear
-  GNUNET_CONTAINER_meta_data_clear (meta2);
-  if (0 != GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+  GNUNET_CONTAINER_meta_data_clear(meta2);
+  if (0 != GNUNET_CONTAINER_meta_data_iterate(meta2, NULL, NULL))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
   // check equal branch in meta_data_test_equal
-  if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+  if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal(meta, meta))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
   // check "count" branch in meta_data_test_equal
-  if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+  if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal(meta, meta2))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
 
   // check meta_data_add_publication_date
-  GNUNET_CONTAINER_meta_data_add_publication_date (meta2);
+  GNUNET_CONTAINER_meta_data_add_publication_date(meta2);
 
   // check meta_data_merge
-  GNUNET_CONTAINER_meta_data_clear (meta2);
-  GNUNET_CONTAINER_meta_data_merge (meta2, meta);
-  if (100 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+  GNUNET_CONTAINER_meta_data_clear(meta2);
+  GNUNET_CONTAINER_meta_data_merge(meta2, meta);
+  if (100 == GNUNET_CONTAINER_meta_data_iterate(meta2, NULL, NULL))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
 
   // check meta_data_get_by_type
-  GNUNET_CONTAINER_meta_data_clear (meta2);
+  GNUNET_CONTAINER_meta_data_clear(meta2);
   if (NULL !=
       (str =
-       GNUNET_CONTAINER_meta_data_get_by_type (meta2,
-                                               EXTRACTOR_METATYPE_UNKNOWN)))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    GNUNET_free (str);
-    ABORT (meta);
-  }
+         GNUNET_CONTAINER_meta_data_get_by_type(meta2,
+                                                EXTRACTOR_METATYPE_UNKNOWN)))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      GNUNET_free(str);
+      ABORT(meta);
+    }
 
   str =
-      GNUNET_CONTAINER_meta_data_get_by_type (meta, EXTRACTOR_METATYPE_UNKNOWN);
-  GNUNET_assert (NULL != str);
+    GNUNET_CONTAINER_meta_data_get_by_type(meta, EXTRACTOR_METATYPE_UNKNOWN);
+  GNUNET_assert(NULL != str);
   if (str[0] != 'T')
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    GNUNET_free (str);
-    ABORT (meta);
-  }
-  GNUNET_free (str);
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      GNUNET_free(str);
+      ABORT(meta);
+    }
+  GNUNET_free(str);
 
   // check branch
   if (NULL !=
       (str =
-       GNUNET_CONTAINER_meta_data_get_by_type (meta,
-                                               EXTRACTOR_METATYPE_PUBLICATION_DATE)))
-  {
-    GNUNET_free (str);
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
+         GNUNET_CONTAINER_meta_data_get_by_type(meta,
+                                                EXTRACTOR_METATYPE_PUBLICATION_DATE)))
+    {
+      GNUNET_free(str);
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
 
   //check meta_data_get_first_by_types
   str =
-      GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
-                                                     EXTRACTOR_METATYPE_UNKNOWN,
-                                                     -1);
-  GNUNET_assert (NULL != str);
+    GNUNET_CONTAINER_meta_data_get_first_by_types(meta,
+                                                  EXTRACTOR_METATYPE_UNKNOWN,
+                                                  -1);
+  GNUNET_assert(NULL != str);
   if (str[0] != 'T')
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    GNUNET_free (str);
-    ABORT (meta);
-  }
-  GNUNET_free (str);
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      GNUNET_free(str);
+      ABORT(meta);
+    }
+  GNUNET_free(str);
 
   //check meta_data_get_thumbnail
-  if (GNUNET_CONTAINER_meta_data_get_thumbnail (meta, &thumb) != 0)
-  {
-    GNUNET_free (thumb);
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
-  GNUNET_CONTAINER_meta_data_destroy (meta2);
+  if (GNUNET_CONTAINER_meta_data_get_thumbnail(meta, &thumb) != 0)
+    {
+      GNUNET_free(thumb);
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
+  GNUNET_CONTAINER_meta_data_destroy(meta2);
   //check meta_data_duplicate
-  meta2 = GNUNET_CONTAINER_meta_data_duplicate (meta);
-  if (200 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
-  {
-    GNUNET_CONTAINER_meta_data_destroy (meta2);
-    ABORT (meta);
-  }
-  GNUNET_CONTAINER_meta_data_destroy (meta2);
-  GNUNET_CONTAINER_meta_data_destroy (meta);
+  meta2 = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  if (200 == GNUNET_CONTAINER_meta_data_iterate(meta2, NULL, NULL))
+    {
+      GNUNET_CONTAINER_meta_data_destroy(meta2);
+      ABORT(meta);
+    }
+  GNUNET_CONTAINER_meta_data_destroy(meta2);
+  GNUNET_CONTAINER_meta_data_destroy(meta);
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
+  GNUNET_log_setup("test-container-meta-data", "WARNING", NULL);
   for (i = 0; i < 255; i++)
-    failureCount += testMeta (i);
+    failureCount += testMeta(i);
   for (i = 1; i < 255; i++)
-    failureCount += testMetaMore (i);
-  failureCount += testMetaLink ();
+    failureCount += testMetaMore(i);
+  failureCount += testMetaLink();
 
-  int ret = check ();
+  int ret = check();
 
   if (ret == 1)
     return 1;
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
index b83e90646..482bcb997 100644
--- a/src/util/test_container_multihashmap.c
+++ b/src/util/test_container_multihashmap.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 util/test_container_multihashmap.c
@@ -27,11 +27,11 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy(m); if (NULL != iter) GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); return 1; }
-#define CHECK(c) { if (! (c)) ABORT(); }
+#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy (m); if (NULL != iter) GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); return 1; }
+#define CHECK(c) { if (!(c)) ABORT (); }
 
 static int
-testMap (int i)
+testMap(int i)
 {
   struct GNUNET_CONTAINER_MultiHashMap *m;
   struct GNUNET_HashCode k1;
@@ -41,77 +41,77 @@ testMap (int i)
   const char *ret;
   int j;
 
-  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i, GNUNET_NO)));
-  memset (&k1, 0, sizeof (k1));
-  memset (&k2, 1, sizeof (k2));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
-  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
-  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
+  CHECK(NULL != (m = GNUNET_CONTAINER_multihashmap_create(i, GNUNET_NO)));
+  memset(&k1, 0, sizeof(k1));
+  memset(&k2, 1, sizeof(k2));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k1, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k2, NULL));
+  CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k1));
+  CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k2));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));
 
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
-  ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
-  GNUNET_assert (ret != NULL);
-  CHECK (0 == strcmp ("v1", ret));
-  CHECK (GNUNET_NO ==
-         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, &key_ret, (const void **)&ret));
-  CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, &key_ret, (const void **)&ret));
-  CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, NULL));
-  GNUNET_free (iter);
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));
+  ret = GNUNET_CONTAINER_multihashmap_get(m, &k1);
+  GNUNET_assert(ret != NULL);
+  CHECK(0 == strcmp("v1", ret));
+  CHECK(GNUNET_NO ==
+        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v3",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK(3 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK(GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove(m, &k1, "v3"));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(m, &k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k2, NULL, NULL));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));
+  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));
+  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+  GNUNET_free(iter);
 
-  CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));
   for (j = 0; j < 1024; j++)
-    CHECK (GNUNET_OK ==
-           GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
-  for (j = 0; j < GNUNET_CONTAINER_multihashmap_size (m); j++)
-    CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, NULL));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, NULL));
-  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+    CHECK(GNUNET_OK ==
+          GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);
+  for (j = 0; j < GNUNET_CONTAINER_multihashmap_size(m); j++)
+    CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
 
-  GNUNET_CONTAINER_multihashmap_destroy (m);
+  GNUNET_CONTAINER_multihashmap_destroy(m);
   return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test-container-multihashmap", "WARNING", NULL);
+  GNUNET_log_setup("test-container-multihashmap", "WARNING", NULL);
   for (i = 1; i < 255; i++)
-    failureCount += testMap (i);
+    failureCount += testMap(i);
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/util/test_container_multihashmap32.c b/src/util/test_container_multihashmap32.c
index e0e813716..d61dea782 100644
--- a/src/util/test_container_multihashmap32.c
+++ b/src/util/test_container_multihashmap32.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 util/test_container_multihashmap32.c
@@ -28,11 +28,11 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap32_destroy(m); return 1; }
-#define CHECK(c) { if (! (c)) ABORT(); }
+#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap32_destroy (m); return 1; }
+#define CHECK(c) { if (!(c)) ABORT (); }
 
 static int
-testMap (int i)
+testMap(int i)
 {
   struct GNUNET_CONTAINER_MultiHashMap32 *m;
   uint32_t k1;
@@ -40,63 +40,63 @@ testMap (int i)
   const char *ret;
   int j;
 
-  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap32_create (i)));
+  CHECK(NULL != (m = GNUNET_CONTAINER_multihashmap32_create(i)));
   k1 = 0;
   k2 = UINT32_MAX;
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains (m, k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains (m, k2));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap32_remove (m, k1, NULL));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap32_remove (m, k2, NULL));
-  CHECK (NULL == GNUNET_CONTAINER_multihashmap32_get (m, k1));
-  CHECK (NULL == GNUNET_CONTAINER_multihashmap32_get (m, k2));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap32_remove_all (m, k1));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap32_size (m));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap32_iterate (m, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap32_get_multiple (m, k1, NULL, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains(m, k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains(m, k2));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap32_remove(m, k1, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap32_remove(m, k2, NULL));
+  CHECK(NULL == GNUNET_CONTAINER_multihashmap32_get(m, k1));
+  CHECK(NULL == GNUNET_CONTAINER_multihashmap32_get(m, k2));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap32_remove_all(m, k1));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap32_size(m));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap32_iterate(m, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap32_get_multiple(m, k1, NULL, NULL));
 
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap32_put (m, k1, "v1",
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multihashmap32_size (m));
-  ret = GNUNET_CONTAINER_multihashmap32_get (m, k1);
-  GNUNET_assert (ret != NULL);
-  CHECK (0 == strcmp ("v1", ret));
-  CHECK (GNUNET_NO ==
-         GNUNET_CONTAINER_multihashmap32_put (m, k1, "v1",
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap32_put(m, k1, "v1",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK(1 == GNUNET_CONTAINER_multihashmap32_size(m));
+  ret = GNUNET_CONTAINER_multihashmap32_get(m, k1);
+  GNUNET_assert(ret != NULL);
+  CHECK(0 == strcmp("v1", ret));
+  CHECK(GNUNET_NO ==
+        GNUNET_CONTAINER_multihashmap32_put(m, k1, "v1",
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multihashmap32_size (m));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap32_put (m, k1, "v2",
+  CHECK(1 == GNUNET_CONTAINER_multihashmap32_size(m));
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap32_put(m, k1, "v2",
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multihashmap32_put (m, k1, "v3",
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap32_put(m, k1, "v3",
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (3 == GNUNET_CONTAINER_multihashmap32_size (m));
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap32_remove (m, k1, "v3"));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap32_size (m));
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap32_contains (m, k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains (m, k2));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap32_get_multiple (m, k1, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multihashmap32_get_multiple (m, k2, NULL, NULL));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap32_iterate (m, NULL, NULL));
-  CHECK (2 == GNUNET_CONTAINER_multihashmap32_remove_all (m, k1));
+  CHECK(3 == GNUNET_CONTAINER_multihashmap32_size(m));
+  CHECK(GNUNET_OK == GNUNET_CONTAINER_multihashmap32_remove(m, k1, "v3"));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap32_size(m));
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap32_contains(m, k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap32_contains(m, k2));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap32_get_multiple(m, k1, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multihashmap32_get_multiple(m, k2, NULL, NULL));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap32_iterate(m, NULL, NULL));
+  CHECK(2 == GNUNET_CONTAINER_multihashmap32_remove_all(m, k1));
   for (j = 0; j < 1024; j++)
-    CHECK (GNUNET_OK ==
-           GNUNET_CONTAINER_multihashmap32_put (m, k1, "v2",
-                                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  GNUNET_CONTAINER_multihashmap32_destroy (m);
+    CHECK(GNUNET_OK ==
+          GNUNET_CONTAINER_multihashmap32_put(m, k1, "v2",
+                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  GNUNET_CONTAINER_multihashmap32_destroy(m);
   return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test-container-multihashmap", "WARNING", NULL);
+  GNUNET_log_setup("test-container-multihashmap", "WARNING", NULL);
   for (i = 1; i < 255; i++)
-    failureCount += testMap (i);
+    failureCount += testMap(i);
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/util/test_container_multipeermap.c b/src/util/test_container_multipeermap.c
index a8ec8b8f2..67bb5d3db 100644
--- a/src/util/test_container_multipeermap.c
+++ b/src/util/test_container_multipeermap.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 util/test_container_multipeermap.c
@@ -27,11 +27,11 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (NULL != m) GNUNET_CONTAINER_multipeermap_destroy(m); if (NULL != iter) GNUNET_CONTAINER_multipeermap_iterator_destroy (iter); return 1; }
-#define CHECK(c) { if (! (c)) ABORT(); }
+#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (NULL != m) GNUNET_CONTAINER_multipeermap_destroy (m); if (NULL != iter) GNUNET_CONTAINER_multipeermap_iterator_destroy (iter); return 1; }
+#define CHECK(c) { if (!(c)) ABORT (); }
 
 static int
-testMap (int i)
+testMap(int i)
 {
   struct GNUNET_CONTAINER_MultiPeerMap *m;
   struct GNUNET_PeerIdentity k1;
@@ -41,77 +41,77 @@ testMap (int i)
   const char *ret;
   int j;
 
-  CHECK (NULL != (m = GNUNET_CONTAINER_multipeermap_create (i, GNUNET_NO)));
-  memset (&k1, 0, sizeof (k1));
-  memset (&k2, 1, sizeof (k2));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k1, NULL));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k2, NULL));
-  CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k1));
-  CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k2));
-  CHECK (0 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
-  CHECK (0 == GNUNET_CONTAINER_multipeermap_size (m));
-  CHECK (0 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
+  CHECK(NULL != (m = GNUNET_CONTAINER_multipeermap_create(i, GNUNET_NO)));
+  memset(&k1, 0, sizeof(k1));
+  memset(&k2, 1, sizeof(k2));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(m, &k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(m, &k2));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove(m, &k1, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove(m, &k2, NULL));
+  CHECK(NULL == GNUNET_CONTAINER_multipeermap_get(m, &k1));
+  CHECK(NULL == GNUNET_CONTAINER_multipeermap_get(m, &k2));
+  CHECK(0 == GNUNET_CONTAINER_multipeermap_remove_all(m, &k1));
+  CHECK(0 == GNUNET_CONTAINER_multipeermap_size(m));
+  CHECK(0 == GNUNET_CONTAINER_multipeermap_iterate(m, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multipeermap_get_multiple(m, &k1, NULL, NULL));
 
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
-  ret = GNUNET_CONTAINER_multipeermap_get (m, &k1);
-  GNUNET_assert (ret != NULL);
-  CHECK (0 == strcmp ("v1", ret));
-  CHECK (GNUNET_NO ==
-         GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (GNUNET_OK ==
-         GNUNET_CONTAINER_multipeermap_put (m, &k1, "v3",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK (3 == GNUNET_CONTAINER_multipeermap_size (m));
-  CHECK (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (m, &k1, "v3"));
-  CHECK (2 == GNUNET_CONTAINER_multipeermap_size (m));
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
-  CHECK (2 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
-  CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k2, NULL, NULL));
-  CHECK (2 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
-  iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, &key_ret, (const void **)&ret));
-  CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
-  CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, &key_ret, (const void **)&ret));
-  CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
-  GNUNET_free (iter);
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multipeermap_put(m, &k1, "v1",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK(1 == GNUNET_CONTAINER_multipeermap_size(m));
+  ret = GNUNET_CONTAINER_multipeermap_get(m, &k1);
+  GNUNET_assert(ret != NULL);
+  CHECK(0 == strcmp("v1", ret));
+  CHECK(GNUNET_NO ==
+        GNUNET_CONTAINER_multipeermap_put(m, &k1, "v1",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK(1 == GNUNET_CONTAINER_multipeermap_size(m));
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multipeermap_put(m, &k1, "v2",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK(GNUNET_OK ==
+        GNUNET_CONTAINER_multipeermap_put(m, &k1, "v3",
+                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK(3 == GNUNET_CONTAINER_multipeermap_size(m));
+  CHECK(GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(m, &k1, "v3"));
+  CHECK(2 == GNUNET_CONTAINER_multipeermap_size(m));
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(m, &k1));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(m, &k2));
+  CHECK(2 == GNUNET_CONTAINER_multipeermap_get_multiple(m, &k1, NULL, NULL));
+  CHECK(0 == GNUNET_CONTAINER_multipeermap_get_multiple(m, &k2, NULL, NULL));
+  CHECK(2 == GNUNET_CONTAINER_multipeermap_iterate(m, NULL, NULL));
+  iter = GNUNET_CONTAINER_multipeermap_iterator_create(m);
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next(iter, &key_ret, (const void **)&ret));
+  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+  CHECK(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next(iter, &key_ret, (const void **)&ret));
+  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next(iter, NULL, NULL));
+  GNUNET_free(iter);
 
-  CHECK (2 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
+  CHECK(2 == GNUNET_CONTAINER_multipeermap_remove_all(m, &k1));
   for (j = 0; j < 1024; j++)
-    CHECK (GNUNET_OK ==
-           GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
-  for (j = 0; j < GNUNET_CONTAINER_multipeermap_size (m); j++)
-    CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
-  CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
-  GNUNET_CONTAINER_multipeermap_iterator_destroy (iter);
+    CHECK(GNUNET_OK ==
+          GNUNET_CONTAINER_multipeermap_put(m, &k1, "v2",
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  iter = GNUNET_CONTAINER_multipeermap_iterator_create(m);
+  for (j = 0; j < GNUNET_CONTAINER_multipeermap_size(m); j++)
+    CHECK(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next(iter, NULL, NULL));
+  CHECK(GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next(iter, NULL, NULL));
+  GNUNET_CONTAINER_multipeermap_iterator_destroy(iter);
 
-  GNUNET_CONTAINER_multipeermap_destroy (m);
+  GNUNET_CONTAINER_multipeermap_destroy(m);
   return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test-container-multipeermap", "WARNING", NULL);
+  GNUNET_log_setup("test-container-multipeermap", "WARNING", NULL);
   for (i = 1; i < 255; i++)
-    failureCount += testMap (i);
+    failureCount += testMap(i);
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/util/test_crypto_crc.c b/src/util/test_crypto_crc.c
index 838da5dbc..fb9d5361b 100644
--- a/src/util/test_crypto_crc.c
+++ b/src/util/test_crypto_crc.c
@@ -11,7 +11,7 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -20,7 +20,7 @@
      For the actual CRC code:
      Copyright abandoned; this code is in the public domain.
      Provided to GNUnet by peter@horizon.com
-*/
+ */
 
 /**
  * @file util/test_crypto_crc.c
@@ -205,16 +205,16 @@ static int expected[] = {
 };
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   char buf[1024];
   int i;
 
-  GNUNET_log_setup ("test-crypto-crc", "WARNING", NULL);
+  GNUNET_log_setup("test-crypto-crc", "WARNING", NULL);
   for (i = 0; i < 1024; i++)
-    buf[i] = (char) i;
+    buf[i] = (char)i;
   for (i = 0; i < 1024; i++)
-    if (expected[i] != GNUNET_CRYPTO_crc32_n (&buf[i], 1024 - i))
+    if (expected[i] != GNUNET_CRYPTO_crc32_n(&buf[i], 1024 - i))
       return 1;
   return 0;
 }
diff --git a/src/util/test_crypto_ecc_dlog.c b/src/util/test_crypto_ecc_dlog.c
index c0828c354..1be7bb678 100644
--- a/src/util/test_crypto_ecc_dlog.c
+++ b/src/util/test_crypto_ecc_dlog.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_ecc_dlog.c
  * @brief testcase for ECC DLOG calculation
@@ -48,12 +48,12 @@
 
 /**
  * How many values do we test?
- */  
+ */
 #define TEST_ITER 10
 
 /**
  * Range of values to use for MATH tests.
- */  
+ */
 #define MATH_MAX 5
 
 
@@ -63,7 +63,7 @@
  * @param edc context for ECC operations
  */
 static void
-test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc)
+test_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc)
 {
   gcry_mpi_t fact;
   gcry_mpi_t n;
@@ -74,46 +74,46 @@ test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc)
   int x;
   int iret;
 
-  GNUNET_assert (0 == gcry_mpi_ec_new (&ctx, NULL, CURVE));
-  g = gcry_mpi_ec_get_point ("g", ctx, 0);
-  GNUNET_assert (NULL != g);
-  n = gcry_mpi_ec_get_mpi ("n", ctx, 0);
-  q = gcry_mpi_point_new (0);
-  fact = gcry_mpi_new (0);
-  for (i=0;i<TEST_ITER;i++)
-  {
-    fprintf (stderr, ".");
-    x = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                  MAX_FACT);
-    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                       2))
-    {
-      gcry_mpi_set_ui (fact, x);
-      gcry_mpi_sub (fact, n, fact);
-      x = - x;
-    }
-    else 
-    {
-      gcry_mpi_set_ui (fact, x);
-    }
-    gcry_mpi_ec_mul (q, fact, g, ctx);
-    if  (x !=
-         (iret = GNUNET_CRYPTO_ecc_dlog (edc,
-                                         q)))
+  GNUNET_assert(0 == gcry_mpi_ec_new(&ctx, NULL, CURVE));
+  g = gcry_mpi_ec_get_point("g", ctx, 0);
+  GNUNET_assert(NULL != g);
+  n = gcry_mpi_ec_get_mpi("n", ctx, 0);
+  q = gcry_mpi_point_new(0);
+  fact = gcry_mpi_new(0);
+  for (i = 0; i < TEST_ITER; i++)
     {
-      fprintf (stderr, 
-               "DLOG failed for value %d (%d)\n", 
-               x,
-               iret);
-      GNUNET_assert (0);
+      fprintf(stderr, ".");
+      x = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                                   MAX_FACT);
+      if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                                        2))
+        {
+          gcry_mpi_set_ui(fact, x);
+          gcry_mpi_sub(fact, n, fact);
+          x = -x;
+        }
+      else
+        {
+          gcry_mpi_set_ui(fact, x);
+        }
+      gcry_mpi_ec_mul(q, fact, g, ctx);
+      if (x !=
+          (iret = GNUNET_CRYPTO_ecc_dlog(edc,
+                                         q)))
+        {
+          fprintf(stderr,
+                  "DLOG failed for value %d (%d)\n",
+                  x,
+                  iret);
+          GNUNET_assert(0);
+        }
     }
-  }
-  gcry_mpi_release (fact);
-  gcry_mpi_release (n);
-  gcry_mpi_point_release (g);
-  gcry_mpi_point_release (q);
-  gcry_ctx_release (ctx);
-  fprintf (stderr, "\n");
+  gcry_mpi_release(fact);
+  gcry_mpi_release(n);
+  gcry_mpi_point_release(g);
+  gcry_mpi_point_release(q);
+  gcry_ctx_release(ctx);
+  fprintf(stderr, "\n");
 }
 
 
@@ -123,7 +123,7 @@ test_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc)
  * @param edc context for ECC operations
  */
 static void
-test_math (struct GNUNET_CRYPTO_EccDlogContext *edc)
+test_math(struct GNUNET_CRYPTO_EccDlogContext *edc)
 {
   int i;
   int j;
@@ -135,59 +135,59 @@ test_math (struct GNUNET_CRYPTO_EccDlogContext *edc)
   gcry_mpi_point_t r_inv;
   gcry_mpi_point_t sum;
 
-  for (i=-MATH_MAX;i<MATH_MAX;i++)
-  {
-    ip = GNUNET_CRYPTO_ecc_dexp (edc, i);
-    for (j=-MATH_MAX;j<MATH_MAX;j++)
+  for (i = -MATH_MAX; i < MATH_MAX; i++)
     {
-      fprintf (stderr, ".");
-      jp = GNUNET_CRYPTO_ecc_dexp (edc, j);
-      GNUNET_CRYPTO_ecc_rnd (edc,
-                             &r,
-                             &r_inv);
-      ir = GNUNET_CRYPTO_ecc_add (edc, ip, r);
-      irj = GNUNET_CRYPTO_ecc_add (edc, ir, jp);
-      sum = GNUNET_CRYPTO_ecc_add (edc, irj, r_inv);
-      GNUNET_assert (i + j ==
-                     GNUNET_CRYPTO_ecc_dlog (edc,
-                                             sum));
-      GNUNET_CRYPTO_ecc_free (jp);
-      GNUNET_CRYPTO_ecc_free (ir);
-      GNUNET_CRYPTO_ecc_free (irj);
-      GNUNET_CRYPTO_ecc_free (r);
-      GNUNET_CRYPTO_ecc_free (r_inv);
-      GNUNET_CRYPTO_ecc_free (sum);
+      ip = GNUNET_CRYPTO_ecc_dexp(edc, i);
+      for (j = -MATH_MAX; j < MATH_MAX; j++)
+        {
+          fprintf(stderr, ".");
+          jp = GNUNET_CRYPTO_ecc_dexp(edc, j);
+          GNUNET_CRYPTO_ecc_rnd(edc,
+                                &r,
+                                &r_inv);
+          ir = GNUNET_CRYPTO_ecc_add(edc, ip, r);
+          irj = GNUNET_CRYPTO_ecc_add(edc, ir, jp);
+          sum = GNUNET_CRYPTO_ecc_add(edc, irj, r_inv);
+          GNUNET_assert(i + j ==
+                        GNUNET_CRYPTO_ecc_dlog(edc,
+                                               sum));
+          GNUNET_CRYPTO_ecc_free(jp);
+          GNUNET_CRYPTO_ecc_free(ir);
+          GNUNET_CRYPTO_ecc_free(irj);
+          GNUNET_CRYPTO_ecc_free(r);
+          GNUNET_CRYPTO_ecc_free(r_inv);
+          GNUNET_CRYPTO_ecc_free(sum);
+        }
+      GNUNET_CRYPTO_ecc_free(ip);
     }
-    GNUNET_CRYPTO_ecc_free (ip);
-  }
-  fprintf (stderr, "\n");
+  fprintf(stderr, "\n");
 }
 
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_CRYPTO_EccDlogContext *edc;
 
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _
-             ("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  GNUNET_log_setup ("test-crypto-ecc-dlog", 
-                    "WARNING", 
-                    NULL);
-  edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_FACT,
-                                        MAX_MEM);
-  test_dlog (edc);
-  test_math (edc);
-  GNUNET_CRYPTO_ecc_dlog_release (edc);
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _
+                ("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("test-crypto-ecc-dlog",
+                   "WARNING",
+                   NULL);
+  edc = GNUNET_CRYPTO_ecc_dlog_prepare(MAX_FACT,
+                                       MAX_MEM);
+  test_dlog(edc);
+  test_math(edc);
+  GNUNET_CRYPTO_ecc_dlog_release(edc);
   return 0;
 }
 
diff --git a/src/util/test_crypto_ecdh_eddsa.c b/src/util/test_crypto_ecdh_eddsa.c
index 00f85033e..5e2d930bc 100644
--- a/src/util/test_crypto_ecdh_eddsa.c
+++ b/src/util/test_crypto_ecdh_eddsa.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_ecdh_eddsa.c
  * @brief testcase for ECC DH key exchange with EdDSA private keys.
@@ -39,56 +39,56 @@ test_ecdh()
   struct GNUNET_HashCode dh[2];
 
   /* Generate keys */
-  priv_dsa = GNUNET_CRYPTO_eddsa_key_create ();
-  GNUNET_CRYPTO_eddsa_key_get_public (priv_dsa,
-                                      &id1);
-  for (unsigned int j=0;j<4;j++)
-  {
-    fprintf (stderr, ",");
-    priv_ecdh = GNUNET_CRYPTO_ecdhe_key_create ();
-    /* Extract public keys */
-    GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdh,
-                                        &id2);
-    /* Do ECDH */
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_eddsa_ecdh (priv_dsa,
+  priv_dsa = GNUNET_CRYPTO_eddsa_key_create();
+  GNUNET_CRYPTO_eddsa_key_get_public(priv_dsa,
+                                     &id1);
+  for (unsigned int j = 0; j < 4; j++)
+    {
+      fprintf(stderr, ",");
+      priv_ecdh = GNUNET_CRYPTO_ecdhe_key_create();
+      /* Extract public keys */
+      GNUNET_CRYPTO_ecdhe_key_get_public(priv_ecdh,
+                                         &id2);
+      /* Do ECDH */
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CRYPTO_eddsa_ecdh(priv_dsa,
                                              &id2,
                                              &dh[0]));
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CRYPTO_ecdh_eddsa (priv_ecdh,
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CRYPTO_ecdh_eddsa(priv_ecdh,
                                              &id1,
                                              &dh[1]));
-    /* Check that both DH results are equal. */
-    GNUNET_assert (0 == memcmp (&dh[0],
+      /* Check that both DH results are equal. */
+      GNUNET_assert(0 == memcmp(&dh[0],
                                 &dh[1],
-                                sizeof (struct GNUNET_HashCode)));
-    GNUNET_free (priv_ecdh);
-  }
-  GNUNET_free (priv_dsa);
+                                sizeof(struct GNUNET_HashCode)));
+      GNUNET_free(priv_ecdh);
+    }
+  GNUNET_free(priv_dsa);
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  GNUNET_log_setup ("test-crypto-ecdh-eddsa", "WARNING", NULL);
-  for (unsigned int i=0;i<4;i++)
-  {
-    fprintf (stderr,
-             ".");
-    if (0 != test_ecdh())
-      return 1;
-  }
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("test-crypto-ecdh-eddsa", "WARNING", NULL);
+  for (unsigned int i = 0; i < 4; i++)
+    {
+      fprintf(stderr,
+              ".");
+      if (0 != test_ecdh())
+        return 1;
+    }
   return 0;
 }
 
diff --git a/src/util/test_crypto_ecdhe.c b/src/util/test_crypto_ecdhe.c
index 71fe9b570..d833abc1d 100644
--- a/src/util/test_crypto_ecdhe.c
+++ b/src/util/test_crypto_ecdhe.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_ecdhe.c
  * @brief testcase for ECC ECDHE public key crypto
@@ -29,7 +29,7 @@
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_CRYPTO_EcdhePrivateKey *priv1;
   struct GNUNET_CRYPTO_EcdhePrivateKey *priv2;
@@ -38,33 +38,33 @@ main (int argc, char *argv[])
   struct GNUNET_HashCode ecdh1;
   struct GNUNET_HashCode ecdh2;
 
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _
-             ("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  GNUNET_log_setup ("test-crypto-ecdhe", "WARNING", NULL);
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _
+                ("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("test-crypto-ecdhe", "WARNING", NULL);
 
-  for (unsigned int i=0;i<100;i++)
-  {
-    fprintf (stderr,
-             ".");
-    priv1 = GNUNET_CRYPTO_ecdhe_key_create ();
-    priv2 = GNUNET_CRYPTO_ecdhe_key_create ();
-    GNUNET_CRYPTO_ecdhe_key_get_public (priv1, &pub1);
-    GNUNET_CRYPTO_ecdhe_key_get_public (priv2, &pub2);
-    GNUNET_CRYPTO_ecc_ecdh (priv1, &pub2, &ecdh1);
-    GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &ecdh2);
-    GNUNET_assert (0 == memcmp (&ecdh1, &ecdh2,
-                                sizeof (struct GNUNET_HashCode)));
-    GNUNET_free (priv1);
-    GNUNET_free (priv2);
-  }
+  for (unsigned int i = 0; i < 100; i++)
+    {
+      fprintf(stderr,
+              ".");
+      priv1 = GNUNET_CRYPTO_ecdhe_key_create();
+      priv2 = GNUNET_CRYPTO_ecdhe_key_create();
+      GNUNET_CRYPTO_ecdhe_key_get_public(priv1, &pub1);
+      GNUNET_CRYPTO_ecdhe_key_get_public(priv2, &pub2);
+      GNUNET_CRYPTO_ecc_ecdh(priv1, &pub2, &ecdh1);
+      GNUNET_CRYPTO_ecc_ecdh(priv2, &pub1, &ecdh2);
+      GNUNET_assert(0 == memcmp(&ecdh1, &ecdh2,
+                                sizeof(struct GNUNET_HashCode)));
+      GNUNET_free(priv1);
+      GNUNET_free(priv2);
+    }
   return 0;
 }
 
diff --git a/src/util/test_crypto_ecdsa.c b/src/util/test_crypto_ecdsa.c
index 00cc72af4..797d61285 100644
--- a/src/util/test_crypto_ecdsa.c
+++ b/src/util/test_crypto_ecdsa.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_ecdsa.c
  * @brief testcase for ECC ECDSA public key crypto
@@ -37,7 +37,7 @@ static struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
 
 
 static int
-testSignVerify ()
+testSignVerify()
 {
   struct GNUNET_CRYPTO_EcdsaSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
@@ -46,48 +46,48 @@ testSignVerify ()
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
-  fprintf (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
-  start = GNUNET_TIME_absolute_get ();
-  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+  fprintf(stderr, "%s", "W");
+  GNUNET_CRYPTO_ecdsa_key_get_public(key, &pkey);
+  start = GNUNET_TIME_absolute_get();
+  purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TEST);
 
   for (i = 0; i < ITER; i++)
-  {
-    fprintf (stderr, "%s",  "."); fflush (stderr);
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (key, &purp, &sig))
-    {
-      fprintf (stderr,
-               "%s",
-               "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
-      ok = GNUNET_SYSERR;
-      continue;
-    }
-    if (GNUNET_SYSERR ==
-        GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
-                                    &pkey))
-    {
-      printf ("GNUNET_CRYPTO_ecdsa_verify failed!\n");
-      ok = GNUNET_SYSERR;
-      continue;
-    }
-    if (GNUNET_SYSERR !=
-        GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
-                                    &purp, &sig, &pkey))
     {
-      printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
-      ok = GNUNET_SYSERR;
-      continue;
+      fprintf(stderr, "%s", "."); fflush(stderr);
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign(key, &purp, &sig))
+        {
+          fprintf(stderr,
+                  "%s",
+                  "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR ==
+          GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
+                                     &pkey))
+        {
+          printf("GNUNET_CRYPTO_ecdsa_verify failed!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR !=
+          GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                     &purp, &sig, &pkey))
+        {
+          printf("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
     }
-  }
-  printf ("%d ECDSA sign/verify operations %s\n", ITER,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
+  printf("%d ECDSA sign/verify operations %s\n", ITER,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start), GNUNET_YES));
   return ok;
 }
 
 
 static int
-testDeriveSignVerify ()
+testDeriveSignVerify()
 {
   struct GNUNET_CRYPTO_EcdsaSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
@@ -95,52 +95,52 @@ testDeriveSignVerify ()
   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
   struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
 
-  dpriv = GNUNET_CRYPTO_ecdsa_private_key_derive (key, "test-derive", "test-CTX");
-  GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
-  GNUNET_CRYPTO_ecdsa_public_key_derive (&pkey, "test-derive", "test-CTX", &dpub);
-  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
-
-  if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (dpriv, &purp, &sig))
-  {
-    fprintf (stderr, "%s",  "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
-    GNUNET_free (dpriv);
-    return GNUNET_SYSERR;
-  }
+  dpriv = GNUNET_CRYPTO_ecdsa_private_key_derive(key, "test-derive", "test-CTX");
+  GNUNET_CRYPTO_ecdsa_key_get_public(key, &pkey);
+  GNUNET_CRYPTO_ecdsa_public_key_derive(&pkey, "test-derive", "test-CTX", &dpub);
+  purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TEST);
+
+  if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign(dpriv, &purp, &sig))
+    {
+      fprintf(stderr, "%s", "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
+      GNUNET_free(dpriv);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_SYSERR ==
-      GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
-                                  &purp, &sig,
-                                  &dpub))
-  {
-    printf ("GNUNET_CRYPTO_ecdsa_verify failed!\n");
-    GNUNET_free (dpriv);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_TEST,
+                                 &purp, &sig,
+                                 &dpub))
+    {
+      printf("GNUNET_CRYPTO_ecdsa_verify failed!\n");
+      GNUNET_free(dpriv);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_SYSERR !=
-      GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
-                                  &purp, &sig,
-                                  &pkey))
-  {
-    printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
-    GNUNET_free (dpriv);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_TEST,
+                                 &purp, &sig,
+                                 &pkey))
+    {
+      printf("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
+      GNUNET_free(dpriv);
+      return GNUNET_SYSERR;
+    }
   if (GNUNET_SYSERR !=
-      GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
-                                  &purp, &sig, &dpub))
-  {
-    printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
-    GNUNET_free (dpriv);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (dpriv);
+      GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                 &purp, &sig, &dpub))
+    {
+      printf("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
+      GNUNET_free(dpriv);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(dpriv);
   return GNUNET_OK;
 }
 
 
 #if PERF
 static int
-testSignPerformance ()
+testSignPerformance()
 {
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_CRYPTO_EcdsaSignature sig;
@@ -149,93 +149,93 @@ testSignPerformance ()
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
-  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
-  fprintf (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
-  start = GNUNET_TIME_absolute_get ();
+  purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TEST);
+  fprintf(stderr, "%s", "W");
+  GNUNET_CRYPTO_ecdsa_key_get_public(key, &pkey);
+  start = GNUNET_TIME_absolute_get();
   for (i = 0; i < ITER; i++)
-  {
-    fprintf (stderr, "%s",  "."); fflush (stderr);
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (key, &purp, &sig))
     {
-      fprintf (stderr, "%s",
-               "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
-      ok = GNUNET_SYSERR;
-      continue;
+      fprintf(stderr, "%s", "."); fflush(stderr);
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign(key, &purp, &sig))
+        {
+          fprintf(stderr, "%s",
+                  "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
     }
-  }
-  printf ("%d ECC sign operations %s\n", ITER,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
+  printf("%d ECC sign operations %s\n", ITER,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
   return ok;
 }
 #endif
 
 
 static void
-perf_keygen ()
+perf_keygen()
 {
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
   int i;
 
-  fprintf (stderr, "%s",  "W");
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    fprintf (stderr, "."); fflush (stderr);
-    pk = GNUNET_CRYPTO_ecdsa_key_create ();
-    GNUNET_free (pk);
-  }
-  for (;i<25;i++)
-    fprintf (stderr, ".");
-  fflush (stderr);
-  printf ("10 ECDSA keys created in %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
+  fprintf(stderr, "%s", "W");
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      fprintf(stderr, "."); fflush(stderr);
+      pk = GNUNET_CRYPTO_ecdsa_key_create();
+      GNUNET_free(pk);
+    }
+  for (; i < 25; i++)
+    fprintf(stderr, ".");
+  fflush(stderr);
+  printf("10 ECDSA keys created in %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start), GNUNET_YES));
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failure_count = 0;
 
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _
-             ("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  GNUNET_log_setup ("test-crypto-ecc", "WARNING", NULL);
-  key = GNUNET_CRYPTO_ecdsa_key_create ();
-  if (GNUNET_OK != testDeriveSignVerify ())
-  {
-    failure_count++;
-    fprintf (stderr,
-             "\n\n%d TESTS FAILED!\n\n", failure_count);
-    return -1;
-  }
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _
+                ("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("test-crypto-ecc", "WARNING", NULL);
+  key = GNUNET_CRYPTO_ecdsa_key_create();
+  if (GNUNET_OK != testDeriveSignVerify())
+    {
+      failure_count++;
+      fprintf(stderr,
+              "\n\n%d TESTS FAILED!\n\n", failure_count);
+      return -1;
+    }
 #if PERF
-  if (GNUNET_OK != testSignPerformance ())
+  if (GNUNET_OK != testSignPerformance())
     failure_count++;
 #endif
-  if (GNUNET_OK != testSignVerify ())
+  if (GNUNET_OK != testSignVerify())
     failure_count++;
-  GNUNET_free (key);
-  perf_keygen ();
+  GNUNET_free(key);
+  perf_keygen();
 
   if (0 != failure_count)
-  {
-    fprintf (stderr,
-             "\n\n%d TESTS FAILED!\n\n",
-             failure_count);
-    return -1;
-  }
+    {
+      fprintf(stderr,
+              "\n\n%d TESTS FAILED!\n\n",
+              failure_count);
+      return -1;
+    }
   return 0;
 }
 
diff --git a/src/util/test_crypto_eddsa.c b/src/util/test_crypto_eddsa.c
index acb5fbdf5..2119e3080 100644
--- a/src/util/test_crypto_eddsa.c
+++ b/src/util/test_crypto_eddsa.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_eddsa.c
  * @brief testcase for ECC public key crypto
@@ -39,7 +39,7 @@ static struct GNUNET_CRYPTO_EddsaPrivateKey *key;
 
 
 static int
-testSignVerify ()
+testSignVerify()
 {
   struct GNUNET_CRYPTO_EddsaSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
@@ -48,47 +48,47 @@ testSignVerify ()
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
-  fprintf (stderr, "%s",  "W");
-  GNUNET_CRYPTO_eddsa_key_get_public (key, &pkey);
-  start = GNUNET_TIME_absolute_get ();
-  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+  fprintf(stderr, "%s", "W");
+  GNUNET_CRYPTO_eddsa_key_get_public(key, &pkey);
+  start = GNUNET_TIME_absolute_get();
+  purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TEST);
 
   for (i = 0; i < ITER; i++)
-  {
-    fprintf (stderr, "%s",  "."); fflush (stderr);
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_sign (key, &purp, &sig))
-    {
-      fprintf (stderr, "%s",  "GNUNET_CRYPTO_eddsa_sign returned SYSERR\n");
-      ok = GNUNET_SYSERR;
-      continue;
-    }
-    if (GNUNET_SYSERR ==
-        GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
-                                  &pkey))
-    {
-      printf ("GNUNET_CRYPTO_eddsa_verify failed!\n");
-      ok = GNUNET_SYSERR;
-      continue;
-    }
-    if (GNUNET_SYSERR !=
-        GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
-                                  &purp, &sig, &pkey))
     {
-      printf ("GNUNET_CRYPTO_eddsa_verify failed to fail!\n");
-      ok = GNUNET_SYSERR;
-      continue;
+      fprintf(stderr, "%s", "."); fflush(stderr);
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_sign(key, &purp, &sig))
+        {
+          fprintf(stderr, "%s", "GNUNET_CRYPTO_eddsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR ==
+          GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
+                                     &pkey))
+        {
+          printf("GNUNET_CRYPTO_eddsa_verify failed!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR !=
+          GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                                     &purp, &sig, &pkey))
+        {
+          printf("GNUNET_CRYPTO_eddsa_verify failed to fail!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
     }
-  }
-  printf ("%d EdDSA sign/verify operations %s\n", ITER,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
+  printf("%d EdDSA sign/verify operations %s\n", ITER,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start), GNUNET_YES));
   return ok;
 }
 
 
 #if PERF
 static int
-testSignPerformance ()
+testSignPerformance()
 {
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_CRYPTO_EddsaSignature sig;
@@ -97,112 +97,112 @@ testSignPerformance ()
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
-  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
-  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
-  fprintf (stderr, "%s",  "W");
-  GNUNET_CRYPTO_eddsa_key_get_public (key, &pkey);
-  start = GNUNET_TIME_absolute_get ();
+  purp.size = htonl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TEST);
+  fprintf(stderr, "%s", "W");
+  GNUNET_CRYPTO_eddsa_key_get_public(key, &pkey);
+  start = GNUNET_TIME_absolute_get();
   for (i = 0; i < ITER; i++)
-  {
-    fprintf (stderr, "%s",  "."); fflush (stderr);
-    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_sign (key, &purp, &sig))
     {
-      fprintf (stderr, "%s",  "GNUNET_CRYPTO_eddsa_sign returned SYSERR\n");
-      ok = GNUNET_SYSERR;
-      continue;
+      fprintf(stderr, "%s", "."); fflush(stderr);
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_sign(key, &purp, &sig))
+        {
+          fprintf(stderr, "%s", "GNUNET_CRYPTO_eddsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
     }
-  }
-  printf ("%d EdDSA sign operations %s\n", ITER,
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
+  printf("%d EdDSA sign operations %s\n", ITER,
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
   return ok;
 }
 #endif
 
 
 static int
-testCreateFromFile ()
+testCreateFromFile()
 {
   struct GNUNET_CRYPTO_EddsaPublicKey p1;
   struct GNUNET_CRYPTO_EddsaPublicKey p2;
 
-  key = GNUNET_CRYPTO_eddsa_key_create_from_file (KEYFILE);
-  GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_eddsa_key_get_public (key, &p1);
-  GNUNET_free (key);
-  key = GNUNET_CRYPTO_eddsa_key_create_from_file (KEYFILE);
-  GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_eddsa_key_get_public (key, &p2);
-  GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
-  GNUNET_free (key);
-  GNUNET_assert (0 == unlink (KEYFILE));
-  key = GNUNET_CRYPTO_eddsa_key_create_from_file (KEYFILE);
-  GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_eddsa_key_get_public (key, &p2);
-  GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
-  GNUNET_free (key);
+  key = GNUNET_CRYPTO_eddsa_key_create_from_file(KEYFILE);
+  GNUNET_assert(NULL != key);
+  GNUNET_CRYPTO_eddsa_key_get_public(key, &p1);
+  GNUNET_free(key);
+  key = GNUNET_CRYPTO_eddsa_key_create_from_file(KEYFILE);
+  GNUNET_assert(NULL != key);
+  GNUNET_CRYPTO_eddsa_key_get_public(key, &p2);
+  GNUNET_assert(0 == memcmp(&p1, &p2, sizeof(p1)));
+  GNUNET_free(key);
+  GNUNET_assert(0 == unlink(KEYFILE));
+  key = GNUNET_CRYPTO_eddsa_key_create_from_file(KEYFILE);
+  GNUNET_assert(NULL != key);
+  GNUNET_CRYPTO_eddsa_key_get_public(key, &p2);
+  GNUNET_assert(0 != memcmp(&p1, &p2, sizeof(p1)));
+  GNUNET_free(key);
   return GNUNET_OK;
 }
 
 
 static void
-perf_keygen ()
+perf_keygen()
 {
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
   int i;
 
-  fprintf (stderr, "%s",  "W");
-  start = GNUNET_TIME_absolute_get ();
-  for (i=0;i<10;i++)
-  {
-    fprintf (stderr, "."); fflush (stderr);
-    pk = GNUNET_CRYPTO_eddsa_key_create ();
-    GNUNET_free (pk);
-  }
-  for (;i<25;i++)
-    fprintf (stderr, ".");
-  fflush (stderr);
-  printf ("10 EdDSA keys created in %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
+  fprintf(stderr, "%s", "W");
+  start = GNUNET_TIME_absolute_get();
+  for (i = 0; i < 10; i++)
+    {
+      fprintf(stderr, "."); fflush(stderr);
+      pk = GNUNET_CRYPTO_eddsa_key_create();
+      GNUNET_free(pk);
+    }
+  for (; i < 25; i++)
+    fprintf(stderr, ".");
+  fflush(stderr);
+  printf("10 EdDSA keys created in %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start), GNUNET_YES));
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failure_count = 0;
 
-  if (! gcry_check_version ("1.6.0"))
-  {
-    fprintf (stderr,
-             _("libgcrypt has not the expected version (version %s is required).\n"),
-             "1.6.0");
-    return 0;
-  }
-  if (getenv ("GNUNET_GCRYPT_DEBUG"))
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  GNUNET_log_setup ("test-crypto-eddsa", "WARNING", NULL);
-  key = GNUNET_CRYPTO_eddsa_key_create ();
+  if (!gcry_check_version("1.6.0"))
+    {
+      fprintf(stderr,
+              _("libgcrypt has not the expected version (version %s is required).\n"),
+              "1.6.0");
+      return 0;
+    }
+  if (getenv("GNUNET_GCRYPT_DEBUG"))
+    gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+  GNUNET_log_setup("test-crypto-eddsa", "WARNING", NULL);
+  key = GNUNET_CRYPTO_eddsa_key_create();
 #if PERF
-  if (GNUNET_OK != testSignPerformance ())
+  if (GNUNET_OK != testSignPerformance())
     failure_count++;
 #endif
-  if (GNUNET_OK != testSignVerify ())
+  if (GNUNET_OK != testSignVerify())
     failure_count++;
-  GNUNET_free (key);
-  if (GNUNET_OK != testCreateFromFile ())
+  GNUNET_free(key);
+  if (GNUNET_OK != testCreateFromFile())
     failure_count++;
-  GNUNET_assert (0 == unlink (KEYFILE));
-  perf_keygen ();
+  GNUNET_assert(0 == unlink(KEYFILE));
+  perf_keygen();
 
   if (0 != failure_count)
-  {
-    fprintf (stderr,
-             "\n\n%d TESTS FAILED!\n\n",
-             failure_count);
-    return -1;
-  }
+    {
+      fprintf(stderr,
+              "\n\n%d TESTS FAILED!\n\n",
+              failure_count);
+      return -1;
+    }
   return 0;
 }
 
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c
index e08348e53..0e8246595 100644
--- a/src/util/test_crypto_hash.c
+++ b/src/util/test_crypto_hash.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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -31,37 +31,37 @@ static char block[65536];
 #define FILENAME "testblock.dat"
 
 static int
-test (int number)
+test(int number)
 {
   struct GNUNET_HashCode h1;
   struct GNUNET_HashCode h2;
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
-  memset (&h1, number, sizeof (struct GNUNET_HashCode));
-  GNUNET_CRYPTO_hash_to_enc (&h1, &enc);
-  if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &h2))
-  {
-    printf ("enc2hash failed!\n");
-    return 1;
-  }
-  if (0 != memcmp (&h1, &h2, sizeof (struct GNUNET_HashCode)))
+  memset(&h1, number, sizeof(struct GNUNET_HashCode));
+  GNUNET_CRYPTO_hash_to_enc(&h1, &enc);
+  if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string((char *)&enc, &h2))
+    {
+      printf("enc2hash failed!\n");
+      return 1;
+    }
+  if (0 != memcmp(&h1, &h2, sizeof(struct GNUNET_HashCode)))
     return 1;
   return 0;
 }
 
 static int
-testEncoding ()
+testEncoding()
 {
   int i;
 
   for (i = 0; i < 255; i++)
-    if (0 != test (i))
+    if (0 != test(i))
       return 1;
   return 0;
 }
 
 static int
-testArithmetic ()
+testArithmetic()
 {
   struct GNUNET_HashCode h1;
   struct GNUNET_HashCode h2;
@@ -70,43 +70,43 @@ testArithmetic ()
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
-  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h1);
-  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h2);
-  if (GNUNET_CRYPTO_hash_distance_u32 (&h1, &h2) !=
-      GNUNET_CRYPTO_hash_distance_u32 (&h2, &h1))
+  GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &h1);
+  GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &h2);
+  if (GNUNET_CRYPTO_hash_distance_u32(&h1, &h2) !=
+      GNUNET_CRYPTO_hash_distance_u32(&h2, &h1))
     return 1;
-  GNUNET_CRYPTO_hash_difference (&h1, &h2, &d);
-  GNUNET_CRYPTO_hash_sum (&h1, &d, &s);
-  if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
+  GNUNET_CRYPTO_hash_difference(&h1, &h2, &d);
+  GNUNET_CRYPTO_hash_sum(&h1, &d, &s);
+  if (0 != GNUNET_CRYPTO_hash_cmp(&s, &h2))
     return 1;
-  GNUNET_CRYPTO_hash_xor (&h1, &h2, &d);
-  GNUNET_CRYPTO_hash_xor (&h1, &d, &s);
-  if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
+  GNUNET_CRYPTO_hash_xor(&h1, &h2, &d);
+  GNUNET_CRYPTO_hash_xor(&h1, &d, &s);
+  if (0 != GNUNET_CRYPTO_hash_cmp(&s, &h2))
     return 1;
-  if (0 != GNUNET_CRYPTO_hash_xorcmp (&s, &h2, &h1))
+  if (0 != GNUNET_CRYPTO_hash_xorcmp(&s, &h2, &h1))
     return 1;
-  if (-1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h1))
+  if (-1 != GNUNET_CRYPTO_hash_xorcmp(&h1, &h2, &h1))
     return 1;
-  if (1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h2))
+  if (1 != GNUNET_CRYPTO_hash_xorcmp(&h1, &h2, &h2))
     return 1;
-  memset (&d, 0xF0, sizeof (d));
-  if (0 != GNUNET_CRYPTO_hash_get_bit (&d, 3))
+  memset(&d, 0xF0, sizeof(d));
+  if (0 != GNUNET_CRYPTO_hash_get_bit(&d, 3))
     return 1;
-  if (1 != GNUNET_CRYPTO_hash_get_bit (&d, 6))
+  if (1 != GNUNET_CRYPTO_hash_get_bit(&d, 6))
     return 1;
-  memset (&d, 0, sizeof (d));
-  GNUNET_CRYPTO_hash_to_aes_key (&d, &skey, &iv);
+  memset(&d, 0, sizeof(d));
+  GNUNET_CRYPTO_hash_to_aes_key(&d, &skey, &iv);
   return 0;
 }
 
 static void
-finished_task (void *cls, const struct GNUNET_HashCode * res)
+finished_task(void *cls, const struct GNUNET_HashCode * res)
 {
   int *ret = cls;
   struct GNUNET_HashCode want;
 
-  GNUNET_CRYPTO_hash (block, sizeof (block), &want);
-  if (0 != memcmp (res, &want, sizeof (want)))
+  GNUNET_CRYPTO_hash(block, sizeof(block), &want);
+  if (0 != memcmp(res, &want, sizeof(want)))
     *ret = 2;
   else
     *ret = 0;
@@ -114,43 +114,43 @@ finished_task (void *cls, const struct GNUNET_HashCode * res)
 
 
 static void
-file_hasher (void *cls)
+file_hasher(void *cls)
 {
-  GNUNET_assert (NULL !=
-                 GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                          FILENAME, 1024, &finished_task, cls));
+  GNUNET_assert(NULL !=
+                GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                        FILENAME, 1024, &finished_task, cls));
 }
 
 
 static int
-testFileHash ()
+testFileHash()
 {
   int ret;
   FILE *f;
 
-  memset (block, 42, sizeof (block) / 2);
-  memset (&block[sizeof (block) / 2], 43, sizeof (block) / 2);
-  GNUNET_assert (NULL != (f = fopen (FILENAME, "w+")));
-  GNUNET_break (sizeof (block) == fwrite (block, 1, sizeof (block), f));
-  GNUNET_break (0 == fclose (f));
+  memset(block, 42, sizeof(block) / 2);
+  memset(&block[sizeof(block) / 2], 43, sizeof(block) / 2);
+  GNUNET_assert(NULL != (f = fopen(FILENAME, "w+")));
+  GNUNET_break(sizeof(block) == fwrite(block, 1, sizeof(block), f));
+  GNUNET_break(0 == fclose(f));
   ret = 1;
-  GNUNET_SCHEDULER_run (&file_hasher, &ret);
-  GNUNET_break (0 == unlink (FILENAME));
+  GNUNET_SCHEDULER_run(&file_hasher, &ret);
+  GNUNET_break(0 == unlink(FILENAME));
   return ret;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test-crypto-hash", "WARNING", NULL);
+  GNUNET_log_setup("test-crypto-hash", "WARNING", NULL);
   for (i = 0; i < 10; i++)
-    failureCount += testEncoding ();
-  failureCount += testArithmetic ();
-  failureCount += testFileHash ();
+    failureCount += testEncoding();
+  failureCount += testArithmetic();
+  failureCount += testFileHash();
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/util/test_crypto_hash_context.c b/src/util/test_crypto_hash_context.c
index 847fe56ba..778b70eec 100644
--- a/src/util/test_crypto_hash_context.c
+++ b/src/util/test_crypto_hash_context.c
@@ -1,22 +1,22 @@
 /*
-  This file is part of GNUnet
-  Copyright (C) 2014 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/>.
+   This file is part of GNUnet
+   Copyright (C) 2014 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 util/test_crypto_hash_context.c
  * @brief test case for incremental hashing
@@ -34,15 +34,15 @@ int main()
   struct GNUNET_HashCode hc2;
   struct GNUNET_HashContext *hctx;
 
-  memset (data, 42, LEN);
+  memset(data, 42, LEN);
 
-  hctx = GNUNET_CRYPTO_hash_context_start ();
-  GNUNET_CRYPTO_hash_context_read (hctx, data, LEN);
-  GNUNET_CRYPTO_hash_context_finish (hctx, &hc1);
+  hctx = GNUNET_CRYPTO_hash_context_start();
+  GNUNET_CRYPTO_hash_context_read(hctx, data, LEN);
+  GNUNET_CRYPTO_hash_context_finish(hctx, &hc1);
 
-  GNUNET_CRYPTO_hash (data, LEN, &hc2);
+  GNUNET_CRYPTO_hash(data, LEN, &hc2);
 
-  if (0 == memcmp (&hc1, &hc2, sizeof (struct GNUNET_HashCode)))
+  if (0 == memcmp(&hc1, &hc2, sizeof(struct GNUNET_HashCode)))
     return 0;
   return 1;
 }
diff --git a/src/util/test_crypto_hkdf.c b/src/util/test_crypto_hkdf.c
index 752116194..d4829791d 100644
--- a/src/util/test_crypto_hkdf.c
+++ b/src/util/test_crypto_hkdf.c
@@ -18,7 +18,7 @@
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
-*/
+ */
 
 /**
  * @file src/util/test_crypt_hkdf.c
@@ -33,319 +33,293 @@
 #include "gnunet_crypto_lib.h"
 
 void
-tc1 ()
+tc1()
 {
   unsigned char ikm[22] =
-      { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
-  };
+  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
   unsigned char salt[13] =
-      { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
-    0x0a, 0x0b, 0x0c
-  };
+  { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x0a, 0x0b, 0x0c };
   unsigned char info[10] =
-      { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
+  { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
   unsigned char okm[42] =
-      { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43,
+  { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43,
     0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a,
     0x5a, 0x4c, 0x5d, 0xb0, 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf, 0x34, 0x00,
-    0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18, 0x58, 0x65
-  };
+    0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18, 0x58, 0x65 };
   unsigned char result[44];
   int l = 42;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, salt,
-                  sizeof (salt), ikm, sizeof (ikm), info, sizeof (info),
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, salt,
+                  sizeof(salt), ikm, sizeof(ikm), info, sizeof(info),
                   NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc2 ()
+tc2()
 {
   unsigned char ikm[80] =
-      { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+  { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
     0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
     0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
     0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
     0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f
-  };
+    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f };
   unsigned char salt[80] =
-      { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+  { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81,
     0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d,
     0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5,
-    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf
-  };
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf };
   unsigned char info[80] =
-      { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
+  { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
     0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
     0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd,
     0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5,
-    0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
-  };
+    0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
   unsigned char okm[82] =
-      { 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7,
+  { 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7,
     0xf7, 0x8c, 0x59, 0x6a, 0x49, 0x34, 0x4f, 0x01, 0x2e, 0xda, 0x2d, 0x4e,
     0xfa, 0xd8, 0xa0, 0x50, 0xcc, 0x4c, 0x19, 0xaf, 0xa9, 0x7c, 0x59, 0x04,
     0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72, 0x71, 0xcb, 0x41, 0xc6, 0x5e, 0x59,
     0x0e, 0x09, 0xda, 0x32, 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8, 0x36, 0x77,
     0x93, 0xa9, 0xac, 0xa3, 0xdb, 0x71, 0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec,
-    0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5, 0xc1, 0xf3, 0x43, 0x4f, 0x1d, 0x87
-  };
+    0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5, 0xc1, 0xf3, 0x43, 0x4f, 0x1d, 0x87 };
   char result[84];
   int l = 82;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, salt,
-                  sizeof (salt), ikm, sizeof (ikm), info, sizeof (info),
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, salt,
+                  sizeof(salt), ikm, sizeof(ikm), info, sizeof(info),
                   NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc3 ()
+tc3()
 {
   unsigned char ikm[22] =
-      { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
-  };
+  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
   unsigned char okm[42] =
-      { 0x8d, 0xa4, 0xe7, 0x75, 0xa5, 0x63, 0xc1, 0x8f, 0x71, 0x5f,
+  { 0x8d, 0xa4, 0xe7, 0x75, 0xa5, 0x63, 0xc1, 0x8f, 0x71, 0x5f,
     0x80, 0x2a, 0x06, 0x3c, 0x5a, 0x31, 0xb8, 0xa1, 0x1f, 0x5c, 0x5e, 0xe1,
     0x87, 0x9e, 0xc3, 0x45, 0x4e, 0x5f, 0x3c, 0x73, 0x8d, 0x2d, 0x9d, 0x20,
-    0x13, 0x95, 0xfa, 0xa4, 0xb6, 0x1a, 0x96, 0xc8
-  };
+    0x13, 0x95, 0xfa, 0xa4, 0xb6, 0x1a, 0x96, 0xc8 };
   unsigned char result[44];
   int l = 42;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, NULL, 0, ikm,
-                  sizeof (ikm), NULL, 0, NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA256, GCRY_MD_SHA256, NULL, 0, ikm,
+                  sizeof(ikm), NULL, 0, NULL) == GNUNET_YES);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc4 ()
+tc4()
 {
   unsigned char ikm[11] =
-      { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-    0x0b
-  };
+  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+    0x0b };
   unsigned char salt[13] =
-      { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
-    0x0a, 0x0b, 0x0c
-  };
+  { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x0a, 0x0b, 0x0c };
   unsigned char info[10] =
-      { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
+  { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
   unsigned char okm[42] =
-      { 0x08, 0x5a, 0x01, 0xea, 0x1b, 0x10, 0xf3, 0x69, 0x33, 0x06,
+  { 0x08, 0x5a, 0x01, 0xea, 0x1b, 0x10, 0xf3, 0x69, 0x33, 0x06,
     0x8b, 0x56, 0xef, 0xa5, 0xad, 0x81, 0xa4, 0xf1, 0x4b, 0x82, 0x2f, 0x5b,
     0x09, 0x15, 0x68, 0xa9, 0xcd, 0xd4, 0xf1, 0x55, 0xfd, 0xa2, 0xc2, 0x2e,
-    0x42, 0x24, 0x78, 0xd3, 0x05, 0xf3, 0xf8, 0x96
-  };
+    0x42, 0x24, 0x78, 0xd3, 0x05, 0xf3, 0xf8, 0x96 };
   char result[84];
   int l = 42;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof (salt),
-                  ikm, sizeof (ikm), info, sizeof (info), NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof(salt),
+                  ikm, sizeof(ikm), info, sizeof(info), NULL) == GNUNET_YES);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc5 ()
+tc5()
 {
   unsigned char ikm[80] =
-      { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+  { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
     0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
     0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
     0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
     0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f
-  };
+    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f };
   unsigned char salt[80] =
-      { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+  { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81,
     0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d,
     0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5,
-    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf
-  };
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf };
   unsigned char info[80] =
-      { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
+  { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
     0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
     0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd,
     0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5,
-    0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
-  };
+    0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
   unsigned char okm[82] =
-      { 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7, 0xc9, 0xf1,
+  { 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7, 0xc9, 0xf1,
     0x2c, 0xd5, 0x91, 0x2a, 0x06, 0xeb, 0xff, 0x6a, 0xdc, 0xae, 0x89, 0x9d,
     0x92, 0x19, 0x1f, 0xe4, 0x30, 0x56, 0x73, 0xba, 0x2f, 0xfe, 0x8f, 0xa3,
     0xf1, 0xa4, 0xe5, 0xad, 0x79, 0xf3, 0xf3, 0x34, 0xb3, 0xb2, 0x02, 0xb2,
     0x17, 0x3c, 0x48, 0x6e, 0xa3, 0x7c, 0xe3, 0xd3, 0x97, 0xed, 0x03, 0x4c,
     0x7f, 0x9d, 0xfe, 0xb1, 0x5c, 0x5e, 0x92, 0x73, 0x36, 0xd0, 0x44, 0x1f,
-    0x4c, 0x43, 0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52, 0xd3, 0xb4
-  };
+    0x4c, 0x43, 0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52, 0xd3, 0xb4 };
   char result[84];
   int l = 82;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof (salt),
-                  ikm, sizeof (ikm), info, sizeof (info), NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof(salt),
+                  ikm, sizeof(ikm), info, sizeof(info), NULL) == GNUNET_YES);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc6 ()
+tc6()
 {
   unsigned char ikm[22] =
-      { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
-  };
+  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
   unsigned char okm[42] =
-      { 0x0a, 0xc1, 0xaf, 0x70, 0x02, 0xb3, 0xd7, 0x61, 0xd1, 0xe5,
+  { 0x0a, 0xc1, 0xaf, 0x70, 0x02, 0xb3, 0xd7, 0x61, 0xd1, 0xe5,
     0x52, 0x98, 0xda, 0x9d, 0x05, 0x06, 0xb9, 0xae, 0x52, 0x05, 0x72, 0x20,
     0xa3, 0x06, 0xe0, 0x7b, 0x6b, 0x87, 0xe8, 0xdf, 0x21, 0xd0, 0xea, 0x00,
-    0x03, 0x3d, 0xe0, 0x39, 0x84, 0xd3, 0x49, 0x18
-  };
+    0x03, 0x3d, 0xe0, 0x39, 0x84, 0xd3, 0x49, 0x18 };
   char result[44];
   int l = 42;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, NULL, 0, ikm,
-                  sizeof (ikm), NULL, 0, NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, NULL, 0, ikm,
+                  sizeof(ikm), NULL, 0, NULL) == GNUNET_YES);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc7 ()
+tc7()
 {
   unsigned char ikm[80] =
-      { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+  { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
     0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
     0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
     0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
     0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f
-  };
+    0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f };
   unsigned char salt[80] =
-      { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+  { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81,
     0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d,
     0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5,
-    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf
-  };
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf };
   unsigned char info1[34] = { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
-    0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-    0xd0, 0xd1
-  };
+                              0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
+                              0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+                              0xd0, 0xd1 };
   unsigned char info2[46] = { 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
-    0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
-    0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1,
-    0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd,
-    0xfe, 0xff
-  };
+                              0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
+                              0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1,
+                              0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd,
+                              0xfe, 0xff };
   unsigned char okm[82] =
-      { 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7, 0xc9, 0xf1,
+  { 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7, 0xc9, 0xf1,
     0x2c, 0xd5, 0x91, 0x2a, 0x06, 0xeb, 0xff, 0x6a, 0xdc, 0xae, 0x89, 0x9d,
     0x92, 0x19, 0x1f, 0xe4, 0x30, 0x56, 0x73, 0xba, 0x2f, 0xfe, 0x8f, 0xa3,
     0xf1, 0xa4, 0xe5, 0xad, 0x79, 0xf3, 0xf3, 0x34, 0xb3, 0xb2, 0x02, 0xb2,
     0x17, 0x3c, 0x48, 0x6e, 0xa3, 0x7c, 0xe3, 0xd3, 0x97, 0xed, 0x03, 0x4c,
     0x7f, 0x9d, 0xfe, 0xb1, 0x5c, 0x5e, 0x92, 0x73, 0x36, 0xd0, 0x44, 0x1f,
-    0x4c, 0x43, 0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52, 0xd3, 0xb4
-  };
+    0x4c, 0x43, 0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52, 0xd3, 0xb4 };
   char result[84];
   int l = 82;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof (salt),
-                  ikm, sizeof (ikm), info1, sizeof (info1), info2,
-                  sizeof (info2), NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA1, GCRY_MD_SHA1, salt, sizeof(salt),
+                  ikm, sizeof(ikm), info1, sizeof(info1), info2,
+                  sizeof(info2), NULL) == GNUNET_YES);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 void
-tc8 ()
+tc8()
 {
   unsigned char ikm[32] =
-      { 0xbf, 0x16, 0x6e, 0x46, 0x3a, 0x6c, 0xf3, 0x93, 0xa7, 0x72,
+  { 0xbf, 0x16, 0x6e, 0x46, 0x3a, 0x6c, 0xf3, 0x93, 0xa7, 0x72,
     0x11, 0xa1, 0xdc, 0x0b, 0x07, 0xdb, 0x1a, 0x5e, 0xd9, 0xb9, 0x81, 0xbe,
-    0xea, 0xe4, 0x31, 0x5f, 0x24, 0xff, 0xfe, 0x50, 0x8a, 0xde
-  };
+    0xea, 0xe4, 0x31, 0x5f, 0x24, 0xff, 0xfe, 0x50, 0x8a, 0xde };
   unsigned char salt[4] = { 0xfc, 0x62, 0x76, 0x35 };
   unsigned char info[86] =
-      { 0x8c, 0x0d, 0xcf, 0xb3, 0x25, 0x6e, 0x88, 0x0d, 0xc1, 0x0b,
+  { 0x8c, 0x0d, 0xcf, 0xb3, 0x25, 0x6e, 0x88, 0x0d, 0xc1, 0x0b,
     0x1d, 0x33, 0x15, 0x3e, 0x52, 0x0b, 0xb0, 0x77, 0xff, 0x7d, 0xc3, 0xc7,
     0xef, 0xe5, 0x8e, 0x3c, 0xc4, 0x4e, 0x8b, 0x41, 0x46, 0x1f, 0x02, 0x94,
     0x82, 0x35, 0xc5, 0xa6, 0x5e, 0x91, 0xd8, 0xa2, 0x90, 0xfd, 0x6f, 0xb4,
     0x07, 0xc9, 0xed, 0x6b, 0x18, 0x90, 0x31, 0xab, 0x0f, 0xb5, 0x6b, 0xec,
     0x9e, 0x45, 0xa2, 0x83, 0x65, 0x41, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61,
     0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x65, 0x63,
-    0x74, 0x6f, 0x72, 0x00
-  };
+    0x74, 0x6f, 0x72, 0x00 };
   unsigned char okm[16] =
-      { 0xd6, 0x90, 0xec, 0x9e, 0x62, 0xdf, 0xb9, 0x41, 0xff, 0x92,
-    0x4f, 0xd2, 0xf6, 0x1d, 0x67, 0xe0
-  };
+  { 0xd6, 0x90, 0xec, 0x9e, 0x62, 0xdf, 0xb9, 0x41, 0xff, 0x92,
+    0x4f, 0xd2, 0xf6, 0x1d, 0x67, 0xe0 };
   char result[18];
   int l = 16;
 
-  memset (result, 0, sizeof (result));
-  GNUNET_assert (GNUNET_CRYPTO_hkdf
-                 (result, l, GCRY_MD_SHA512, GCRY_MD_SHA256, salt,
-                  sizeof (salt), ikm, sizeof (ikm), info, sizeof (info),
+  memset(result, 0, sizeof(result));
+  GNUNET_assert(GNUNET_CRYPTO_hkdf
+                  (result, l, GCRY_MD_SHA512, GCRY_MD_SHA256, salt,
+                  sizeof(salt), ikm, sizeof(ikm), info, sizeof(info),
                   NULL) == GNUNET_YES);
-  GNUNET_assert (memcmp (result, okm, l) == 0);
-  GNUNET_assert (memcmp (result + l, "\0", 2) == 0);
+  GNUNET_assert(memcmp(result, okm, l) == 0);
+  GNUNET_assert(memcmp(result + l, "\0", 2) == 0);
 }
 
 int
-main ()
+main()
 {
-  GNUNET_log_setup ("test-crypto-hkdf", "WARNING", NULL);
+  GNUNET_log_setup("test-crypto-hkdf", "WARNING", NULL);
 
   /* Official test vectors */
-  tc1 ();
-  tc2 ();
-  tc3 ();
-  tc4 ();
-  tc5 ();
-  tc6 ();
+  tc1();
+  tc2();
+  tc3();
+  tc4();
+  tc5();
+  tc6();
 
   /* Additional tests */
-  tc7 ();
-  tc8 ();
+  tc7();
+  tc8();
 
   return 0;
 }
diff --git a/src/util/test_crypto_kdf.c b/src/util/test_crypto_kdf.c
index f75bafbb1..a5c9bba20 100644
--- a/src/util/test_crypto_kdf.c
+++ b/src/util/test_crypto_kdf.c
@@ -18,7 +18,7 @@
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
-*/
+ */
 
 /**
  * @file src/util/test_crypt_kdf.c
@@ -33,38 +33,39 @@
 
 
 int
-main ()
+main()
 {
 #define RND_BLK_SIZE 4096
   unsigned char rnd_blk[RND_BLK_SIZE];
   int i;
-  gcry_mpi_t r,n;
+  gcry_mpi_t r, n;
 
-  GNUNET_log_setup ("test-crypto-kdf", "WARNING", NULL);
+  GNUNET_log_setup("test-crypto-kdf", "WARNING", NULL);
 
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              rnd_blk,
-                              RND_BLK_SIZE);
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             rnd_blk,
+                             RND_BLK_SIZE);
 
   /* test full domain hash size */
-  for (i=0; i<100; i++) {
-    gcry_mpi_scan (&n,
-                   GCRYMPI_FMT_USG,
-                   rnd_blk, RND_BLK_SIZE,
-                   NULL);
-    GNUNET_CRYPTO_kdf_mod_mpi (&r, n,
-                               "", 0,
-                               "", 0,
-                               "");
-    GNUNET_assert( 0 > gcry_mpi_cmp(r,n) );
+  for (i = 0; i < 100; i++)
+    {
+      gcry_mpi_scan(&n,
+                    GCRYMPI_FMT_USG,
+                    rnd_blk, RND_BLK_SIZE,
+                    NULL);
+      GNUNET_CRYPTO_kdf_mod_mpi(&r, n,
+                                "", 0,
+                                "", 0,
+                                "");
+      GNUNET_assert(0 > gcry_mpi_cmp(r, n));
 
-    /* Is it worth checking that it's not too small? */
-    /* GNUNET_assert (gcry_mpi_get_nbits(r) > 3*RND_BLK_SIZE/4); */
-    /* This test necessarily randomly fails with probability 2^(3 - RND_BLK_SIZE/4) */
+      /* Is it worth checking that it's not too small? */
+      /* GNUNET_assert (gcry_mpi_get_nbits(r) > 3*RND_BLK_SIZE/4); */
+      /* This test necessarily randomly fails with probability 2^(3 - RND_BLK_SIZE/4) */
 
-    gcry_mpi_release(n);
-    gcry_mpi_release(r);
-  }
+      gcry_mpi_release(n);
+      gcry_mpi_release(r);
+    }
 
   return 0;
 }
diff --git a/src/util/test_crypto_paillier.c b/src/util/test_crypto_paillier.c
index d19696372..c4555fd10 100644
--- a/src/util/test_crypto_paillier.c
+++ b/src/util/test_crypto_paillier.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_paillier.c
  * @brief testcase paillier crypto
@@ -30,7 +30,7 @@
 
 
 static int
-test_crypto ()
+test_crypto()
 {
   gcry_mpi_t plaintext;
   gcry_mpi_t plaintext_result;
@@ -39,43 +39,43 @@ test_crypto ()
   struct GNUNET_CRYPTO_PaillierPrivateKey private_key;
   int ret = 0;
 
-  GNUNET_CRYPTO_paillier_create (&public_key,
-                                 &private_key);
-  GNUNET_assert (NULL != (plaintext = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (plaintext_result = gcry_mpi_new (0)));
-  gcry_mpi_randomize (plaintext,
-                      GNUNET_CRYPTO_PAILLIER_BITS / 2,
-                      GCRY_WEAK_RANDOM);
-
-  GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                  plaintext,
-                                  0 /* 0 hom ops */,
-                                  &ciphertext);
-  GNUNET_CRYPTO_paillier_decrypt (&private_key,
-                                  &public_key,
-                                  &ciphertext,
-                                  plaintext_result);
-  if (0 != gcry_mpi_cmp (plaintext,
-                         plaintext_result))
-  {
-    fprintf (stderr,
-             "Paillier decryption failed with plaintext of size %u\n",
-             gcry_mpi_get_nbits (plaintext));
-    gcry_log_debugmpi ("\n",
-                       plaintext);
-    gcry_log_debugmpi ("\n",
-                       plaintext_result);
-    ret = 1;
-  }
-  gcry_mpi_release (plaintext);
-  gcry_mpi_release (plaintext_result);
+  GNUNET_CRYPTO_paillier_create(&public_key,
+                                &private_key);
+  GNUNET_assert(NULL != (plaintext = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (plaintext_result = gcry_mpi_new(0)));
+  gcry_mpi_randomize(plaintext,
+                     GNUNET_CRYPTO_PAILLIER_BITS / 2,
+                     GCRY_WEAK_RANDOM);
+
+  GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                 plaintext,
+                                 0 /* 0 hom ops */,
+                                 &ciphertext);
+  GNUNET_CRYPTO_paillier_decrypt(&private_key,
+                                 &public_key,
+                                 &ciphertext,
+                                 plaintext_result);
+  if (0 != gcry_mpi_cmp(plaintext,
+                        plaintext_result))
+    {
+      fprintf(stderr,
+              "Paillier decryption failed with plaintext of size %u\n",
+              gcry_mpi_get_nbits(plaintext));
+      gcry_log_debugmpi("\n",
+                        plaintext);
+      gcry_log_debugmpi("\n",
+                        plaintext_result);
+      ret = 1;
+    }
+  gcry_mpi_release(plaintext);
+  gcry_mpi_release(plaintext_result);
   return ret;
 }
 
 
 static int
-test_hom_simple (unsigned int a,
-                 unsigned int b)
+test_hom_simple(unsigned int a,
+                unsigned int b)
 {
   gcry_mpi_t m1;
   gcry_mpi_t m2;
@@ -88,52 +88,52 @@ test_hom_simple (unsigned int a,
   struct GNUNET_CRYPTO_PaillierPrivateKey private_key;
   int ret = 0;
 
-  GNUNET_CRYPTO_paillier_create (&public_key,
-                                 &private_key);
-
-  GNUNET_assert (NULL != (m1 = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (m2 = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (result = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (hom_result = gcry_mpi_new (0)));
-  m1 = gcry_mpi_set_ui (m1, a);
-  m2 = gcry_mpi_set_ui (m2, b);
-  gcry_mpi_add (result,
-                m1,
-                m2);
-  GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                  m1,
-                                  2,
-                                  &c1);
-  GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                  m2,
-                                  2,
-                                  &c2);
-  GNUNET_CRYPTO_paillier_hom_add (&public_key,
-                                  &c1,
-                                  &c2,
-                                  &c_result);
-  GNUNET_CRYPTO_paillier_decrypt (&private_key,
-                                  &public_key,
-                                  &c_result,
-                                  hom_result);
-  if (0 != gcry_mpi_cmp (result, hom_result))
-  {
-    fprintf (stderr,
-             "GNUNET_CRYPTO_paillier failed simple math!\n");
-    gcry_log_debugmpi ("got ", hom_result);
-    gcry_log_debugmpi ("wanted ", result);
-    ret = 1;
-  }
-  gcry_mpi_release (m1);
-  gcry_mpi_release (m2);
-  gcry_mpi_release (result);
-  gcry_mpi_release (hom_result);
+  GNUNET_CRYPTO_paillier_create(&public_key,
+                                &private_key);
+
+  GNUNET_assert(NULL != (m1 = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (m2 = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (result = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (hom_result = gcry_mpi_new(0)));
+  m1 = gcry_mpi_set_ui(m1, a);
+  m2 = gcry_mpi_set_ui(m2, b);
+  gcry_mpi_add(result,
+               m1,
+               m2);
+  GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                 m1,
+                                 2,
+                                 &c1);
+  GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                 m2,
+                                 2,
+                                 &c2);
+  GNUNET_CRYPTO_paillier_hom_add(&public_key,
+                                 &c1,
+                                 &c2,
+                                 &c_result);
+  GNUNET_CRYPTO_paillier_decrypt(&private_key,
+                                 &public_key,
+                                 &c_result,
+                                 hom_result);
+  if (0 != gcry_mpi_cmp(result, hom_result))
+    {
+      fprintf(stderr,
+              "GNUNET_CRYPTO_paillier failed simple math!\n");
+      gcry_log_debugmpi("got ", hom_result);
+      gcry_log_debugmpi("wanted ", result);
+      ret = 1;
+    }
+  gcry_mpi_release(m1);
+  gcry_mpi_release(m2);
+  gcry_mpi_release(result);
+  gcry_mpi_release(hom_result);
   return ret;
 }
 
 
 static int
-test_hom ()
+test_hom()
 {
   int ret;
   gcry_mpi_t m1;
@@ -146,99 +146,100 @@ test_hom ()
   struct GNUNET_CRYPTO_PaillierPublicKey public_key;
   struct GNUNET_CRYPTO_PaillierPrivateKey private_key;
 
-  GNUNET_CRYPTO_paillier_create (&public_key,
-                                 &private_key);
+  GNUNET_CRYPTO_paillier_create(&public_key,
+                                &private_key);
 
-  GNUNET_assert (NULL != (m1 = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (m2 = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (result = gcry_mpi_new (0)));
-  GNUNET_assert (NULL != (hom_result = gcry_mpi_new (0)));
-  m1 = gcry_mpi_set_ui (m1, 1);
+  GNUNET_assert(NULL != (m1 = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (m2 = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (result = gcry_mpi_new(0)));
+  GNUNET_assert(NULL != (hom_result = gcry_mpi_new(0)));
+  m1 = gcry_mpi_set_ui(m1, 1);
   /* m1 = m1 * 2 ^ (GCPB - 3) */
-  gcry_mpi_mul_2exp (m1,
-                     m1,
-                     GNUNET_CRYPTO_PAILLIER_BITS - 3);
-  m2 = gcry_mpi_set_ui (m2, 15);
+  gcry_mpi_mul_2exp(m1,
+                    m1,
+                    GNUNET_CRYPTO_PAILLIER_BITS - 3);
+  m2 = gcry_mpi_set_ui(m2, 15);
   /* m1 = m1 * 2 ^ (GCPB / 2) */
-  gcry_mpi_mul_2exp (m2,
-                     m2,
-                     GNUNET_CRYPTO_PAILLIER_BITS / 2);
-  gcry_mpi_add (result,
-                m1,
-                m2);
-
-  if (1 != (ret = GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                                  m1,
-                                                  2,
-                                                  &c1)))
-  {
-    fprintf (stderr,
-             "GNUNET_CRYPTO_paillier_encrypt 1 failed, should return 1 allowed operation, got %d!\n",
-             ret);
-    ret = 1;
-    goto out;
-  }
-  if (2 != (ret = GNUNET_CRYPTO_paillier_encrypt (&public_key,
-                                                  m2,
-                                                  2,
-                                                  &c2)))
-  {
-    fprintf (stderr,
-             "GNUNET_CRYPTO_paillier_encrypt 2 failed, should return 2 allowed operation, got %d!\n",
-             ret);
-    ret = 1;
-    goto out;
-  }
-
-  if (0 != (ret = GNUNET_CRYPTO_paillier_hom_add (&public_key,
-                                                  &c1,
-                                                  &c2,
-                                                  &c_result)))
-  {
-    fprintf (stderr,
-             "GNUNET_CRYPTO_paillier_hom_add failed, expected 0 remaining operations, got %d!\n",
-             ret);
-    ret = 1;
-    goto out;
-  }
-
-  GNUNET_CRYPTO_paillier_decrypt (&private_key,
-                                  &public_key,
-                                  &c_result,
-                                  hom_result);
-
-  if (0 != gcry_mpi_cmp (result, hom_result))
-  {
-    fprintf (stderr,
-             "GNUNET_CRYPTO_paillier miscalculated with large numbers!\n");
-    gcry_log_debugmpi ("got", hom_result);
-    gcry_log_debugmpi ("wanted", result);
-    ret = 1;
-  }
+  gcry_mpi_mul_2exp(m2,
+                    m2,
+                    GNUNET_CRYPTO_PAILLIER_BITS / 2);
+  gcry_mpi_add(result,
+               m1,
+               m2);
+
+  if (1 != (ret = GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                                 m1,
+                                                 2,
+                                                 &c1)))
+    {
+      fprintf(stderr,
+              "GNUNET_CRYPTO_paillier_encrypt 1 failed, should return 1 allowed operation, got %d!\n",
+              ret);
+      ret = 1;
+      goto out;
+    }
+  if (2 != (ret = GNUNET_CRYPTO_paillier_encrypt(&public_key,
+                                                 m2,
+                                                 2,
+                                                 &c2)))
+    {
+      fprintf(stderr,
+              "GNUNET_CRYPTO_paillier_encrypt 2 failed, should return 2 allowed operation, got %d!\n",
+              ret);
+      ret = 1;
+      goto out;
+    }
+
+  if (0 != (ret = GNUNET_CRYPTO_paillier_hom_add(&public_key,
+                                                 &c1,
+                                                 &c2,
+                                                 &c_result)))
+    {
+      fprintf(stderr,
+              "GNUNET_CRYPTO_paillier_hom_add failed, expected 0 remaining operations, got %d!\n",
+              ret);
+      ret = 1;
+      goto out;
+    }
+
+  GNUNET_CRYPTO_paillier_decrypt(&private_key,
+                                 &public_key,
+                                 &c_result,
+                                 hom_result);
+
+  if (0 != gcry_mpi_cmp(result, hom_result))
+    {
+      fprintf(stderr,
+              "GNUNET_CRYPTO_paillier miscalculated with large numbers!\n");
+      gcry_log_debugmpi("got", hom_result);
+      gcry_log_debugmpi("wanted", result);
+      ret = 1;
+    }
 out:
-  gcry_mpi_release (m1);
-  gcry_mpi_release (m2);
-  gcry_mpi_release (result);
-  gcry_mpi_release (hom_result);
+  gcry_mpi_release(m1);
+  gcry_mpi_release(m2);
+  gcry_mpi_release(result);
+  gcry_mpi_release(hom_result);
   return ret;
 }
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   int ret;
-  ret = test_crypto ();
+
+  ret = test_crypto();
   if (0 != ret)
     return ret;
-  ret = test_hom_simple (2,4);
+  ret = test_hom_simple(2, 4);
   if (0 != ret)
     return ret;
-  ret = test_hom_simple (13,17);
+  ret = test_hom_simple(13, 17);
   if (0 != ret)
     return ret;
-  ret = test_hom ();
+  ret = test_hom();
   return ret;
 }
 
diff --git a/src/util/test_crypto_random.c b/src/util/test_crypto_random.c
index 6386c79db..11f87a25e 100644
--- a/src/util/test_crypto_random.c
+++ b/src/util/test_crypto_random.c
@@ -11,13 +11,13 @@
      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 util/test_crypto_random.c
@@ -27,43 +27,42 @@
 #include "gnunet_util_lib.h"
 
 static int
-test (enum GNUNET_CRYPTO_Quality mode)
+test(enum GNUNET_CRYPTO_Quality mode)
 {
-
   int buf[1024];
   unsigned int *b2;
   int i;
   unsigned long long n;
 
   for (i = 0; i < 1024; i++)
-    GNUNET_break (1024 > (buf[i] = GNUNET_CRYPTO_random_u32 (mode, 1024)));
+    GNUNET_break(1024 > (buf[i] = GNUNET_CRYPTO_random_u32(mode, 1024)));
   for (i = 0; i < 10; i++)
-  {
-    b2 = GNUNET_CRYPTO_random_permute (mode, 1024);
-    if (0 == memcmp (b2, buf, sizeof (buf)))
     {
-      fprintf (stderr, "%s",  "!");
-      GNUNET_free (b2);
-      continue;
+      b2 = GNUNET_CRYPTO_random_permute(mode, 1024);
+      if (0 == memcmp(b2, buf, sizeof(buf)))
+        {
+          fprintf(stderr, "%s", "!");
+          GNUNET_free(b2);
+          continue;
+        }
+      GNUNET_free(b2);
+      break;
     }
-    GNUNET_free (b2);
-    break;
-  }
   if (i == 10)
     return 1;                   /* virtually impossible... */
 
   for (n = 10; n < 1024LL * 1024LL * 1024LL; n *= 10)
-    GNUNET_break (n > GNUNET_CRYPTO_random_u64 (mode, n));
+    GNUNET_break(n > GNUNET_CRYPTO_random_u64(mode, n));
   return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-crypto-random", "WARNING", NULL);
-  if (0 != test (GNUNET_CRYPTO_QUALITY_WEAK))
+  GNUNET_log_setup("test-crypto-random", "WARNING", NULL);
+  if (0 != test(GNUNET_CRYPTO_QUALITY_WEAK))
     return 1;
-  if (0 != test (GNUNET_CRYPTO_QUALITY_STRONG))
+  if (0 != test(GNUNET_CRYPTO_QUALITY_STRONG))
     return 1;
 
   return 0;
diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c
index 36c47005e..0d8827c84 100644
--- a/src/util/test_crypto_rsa.c
+++ b/src/util/test_crypto_rsa.c
@@ -1,22 +1,22 @@
 /*
-  This file is part of GNUnet
-  Copyright (C) 2014,2015 GNUnet e.V.
+   This file is part of GNUnet
+   Copyright (C) 2014,2015 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 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/>.
+   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 util/test_crypto_rsa.c
@@ -32,8 +32,8 @@
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
 #define RND_BLK_SIZE 4096
   unsigned char rnd_blk[RND_BLK_SIZE];
@@ -49,79 +49,79 @@ main (int argc,
   char *blind_buf;
   size_t bsize;
 
-  GNUNET_log_setup ("test-rsa", "WARNING", NULL);
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              rnd_blk,
-                              RND_BLK_SIZE);
-  GNUNET_CRYPTO_hash (rnd_blk,
-                      RND_BLK_SIZE,
-                      &hash);
-  priv = GNUNET_CRYPTO_rsa_private_key_create (KEY_SIZE);
-  priv_copy = GNUNET_CRYPTO_rsa_private_key_dup (priv);
-  GNUNET_assert (NULL != priv_copy);
-  GNUNET_assert (0 == GNUNET_CRYPTO_rsa_private_key_cmp (priv, priv_copy));
-  pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
+  GNUNET_log_setup("test-rsa", "WARNING", NULL);
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             rnd_blk,
+                             RND_BLK_SIZE);
+  GNUNET_CRYPTO_hash(rnd_blk,
+                     RND_BLK_SIZE,
+                     &hash);
+  priv = GNUNET_CRYPTO_rsa_private_key_create(KEY_SIZE);
+  priv_copy = GNUNET_CRYPTO_rsa_private_key_dup(priv);
+  GNUNET_assert(NULL != priv_copy);
+  GNUNET_assert(0 == GNUNET_CRYPTO_rsa_private_key_cmp(priv, priv_copy));
+  pub = GNUNET_CRYPTO_rsa_private_key_get_public(priv);
 
   /* Encoding */
   size_t size;
   char *enc;
   enc = NULL;
-  size = GNUNET_CRYPTO_rsa_private_key_encode (priv, &enc);
+  size = GNUNET_CRYPTO_rsa_private_key_encode(priv, &enc);
 
   /* Decoding */
-  GNUNET_CRYPTO_rsa_private_key_free (priv);
+  GNUNET_CRYPTO_rsa_private_key_free(priv);
   priv = NULL;
-  priv = GNUNET_CRYPTO_rsa_private_key_decode (enc, size);
-  GNUNET_assert (NULL != priv);
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              enc, size);
-  GNUNET_assert (NULL == GNUNET_CRYPTO_rsa_private_key_decode (enc, size));
-  (void) fprintf (stderr, "The above warning is expected.\n");
-  GNUNET_free (enc);
+  priv = GNUNET_CRYPTO_rsa_private_key_decode(enc, size);
+  GNUNET_assert(NULL != priv);
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             enc, size);
+  GNUNET_assert(NULL == GNUNET_CRYPTO_rsa_private_key_decode(enc, size));
+  (void)fprintf(stderr, "The above warning is expected.\n");
+  GNUNET_free(enc);
 
   /* try ordinary sig first */
-  sig = GNUNET_CRYPTO_rsa_sign_fdh (priv,
-                                    &hash);
-  sig_copy = GNUNET_CRYPTO_rsa_signature_dup (sig);
-  GNUNET_assert (NULL != sig);
-  GNUNET_assert (0 == GNUNET_CRYPTO_rsa_signature_cmp (sig, sig_copy));
-  pub_copy = GNUNET_CRYPTO_rsa_public_key_dup (pub);
-  GNUNET_assert (NULL != pub_copy);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_rsa_verify (&hash, sig, pub_copy));
+  sig = GNUNET_CRYPTO_rsa_sign_fdh(priv,
+                                   &hash);
+  sig_copy = GNUNET_CRYPTO_rsa_signature_dup(sig);
+  GNUNET_assert(NULL != sig);
+  GNUNET_assert(0 == GNUNET_CRYPTO_rsa_signature_cmp(sig, sig_copy));
+  pub_copy = GNUNET_CRYPTO_rsa_public_key_dup(pub);
+  GNUNET_assert(NULL != pub_copy);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CRYPTO_rsa_verify(&hash, sig, pub_copy));
   /* corrupt our hash and see if the signature is still valid */
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &hash,
-                              sizeof (struct GNUNET_HashCode));
-  GNUNET_assert (GNUNET_OK != GNUNET_CRYPTO_rsa_verify (&hash,
-                                                        sig,
-                                                        pub));
-  (void) fprintf (stderr, "The above warning is expected.\n");
-  GNUNET_CRYPTO_rsa_signature_free (sig);
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, &hash,
+                             sizeof(struct GNUNET_HashCode));
+  GNUNET_assert(GNUNET_OK != GNUNET_CRYPTO_rsa_verify(&hash,
+                                                      sig,
+                                                      pub));
+  (void)fprintf(stderr, "The above warning is expected.\n");
+  GNUNET_CRYPTO_rsa_signature_free(sig);
 
   /* test blind signing */
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                              &bsec,
-                              sizeof (bsec));
-  GNUNET_CRYPTO_rsa_blind (&hash,
-                           &bsec,
-                           pub,
-                           &blind_buf,&bsize);
-  GNUNET_assert (0 != bsize);
-  bsig = GNUNET_CRYPTO_rsa_sign_blinded (priv,
-                                         blind_buf,
-                                         bsize);
-  GNUNET_free (blind_buf);
-  sig = GNUNET_CRYPTO_rsa_unblind (bsig,
-                                   &bsec,
-                                   pub);
-  GNUNET_CRYPTO_rsa_signature_free (bsig);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_rsa_verify (&hash, sig, pub));
-  GNUNET_CRYPTO_rsa_signature_free (sig);
-  GNUNET_CRYPTO_rsa_signature_free (sig_copy);
-  GNUNET_CRYPTO_rsa_private_key_free (priv);
-  GNUNET_CRYPTO_rsa_private_key_free (priv_copy);
-  GNUNET_CRYPTO_rsa_public_key_free (pub);
-  GNUNET_CRYPTO_rsa_public_key_free (pub_copy);
+  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+                             &bsec,
+                             sizeof(bsec));
+  GNUNET_CRYPTO_rsa_blind(&hash,
+                          &bsec,
+                          pub,
+                          &blind_buf, &bsize);
+  GNUNET_assert(0 != bsize);
+  bsig = GNUNET_CRYPTO_rsa_sign_blinded(priv,
+                                        blind_buf,
+                                        bsize);
+  GNUNET_free(blind_buf);
+  sig = GNUNET_CRYPTO_rsa_unblind(bsig,
+                                  &bsec,
+                                  pub);
+  GNUNET_CRYPTO_rsa_signature_free(bsig);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CRYPTO_rsa_verify(&hash, sig, pub));
+  GNUNET_CRYPTO_rsa_signature_free(sig);
+  GNUNET_CRYPTO_rsa_signature_free(sig_copy);
+  GNUNET_CRYPTO_rsa_private_key_free(priv);
+  GNUNET_CRYPTO_rsa_private_key_free(priv_copy);
+  GNUNET_CRYPTO_rsa_public_key_free(pub);
+  GNUNET_CRYPTO_rsa_public_key_free(pub_copy);
   return 0;
 }
diff --git a/src/util/test_crypto_symmetric.c b/src/util/test_crypto_symmetric.c
index d731c45b7..c6854711f 100644
--- a/src/util/test_crypto_symmetric.c
+++ b/src/util/test_crypto_symmetric.c
@@ -11,13 +11,13 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
 
-*/
+ */
 /**
  * @author Christian Grothoff
  * @file util/test_crypto_symmetric.c
@@ -30,46 +30,46 @@
 #define INITVALUE "InitializationVectorValueinitializationvectorvalue"
 
 static int
-testSymcipher ()
+testSymcipher()
 {
   struct GNUNET_CRYPTO_SymmetricSessionKey key;
   char result[100];
   int size;
   char res[100];
 
-  GNUNET_CRYPTO_symmetric_create_session_key (&key);
+  GNUNET_CRYPTO_symmetric_create_session_key(&key);
   size =
-      GNUNET_CRYPTO_symmetric_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &key,
-                                 (const struct
-                                  GNUNET_CRYPTO_SymmetricInitializationVector *)
-                                 INITVALUE, result);
+    GNUNET_CRYPTO_symmetric_encrypt(TESTSTRING, strlen(TESTSTRING) + 1, &key,
+                                    (const struct
+                                     GNUNET_CRYPTO_SymmetricInitializationVector *)
+                                    INITVALUE, result);
   if (size == -1)
-  {
-    printf ("symciphertest failed: encryptBlock returned %d\n", size);
-    return 1;
-  }
+    {
+      printf("symciphertest failed: encryptBlock returned %d\n", size);
+      return 1;
+    }
   size =
-      GNUNET_CRYPTO_symmetric_decrypt (result, size, &key,
-                                 (const struct
-                                  GNUNET_CRYPTO_SymmetricInitializationVector *)
-                                 INITVALUE, res);
-  if (strlen (TESTSTRING) + 1 != size)
-  {
-    printf ("symciphertest failed: decryptBlock returned %d\n", size);
-    return 1;
-  }
-  if (0 != strcmp (res, TESTSTRING))
-  {
-    printf ("symciphertest failed: %s != %s\n", res, TESTSTRING);
-    return 1;
-  }
+    GNUNET_CRYPTO_symmetric_decrypt(result, size, &key,
+                                    (const struct
+                                     GNUNET_CRYPTO_SymmetricInitializationVector *)
+                                    INITVALUE, res);
+  if (strlen(TESTSTRING) + 1 != size)
+    {
+      printf("symciphertest failed: decryptBlock returned %d\n", size);
+      return 1;
+    }
+  if (0 != strcmp(res, TESTSTRING))
+    {
+      printf("symciphertest failed: %s != %s\n", res, TESTSTRING);
+      return 1;
+    }
   else
     return 0;
 }
 
 
 static int
-verifyCrypto ()
+verifyCrypto()
 {
   struct GNUNET_CRYPTO_SymmetricSessionKey key;
   char result[GNUNET_CRYPTO_AES_KEY_LENGTH];
@@ -103,68 +103,68 @@ verifyCrypto ()
   res = NULL;
   ret = 0;
 
-  GNUNET_memcpy (key.aes_key, raw_key_aes, GNUNET_CRYPTO_AES_KEY_LENGTH);
-  GNUNET_memcpy (key.twofish_key, raw_key_twofish, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_memcpy(key.aes_key, raw_key_aes, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_memcpy(key.twofish_key, raw_key_twofish, GNUNET_CRYPTO_AES_KEY_LENGTH);
   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
-      GNUNET_CRYPTO_symmetric_encrypt (plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
-                                       (const struct
-                                        GNUNET_CRYPTO_SymmetricInitializationVector *)
-                                       "testtesttesttesttesttesttesttest",
-                                       result))
-  {
-    printf ("Wrong return value from encrypt block.\n");
-    ret = 1;
-    goto error;
-  }
-
-  if (0 != memcmp (encrresult, result, GNUNET_CRYPTO_AES_KEY_LENGTH))
-  {
-    int i;
-    printf ("Encrypted result wrong.\n");
-    for (i=0;i<GNUNET_CRYPTO_AES_KEY_LENGTH;i++)
-      printf ("%u, ", (uint8_t) result[i]);
-    ret = 1;
-    goto error;
-  }
-
-  res = GNUNET_malloc (GNUNET_CRYPTO_AES_KEY_LENGTH);
+      GNUNET_CRYPTO_symmetric_encrypt(plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
+                                      (const struct
+                                       GNUNET_CRYPTO_SymmetricInitializationVector *)
+                                      "testtesttesttesttesttesttesttest",
+                                      result))
+    {
+      printf("Wrong return value from encrypt block.\n");
+      ret = 1;
+      goto error;
+    }
+
+  if (0 != memcmp(encrresult, result, GNUNET_CRYPTO_AES_KEY_LENGTH))
+    {
+      int i;
+      printf("Encrypted result wrong.\n");
+      for (i = 0; i < GNUNET_CRYPTO_AES_KEY_LENGTH; i++)
+        printf("%u, ", (uint8_t)result[i]);
+      ret = 1;
+      goto error;
+    }
+
+  res = GNUNET_malloc(GNUNET_CRYPTO_AES_KEY_LENGTH);
   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
-      GNUNET_CRYPTO_symmetric_decrypt (result, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
-                                 (const struct
-                                  GNUNET_CRYPTO_SymmetricInitializationVector *)
-                                 "testtesttesttesttesttesttesttest", res))
-  {
-    printf ("Wrong return value from decrypt block.\n");
-    ret = 1;
-    goto error;
-  }
-  if (0 != memcmp (res, plain, GNUNET_CRYPTO_AES_KEY_LENGTH))
-  {
-    printf ("Decrypted result does not match input.\n");
-    ret = 1;
-  }
+      GNUNET_CRYPTO_symmetric_decrypt(result, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
+                                      (const struct
+                                       GNUNET_CRYPTO_SymmetricInitializationVector *)
+                                      "testtesttesttesttesttesttesttest", res))
+    {
+      printf("Wrong return value from decrypt block.\n");
+      ret = 1;
+      goto error;
+    }
+  if (0 != memcmp(res, plain, GNUNET_CRYPTO_AES_KEY_LENGTH))
+    {
+      printf("Decrypted result does not match input.\n");
+      ret = 1;
+    }
 error:
-  GNUNET_free_non_null (res);
+  GNUNET_free_non_null(res);
   return ret;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int failureCount = 0;
 
-  GNUNET_log_setup ("test-crypto-aes", "WARNING", NULL);
-  GNUNET_assert (strlen (INITVALUE) >
-                 sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector));
-  failureCount += testSymcipher ();
-  failureCount += verifyCrypto ();
+  GNUNET_log_setup("test-crypto-aes", "WARNING", NULL);
+  GNUNET_assert(strlen(INITVALUE) >
+                sizeof(struct GNUNET_CRYPTO_SymmetricInitializationVector));
+  failureCount += testSymcipher();
+  failureCount += verifyCrypto();
 
   if (failureCount != 0)
-  {
-    printf ("%d TESTS FAILED!\n", failureCount);
-    return -1;
-  }
+    {
+      printf("%d TESTS FAILED!\n", failureCount);
+      return -1;
+    }
   return 0;
 }
 
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
index 5746aa96e..13fb18e88 100644
--- a/src/util/test_disk.c
+++ b/src/util/test_disk.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 util/test_disk.c
@@ -30,51 +30,51 @@
 
 
 static int
-testReadWrite ()
+testReadWrite()
 {
   char tmp[100 + 1];
   int ret;
 
-  if (strlen (TESTSTRING) !=
-      GNUNET_DISK_fn_write (".testfile", TESTSTRING, strlen (TESTSTRING),
-                            GNUNET_DISK_PERM_USER_READ |
-                            GNUNET_DISK_PERM_USER_WRITE))
+  if (strlen(TESTSTRING) !=
+      GNUNET_DISK_fn_write(".testfile", TESTSTRING, strlen(TESTSTRING),
+                           GNUNET_DISK_PERM_USER_READ |
+                           GNUNET_DISK_PERM_USER_WRITE))
     return 1;
-  if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
+  if (GNUNET_OK != GNUNET_DISK_file_test(".testfile"))
     return 1;
-  ret = GNUNET_DISK_fn_read (".testfile", tmp, sizeof (tmp) - 1);
+  ret = GNUNET_DISK_fn_read(".testfile", tmp, sizeof(tmp) - 1);
   if (ret < 0)
-  {
-    fprintf (stderr, "Error reading file `%s' in testReadWrite\n", ".testfile");
-    return 1;
-  }
+    {
+      fprintf(stderr, "Error reading file `%s' in testReadWrite\n", ".testfile");
+      return 1;
+    }
   tmp[ret] = '\0';
-  if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
-  {
-    fprintf (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
-             TESTSTRING, ".testfile");
-    return 1;
-  }
-  GNUNET_DISK_file_copy (".testfile", ".testfile2");
-  memset (tmp, 0, sizeof (tmp));
-  ret = GNUNET_DISK_fn_read (".testfile2", tmp, sizeof (tmp) - 1);
+  if (0 != memcmp(tmp, TESTSTRING, strlen(TESTSTRING) + 1))
+    {
+      fprintf(stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
+              TESTSTRING, ".testfile");
+      return 1;
+    }
+  GNUNET_DISK_file_copy(".testfile", ".testfile2");
+  memset(tmp, 0, sizeof(tmp));
+  ret = GNUNET_DISK_fn_read(".testfile2", tmp, sizeof(tmp) - 1);
   if (ret < 0)
-  {
-    fprintf (stderr, "Error reading file `%s' in testReadWrite\n",
-             ".testfile2");
-    return 1;
-  }
+    {
+      fprintf(stderr, "Error reading file `%s' in testReadWrite\n",
+              ".testfile2");
+      return 1;
+    }
   tmp[ret] = '\0';
-  if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
-  {
-    fprintf (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
-             TESTSTRING, ".testfile2");
-    return 1;
-  }
-
-  GNUNET_break (0 == unlink (".testfile"));
-  GNUNET_break (0 == unlink (".testfile2"));
-  if (GNUNET_NO != GNUNET_DISK_file_test (".testfile"))
+  if (0 != memcmp(tmp, TESTSTRING, strlen(TESTSTRING) + 1))
+    {
+      fprintf(stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
+              TESTSTRING, ".testfile2");
+      return 1;
+    }
+
+  GNUNET_break(0 == unlink(".testfile"));
+  GNUNET_break(0 == unlink(".testfile2"));
+  if (GNUNET_NO != GNUNET_DISK_file_test(".testfile"))
     return 1;
 
   return 0;
@@ -82,24 +82,24 @@ testReadWrite ()
 
 
 static int
-testOpenClose ()
+testOpenClose()
 {
   struct GNUNET_DISK_FileHandle *fh;
   uint64_t size;
 
-  fh = GNUNET_DISK_file_open (".testfile",
-                              GNUNET_DISK_OPEN_READWRITE |
-                              GNUNET_DISK_OPEN_CREATE,
-                              GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE);
-  GNUNET_assert (GNUNET_NO == GNUNET_DISK_handle_invalid (fh));
-  GNUNET_break (5 == GNUNET_DISK_file_write (fh, "Hello", 5));
-  GNUNET_DISK_file_close (fh);
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_DISK_file_size (".testfile", &size, GNUNET_NO, GNUNET_YES));
+  fh = GNUNET_DISK_file_open(".testfile",
+                             GNUNET_DISK_OPEN_READWRITE |
+                             GNUNET_DISK_OPEN_CREATE,
+                             GNUNET_DISK_PERM_USER_READ |
+                             GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_assert(GNUNET_NO == GNUNET_DISK_handle_invalid(fh));
+  GNUNET_break(5 == GNUNET_DISK_file_write(fh, "Hello", 5));
+  GNUNET_DISK_file_close(fh);
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_DISK_file_size(".testfile", &size, GNUNET_NO, GNUNET_YES));
   if (size != 5)
     return 1;
-  GNUNET_break (0 == unlink (".testfile"));
+  GNUNET_break(0 == unlink(".testfile"));
 
   return 0;
 }
@@ -108,116 +108,116 @@ static int ok;
 
 
 static int
-scan_callback (void *want, const char *filename)
+scan_callback(void *want, const char *filename)
 {
-  if (NULL != strstr (filename, want))
+  if (NULL != strstr(filename, want))
     ok++;
   return GNUNET_OK;
 }
 
 
 static int
-testDirScan ()
+testDirScan()
 {
   if (GNUNET_OK !=
-      GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+      GNUNET_DISK_directory_create("test" DIR_SEPARATOR_STR "entry"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   if (GNUNET_OK !=
-      GNUNET_DISK_directory_create ("test" DIR_SEPARATOR_STR "entry_more"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  GNUNET_DISK_directory_scan ("test", &scan_callback,
-                              "test" DIR_SEPARATOR_STR "entry");
-  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+      GNUNET_DISK_directory_create("test" DIR_SEPARATOR_STR "entry_more"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  GNUNET_DISK_directory_scan("test", &scan_callback,
+                             "test" DIR_SEPARATOR_STR "entry");
+  if (GNUNET_OK != GNUNET_DISK_directory_remove("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   if (ok < 2)
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 static int
-iter_callback (void *cls,
-               const char *filename)
+iter_callback(void *cls,
+              const char *filename)
 {
   int *i = cls;
-  
+
   (*i)++;
   return GNUNET_OK;
 }
 
 
 static int
-testDirIter ()
+testDirIter()
 {
   int i;
 
   i = 0;
-  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry_many"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry_more"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  GNUNET_DISK_directory_scan ("test",
-                              &iter_callback,
-                              &i);
-  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  if (GNUNET_OK != GNUNET_DISK_directory_create("test/entry"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_directory_create("test/entry_many"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_directory_create("test/entry_more"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  GNUNET_DISK_directory_scan("test",
+                             &iter_callback,
+                             &i);
+  if (GNUNET_OK != GNUNET_DISK_directory_remove("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   if (i < 3)
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 static int
-testCanonicalize ()
+testCanonicalize()
 {
-  char *fn = GNUNET_strdup ("ab?><|cd*ef:/g\"");
-
-  GNUNET_DISK_filename_canonicalize (fn);
-  if (0 != strcmp (fn, "ab____cd_ef__g_"))
-  {
-    GNUNET_free (fn);
-    return 1;
-  }
-  GNUNET_free (fn);
+  char *fn = GNUNET_strdup("ab?><|cd*ef:/g\"");
+
+  GNUNET_DISK_filename_canonicalize(fn);
+  if (0 != strcmp(fn, "ab____cd_ef__g_"))
+    {
+      GNUNET_free(fn);
+      return 1;
+    }
+  GNUNET_free(fn);
   return 0;
 }
 
 
 static int
-testChangeOwner ()
+testChangeOwner()
 {
 #ifndef WINDOWS
-  GNUNET_log_skip (1, GNUNET_NO);
-  if (GNUNET_OK == GNUNET_DISK_file_change_owner ("/dev/null", "unknownuser"))
+  GNUNET_log_skip(1, GNUNET_NO);
+  if (GNUNET_OK == GNUNET_DISK_file_change_owner("/dev/null", "unknownuser"))
     return 1;
 #endif
   return 0;
@@ -225,66 +225,66 @@ testChangeOwner ()
 
 
 static int
-testDirMani ()
+testDirMani()
 {
-  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file ("test/ing"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_NO != GNUNET_DISK_file_test ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_NO != GNUNET_DISK_file_test ("test/ing"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_directory_create ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_YES != GNUNET_DISK_directory_test ("test", GNUNET_YES))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file("test/ing"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_NO != GNUNET_DISK_file_test("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_NO != GNUNET_DISK_file_test("test/ing"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_directory_remove("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_directory_create("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_YES != GNUNET_DISK_directory_test("test", GNUNET_YES))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (GNUNET_OK != GNUNET_DISK_directory_remove("test"))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   unsigned int failureCount = 0;
 
-  GNUNET_log_setup ("test-disk", "WARNING", NULL);
-  failureCount += testReadWrite ();
-  failureCount += testOpenClose ();
-  failureCount += testDirScan ();
-  failureCount += testDirIter ();
-  failureCount += testCanonicalize ();
-  failureCount += testChangeOwner ();
-  failureCount += testDirMani ();
+  GNUNET_log_setup("test-disk", "WARNING", NULL);
+  failureCount += testReadWrite();
+  failureCount += testOpenClose();
+  failureCount += testDirScan();
+  failureCount += testDirIter();
+  failureCount += testCanonicalize();
+  failureCount += testChangeOwner();
+  failureCount += testDirMani();
   if (0 != failureCount)
-  {
-    fprintf (stderr,
-             "\n%u TESTS FAILED!\n",
-             failureCount);
-    return -1;
-  }
+    {
+      fprintf(stderr,
+              "\n%u TESTS FAILED!\n",
+              failureCount);
+      return -1;
+    }
   return 0;
 }                               /* end of main */
diff --git a/src/util/test_getopt.c b/src/util/test_getopt.c
index d9dd7121f..620605f96 100644
--- a/src/util/test_getopt.c
+++ b/src/util/test_getopt.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 util/test_getopt.c
  * @brief testcase for util/getopt.c
@@ -26,13 +26,14 @@
 
 
 static int
-testMinimal ()
+testMinimal()
 {
-  char *const emptyargv[] = {"test", NULL};
+  char *const emptyargv[] = { "test", NULL };
   const struct GNUNET_GETOPT_CommandLineOption emptyoptionlist[] = {
-    GNUNET_GETOPT_OPTION_END};
+    GNUNET_GETOPT_OPTION_END
+  };
 
-  if (1 != GNUNET_GETOPT_run ("test", emptyoptionlist, 1, emptyargv))
+  if (1 != GNUNET_GETOPT_run("test", emptyoptionlist, 1, emptyargv))
     return 1;
 
   return 0;
@@ -40,142 +41,142 @@ testMinimal ()
 
 
 static int
-testVerbose ()
+testVerbose()
 {
-  char *const myargv[] = {"test", "-V", "-V", "more", NULL};
+  char *const myargv[] = { "test", "-V", "-V", "more", NULL };
   unsigned int vflags = 0;
 
   const struct GNUNET_GETOPT_CommandLineOption verboseoptionlist[] =
-    {GNUNET_GETOPT_option_verbose (&vflags), GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_verbose(&vflags), GNUNET_GETOPT_OPTION_END };
 
-  if (3 != GNUNET_GETOPT_run ("test", verboseoptionlist, 4, myargv))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  if (3 != GNUNET_GETOPT_run("test", verboseoptionlist, 4, myargv))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   if (vflags != 2)
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 static int
-testVersion ()
+testVersion()
 {
-  char *const myargv[] = {"test_getopt", "-v", NULL};
+  char *const myargv[] = { "test_getopt", "-v", NULL };
   const struct GNUNET_GETOPT_CommandLineOption versionoptionlist[] =
-    {GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION),
-     GNUNET_GETOPT_OPTION_END};
-
-  if (0 != GNUNET_GETOPT_run ("test_getopt", versionoptionlist, 2, myargv))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  { GNUNET_GETOPT_option_version(PACKAGE_VERSION " " VCS_VERSION),
+    GNUNET_GETOPT_OPTION_END };
+
+  if (0 != GNUNET_GETOPT_run("test_getopt", versionoptionlist, 2, myargv))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 static int
-testAbout ()
+testAbout()
 {
-  char *const myargv[] = {"test_getopt", "-h", NULL};
+  char *const myargv[] = { "test_getopt", "-h", NULL };
   const struct GNUNET_GETOPT_CommandLineOption aboutoptionlist[] =
-    {GNUNET_GETOPT_option_help ("Testing"), GNUNET_GETOPT_OPTION_END};
+  { GNUNET_GETOPT_option_help("Testing"), GNUNET_GETOPT_OPTION_END };
 
-  if (0 != GNUNET_GETOPT_run ("test_getopt", aboutoptionlist, 2, myargv))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  if (0 != GNUNET_GETOPT_run("test_getopt", aboutoptionlist, 2, myargv))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 static int
-testLogOpts ()
+testLogOpts()
 {
   char *const myargv[] =
-    {"test_getopt", "-l", "filename", "-L", "WARNING", NULL};
-  char *level = GNUNET_strdup ("stuff");
+  { "test_getopt", "-l", "filename", "-L", "WARNING", NULL };
+  char *level = GNUNET_strdup("stuff");
   char *fn = NULL;
 
   const struct GNUNET_GETOPT_CommandLineOption logoptionlist[] =
-    {GNUNET_GETOPT_option_logfile (&fn),
-     GNUNET_GETOPT_option_loglevel (&level),
-     GNUNET_GETOPT_OPTION_END};
-
-  if (5 != GNUNET_GETOPT_run ("test_getopt", logoptionlist, 5, myargv))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  GNUNET_assert (NULL != fn);
-  if ((0 != strcmp (level, "WARNING")) || (NULL == strstr (fn, "/filename")))
-  {
-    GNUNET_break (0);
-    GNUNET_free (level);
-    GNUNET_free (fn);
-    return 1;
-  }
-  GNUNET_free (level);
-  GNUNET_free (fn);
+  { GNUNET_GETOPT_option_logfile(&fn),
+    GNUNET_GETOPT_option_loglevel(&level),
+    GNUNET_GETOPT_OPTION_END };
+
+  if (5 != GNUNET_GETOPT_run("test_getopt", logoptionlist, 5, myargv))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  GNUNET_assert(NULL != fn);
+  if ((0 != strcmp(level, "WARNING")) || (NULL == strstr(fn, "/filename")))
+    {
+      GNUNET_break(0);
+      GNUNET_free(level);
+      GNUNET_free(fn);
+      return 1;
+    }
+  GNUNET_free(level);
+  GNUNET_free(fn);
   return 0;
 }
 
 
 static int
-testFlagNum ()
+testFlagNum()
 {
-  char *const myargv[] = {"test_getopt", "-f", "-n", "42", "-N", "42", NULL};
+  char *const myargv[] = { "test_getopt", "-f", "-n", "42", "-N", "42", NULL };
   int flag = 0;
   unsigned int num = 0;
   unsigned long long lnum = 0;
 
   const struct GNUNET_GETOPT_CommandLineOption logoptionlist[] =
-    {GNUNET_GETOPT_option_flag ('f', "--flag", "helptext", &flag),
-     GNUNET_GETOPT_option_uint ('n', "--num", "ARG", "helptext", &num),
-     GNUNET_GETOPT_option_ulong ('N', "--lnum", "ARG", "helptext", &lnum),
-     GNUNET_GETOPT_OPTION_END};
-
-  if (6 != GNUNET_GETOPT_run ("test_getopt", logoptionlist, 6, myargv))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+  { GNUNET_GETOPT_option_flag('f', "--flag", "helptext", &flag),
+    GNUNET_GETOPT_option_uint('n', "--num", "ARG", "helptext", &num),
+    GNUNET_GETOPT_option_ulong('N', "--lnum", "ARG", "helptext", &lnum),
+    GNUNET_GETOPT_OPTION_END };
+
+  if (6 != GNUNET_GETOPT_run("test_getopt", logoptionlist, 6, myargv))
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   if ((1 != flag) || (42 != num) || (42 != lnum))
-  {
-    GNUNET_break (0);
-    return 1;
-  }
+    {
+      GNUNET_break(0);
+      return 1;
+    }
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int errCnt = 0;
 
-  GNUNET_log_setup ("test_getopt", "WARNING", NULL);
+  GNUNET_log_setup("test_getopt", "WARNING", NULL);
   /* suppress output from -h, -v options */
 #ifndef MINGW
-  GNUNET_break (0 == close (1));
+  GNUNET_break(0 == close(1));
 #endif
-  if (0 != testMinimal ())
+  if (0 != testMinimal())
     errCnt++;
-  if (0 != testVerbose ())
+  if (0 != testVerbose())
     errCnt++;
-  if (0 != testVersion ())
+  if (0 != testVersion())
     errCnt++;
-  if (0 != testAbout ())
+  if (0 != testAbout())
     errCnt++;
-  if (0 != testLogOpts ())
+  if (0 != testLogOpts())
     errCnt++;
-  if (0 != testFlagNum ())
+  if (0 != testFlagNum())
     errCnt++;
   return errCnt;
 }
diff --git a/src/util/test_hexcoder.c b/src/util/test_hexcoder.c
index f73989a0e..69e2061cb 100644
--- a/src/util/test_hexcoder.c
+++ b/src/util/test_hexcoder.c
@@ -11,13 +11,13 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
 
-*/
+ */
 /**
  * @author Christian Grothoff
  * @file dns/test_hexcoder.c
@@ -32,23 +32,23 @@
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
-  char buf[strlen (TESTSTRING)  + 1];
+  char buf[strlen(TESTSTRING) + 1];
   char *ret;
 
-  GNUNET_log_setup ("test-hexcoder", "WARNING", NULL);
-  ret = GNUNET_DNSPARSER_bin_to_hex (TESTSTRING,
-                                     strlen (TESTSTRING) + 1);
-  GNUNET_assert (NULL != ret);
-  GNUNET_assert (sizeof (buf) ==
-                 GNUNET_DNSPARSER_hex_to_bin (ret,
-                                              buf));
-  GNUNET_assert (0 == memcmp (TESTSTRING,
-                              buf,
-                              sizeof (buf)));
-  GNUNET_free (ret);
+  GNUNET_log_setup("test-hexcoder", "WARNING", NULL);
+  ret = GNUNET_DNSPARSER_bin_to_hex(TESTSTRING,
+                                    strlen(TESTSTRING) + 1);
+  GNUNET_assert(NULL != ret);
+  GNUNET_assert(sizeof(buf) ==
+                GNUNET_DNSPARSER_hex_to_bin(ret,
+                                            buf));
+  GNUNET_assert(0 == memcmp(TESTSTRING,
+                            buf,
+                            sizeof(buf)));
+  GNUNET_free(ret);
   return 0;
 }
 
diff --git a/src/util/test_mq.c b/src/util/test_mq.c
index 9a396bcae..4282f06b7 100644
--- a/src/util/test_mq.c
+++ b/src/util/test_mq.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 util/test_mq.c
@@ -32,15 +32,14 @@
 /**
  * How long does the receiver take per message?
  */
-#define RECEIVER_THROTTLE GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 1)
+#define RECEIVER_THROTTLE GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1)
 
 static unsigned int received_cnt;
 
 
 GNUNET_NETWORK_STRUCT_BEGIN
 
-struct MyMessage
-{
+struct MyMessage {
   struct GNUNET_MessageHeader header;
   uint32_t x GNUNET_PACKED;
 };
@@ -57,28 +56,28 @@ static struct GNUNET_MQ_Handle *cmq;
 
 
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != tt)
-  {
-    GNUNET_SCHEDULER_cancel (tt);
-    tt = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(tt);
+      tt = NULL;
+    }
   if (NULL != cmq)
-  {
-    GNUNET_MQ_destroy (cmq);
-    cmq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(cmq);
+      cmq = NULL;
+    }
 }
 
 
 static void
-do_timeout (void *cls)
+do_timeout(void *cls)
 {
-  (void) cls;
+  (void)cls;
   tt = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
   global_ret = 1;
 }
 
@@ -93,59 +92,59 @@ do_timeout (void *cls)
  * @param error error code
  */
 static void
-error_cb (void *cls,
-          enum GNUNET_MQ_Error error)
+error_cb(void *cls,
+         enum GNUNET_MQ_Error error)
 {
-  GNUNET_break (0);
+  GNUNET_break(0);
   global_ret = 3;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-client_continue (void *cls)
+client_continue(void *cls)
 {
   struct GNUNET_SERVICE_Client *c = cls;
 
   dt = NULL;
-  GNUNET_SERVICE_client_continue (c);
+  GNUNET_SERVICE_client_continue(c);
 }
 
 
 static void
-handle_dummy (void *cls,
-              const struct MyMessage *msg)
+handle_dummy(void *cls,
+             const struct MyMessage *msg)
 {
   struct GNUNET_SERVICE_Client *c = cls;
 
-  GNUNET_assert (NULL == dt);
+  GNUNET_assert(NULL == dt);
   /* artificially make receiver slower than sender */
-  dt = GNUNET_SCHEDULER_add_delayed (RECEIVER_THROTTLE,
-                                     &client_continue,
-                                     c);
-  if (received_cnt != ntohl (msg->x))
-  {
-    GNUNET_break (0);
-    global_ret = 4;
-    GNUNET_SCHEDULER_shutdown ();
-  }
+  dt = GNUNET_SCHEDULER_add_delayed(RECEIVER_THROTTLE,
+                                    &client_continue,
+                                    c);
+  if (received_cnt != ntohl(msg->x))
+    {
+      GNUNET_break(0);
+      global_ret = 4;
+      GNUNET_SCHEDULER_shutdown();
+    }
   received_cnt++;
 }
 
 
 static void
-handle_dummy2 (void *cls,
-               const struct MyMessage *msg)
+handle_dummy2(void *cls,
+              const struct MyMessage *msg)
 {
   struct GNUNET_SERVICE_Client *c = cls;
 
-  GNUNET_SERVICE_client_continue (c);
+  GNUNET_SERVICE_client_continue(c);
   if (NUM_TRANSMISSIONS != received_cnt)
-  {
-    GNUNET_break (0);
-    global_ret = 5;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+    {
+      GNUNET_break(0);
+      global_ret = 5;
+    }
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -153,19 +152,19 @@ handle_dummy2 (void *cls,
  * Function called whenever MQ has sent a message.
  */
 static void
-notify_sent_cb (void *cls)
+notify_sent_cb(void *cls)
 {
   static unsigned int seen;
   unsigned int *cnt = cls;
 
   if (seen != *cnt)
-  {
-    GNUNET_break (0);
-    global_ret = 6;
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_break(0);
+      global_ret = 6;
+      GNUNET_SCHEDULER_shutdown();
+    }
   seen++;
-  GNUNET_free (cnt);
+  GNUNET_free(cnt);
 }
 
 
@@ -177,47 +176,47 @@ notify_sent_cb (void *cls)
  * @param sh handle to the newly create service
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_SERVICE_Handle *sh)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_SERVICE_Handle *sh)
 {
   struct GNUNET_MQ_MessageHandler ch[] = {
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_handler_end()
   };
   struct GNUNET_MQ_Envelope *env;
   struct MyMessage *m;
 
-  (void) cls;
-  (void) sh;
-  cmq = GNUNET_CLIENT_connect (cfg,
-                               "test_client",
-                               ch,
-                               &error_cb,
-                               NULL);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
-                                 NULL);
-  tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                     &do_timeout,
-                                     NULL);
-  for (unsigned int i=0;i<NUM_TRANSMISSIONS;i++)
-  {
-    unsigned int *cnt;
-
-    cnt = GNUNET_new (unsigned int);
-    *cnt = i;
-    env = GNUNET_MQ_msg (m,
-                         GNUNET_MESSAGE_TYPE_DUMMY);
-    GNUNET_MQ_notify_sent (env,
-                           &notify_sent_cb,
-                           cnt);
-    m->x = htonl (i);
-    GNUNET_MQ_send (cmq,
-                    env);
-  }
-  env = GNUNET_MQ_msg (m,
-                       GNUNET_MESSAGE_TYPE_DUMMY2);
-  GNUNET_MQ_send (cmq,
-                  env);
+  (void)cls;
+  (void)sh;
+  cmq = GNUNET_CLIENT_connect(cfg,
+                              "test_client",
+                              ch,
+                              &error_cb,
+                              NULL);
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
+                                NULL);
+  tt = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
+                                    &do_timeout,
+                                    NULL);
+  for (unsigned int i = 0; i < NUM_TRANSMISSIONS; i++)
+    {
+      unsigned int *cnt;
+
+      cnt = GNUNET_new(unsigned int);
+      *cnt = i;
+      env = GNUNET_MQ_msg(m,
+                          GNUNET_MESSAGE_TYPE_DUMMY);
+      GNUNET_MQ_notify_sent(env,
+                            &notify_sent_cb,
+                            cnt);
+      m->x = htonl(i);
+      GNUNET_MQ_send(cmq,
+                     env);
+    }
+  env = GNUNET_MQ_msg(m,
+                      GNUNET_MESSAGE_TYPE_DUMMY2);
+  GNUNET_MQ_send(cmq,
+                 env);
 }
 
 
@@ -230,12 +229,12 @@ run (void *cls,
  * @return the client-specific (`internal') closure
  */
 static void *
-connect_cb (void *cls,
-            struct GNUNET_SERVICE_Client *c,
-            struct GNUNET_MQ_Handle *mq)
+connect_cb(void *cls,
+           struct GNUNET_SERVICE_Client *c,
+           struct GNUNET_MQ_Handle *mq)
 {
-  (void) cls;
-  (void) mq;
+  (void)cls;
+  (void)mq;
   return c;
 }
 
@@ -248,18 +247,18 @@ connect_cb (void *cls,
  * @param internal_cls the client-specific (`internal') closure
  */
 static void
-disconnect_cb (void *cls,
-               struct GNUNET_SERVICE_Client *c,
-               void *internal_cls)
+disconnect_cb(void *cls,
+              struct GNUNET_SERVICE_Client *c,
+              void *internal_cls)
 {
-  (void) cls;
-  (void) c;
-  (void) internal_cls;
+  (void)cls;
+  (void)c;
+  (void)internal_cls;
 }
 
 
 static void
-test1 ()
+test1()
 {
   struct GNUNET_MQ_Envelope *mqm;
   struct MyMessage *mm;
@@ -267,74 +266,74 @@ test1 ()
   mm = NULL;
   mqm = NULL;
 
-  mqm = GNUNET_MQ_msg (mm,
-                       GNUNET_MESSAGE_TYPE_DUMMY);
-  GNUNET_assert (NULL != mqm);
-  GNUNET_assert (NULL != mm);
-  GNUNET_assert (GNUNET_MESSAGE_TYPE_DUMMY == ntohs (mm->header.type));
-  GNUNET_assert (sizeof (struct MyMessage) == ntohs (mm->header.size));
-  GNUNET_MQ_discard (mqm);
+  mqm = GNUNET_MQ_msg(mm,
+                      GNUNET_MESSAGE_TYPE_DUMMY);
+  GNUNET_assert(NULL != mqm);
+  GNUNET_assert(NULL != mm);
+  GNUNET_assert(GNUNET_MESSAGE_TYPE_DUMMY == ntohs(mm->header.type));
+  GNUNET_assert(sizeof(struct MyMessage) == ntohs(mm->header.size));
+  GNUNET_MQ_discard(mqm);
 }
 
 
 static void
-test2 ()
+test2()
 {
   struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_MessageHeader *mh;
 
-  mqm = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_DUMMY);
+  mqm = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_DUMMY);
   /* how could the above be checked? */
 
-  GNUNET_MQ_discard (mqm);
+  GNUNET_MQ_discard(mqm);
 
-  mqm = GNUNET_MQ_msg_header_extra (mh,
-                                    20,
-                                    GNUNET_MESSAGE_TYPE_DUMMY);
-  GNUNET_assert (GNUNET_MESSAGE_TYPE_DUMMY == ntohs (mh->type));
-  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) + 20 == ntohs (mh->size));
-  GNUNET_MQ_discard (mqm);
+  mqm = GNUNET_MQ_msg_header_extra(mh,
+                                   20,
+                                   GNUNET_MESSAGE_TYPE_DUMMY);
+  GNUNET_assert(GNUNET_MESSAGE_TYPE_DUMMY == ntohs(mh->type));
+  GNUNET_assert(sizeof(struct GNUNET_MessageHeader) + 20 == ntohs(mh->size));
+  GNUNET_MQ_discard(mqm);
 }
 
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   char * test_argv[] = {
-    (char *) "test_client",
+    (char *)"test_client",
     "-c",
     "test_client_data.conf",
     NULL
   };
   struct GNUNET_MQ_MessageHandler mh[] = {
-    GNUNET_MQ_hd_fixed_size (dummy,
-                             GNUNET_MESSAGE_TYPE_DUMMY,
-                             struct MyMessage,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (dummy2,
-                             GNUNET_MESSAGE_TYPE_DUMMY2,
-                             struct MyMessage,
-                             NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_fixed_size(dummy,
+                            GNUNET_MESSAGE_TYPE_DUMMY,
+                            struct MyMessage,
+                            NULL),
+    GNUNET_MQ_hd_fixed_size(dummy2,
+                            GNUNET_MESSAGE_TYPE_DUMMY2,
+                            struct MyMessage,
+                            NULL),
+    GNUNET_MQ_handler_end()
   };
 
-  (void) argc;
-  (void) argv;
-  GNUNET_log_setup ("test-mq",
-                    "INFO",
-                    NULL);
-  test1 ();
-  test2 ();
+  (void)argc;
+  (void)argv;
+  GNUNET_log_setup("test-mq",
+                   "INFO",
+                   NULL);
+  test1();
+  test2();
   if (0 !=
-      GNUNET_SERVICE_run_ (3,
-                           test_argv,
-                           "test_client",
-                           GNUNET_SERVICE_OPTION_NONE,
-                           &run,
-                           &connect_cb,
-                           &disconnect_cb,
-                           NULL,
-                           mh))
+      GNUNET_SERVICE_run_(3,
+                          test_argv,
+                          "test_client",
+                          GNUNET_SERVICE_OPTION_NONE,
+                          &run,
+                          &connect_cb,
+                          &disconnect_cb,
+                          NULL,
+                          mh))
     return 1;
   return global_ret;
 }
diff --git a/src/util/test_os_network.c b/src/util/test_os_network.c
index fa769de6f..f6b0e3482 100644
--- a/src/util/test_os_network.c
+++ b/src/util/test_os_network.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 util/test_os_network.c
  * @brief testcase for util/os_network.c
@@ -31,13 +31,13 @@
  * (success).
  */
 static int
-proc (void *cls,
-      const char *name,
-      int isDefault,
-      const struct sockaddr *addr,
-      const struct sockaddr *broadcast_addr,
-      const struct sockaddr *netmask,
-      socklen_t addrlen)
+proc(void *cls,
+     const char *name,
+     int isDefault,
+     const struct sockaddr *addr,
+     const struct sockaddr *broadcast_addr,
+     const struct sockaddr *netmask,
+     socklen_t addrlen)
 {
   int *ok = cls;
   char buf[INET6_ADDRSTRLEN];
@@ -45,45 +45,45 @@ proc (void *cls,
 
   if (NULL == addr)
     return GNUNET_OK;
-  if (addrlen == sizeof (struct sockaddr_in))
+  if (addrlen == sizeof(struct sockaddr_in))
     protocol = "IPv4";
   else
     protocol = "IPv6";
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s Address `%s'\n",
-              protocol,
-              GNUNET_a2s ((const struct sockaddr *) addr,
-                          addrlen) );
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Netmask `%s'\n",
-              GNUNET_a2s ((const struct sockaddr *) netmask,
-                          addrlen) );
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "`%s'\n",
-              GNUNET_a2s ((const struct sockaddr *) broadcast_addr,
-                          addrlen) );
-  inet_ntop (addr->sa_family,
-             (addr->sa_family ==
-              AF_INET) ? (void *) &((struct sockaddr_in *) addr)->sin_addr
-             : (void *) &((struct sockaddr_in6 *) addr)->sin6_addr, buf,
-             sizeof (buf));
-  if ((0 == strcmp ("::1", buf)) || (0 == strcmp ("127.0.0.1", buf)))
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "%s Address `%s'\n",
+             protocol,
+             GNUNET_a2s((const struct sockaddr *)addr,
+                        addrlen));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Netmask `%s'\n",
+             GNUNET_a2s((const struct sockaddr *)netmask,
+                        addrlen));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "`%s'\n",
+             GNUNET_a2s((const struct sockaddr *)broadcast_addr,
+                        addrlen));
+  inet_ntop(addr->sa_family,
+            (addr->sa_family ==
+             AF_INET) ? (void *)&((struct sockaddr_in *)addr)->sin_addr
+            : (void *)&((struct sockaddr_in6 *)addr)->sin6_addr, buf,
+            sizeof(buf));
+  if ((0 == strcmp("::1", buf)) || (0 == strcmp("127.0.0.1", buf)))
     *ok = 0;
   return GNUNET_OK;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ret;
 
-  GNUNET_log_setup ("test-os-network",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("test-os-network",
+                   "WARNING",
+                   NULL);
   ret = 1;
-  GNUNET_OS_network_interfaces_list (&proc,
-                                     &ret);
+  GNUNET_OS_network_interfaces_list(&proc,
+                                    &ret);
   return ret;
 }
 
diff --git a/src/util/test_os_start_process.c b/src/util/test_os_start_process.c
index 826e5744c..4efbe91af 100644
--- a/src/util/test_os_start_process.c
+++ b/src/util/test_os_start_process.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 util/test_os_start_process.c
  * @brief testcase for os start process code
@@ -48,8 +48,7 @@ static struct GNUNET_DISK_PipeHandle *hello_pipe_stdout;
 
 static struct GNUNET_SCHEDULER_Task * die_task;
 
-struct read_context
-{
+struct read_context {
   char buf[16];
   int buf_offset;
   const struct GNUNET_DISK_FileHandle *stdout_read_handle;
@@ -60,126 +59,126 @@ static struct read_context rc;
 
 
 static void
-end_task (void *cls)
+end_task(void *cls)
 {
-  if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  }
-  GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
-  GNUNET_OS_process_destroy (proc);
+  if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+    }
+  GNUNET_assert(GNUNET_OK == GNUNET_OS_process_wait(proc));
+  GNUNET_OS_process_destroy(proc);
   proc = NULL;
-  GNUNET_DISK_pipe_close (hello_pipe_stdout);
-  GNUNET_DISK_pipe_close (hello_pipe_stdin);
+  GNUNET_DISK_pipe_close(hello_pipe_stdout);
+  GNUNET_DISK_pipe_close(hello_pipe_stdin);
 }
 
 
 static void
-read_call (void *cls)
+read_call(void *cls)
 {
   int bytes;
 
-  bytes = GNUNET_DISK_file_read (rc.stdout_read_handle,
-                                 &rc.buf[rc.buf_offset],
-                                 sizeof (rc.buf) - rc.buf_offset);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "bytes is %d\n",
-              bytes);
+  bytes = GNUNET_DISK_file_read(rc.stdout_read_handle,
+                                &rc.buf[rc.buf_offset],
+                                sizeof(rc.buf) - rc.buf_offset);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "bytes is %d\n",
+             bytes);
 
   if (bytes < 1)
-  {
-    GNUNET_break (0);
-    ok = 1;
-    GNUNET_SCHEDULER_cancel (die_task);
-    (void) GNUNET_SCHEDULER_add_now (&end_task, NULL);
-    return;
-  }
-
-  ok = strncmp (rc.buf, test_phrase, strlen (test_phrase));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "read %s\n",
-              &rc.buf[rc.buf_offset]);
+    {
+      GNUNET_break(0);
+      ok = 1;
+      GNUNET_SCHEDULER_cancel(die_task);
+      (void)GNUNET_SCHEDULER_add_now(&end_task, NULL);
+      return;
+    }
+
+  ok = strncmp(rc.buf, test_phrase, strlen(test_phrase));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "read %s\n",
+             &rc.buf[rc.buf_offset]);
   rc.buf_offset += bytes;
 
   if (0 == ok)
-  {
-    GNUNET_SCHEDULER_cancel (die_task);
-    (void) GNUNET_SCHEDULER_add_now (&end_task, NULL);
-    return;
-  }
-
-  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  rc.stdout_read_handle,
-                                  &read_call,
-                                  NULL);
+    {
+      GNUNET_SCHEDULER_cancel(die_task);
+      (void)GNUNET_SCHEDULER_add_now(&end_task, NULL);
+      return;
+    }
+
+  GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                 rc.stdout_read_handle,
+                                 &read_call,
+                                 NULL);
 }
 
 
 static void
-run_task (void *cls)
+run_task(void *cls)
 {
   char *fn;
   const struct GNUNET_DISK_FileHandle *stdout_read_handle;
   const struct GNUNET_DISK_FileHandle *wh;
 
 #if !WINDOWS
-  GNUNET_asprintf (&fn, "cat");
+  GNUNET_asprintf(&fn, "cat");
 #else
-  GNUNET_asprintf (&fn, "w32cat");
+  GNUNET_asprintf(&fn, "w32cat");
 #endif
 
-  hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
-  hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  hello_pipe_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
+  hello_pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
 
   if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
-  {
-    GNUNET_break (0);
-    ok = 1;
-    GNUNET_free (fn);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      ok = 1;
+      GNUNET_free(fn);
+      return;
+    }
 
   proc =
-      GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR,
-                               hello_pipe_stdin, hello_pipe_stdout, NULL,
-                               fn,
-                               "test_gnunet_echo_hello", "-", NULL);
-  GNUNET_free (fn);
+    GNUNET_OS_start_process(GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR,
+                            hello_pipe_stdin, hello_pipe_stdout, NULL,
+                            fn,
+                            "test_gnunet_echo_hello", "-", NULL);
+  GNUNET_free(fn);
 
   /* Close the write end of the read pipe */
-  GNUNET_DISK_pipe_close_end (hello_pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_DISK_pipe_close_end(hello_pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
   /* Close the read end of the write pipe */
-  GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_READ);
+  GNUNET_DISK_pipe_close_end(hello_pipe_stdin, GNUNET_DISK_PIPE_END_READ);
 
-  wh = GNUNET_DISK_pipe_handle (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
+  wh = GNUNET_DISK_pipe_handle(hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
 
   /* Write the test_phrase to the cat process */
-  if (GNUNET_DISK_file_write (wh, test_phrase, strlen (test_phrase) + 1) !=
-      strlen (test_phrase) + 1)
-  {
-    GNUNET_break (0);
-    ok = 1;
-    return;
-  }
+  if (GNUNET_DISK_file_write(wh, test_phrase, strlen(test_phrase) + 1) !=
+      strlen(test_phrase) + 1)
+    {
+      GNUNET_break(0);
+      ok = 1;
+      return;
+    }
 
   /* Close the write end to end the cycle! */
-  GNUNET_DISK_pipe_close_end (hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_DISK_pipe_close_end(hello_pipe_stdin, GNUNET_DISK_PIPE_END_WRITE);
 
   stdout_read_handle =
-      GNUNET_DISK_pipe_handle (hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);
+    GNUNET_DISK_pipe_handle(hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);
 
   die_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_MINUTES, 1),
-                                    &end_task,
-                                    NULL);
+    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_MINUTES, 1),
+                                 &end_task,
+                                 NULL);
 
-  memset (&rc, 0, sizeof (rc));
+  memset(&rc, 0, sizeof(rc));
   rc.stdout_read_handle = stdout_read_handle;
-  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  stdout_read_handle,
-                                  &read_call,
-                                  NULL);
+  GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                 stdout_read_handle,
+                                 &read_call,
+                                 NULL);
 }
 
 
@@ -188,10 +187,10 @@ run_task (void *cls)
  * checks that "ok" is correct at the end.
  */
 static int
-check_run ()
+check_run()
 {
   ok = 1;
-  GNUNET_SCHEDULER_run (&run_task, &ok);
+  GNUNET_SCHEDULER_run(&run_task, &ok);
   return ok;
 }
 
@@ -200,40 +199,40 @@ check_run ()
  * Test killing via pipe.
  */
 static int
-check_kill ()
+check_kill()
 {
   char *fn;
 
-  hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
-  hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  hello_pipe_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
+  hello_pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
-  {
-    return 1;
-  }
-  fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
+    {
+      return 1;
+    }
+  fn = GNUNET_OS_get_libexec_binary_path("gnunet-service-resolver");
   proc =
-    GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR,
-                             hello_pipe_stdin,
-                             hello_pipe_stdout,
-                             NULL,
-                             fn,
-                             "gnunet-service-resolver", "-",
-                             NULL);
+    GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR,
+                            hello_pipe_stdin,
+                            hello_pipe_stdout,
+                            NULL,
+                            fn,
+                            "gnunet-service-resolver", "-",
+                            NULL);
   if (NULL == proc)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to launch gnunet-service-resolver. Is your system setup correct?\n");
-    return 77;
-  }
-  sleep (1); /* give process time to start, so we actually use the pipe-kill mechanism! */
-  GNUNET_free (fn);
-  if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
-  GNUNET_OS_process_destroy (proc);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to launch gnunet-service-resolver. Is your system setup correct?\n");
+      return 77;
+    }
+  sleep(1);  /* give process time to start, so we actually use the pipe-kill mechanism! */
+  GNUNET_free(fn);
+  if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG))
+    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+  GNUNET_assert(GNUNET_OK == GNUNET_OS_process_wait(proc));
+  GNUNET_OS_process_destroy(proc);
   proc = NULL;
-  GNUNET_DISK_pipe_close (hello_pipe_stdout);
-  GNUNET_DISK_pipe_close (hello_pipe_stdin);
+  GNUNET_DISK_pipe_close(hello_pipe_stdout);
+  GNUNET_DISK_pipe_close(hello_pipe_stdin);
   return 0;
 }
 
@@ -242,55 +241,55 @@ check_kill ()
  * Test killing via pipe.
  */
 static int
-check_instant_kill ()
+check_instant_kill()
 {
   char *fn;
 
-  hello_pipe_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
-  hello_pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
+  hello_pipe_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
+  hello_pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if ((hello_pipe_stdout == NULL) || (hello_pipe_stdin == NULL))
-  {
-    return 1;
-  }
-  fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
+    {
+      return 1;
+    }
+  fn = GNUNET_OS_get_libexec_binary_path("gnunet-service-resolver");
   proc =
-    GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR,
-                             hello_pipe_stdin, hello_pipe_stdout, NULL,
-                             fn,
-                             "gnunet-service-resolver", "-", NULL);
+    GNUNET_OS_start_process(GNUNET_YES, GNUNET_OS_INHERIT_STD_ERR,
+                            hello_pipe_stdin, hello_pipe_stdout, NULL,
+                            fn,
+                            "gnunet-service-resolver", "-", NULL);
   if (NULL == proc)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to launch gnunet-service-resolver. Is your system setup correct?\n");
-    return 77;
-  }
-  if (0 != GNUNET_OS_process_kill (proc,
-                                   GNUNET_TERM_SIG))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  }
-  GNUNET_free (fn);
-  GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (proc));
-  GNUNET_OS_process_destroy (proc);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to launch gnunet-service-resolver. Is your system setup correct?\n");
+      return 77;
+    }
+  if (0 != GNUNET_OS_process_kill(proc,
+                                  GNUNET_TERM_SIG))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+    }
+  GNUNET_free(fn);
+  GNUNET_assert(GNUNET_OK == GNUNET_OS_process_wait(proc));
+  GNUNET_OS_process_destroy(proc);
   proc = NULL;
-  GNUNET_DISK_pipe_close (hello_pipe_stdout);
-  GNUNET_DISK_pipe_close (hello_pipe_stdin);
+  GNUNET_DISK_pipe_close(hello_pipe_stdout);
+  GNUNET_DISK_pipe_close(hello_pipe_stdin);
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ret;
 
-  GNUNET_log_setup ("test-os-start-process",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("test-os-start-process",
+                   "WARNING",
+                   NULL);
   ret = 0;
-  ret |= check_run ();
-  ret |= check_kill ();
-  ret |= check_instant_kill ();
+  ret |= check_run();
+  ret |= check_kill();
+  ret |= check_instant_kill();
   return ret;
 }
 
diff --git a/src/util/test_peer.c b/src/util/test_peer.c
index b059f2cf3..46a803e39 100644
--- a/src/util/test_peer.c
+++ b/src/util/test_peer.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 util/test_peer.c
  * @brief testcase for peer.c
@@ -36,102 +36,102 @@ static struct GNUNET_PeerIdentity pidArr[NUMBER_OF_PEERS];
 
 
 static void
-generatePeerIdList ()
+generatePeerIdList()
 {
   for (unsigned int i = 0; i < NUMBER_OF_PEERS; i++)
-  {
-    gcry_randomize (&pidArr[i],
-                    sizeof (struct GNUNET_PeerIdentity),
-                    GCRY_STRONG_RANDOM);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Peer %u: %s\n",
-                i,
-                GNUNET_i2s (&pidArr[i]));
-  }
+    {
+      gcry_randomize(&pidArr[i],
+                     sizeof(struct GNUNET_PeerIdentity),
+                     GCRY_STRONG_RANDOM);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Peer %u: %s\n",
+                 i,
+                 GNUNET_i2s(&pidArr[i]));
+    }
 }
 
 
 static int
-check ()
+check()
 {
   GNUNET_PEER_Id pid;
   struct GNUNET_PeerIdentity res;
   GNUNET_PEER_Id ids[] = { 1, 2, 3 };
 
-  GNUNET_assert (0 == GNUNET_PEER_intern (NULL));
+  GNUNET_assert(0 == GNUNET_PEER_intern(NULL));
   /* Insert Peers into PeerEntry table and hashmap */
   for (unsigned int i = 0; i < NUMBER_OF_PEERS; i++)
-  {
-    pid = GNUNET_PEER_intern (&pidArr[i]);
-    if (pid != (i + 1))
     {
-      fprintf (stderr, "%s",  "Unexpected Peer ID returned by intern function\n");
-      return 1;
+      pid = GNUNET_PEER_intern(&pidArr[i]);
+      if (pid != (i + 1))
+        {
+          fprintf(stderr, "%s", "Unexpected Peer ID returned by intern function\n");
+          return 1;
+        }
     }
-  }
 
   /* Referencing the first 3 peers once again */
   for (unsigned int i = 0; i < 3; i++)
-  {
-    pid = GNUNET_PEER_intern (&pidArr[i]);
-    if (pid != (i + 1))
     {
-      fprintf (stderr, "%s",  "Unexpected Peer ID returned by intern function\n");
-      return 1;
+      pid = GNUNET_PEER_intern(&pidArr[i]);
+      if (pid != (i + 1))
+        {
+          fprintf(stderr, "%s", "Unexpected Peer ID returned by intern function\n");
+          return 1;
+        }
     }
-  }
 
   /* Dereferencing the first 3 peers once [decrementing their reference count] */
-  GNUNET_PEER_decrement_rcs (ids, 3);
+  GNUNET_PEER_decrement_rcs(ids, 3);
 
   /* re-referencing the first 3 peers using the change_rc function */
   for (unsigned int i = 1; i <= 3; i++)
-    GNUNET_PEER_change_rc (i, 1);
+    GNUNET_PEER_change_rc(i, 1);
 
   /* Removing the second Peer from the PeerEntry hash map */
-  GNUNET_PEER_change_rc (2, -2);
+  GNUNET_PEER_change_rc(2, -2);
 
   /* convert the pid of the first PeerEntry into that of the third */
-  GNUNET_PEER_resolve (1,
-                       &res);
-  GNUNET_assert (0 ==
-                 GNUNET_memcmp (&res,
-                                &pidArr[0]));
+  GNUNET_PEER_resolve(1,
+                      &res);
+  GNUNET_assert(0 ==
+                GNUNET_memcmp(&res,
+                              &pidArr[0]));
 
   /*
    * Attempt to convert pid = 0 (which is reserved)
    * into a peer identity object, the peer identity memory
    * is expected to be set to zero
    */
-  GNUNET_log_skip (1, GNUNET_YES);
-  GNUNET_PEER_resolve (0, &res);
-  GNUNET_assert (0 ==
-                 GNUNET_is_zero (&res));
+  GNUNET_log_skip(1, GNUNET_YES);
+  GNUNET_PEER_resolve(0, &res);
+  GNUNET_assert(0 ==
+                GNUNET_is_zero(&res));
 
   /* Removing peer entries 1 and 3 from table using the list decrement function */
   /* If count = 0, nothing should be done whatsoever */
-  GNUNET_PEER_decrement_rcs (ids, 0);
+  GNUNET_PEER_decrement_rcs(ids, 0);
 
   ids[1] = 3;
-  GNUNET_PEER_decrement_rcs (ids, 2);
-  GNUNET_PEER_decrement_rcs (ids, 2);
+  GNUNET_PEER_decrement_rcs(ids, 2);
+  GNUNET_PEER_decrement_rcs(ids, 2);
 
   return 0;
 }
 
 
 int
-main ()
+main()
 {
-  GNUNET_log_setup ("test-peer",
-                    "ERROR",
-                    NULL);
+  GNUNET_log_setup("test-peer",
+                   "ERROR",
+                   NULL);
   for (unsigned int i = 0; i < 1; i++)
-  {
-    generatePeerIdList ();
-    if (0 != check ())
-      return 1;
-  }
+    {
+      generatePeerIdList();
+      if (0 != check())
+        return 1;
+    }
   return 0;
 }
 
diff --git a/src/util/test_plugin.c b/src/util/test_plugin.c
index 04dcdf213..98e6173d5 100644
--- a/src/util/test_plugin.c
+++ b/src/util/test_plugin.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 util/test_plugin.c
  * @brief testcase for plugin.c
@@ -26,42 +26,42 @@
 
 
 static void
-test_cb (void *cls, const char *libname, void *lib_ret)
+test_cb(void *cls, const char *libname, void *lib_ret)
 {
   void *ret;
 
-  GNUNET_assert (0 == strcmp (cls, "test"));
-  GNUNET_assert (0 == strcmp (lib_ret, "Hello"));
-  ret = GNUNET_PLUGIN_unload (libname, "out");
-  GNUNET_assert (NULL != ret);
-  GNUNET_assert (0 == strcmp (ret, "World"));
-  free (ret);
+  GNUNET_assert(0 == strcmp(cls, "test"));
+  GNUNET_assert(0 == strcmp(lib_ret, "Hello"));
+  ret = GNUNET_PLUGIN_unload(libname, "out");
+  GNUNET_assert(NULL != ret);
+  GNUNET_assert(0 == strcmp(ret, "World"));
+  free(ret);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   void *ret;
 
-  GNUNET_log_setup ("test-plugin", "WARNING", NULL);
-  GNUNET_log_skip (1, GNUNET_NO);
-  ret = GNUNET_PLUGIN_load ("libgnunet_plugin_missing", NULL);
-  GNUNET_log_skip (0, GNUNET_NO);
+  GNUNET_log_setup("test-plugin", "WARNING", NULL);
+  GNUNET_log_skip(1, GNUNET_NO);
+  ret = GNUNET_PLUGIN_load("libgnunet_plugin_missing", NULL);
+  GNUNET_log_skip(0, GNUNET_NO);
   if (ret != NULL)
     return 1;
-  ret = GNUNET_PLUGIN_load ("libgnunet_plugin_test", "in");
+  ret = GNUNET_PLUGIN_load("libgnunet_plugin_test", "in");
   if (ret == NULL)
     return 1;
-  if (0 != strcmp (ret, "Hello"))
+  if (0 != strcmp(ret, "Hello"))
     return 2;
-  ret = GNUNET_PLUGIN_unload ("libgnunet_plugin_test", "out");
+  ret = GNUNET_PLUGIN_unload("libgnunet_plugin_test", "out");
   if (ret == NULL)
     return 3;
-  if (0 != strcmp (ret, "World"))
+  if (0 != strcmp(ret, "World"))
     return 4;
-  free (ret);
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_tes", "in", &test_cb, "test");
+  free(ret);
+  GNUNET_PLUGIN_load_all("libgnunet_plugin_tes", "in", &test_cb, "test");
   return 0;
 }
 
diff --git a/src/util/test_plugin_plug.c b/src/util/test_plugin_plug.c
index deb36b0a0..f719a075f 100644
--- a/src/util/test_plugin_plug.c
+++ b/src/util/test_plugin_plug.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 util/test_plugin_plug.c
  * @brief plugin for testing
@@ -24,18 +24,18 @@
 #include "platform.h"
 
 void *
-libgnunet_plugin_test_init (void *arg)
+libgnunet_plugin_test_init(void *arg)
 {
-  if (0 == strcmp (arg, "in"))
+  if (0 == strcmp(arg, "in"))
     return "Hello";
   return NULL;
 }
 
 void *
-libgnunet_plugin_test_done (void *arg)
+libgnunet_plugin_test_done(void *arg)
 {
-  if (0 == strcmp (arg, "out"))
-    return strdup ("World");
+  if (0 == strcmp(arg, "out"))
+    return strdup("World");
   return NULL;
 }
 
diff --git a/src/util/test_program.c b/src/util/test_program.c
index a9b3b064a..983610f2e 100644
--- a/src/util/test_program.c
+++ b/src/util/test_program.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 util/test_program.c
  * @brief tests for program.c
@@ -34,23 +34,23 @@ static int setme2;
  * Main function that will be run.
  */
 static void
-runner (void *cls,
-        char *const *args,
-        const char *cfgfile,
-        const struct GNUNET_CONFIGURATION_Handle *cfg)
+runner(void *cls,
+       char *const *args,
+       const char *cfgfile,
+       const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int *ok = cls;
 
-  GNUNET_assert (setme1 == 1);
-  GNUNET_assert (0 == strcmp (args[0], "extra"));
-  GNUNET_assert (args[1] == NULL);
-  GNUNET_assert (NULL != strstr (cfgfile, "/test_program_data.conf"));
+  GNUNET_assert(setme1 == 1);
+  GNUNET_assert(0 == strcmp(args[0], "extra"));
+  GNUNET_assert(args[1] == NULL);
+  GNUNET_assert(NULL != strstr(cfgfile, "/test_program_data.conf"));
   *ok = 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ok = 1;
   char *const argvx[] = {
@@ -64,72 +64,72 @@ main (int argc, char *argv[])
     NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options1[] = {
-    GNUNET_GETOPT_option_flag ('n',
-                                  "name",
-                                  "description",
-                                  &setme1),
+    GNUNET_GETOPT_option_flag('n',
+                              "name",
+                              "description",
+                              &setme1),
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_GETOPT_CommandLineOption options2[] = {
-    GNUNET_GETOPT_option_flag ('n',
-                                  "name",
-                                  "description",
-                                  &setme1),
-    GNUNET_GETOPT_option_flag ('N',
-                                  "number",
-                                  "description",
-                                  &setme2),
+    GNUNET_GETOPT_option_flag('n',
+                              "name",
+                              "description",
+                              &setme1),
+    GNUNET_GETOPT_option_flag('N',
+                              "number",
+                              "description",
+                              &setme2),
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_GETOPT_CommandLineOption options3[] = {
-    GNUNET_GETOPT_option_flag ('N',
-                                  "number",
-                                  "description",
-                                  &setme1),
-    GNUNET_GETOPT_option_flag ('n',
-                                  "name",
-                                  "description",
-                                  &setme2),
+    GNUNET_GETOPT_option_flag('N',
+                              "number",
+                              "description",
+                              &setme1),
+    GNUNET_GETOPT_option_flag('n',
+                              "name",
+                              "description",
+                              &setme2),
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_GETOPT_CommandLineOption options4[] = {
-    GNUNET_GETOPT_option_flag ('n',
-                                  "name",
-                                  "description",
-                                  &setme1),
-    GNUNET_GETOPT_option_flag ('n',
-                                  "name",
-                                  "description",
-                                  &setme2),
+    GNUNET_GETOPT_option_flag('n',
+                              "name",
+                              "description",
+                              &setme1),
+    GNUNET_GETOPT_option_flag('n',
+                              "name",
+                              "description",
+                              &setme2),
     GNUNET_GETOPT_OPTION_END
   };
 
 
-  GNUNET_log_setup ("test_program",
-                    "WARNING",
-                    NULL);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7, argvx,
-                                     "test_program",
-                                     "A test",
-                                     options1,
-                                     &runner, &ok));
-
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7, argvx,
-                                     "test_program", "A test",
-                                     options2,
-                                     &runner, &ok));
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7, argvx,
-                                     "test_program", "A test",
-                                     options3,
-                                     &runner, &ok));
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run (7, argvx,
-                                     "test_program", "A test",
-                                     options4,
-                                     &runner, &ok));
+  GNUNET_log_setup("test_program",
+                   "WARNING",
+                   NULL);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_PROGRAM_run(7, argvx,
+                                   "test_program",
+                                   "A test",
+                                   options1,
+                                   &runner, &ok));
+
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_PROGRAM_run(7, argvx,
+                                   "test_program", "A test",
+                                   options2,
+                                   &runner, &ok));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_PROGRAM_run(7, argvx,
+                                   "test_program", "A test",
+                                   options3,
+                                   &runner, &ok));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_PROGRAM_run(7, argvx,
+                                   "test_program", "A test",
+                                   options4,
+                                   &runner, &ok));
 
   return ok;
 }
diff --git a/src/util/test_regex.c b/src/util/test_regex.c
index b47314084..c2306b971 100644
--- a/src/util/test_regex.c
+++ b/src/util/test_regex.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 tun/test_regex.c
  * @brief simple test for regex.c iptoregex functions
@@ -32,12 +32,12 @@
 
 
 static int
-test_iptoregex (const char *ipv4,
-                uint16_t port,
-                const char *expectedv4,
-                const char *ipv6,
-                uint16_t port6,
-                const char *expectedv6)
+test_iptoregex(const char *ipv4,
+               uint16_t port,
+               const char *expectedv4,
+               const char *ipv6,
+               uint16_t port6,
+               const char *expectedv6)
 {
   int error = 0;
 
@@ -46,136 +46,136 @@ test_iptoregex (const char *ipv4,
   char rxv4[GNUNET_TUN_IPV4_REGEXLEN];
   char rxv6[GNUNET_TUN_IPV6_REGEXLEN];
 
-  GNUNET_assert (1 == inet_pton (AF_INET, ipv4, &a));
-  GNUNET_TUN_ipv4toregexsearch (&a, port, rxv4);
-
-  if (0 != strcmp (rxv4, expectedv4))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Expected: %s but got: %s\n",
-                expectedv4,
-                rxv4);
-    error++;
-  }
-
-  GNUNET_assert (1 == inet_pton (AF_INET6, ipv6, &b));
-  GNUNET_TUN_ipv6toregexsearch (&b, port6, rxv6);
-  if (0 != strcmp (rxv6, expectedv6))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Expected: %s but got: %s\n",
-                expectedv6, rxv6);
-    error++;
-  }
+  GNUNET_assert(1 == inet_pton(AF_INET, ipv4, &a));
+  GNUNET_TUN_ipv4toregexsearch(&a, port, rxv4);
+
+  if (0 != strcmp(rxv4, expectedv4))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Expected: %s but got: %s\n",
+                 expectedv4,
+                 rxv4);
+      error++;
+    }
+
+  GNUNET_assert(1 == inet_pton(AF_INET6, ipv6, &b));
+  GNUNET_TUN_ipv6toregexsearch(&b, port6, rxv6);
+  if (0 != strcmp(rxv6, expectedv6))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Expected: %s but got: %s\n",
+                 expectedv6, rxv6);
+      error++;
+    }
   return error;
 }
 
 
 static int
-test_policy4toregex (const char *policy,
-                     const char *regex)
+test_policy4toregex(const char *policy,
+                    const char *regex)
 {
   char *r;
   int ret;
 
   ret = 0;
-  r = GNUNET_TUN_ipv4policy2regex (policy);
+  r = GNUNET_TUN_ipv4policy2regex(policy);
   if (NULL == r)
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (0 != strcmp (regex, r))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Expected: `%s' but got: `%s'\n",
-                regex, r);
-    ret = 2;
-  }
-  GNUNET_free (r);
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (0 != strcmp(regex, r))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Expected: `%s' but got: `%s'\n",
+                 regex, r);
+      ret = 2;
+    }
+  GNUNET_free(r);
   return ret;
 }
 
 
 static int
-test_policy6toregex (const char *policy,
-                     const char *regex)
+test_policy6toregex(const char *policy,
+                    const char *regex)
 {
   char *r;
   int ret;
 
   ret = 0;
-  r = GNUNET_TUN_ipv6policy2regex (policy);
+  r = GNUNET_TUN_ipv6policy2regex(policy);
   if (NULL == r)
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  if (0 != strcmp (regex, r))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Expected: `%s' but got: `%s'\n",
-                regex, r);
-    ret = 2;
-  }
-  GNUNET_free (r);
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  if (0 != strcmp(regex, r))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Expected: `%s' but got: `%s'\n",
+                 regex, r);
+      ret = 2;
+    }
+  GNUNET_free(r);
   return ret;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int error;
   char *r;
 
-  GNUNET_log_setup ("test-regex", "WARNING", NULL);
+  GNUNET_log_setup("test-regex", "WARNING", NULL);
   error = 0;
 
   /* this is just a performance test ... */
-  r = GNUNET_TUN_ipv4policy2regex ("1.2.3.4/16:!25;");
-  GNUNET_break (NULL != r);
-  GNUNET_free (r);
+  r = GNUNET_TUN_ipv4policy2regex("1.2.3.4/16:!25;");
+  GNUNET_break(NULL != r);
+  GNUNET_free(r);
 
   error +=
-    test_iptoregex ("192.1.2.3", 2086,
-                    "4-0826-C0010203",
-                    "FFFF::1", 8080,
-                    "6-1F90-FFFF0000000000000000000000000001");
+    test_iptoregex("192.1.2.3", 2086,
+                   "4-0826-C0010203",
+                   "FFFF::1", 8080,
+                   "6-1F90-FFFF0000000000000000000000000001");
   error +=
-    test_iptoregex ("187.238.255.0", 80,
-                    "4-0050-BBEEFF00",
-                    "E1E1:73F9:51BE::0", 49,
-                    "6-0031-E1E173F951BE00000000000000000000");
+    test_iptoregex("187.238.255.0", 80,
+                   "4-0050-BBEEFF00",
+                   "E1E1:73F9:51BE::0", 49,
+                   "6-0031-E1E173F951BE00000000000000000000");
   error +=
-    test_policy4toregex ("192.1.2.0/24:80;",
-                         "4-0050-C00102" DOT DOT);
+    test_policy4toregex("192.1.2.0/24:80;",
+                        "4-0050-C00102" DOT DOT);
   error +=
-    test_policy4toregex ("192.1.0.0/16;",
-                         "4-" DOT DOT DOT DOT "-C001" DOT DOT DOT DOT);
+    test_policy4toregex("192.1.0.0/16;",
+                        "4-" DOT DOT DOT DOT "-C001" DOT DOT DOT DOT);
   error +=
-    test_policy4toregex ("192.1.0.0/16:80-81;",
-                         "4-(0050|0051)-C001" DOT DOT DOT DOT);
+    test_policy4toregex("192.1.0.0/16:80-81;",
+                        "4-(0050|0051)-C001" DOT DOT DOT DOT);
   error +=
-    test_policy4toregex ("192.1.0.0/8:!3-65535;",
-                         "4-000(0|1|2)-C0" DOT DOT DOT DOT DOT DOT);
+    test_policy4toregex("192.1.0.0/8:!3-65535;",
+                        "4-000(0|1|2)-C0" DOT DOT DOT DOT DOT DOT);
   error +=
-    test_policy4toregex ("192.1.0.0/8:!25-56;",
-                         "4-(0(0(0"DOT"|1(0|1|2|3|4|5|6|7|8)|3(9|A|B|C|D|E|F)|(4|5|6|7|8|9|A|B|C|D|E|F)"DOT")|(1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"DOT DOT")|(1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"DOT DOT DOT")-C0"DOT DOT DOT DOT DOT DOT);
+    test_policy4toregex("192.1.0.0/8:!25-56;",
+                        "4-(0(0(0"DOT "|1(0|1|2|3|4|5|6|7|8)|3(9|A|B|C|D|E|F)|(4|5|6|7|8|9|A|B|C|D|E|F)"DOT ")|(1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"DOT DOT ")|(1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"DOT DOT DOT ")-C0"DOT DOT DOT DOT DOT DOT);
   error +=
-    test_policy6toregex ("E1E1::1;",
-                         "6-"DOT DOT DOT DOT"-E1E10000000000000000000000000001");
+    test_policy6toregex("E1E1::1;",
+                        "6-"DOT DOT DOT DOT "-E1E10000000000000000000000000001");
   error +=
-    test_policy6toregex ("E1E1:ABCD::1/120;",
-                         "6-"DOT DOT DOT DOT"-E1E1ABCD0000000000000000000000" DOT DOT);
+    test_policy6toregex("E1E1:ABCD::1/120;",
+                        "6-"DOT DOT DOT DOT "-E1E1ABCD0000000000000000000000" DOT DOT);
   error +=
-    test_policy6toregex ("E1E1:ABCD::ABCD/126;",
-                         "6-"DOT DOT DOT DOT"-E1E1ABCD00000000000000000000ABC(C|D|E|F)");
+    test_policy6toregex("E1E1:ABCD::ABCD/126;",
+                        "6-"DOT DOT DOT DOT "-E1E1ABCD00000000000000000000ABC(C|D|E|F)");
   error +=
-    test_policy6toregex ("E1E1:ABCD::ABCD/127;",
-                         "6-"DOT DOT DOT DOT"-E1E1ABCD00000000000000000000ABC(C|D)");
+    test_policy6toregex("E1E1:ABCD::ABCD/127;",
+                        "6-"DOT DOT DOT DOT "-E1E1ABCD00000000000000000000ABC(C|D)");
   error +=
-    test_policy6toregex ("E1E1:ABCD::ABCD/128:80;",
-                         "6-0050-E1E1ABCD00000000000000000000ABCD");
+    test_policy6toregex("E1E1:ABCD::ABCD/128:80;",
+                        "6-0050-E1E1ABCD00000000000000000000ABCD");
   return error;
 }
diff --git a/src/util/test_resolver_api.c b/src/util/test_resolver_api.c
index f4184aa84..ea26c4ee6 100644
--- a/src/util/test_resolver_api.c
+++ b/src/util/test_resolver_api.c
@@ -1,19 +1,19 @@
 /*
- This file is part of GNUnet.
- Copyright (C) 2009 GNUnet e.V.
+   This file is part of GNUnet.
+   Copyright (C) 2009 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 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.
+   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/>.
+   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
  */
@@ -36,308 +36,307 @@ static int disable_rootserver_check;
  * For more information have a look at IANA's website http://www.root-servers.org/
  */
 #define ROOTSERVER_NAME "a.root-servers.net"
-#define ROOTSERVER_IP   "198.41.0.4"
+#define ROOTSERVER_IP   "198.41.0.4"
 
 
 static void
-check_hostname (void *cls,
-                const struct sockaddr *sa,
-                socklen_t salen)
+check_hostname(void *cls,
+               const struct sockaddr *sa,
+               socklen_t salen)
 {
   int *ok = cls;
 
   if (0 == salen)
-  {
-    (*ok) &= ~8;
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Got IP address `%s' for our host.\n",
-              GNUNET_a2s (sa, salen));
+    {
+      (*ok) &= ~8;
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Got IP address `%s' for our host.\n",
+             GNUNET_a2s(sa, salen));
 }
 
 
 static void
-check_localhost_num (void *cls,
-                     const char *hostname)
+check_localhost_num(void *cls,
+                    const char *hostname)
 {
   int *ok = cls;
 
   if (hostname == NULL)
     return;
-  if (0 == strcmp (hostname, "127.0.0.1"))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct hostname `%s'.\n",
-                hostname);
-    (*ok) &= ~4;
-  }
+  if (0 == strcmp(hostname, "127.0.0.1"))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received correct hostname `%s'.\n",
+                 hostname);
+      (*ok) &= ~4;
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received invalid hostname `%s'.\n",
-                hostname);
-    GNUNET_break (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received invalid hostname `%s'.\n",
+                 hostname);
+      GNUNET_break(0);
+    }
 }
 
 
 static void
-check_localhost (void *cls,
-                 const char *hostname)
+check_localhost(void *cls,
+                const char *hostname)
 {
   int *ok = cls;
 
   if (NULL == hostname)
     return;
-  if (0 == strcmp (hostname, "localhost"))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct hostname `%s'.\n",
-                hostname);
-    (*ok) &= ~2;
-  }
+  if (0 == strcmp(hostname, "localhost"))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received correct hostname `%s'.\n",
+                 hostname);
+      (*ok) &= ~2;
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Received unexpected hostname `%s', expected `localhost' (this could be OK).\n",
-                hostname);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Received unexpected hostname `%s', expected `localhost' (this could be OK).\n",
+                 hostname);
+    }
 }
 
 
 static void
-check_127 (void *cls, const struct sockaddr *sa, socklen_t salen)
+check_127(void *cls, const struct sockaddr *sa, socklen_t salen)
 {
   int *ok = cls;
-  const struct sockaddr_in *sai = (const struct sockaddr_in *) sa;
+  const struct sockaddr_in *sai = (const struct sockaddr_in *)sa;
 
   if (NULL == sa)
     return;
-  GNUNET_assert (sizeof (struct sockaddr_in) == salen);
-  if (sai->sin_addr.s_addr == htonl (INADDR_LOOPBACK))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct address.\n");
-    (*ok) &= ~1;
-  }
+  GNUNET_assert(sizeof(struct sockaddr_in) == salen);
+  if (sai->sin_addr.s_addr == htonl(INADDR_LOOPBACK))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received correct address.\n");
+      (*ok) &= ~1;
+    }
   else
-  {
-    char buf[INET_ADDRSTRLEN];
+    {
+      char buf[INET_ADDRSTRLEN];
 
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Received incorrect address `%s'.\n",
-                inet_ntop (AF_INET,
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Received incorrect address `%s'.\n",
+                 inet_ntop(AF_INET,
                            &sai->sin_addr,
                            buf,
-                           sizeof (buf)));
-    GNUNET_break (0);
-  }
+                           sizeof(buf)));
+      GNUNET_break(0);
+    }
 }
 
 
 static void
-check_rootserver_ip (void *cls, const struct sockaddr *sa, socklen_t salen)
+check_rootserver_ip(void *cls, const struct sockaddr *sa, socklen_t salen)
 {
   int *ok = cls;
-  const struct sockaddr_in *sai = (const struct sockaddr_in *) sa;
+  const struct sockaddr_in *sai = (const struct sockaddr_in *)sa;
 
   if (NULL == sa)
     return;
-  GNUNET_assert (sizeof (struct sockaddr_in) == salen);
-
-  if (0 == strcmp (inet_ntoa (sai->sin_addr), ROOTSERVER_IP))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct rootserver ip address.\n");
-    (*ok) &= ~1;
-  }
+  GNUNET_assert(sizeof(struct sockaddr_in) == salen);
+
+  if (0 == strcmp(inet_ntoa(sai->sin_addr), ROOTSERVER_IP))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received correct rootserver ip address.\n");
+      (*ok) &= ~1;
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received incorrect rootserver ip address.\n");
-    GNUNET_break (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received incorrect rootserver ip address.\n");
+      GNUNET_break(0);
+    }
 }
 
 
 static void
-check_rootserver_name (void *cls,
-                       const char *hostname)
+check_rootserver_name(void *cls,
+                      const char *hostname)
 {
   int *ok = cls;
 
   if (NULL == hostname)
     return;
 
-  if (0 == strcmp (hostname, ROOTSERVER_NAME))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received correct rootserver hostname `%s'.\n",
-                hostname);
-    (*ok) &= ~2;
-  }
+  if (0 == strcmp(hostname, ROOTSERVER_NAME))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Received correct rootserver hostname `%s'.\n",
+                 hostname);
+      (*ok) &= ~2;
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Received invalid rootserver hostname `%s', expected `%s'\n",
-                hostname,
-                ROOTSERVER_NAME);
-    GNUNET_break (disable_rootserver_check);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Received invalid rootserver hostname `%s', expected `%s'\n",
+                 hostname,
+                 ROOTSERVER_NAME);
+      GNUNET_break(disable_rootserver_check);
+    }
 }
 
 
 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)
 {
   int *ok = cls;
   struct sockaddr_in sa;
   struct GNUNET_TIME_Relative timeout =
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
+    GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30);
   int count_ips = 0;
   char *own_fqdn;
   const char *rootserver_name = ROOTSERVER_NAME;
   struct hostent *rootserver;
   struct in_addr rootserver_addr;
 
-  memset (&sa, 0, sizeof (sa));
+  memset(&sa, 0, sizeof(sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa.sin_len = (u_char) sizeof (sa);
+  sa.sin_len = (u_char)sizeof(sa);
 #endif
-  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 
   /*
    * Looking up our own fqdn
    */
-  own_fqdn = GNUNET_RESOLVER_local_fqdn_get ();
+  own_fqdn = GNUNET_RESOLVER_local_fqdn_get();
   /* can't really check, only thing we can safely
      compare against is our own identical logic... */
-  GNUNET_free_non_null (own_fqdn);
+  GNUNET_free_non_null(own_fqdn);
 
   /*
    * Testing non-local DNS resolution
    * DNS rootserver to test: a.root-servers.net - 198.41.0.4
    */
 
-  rootserver = gethostbyname (rootserver_name);
+  rootserver = gethostbyname(rootserver_name);
   if (NULL == rootserver)
-  {
-    /* Error: resolving ip addresses does not work */
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("gethostbyname() could not lookup IP address: %s\n"),
-                hstrerror (h_errno));
-    fprintf (stderr,
-             "%s",
-             "System seems to be off-line, will not run all DNS tests\n");
-    *ok = 0;                    /* mark test as passing anyway */
-    return;
-  }
+    {
+      /* Error: resolving ip addresses does not work */
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("gethostbyname() could not lookup IP address: %s\n"),
+                 hstrerror(h_errno));
+      fprintf(stderr,
+              "%s",
+              "System seems to be off-line, will not run all DNS tests\n");
+      *ok = 0;                  /* mark test as passing anyway */
+      return;
+    }
 
   /* Counting returned IP addresses */
   while (NULL != rootserver->h_addr_list[count_ips])
     count_ips++;
   if (count_ips > 1)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "IP received range for root name server, but a root name server has only 1 IP\n");
-    GNUNET_break (0);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "IP received range for root name server, but a root name server has only 1 IP\n");
+      GNUNET_break(0);
+    }
 
   /* Comparing to resolved address to the address the root name server should have */
   if (0 !=
-      strcmp (inet_ntoa (*(struct in_addr *) rootserver->h_addr_list[0]),
-              ROOTSERVER_IP))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "IP received and IP for root name server differ\n");
-    GNUNET_break (0);
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "System's own forward name resolution is working\n");
+      strcmp(inet_ntoa(*(struct in_addr *)rootserver->h_addr_list[0]),
+             ROOTSERVER_IP))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "IP received and IP for root name server differ\n");
+      GNUNET_break(0);
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "System's own forward name resolution is working\n");
   /* Resolve the same using GNUNET */
-  GNUNET_RESOLVER_ip_get (ROOTSERVER_NAME, AF_INET, timeout,
-                          &check_rootserver_ip, cls);
-  GNUNET_RESOLVER_ip_get (ROOTSERVER_NAME, AF_INET, timeout,
-                          &check_rootserver_ip, cls);
+  GNUNET_RESOLVER_ip_get(ROOTSERVER_NAME, AF_INET, timeout,
+                         &check_rootserver_ip, cls);
+  GNUNET_RESOLVER_ip_get(ROOTSERVER_NAME, AF_INET, timeout,
+                         &check_rootserver_ip, cls);
 
   /*
    * Success: forward lookups work as expected
    * Next step: reverse lookups
    */
-  if (1 != inet_pton (AF_INET,
-                      ROOTSERVER_IP,
-                      &rootserver_addr))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Could not transform root name server IP address\n");
-    GNUNET_break (0);
-  }
+  if (1 != inet_pton(AF_INET,
+                     ROOTSERVER_IP,
+                     &rootserver_addr))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Could not transform root name server IP address\n");
+      GNUNET_break(0);
+    }
 
   rootserver =
-      gethostbyaddr ((const void *) &rootserver_addr,
-                     sizeof (rootserver_addr),
-                     AF_INET);
+    gethostbyaddr((const void *)&rootserver_addr,
+                  sizeof(rootserver_addr),
+                  AF_INET);
   if (NULL == rootserver)
-  {
-    /* Error: resolving IP addresses does not work */
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "gethostbyaddr() could not lookup hostname: %s\n",
-                hstrerror (h_errno));
-    disable_rootserver_check = GNUNET_YES;
-  }
-  else
-  {
-    if (0 != strcmp (rootserver->h_name,
-                     ROOTSERVER_NAME))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Received hostname and hostname for root name server differ\n");
+      /* Error: resolving IP addresses does not work */
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "gethostbyaddr() could not lookup hostname: %s\n",
+                 hstrerror(h_errno));
       disable_rootserver_check = GNUNET_YES;
     }
-  }
+  else
+    {
+      if (0 != strcmp(rootserver->h_name,
+                      ROOTSERVER_NAME))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Received hostname and hostname for root name server differ\n");
+          disable_rootserver_check = GNUNET_YES;
+        }
+    }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "System's own reverse name resolution is working\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "System's own reverse name resolution is working\n");
   /* Resolve the same using GNUNET */
-  memset (&sa, 0, sizeof (sa));
+  memset(&sa, 0, sizeof(sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa.sin_len = (u_char) sizeof (sa);
+  sa.sin_len = (u_char)sizeof(sa);
 #endif
 #ifndef MINGW
-  inet_aton (ROOTSERVER_IP, &sa.sin_addr);
+  inet_aton(ROOTSERVER_IP, &sa.sin_addr);
 #else
-  sa.sin_addr.S_un.S_addr = inet_addr (ROOTSERVER_IP);
+  sa.sin_addr.S_un.S_addr = inet_addr(ROOTSERVER_IP);
 #endif
-  GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
-                                sizeof (struct sockaddr), GNUNET_YES, timeout,
-                                &check_rootserver_name, cls);
+  GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa,
+                               sizeof(struct sockaddr), GNUNET_YES, timeout,
+                               &check_rootserver_name, cls);
 
-  memset (&sa, 0, sizeof (sa));
+  memset(&sa, 0, sizeof(sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa.sin_len = (u_char) sizeof (sa);
+  sa.sin_len = (u_char)sizeof(sa);
 #endif
-  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-
-  GNUNET_RESOLVER_ip_get ("localhost", AF_INET, timeout, &check_127, cls);
-  GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
-                                sizeof (struct sockaddr), GNUNET_YES, timeout,
-                                &check_localhost, cls);
+  sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 
-  GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
-                                sizeof (struct sockaddr), GNUNET_NO, timeout,
-                                &check_localhost_num, cls);
-  GNUNET_RESOLVER_hostname_resolve (AF_UNSPEC, timeout, &check_hostname, cls);
+  GNUNET_RESOLVER_ip_get("localhost", AF_INET, timeout, &check_127, cls);
+  GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa,
+                               sizeof(struct sockaddr), GNUNET_YES, timeout,
+                               &check_localhost, cls);
 
+  GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa,
+                               sizeof(struct sockaddr), GNUNET_NO, timeout,
+                               &check_localhost_num, cls);
+  GNUNET_RESOLVER_hostname_resolve(AF_UNSPEC, timeout, &check_hostname, cls);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ok = 1 + 2 + 4 + 8;
   char *fn;
@@ -346,34 +345,34 @@ main (int argc, char *argv[])
     "test-resolver-api", "-c", "test_resolver_api_data.conf", NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options[] =
-      { GNUNET_GETOPT_OPTION_END };
-
-  GNUNET_log_setup ("test-resolver-api",
-                    "WARNING",
-                    NULL);
-  fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
-  proc = GNUNET_OS_start_process (GNUNET_YES,
-                                  GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                  NULL, NULL, NULL,
-                                  fn,
-                                  "gnunet-service-resolver",
-                                  "-c", "test_resolver_api_data.conf", NULL);
-  GNUNET_assert (NULL != proc);
-  GNUNET_free (fn);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                                     argvx, "test-resolver-api", "nohelp",
-                                     options, &run, &ok));
-  if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-    ok = 1;
-  }
-  GNUNET_OS_process_wait (proc);
-  GNUNET_OS_process_destroy (proc);
+  { GNUNET_GETOPT_OPTION_END };
+
+  GNUNET_log_setup("test-resolver-api",
+                   "WARNING",
+                   NULL);
+  fn = GNUNET_OS_get_libexec_binary_path("gnunet-service-resolver");
+  proc = GNUNET_OS_start_process(GNUNET_YES,
+                                 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                 NULL, NULL, NULL,
+                                 fn,
+                                 "gnunet-service-resolver",
+                                 "-c", "test_resolver_api_data.conf", NULL);
+  GNUNET_assert(NULL != proc);
+  GNUNET_free(fn);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_PROGRAM_run((sizeof(argvx) / sizeof(char *)) - 1,
+                                   argvx, "test-resolver-api", "nohelp",
+                                   options, &run, &ok));
+  if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG))
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+      ok = 1;
+    }
+  GNUNET_OS_process_wait(proc);
+  GNUNET_OS_process_destroy(proc);
   proc = NULL;
   if (0 != ok)
-    fprintf (stderr, "Missed some resolutions: %u\n", ok);
+    fprintf(stderr, "Missed some resolutions: %u\n", ok);
   return ok;
 }
 
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
index 234a2aae1..236bb4e76 100644
--- a/src/util/test_scheduler.c
+++ b/src/util/test_scheduler.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 util/test_scheduler.c
  * @brief tests for the scheduler
@@ -33,135 +33,135 @@ static struct GNUNET_SCHEDULER_Task *never_run_task;
 
 
 static void
-task2 (void *cls)
+task2(void *cls)
 {
   int *ok = cls;
 
   /* t3 should be ready (albeit with lower priority) */
-  GNUNET_assert (1 ==
-                 GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_COUNT));
-  GNUNET_assert (2 == *ok);
+  GNUNET_assert(1 ==
+                GNUNET_SCHEDULER_get_load(GNUNET_SCHEDULER_PRIORITY_COUNT));
+  GNUNET_assert(2 == *ok);
   (*ok) = 3;
 }
 
 
 static void
-task3 (void *cls)
+task3(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (3 == *ok);
+  GNUNET_assert(3 == *ok);
   (*ok) = 4;
 }
 
 
 static void
-taskWrt (void *cls)
+taskWrt(void *cls)
 {
   static char c;
   int *ok = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
-  tc = GNUNET_SCHEDULER_get_task_context ();
-  GNUNET_assert (6 == *ok);
-  GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->write_ready, fds[1]));
+  tc = GNUNET_SCHEDULER_get_task_context();
+  GNUNET_assert(6 == *ok);
+  GNUNET_assert(GNUNET_NETWORK_fdset_handle_isset(tc->write_ready, fds[1]));
   (*ok) = 7;
-  GNUNET_assert (1 == GNUNET_DISK_file_write (fds[1], &c, 1));
+  GNUNET_assert(1 == GNUNET_DISK_file_write(fds[1], &c, 1));
 }
 
 
 static void
-taskNeverRun (void *cls)
+taskNeverRun(void *cls)
 {
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
 static void
-taskLastRd (void *cls)
+taskLastRd(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (8 == *ok);
+  GNUNET_assert(8 == *ok);
   (*ok) = 0;
 }
 
 
 static void
-taskLastSig (void *cls)
+taskLastSig(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_SCHEDULER_cancel (never_run_task);
-  GNUNET_assert (9 == *ok);
+  GNUNET_SCHEDULER_cancel(never_run_task);
+  GNUNET_assert(9 == *ok);
   (*ok) = 0;
 }
 
 
 static void
-taskLastShutdown (void *cls)
+taskLastShutdown(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (10 == *ok);
+  GNUNET_assert(10 == *ok);
   (*ok) = 0;
 }
 
 
 static void
-taskRd (void *cls)
+taskRd(void *cls)
 {
   static char c;
   int *ok = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
-  tc = GNUNET_SCHEDULER_get_task_context ();
-  GNUNET_assert (7 == *ok);
-  GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0]));
-  GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
+  tc = GNUNET_SCHEDULER_get_task_context();
+  GNUNET_assert(7 == *ok);
+  GNUNET_assert(GNUNET_NETWORK_fdset_handle_isset(tc->read_ready, fds[0]));
+  GNUNET_assert(1 == GNUNET_DISK_file_read(fds[0], &c, 1));
   (*ok) = 8;
-  GNUNET_SCHEDULER_add_shutdown (&taskLastRd,
-                                 cls);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_add_shutdown(&taskLastRd,
+                                cls);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
 static void
-task4 (void *cls)
+task4(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (4 == *ok);
+  GNUNET_assert(4 == *ok);
   (*ok) = 6;
-  p = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
-  GNUNET_assert (NULL != p);
-  fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ);
-  fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE);
-  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                  fds[0],
-                                  &taskRd,
+  p = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
+  GNUNET_assert(NULL != p);
+  fds[0] = GNUNET_DISK_pipe_handle(p, GNUNET_DISK_PIPE_END_READ);
+  fds[1] = GNUNET_DISK_pipe_handle(p, GNUNET_DISK_PIPE_END_WRITE);
+  GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                 fds[0],
+                                 &taskRd,
+                                 cls);
+  GNUNET_SCHEDULER_add_write_file(GNUNET_TIME_UNIT_FOREVER_REL,
+                                  fds[1],
+                                  &taskWrt,
                                   cls);
-  GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                   fds[1],
-                                   &taskWrt,
-                                   cls);
 }
 
 
 static void
-task1 (void *cls)
+task1(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (1 == *ok);
+  GNUNET_assert(1 == *ok);
   (*ok) = 2;
-  GNUNET_SCHEDULER_add_now (&task3, cls);
-  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
-                                      &task2,
-                                      cls);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                &task4,
-                                cls);
+  GNUNET_SCHEDULER_add_now(&task3, cls);
+  GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_UI,
+                                     &task2,
+                                     cls);
+  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
+                               &task4,
+                               cls);
 }
 
 
@@ -170,27 +170,27 @@ task1 (void *cls)
  * checks that "ok" is correct at the end.
  */
 static int
-check ()
+check()
 {
   int ok;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "[Check scheduling]\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "[Check scheduling]\n");
   ok = 1;
-  GNUNET_SCHEDULER_run (&task1, &ok);
+  GNUNET_SCHEDULER_run(&task1, &ok);
   return ok;
 }
 
 
 static void
-taskShutdown (void *cls)
+taskShutdown(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (1 == *ok);
+  GNUNET_assert(1 == *ok);
   *ok = 10;
-  GNUNET_SCHEDULER_add_shutdown (&taskLastShutdown, cls);
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_add_shutdown(&taskLastShutdown, cls);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -199,33 +199,33 @@ taskShutdown (void *cls)
  * checks that "ok" is correct at the end.
  */
 static int
-checkShutdown ()
+checkShutdown()
 {
   int ok;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "[Check shutdown]\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "[Check shutdown]\n");
   ok = 1;
-  GNUNET_SCHEDULER_run (&taskShutdown, &ok);
+  GNUNET_SCHEDULER_run(&taskShutdown, &ok);
   return ok;
 }
 
 
 #ifndef MINGW
 static void
-taskSig (void *cls)
+taskSig(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (1 == *ok);
+  GNUNET_assert(1 == *ok);
   *ok = 9;
-  GNUNET_SCHEDULER_add_shutdown (&taskLastSig, cls);
-  never_run_task = 
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
-                                  &taskNeverRun,
-                                  NULL);
-  GNUNET_break (0 == kill (getpid (),
-                                 GNUNET_TERM_SIG));
+  GNUNET_SCHEDULER_add_shutdown(&taskLastSig, cls);
+  never_run_task =
+    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
+                                 &taskNeverRun,
+                                 NULL);
+  GNUNET_break(0 == kill(getpid(),
+                         GNUNET_TERM_SIG));
 }
 
 
@@ -234,27 +234,27 @@ taskSig (void *cls)
  * checks that "ok" is correct at the end.
  */
 static int
-checkSignal ()
+checkSignal()
 {
   int ok;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "[Check signal handling]\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "[Check signal handling]\n");
   ok = 1;
-  GNUNET_SCHEDULER_run (&taskSig, &ok);
+  GNUNET_SCHEDULER_run(&taskSig, &ok);
   return ok;
 }
 #endif
 
 
 static void
-taskCancel (void *cls)
+taskCancel(void *cls)
 {
   int *ok = cls;
 
-  GNUNET_assert (1 == *ok);
+  GNUNET_assert(1 == *ok);
   *ok = 0;
-  GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_add_now (&taskNeverRun, NULL));
+  GNUNET_SCHEDULER_cancel(GNUNET_SCHEDULER_add_now(&taskNeverRun, NULL));
 }
 
 
@@ -263,31 +263,31 @@ taskCancel (void *cls)
  * checks that "ok" is correct at the end.
  */
 static int
-checkCancel ()
+checkCancel()
 {
   int ok;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "[Check task cancellation]\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "[Check task cancellation]\n");
   ok = 1;
-  GNUNET_SCHEDULER_run (&taskCancel, &ok);
+  GNUNET_SCHEDULER_run(&taskCancel, &ok);
   return ok;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ret = 0;
 
-  GNUNET_log_setup ("test_scheduler", "WARNING", NULL);
-  ret += check ();
-  ret += checkCancel ();
+  GNUNET_log_setup("test_scheduler", "WARNING", NULL);
+  ret += check();
+  ret += checkCancel();
 #ifndef MINGW
-  ret += checkSignal ();
+  ret += checkSignal();
 #endif
-  ret += checkShutdown ();
-  GNUNET_DISK_pipe_close (p);
+  ret += checkShutdown();
+  GNUNET_DISK_pipe_close(p);
 
   return ret;
 }
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index 1ec86c647..c72ee7b19 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.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 util/test_scheduler_delay.c
  * @brief testcase for delay of scheduler, measures how
@@ -43,51 +43,51 @@ static unsigned long long cumDelta;
  * @param cls closure
  */
 static void
-test_task (void *cls)
+test_task(void *cls)
 {
   struct GNUNET_TIME_Absolute now;
 
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   if (now.abs_value_us > target.abs_value_us)
     cumDelta += (now.abs_value_us - target.abs_value_us);
   else
     cumDelta += (target.abs_value_us - now.abs_value_us);
   target =
-      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
-                                        (GNUNET_TIME_UNIT_MICROSECONDS, i));
-  fprintf (stderr, "%s",  ".");
+    GNUNET_TIME_relative_to_absolute(GNUNET_TIME_relative_multiply
+                                       (GNUNET_TIME_UNIT_MICROSECONDS, i));
+  fprintf(stderr, "%s", ".");
   if (i > MAXV)
-  {
-    fprintf (stderr, "%s",  "\n");
-    return;
-  }
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_MICROSECONDS, i),
-                                &test_task,
-                                NULL);
+    {
+      fprintf(stderr, "%s", "\n");
+      return;
+    }
+  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
+                                 (GNUNET_TIME_UNIT_MICROSECONDS, i),
+                               &test_task,
+                               NULL);
   i += INCR;
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-scheduler-delay",
-                    "WARNING",
-                    NULL);
-  target = GNUNET_TIME_absolute_get ();
-  GNUNET_SCHEDULER_run (&test_task, NULL);
-  fprintf (stdout,
-           "Sleep precision: %llu microseconds (average delta). ",
-           cumDelta / (MAXV / INCR));
+  GNUNET_log_setup("test-scheduler-delay",
+                   "WARNING",
+                   NULL);
+  target = GNUNET_TIME_absolute_get();
+  GNUNET_SCHEDULER_run(&test_task, NULL);
+  fprintf(stdout,
+          "Sleep precision: %llu microseconds (average delta). ",
+          cumDelta / (MAXV / INCR));
   if (cumDelta <= 500 * MAXV / INCR)
-    fprintf (stdout, "%s",  "Timer precision is excellent.\n");
+    fprintf(stdout, "%s", "Timer precision is excellent.\n");
   else if (cumDelta <= 5000 * MAXV / INCR)        /* 5 ms average deviation */
-    fprintf (stdout, "%s",  "Timer precision is good.\n");
+    fprintf(stdout, "%s", "Timer precision is good.\n");
   else if (cumDelta > 25000 * MAXV / INCR)
-    fprintf (stdout, "%s",  "Timer precision is awful.\n");
+    fprintf(stdout, "%s", "Timer precision is awful.\n");
   else
-    fprintf (stdout, "%s",  "Timer precision is acceptable.\n");
+    fprintf(stdout, "%s", "Timer precision is acceptable.\n");
   return 0;
 }
 
diff --git a/src/util/test_service.c b/src/util/test_service.c
index dc8bc59c1..c0b02872f 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.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 util/test_service.c
  * @brief tests for service.c
@@ -43,20 +43,20 @@ static struct GNUNET_SCHEDULER_Task *tt;
 
 
 static void
-handle_recv (void *cls,
-             const struct GNUNET_MessageHeader *message)
+handle_recv(void *cls,
+            const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
-  
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received client message...\n");
-  GNUNET_SERVICE_client_continue (client);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Received client message...\n");
+  GNUNET_SERVICE_client_continue(client);
   global_ret = 2;
   if (NULL != mq)
-  {
-    GNUNET_MQ_destroy (mq);
-    mq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(mq);
+      mq = NULL;
+    }
 }
 
 
@@ -69,9 +69,9 @@ handle_recv (void *cls,
  * @return @a c so we have the client handle in the future
  */
 static void *
-connect_cb (void *cls,
-            struct GNUNET_SERVICE_Client *c,
-            struct GNUNET_MQ_Handle *mq)
+connect_cb(void *cls,
+           struct GNUNET_SERVICE_Client *c,
+           struct GNUNET_MQ_Handle *mq)
 {
   /* FIXME: in the future, do something with mq
      to test sending messages to the client! */
@@ -85,37 +85,37 @@ connect_cb (void *cls,
  * @param cls our service name
  * @param c disconnecting client
  * @param internal_cls must match @a c
- */ 
+ */
 static void
-disconnect_cb (void *cls,
-               struct GNUNET_SERVICE_Client *c,
-               void *internal_cls)
+disconnect_cb(void *cls,
+              struct GNUNET_SERVICE_Client *c,
+              void *internal_cls)
 {
-  GNUNET_assert (c == internal_cls);
+  GNUNET_assert(c == internal_cls);
   if (2 == global_ret)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    global_ret = 0;
-    if (NULL != tt)
     {
-      GNUNET_SCHEDULER_cancel (tt);
-      tt = NULL;
+      GNUNET_SCHEDULER_shutdown();
+      global_ret = 0;
+      if (NULL != tt)
+        {
+          GNUNET_SCHEDULER_cancel(tt);
+          tt = NULL;
+        }
     }
-  }
 }
 
 
 static void
-timeout_task (void *cls)
+timeout_task(void *cls)
 {
   tt = NULL;
   if (NULL != mq)
-  {
-    GNUNET_MQ_destroy (mq);
-    mq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(mq);
+      mq = NULL;
+    }
   global_ret = 33;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -128,28 +128,28 @@ timeout_task (void *cls)
  * @param sh handle to the service
  */
 static void
-service_init (void *cls,
-              const struct GNUNET_CONFIGURATION_Handle *cfg,
-              struct GNUNET_SERVICE_Handle *sh)
+service_init(void *cls,
+             const struct GNUNET_CONFIGURATION_Handle *cfg,
+             struct GNUNET_SERVICE_Handle *sh)
 {
   const char *service_name = cls;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
-  GNUNET_assert (NULL == tt);
-  tt = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                     &timeout_task,
-                                     NULL);
-  mq = GNUNET_CLIENT_connect (cfg,
-                              service_name,
-                              NULL,
-                              NULL,
-                              NULL);
-  GNUNET_assert (NULL != mq);
-  env = GNUNET_MQ_msg (msg,
-                       MY_TYPE);
-  GNUNET_MQ_send (mq,
-                  env);
+  GNUNET_assert(NULL == tt);
+  tt = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                    &timeout_task,
+                                    NULL);
+  mq = GNUNET_CLIENT_connect(cfg,
+                             service_name,
+                             NULL,
+                             NULL,
+                             NULL);
+  GNUNET_assert(NULL != mq);
+  env = GNUNET_MQ_msg(msg,
+                      MY_TYPE);
+  GNUNET_MQ_send(mq,
+                 env);
 }
 
 
@@ -160,78 +160,78 @@ service_init (void *cls,
  * @param sname name of the service to run
  */
 static int
-check (const char *sname)
+check(const char *sname)
 {
   struct GNUNET_MQ_MessageHandler myhandlers[] = {
-    GNUNET_MQ_hd_fixed_size (recv,
-                             MY_TYPE,
-                             struct GNUNET_MessageHeader,
-                             NULL),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_fixed_size(recv,
+                            MY_TYPE,
+                            struct GNUNET_MessageHeader,
+                            NULL),
+    GNUNET_MQ_handler_end()
   };
   char *const argv[] = {
-    (char *) sname,
+    (char *)sname,
     "-c",
     "test_service_data.conf",
     NULL
   };
-  
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting `%s' service\n",
-              sname);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Starting `%s' service\n",
+             sname);
   global_ret = 1;
-  GNUNET_assert (0 ==
-                 GNUNET_SERVICE_run_ (3,
-                                      argv,
-                                      sname,
-                                      GNUNET_SERVICE_OPTION_NONE,
-                                      &service_init,
-                                      &connect_cb,
-                                      &disconnect_cb,
-                                      (void *) sname,
-                                      myhandlers));
+  GNUNET_assert(0 ==
+                GNUNET_SERVICE_run_(3,
+                                    argv,
+                                    sname,
+                                    GNUNET_SERVICE_OPTION_NONE,
+                                    &service_init,
+                                    &connect_cb,
+                                    &disconnect_cb,
+                                    (void *)sname,
+                                    myhandlers));
   return global_ret;
 }
 
 
 int
-main (int argc,
-      char *argv[])
+main(int argc,
+     char *argv[])
 {
   int ret = 0;
   struct GNUNET_NETWORK_Handle *s = NULL;
 
-  GNUNET_log_setup ("test-service",
-                    "WARNING",
-                    NULL);
-  ret += check ("test_service");
-  ret += check ("test_service");
+  GNUNET_log_setup("test-service",
+                   "WARNING",
+                   NULL);
+  ret += check("test_service");
+  ret += check("test_service");
 #ifndef MINGW
-  s = GNUNET_NETWORK_socket_create (PF_INET6,
-                                    SOCK_STREAM,
-                                    0);
+  s = GNUNET_NETWORK_socket_create(PF_INET6,
+                                   SOCK_STREAM,
+                                   0);
 #endif
   if (NULL == s)
-  {
-    if ( (errno == ENOBUFS) ||
-         (errno == ENOMEM) ||
-         (errno == ENFILE) ||
-         (errno == EACCES) )
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                           "socket");
-      return 1;
+      if ((errno == ENOBUFS) ||
+          (errno == ENOMEM) ||
+          (errno == ENFILE) ||
+          (errno == EACCES))
+        {
+          GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                              "socket");
+          return 1;
+        }
+      fprintf(stderr,
+              "IPv6 support seems to not be available (%s), not testing it!\n",
+              strerror(errno));
     }
-    fprintf (stderr,
-             "IPv6 support seems to not be available (%s), not testing it!\n",
-             strerror (errno));
-  }
   else
-  {
-    GNUNET_break (GNUNET_OK ==
-                  GNUNET_NETWORK_socket_close (s));
-    ret += check ("test_service6");
-  }
+    {
+      GNUNET_break(GNUNET_OK ==
+                   GNUNET_NETWORK_socket_close(s));
+      ret += check("test_service6");
+    }
   return ret;
 }
 
diff --git a/src/util/test_socks.c b/src/util/test_socks.c
index 89a350feb..dc5847d14 100644
--- a/src/util/test_socks.c
+++ b/src/util/test_socks.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 util/test_socks.c
  * @brief tests for socks.c
@@ -37,26 +37,25 @@ static struct GNUNET_CONFIGURATION_Handle *cfg;
 
 #define MY_TYPE 130
 
-struct CopyContext
-{
+struct CopyContext {
   struct GNUNET_SERVER_Client *client;
   struct GNUNET_MessageHeader *cpy;
 };
 
 static size_t
-copy_msg (void *cls, size_t size, void *buf)
+copy_msg(void *cls, size_t size, void *buf)
 {
   struct CopyContext *ctx = cls;
   struct GNUNET_MessageHeader *cpy = ctx->cpy;
 
-  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size));
-  GNUNET_assert (size >= ntohs (cpy->size));
-  GNUNET_memcpy (buf, cpy, ntohs (cpy->size));
-  GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK);
-  GNUNET_free (cpy);
-  GNUNET_free (ctx);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message bounced back to client\n");
-  return sizeof (struct GNUNET_MessageHeader);
+  GNUNET_assert(sizeof(struct GNUNET_MessageHeader) == ntohs(cpy->size));
+  GNUNET_assert(size >= ntohs(cpy->size));
+  GNUNET_memcpy(buf, cpy, ntohs(cpy->size));
+  GNUNET_SERVER_receive_done(ctx->client, GNUNET_OK);
+  GNUNET_free(cpy);
+  GNUNET_free(ctx);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Message bounced back to client\n");
+  return sizeof(struct GNUNET_MessageHeader);
 }
 
 
@@ -64,46 +63,46 @@ copy_msg (void *cls, size_t size, void *buf)
  * Callback that just bounces the message back to the sender.
  */
 static void
-echo_cb (void *cls, struct GNUNET_SERVER_Client *client,
-         const struct GNUNET_MessageHeader *message)
+echo_cb(void *cls, struct GNUNET_SERVER_Client *client,
+        const struct GNUNET_MessageHeader *message)
 {
   struct CopyContext *cc;
   struct GNUNET_MessageHeader *cpy;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving message from client, bouncing back\n");
-  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size));
-  cc = GNUNET_new (struct CopyContext);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving message from client, bouncing back\n");
+  GNUNET_assert(sizeof(struct GNUNET_MessageHeader) == ntohs(message->size));
+  cc = GNUNET_new(struct CopyContext);
   cc->client = client;
-  cpy = GNUNET_malloc (ntohs (message->size));
-  GNUNET_memcpy (cpy, message, ntohs (message->size));
+  cpy = GNUNET_malloc(ntohs(message->size));
+  GNUNET_memcpy(cpy, message, ntohs(message->size));
   cc->cpy = cpy;
-  GNUNET_assert (NULL !=
-                 GNUNET_SERVER_notify_transmit_ready (client,
-                                                      ntohs (message->size),
-                                                      GNUNET_TIME_UNIT_SECONDS,
-                                                      &copy_msg, cc));
+  GNUNET_assert(NULL !=
+                GNUNET_SERVER_notify_transmit_ready(client,
+                                                    ntohs(message->size),
+                                                    GNUNET_TIME_UNIT_SECONDS,
+                                                    &copy_msg, cc));
 }
 
 
 static struct GNUNET_SERVER_MessageHandler handlers[] = {
-  {&echo_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
-  {NULL, NULL, 0, 0}
+  { &echo_cb, NULL, MY_TYPE, sizeof(struct GNUNET_MessageHeader) },
+  { NULL, NULL, 0, 0 }
 };
 
 
 static void
-handle_bounce (void *cls,
-               const struct GNUNET_MessageHeader *got)
+handle_bounce(void *cls,
+              const struct GNUNET_MessageHeader *got)
 {
   int *ok = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving bounce, checking content\n");
-  GNUNET_assert (NULL != got);
-  GNUNET_MQ_destroy (mq);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Receiving bounce, checking content\n");
+  GNUNET_assert(NULL != got);
+  GNUNET_MQ_destroy(mq);
   mq = NULL;
-  GNUNET_SERVER_destroy (server);
+  GNUNET_SERVER_destroy(server);
   server = NULL;
   *ok = 0;
 }
@@ -118,15 +117,15 @@ handle_bounce (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)
 {
-  GNUNET_assert (0); /* should never happen */
+  GNUNET_assert(0);  /* should never happen */
 }
 
 
 static void
-task (void *cls)
+task(void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
@@ -134,121 +133,121 @@ task (void *cls)
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
   struct GNUNET_MQ_MessageHandler chandlers[] = {
-    GNUNET_MQ_hd_fixed_size (bounce,
-                             MY_TYPE,
-                             struct GNUNET_MessageHeader,
-                             cls),
-    GNUNET_MQ_handler_end ()
+    GNUNET_MQ_hd_fixed_size(bounce,
+                            MY_TYPE,
+                            struct GNUNET_MessageHeader,
+                            cls),
+    GNUNET_MQ_handler_end()
   };
 
   /* test IPC between client and server */
-  sap[0] = (struct sockaddr *) &sa;
-  slens[0] = sizeof (sa);
+  sap[0] = (struct sockaddr *)&sa;
+  slens[0] = sizeof(sa);
   sap[1] = NULL;
   slens[1] = 0;
-  memset (&sa, 0, sizeof (sa));
+  memset(&sa, 0, sizeof(sa));
 #if HAVE_SOCKADDR_IN_SIN_LEN
-  sa.sin_len = sizeof (sa);
+  sa.sin_len = sizeof(sa);
 #endif
   sa.sin_family = AF_INET;
-  sa.sin_port = htons (PORT);
+  sa.sin_port = htons(PORT);
   server =
-      GNUNET_SERVER_create (NULL, NULL, sap, slens,
-                            GNUNET_TIME_relative_multiply
-                            (GNUNET_TIME_UNIT_MILLISECONDS, 10000), GNUNET_NO);
-  GNUNET_assert (server != NULL);
+    GNUNET_SERVER_create(NULL, NULL, sap, slens,
+                         GNUNET_TIME_relative_multiply
+                           (GNUNET_TIME_UNIT_MILLISECONDS, 10000), GNUNET_NO);
+  GNUNET_assert(server != NULL);
   handlers[0].callback_cls = cls;
   handlers[1].callback_cls = cls;
-  GNUNET_SERVER_add_handlers (server, handlers);
-  mq = GNUNET_CLIENT_connect (cfg,
-                              MYNAME,
-                              chandlers,
-                              &mq_error_handler,
-                              NULL);
-  GNUNET_assert (NULL != mq);
-  env = GNUNET_MQ_msg (msg,
-                       MY_TYPE);
-  GNUNET_MQ_send (mq,
-                  env);
+  GNUNET_SERVER_add_handlers(server, handlers);
+  mq = GNUNET_CLIENT_connect(cfg,
+                             MYNAME,
+                             chandlers,
+                             &mq_error_handler,
+                             NULL);
+  GNUNET_assert(NULL != mq);
+  env = GNUNET_MQ_msg(msg,
+                      MY_TYPE);
+  GNUNET_MQ_send(mq,
+                 env);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ok;
   int status;
   const char *socksport = "1081";
 
-  GNUNET_log_setup ("test_client",
-                    "WARNING",
-                    NULL);
+  GNUNET_log_setup("test_client",
+                   "WARNING",
+                   NULL);
 
   pid_t pid = fork();
-  GNUNET_assert (pid >= 0);
+  GNUNET_assert(pid >= 0);
   if (pid == 0)
-  {
-    execlp ("ssh",
-            "ssh","-D",socksport,
-            "-o","BatchMode yes",
-            "-o","UserKnownHostsFile /tmp/gnunet_test_socks_ssh_garbage",
-            "-o","StrictHostKeyChecking no",
-            "127.0.0.1","-N",(char*)NULL);
-    perror ("execlp (\"ssh\",\"ssh\",...,\"-D\",\"1081\",\"127.0.0.1\",\"-N\") ");
-    printf (""
-"Please ensure you have ssh installed and have sshd installed and running :\n"
-"\tsudo apt-get install openssh-client openssh-server\n"
-"If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
-"to localhost.  Please either run  make check  from an unproxied user, or else\n"
-"add these lines to the beginning of your ~/.ssh/config file :"
-"\tHost 127.0.0.1 localhost\n"
-"\t  CheckHostIP no\n"
-"\t  Protocol 2\n"
-"\t  ProxyCommand nc 127.0.0.1 22\n");
-    kill (getppid(), SIGALRM);
-    return 1;
-  }
-  if (0 != sleep (1))
-  {
-    /* sleep interrupted, likely SIGALRM, failure to
-       launch child, terminate */
-    printf (""
-"Please ensure you have ssh installed and have sshd installed and running :\n"
-"\tsudo apt-get install openssh-client openssh-server\n"
-"If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
-"to localhost.  Please either run  make check  from an unproxied user, or else\n"
-"add these lines to the beginning of your ~/.ssh/config file :"
-"\tHost 127.0.0.1 localhost\n"
-"\t  CheckHostIP no\n"
-"\t  Protocol 2\n"
-"\t  ProxyCommand nc 127.0.0.1 22\n");
-    return 77;
-  }
+    {
+      execlp("ssh",
+             "ssh", "-D", socksport,
+             "-o", "BatchMode yes",
+             "-o", "UserKnownHostsFile /tmp/gnunet_test_socks_ssh_garbage",
+             "-o", "StrictHostKeyChecking no",
+             "127.0.0.1", "-N", (char*)NULL);
+      perror("execlp (\"ssh\",\"ssh\",...,\"-D\",\"1081\",\"127.0.0.1\",\"-N\") ");
+      printf(""
+             "Please ensure you have ssh installed and have sshd installed and running :\n"
+             "\tsudo apt-get install openssh-client openssh-server\n"
+             "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
+             "to localhost.  Please either run  make check  from an unproxied user, or else\n"
+             "add these lines to the beginning of your ~/.ssh/config file :"
+             "\tHost 127.0.0.1 localhost\n"
+             "\t  CheckHostIP no\n"
+             "\t  Protocol 2\n"
+             "\t  ProxyCommand nc 127.0.0.1 22\n");
+      kill(getppid(), SIGALRM);
+      return 1;
+    }
+  if (0 != sleep(1))
+    {
+      /* sleep interrupted, likely SIGALRM, failure to
+         launch child, terminate */
+      printf(""
+             "Please ensure you have ssh installed and have sshd installed and running :\n"
+             "\tsudo apt-get install openssh-client openssh-server\n"
+             "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
+             "to localhost.  Please either run  make check  from an unproxied user, or else\n"
+             "add these lines to the beginning of your ~/.ssh/config file :"
+             "\tHost 127.0.0.1 localhost\n"
+             "\t  CheckHostIP no\n"
+             "\t  Protocol 2\n"
+             "\t  ProxyCommand nc 127.0.0.1 22\n");
+      return 77;
+    }
   /* check if child exec()ed but died */
-  if (0 != waitpid (pid, &status, WNOHANG))
-  {
-    printf (""
-"If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
-"to localhost.  Please either run  make check  from an unproxied user, or else\n"
-"add these lines to the beginning of your ~/.ssh/config file :"
-"\tHost 127.0.0.1 localhost\n"
-"\t  CheckHostIP no\n"
-"\t  Protocol 2\n"
-"\t  ProxyCommand nc 127.0.0.1 22\n");
-    return 77;
-  }
-
-  cfg = GNUNET_CONFIGURATION_create ();
-  GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSHOST", "127.0.0.1");
-  GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSPORT", socksport);
-  GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT);
-  GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "HOSTNAME", "127.0.0.1");
+  if (0 != waitpid(pid, &status, WNOHANG))
+    {
+      printf(""
+             "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
+             "to localhost.  Please either run  make check  from an unproxied user, or else\n"
+             "add these lines to the beginning of your ~/.ssh/config file :"
+             "\tHost 127.0.0.1 localhost\n"
+             "\t  CheckHostIP no\n"
+             "\t  Protocol 2\n"
+             "\t  ProxyCommand nc 127.0.0.1 22\n");
+      return 77;
+    }
+
+  cfg = GNUNET_CONFIGURATION_create();
+  GNUNET_CONFIGURATION_set_value_string(cfg, MYNAME, "SOCKSHOST", "127.0.0.1");
+  GNUNET_CONFIGURATION_set_value_string(cfg, MYNAME, "SOCKSPORT", socksport);
+  GNUNET_CONFIGURATION_set_value_number(cfg, MYNAME, "PORT", PORT);
+  GNUNET_CONFIGURATION_set_value_string(cfg, MYNAME, "HOSTNAME", "127.0.0.1");
   ok = 1;
-  GNUNET_SCHEDULER_run (&task, &ok);
-  GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_SCHEDULER_run(&task, &ok);
+  GNUNET_CONFIGURATION_destroy(cfg);
 
-  GNUNET_break (0 == kill (pid, SIGTERM));
-  GNUNET_break (pid == waitpid (pid, &status, 0));
+  GNUNET_break(0 == kill(pid, SIGTERM));
+  GNUNET_break(pid == waitpid(pid, &status, 0));
   return ok;
 }
 
diff --git a/src/util/test_speedup.c b/src/util/test_speedup.c
index a46d83dc3..eacc879df 100644
--- a/src/util/test_speedup.c
+++ b/src/util/test_speedup.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 util/test_speedup.c
  * @brief testcase for speedup.c
@@ -47,19 +47,19 @@ static unsigned int cycles;
  * @param tc scheduler context, unused
  */
 static void
-run (void *cls)
+run(void *cls)
 {
   cycles++;
-  fprintf (stderr, "..%u", cycles);
+  fprintf(stderr, "..%u", cycles);
   if (cycles <= 5)
-  {
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                  &run,
-                                  NULL);
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
+                                   &run,
+                                   NULL);
+      return;
+    }
   end = GNUNET_TIME_absolute_get();
-  fprintf (stderr, "\n");
+  fprintf(stderr, "\n");
   fflush(stdout);
 }
 
@@ -68,23 +68,23 @@ run (void *cls)
  *
  */
 static void
-check (void *cls,
-       char *const *args,
-       const char *cfgfile,
-       const struct GNUNET_CONFIGURATION_Handle *cfg)
+check(void *cls,
+      char *const *args,
+      const char *cfgfile,
+      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  fprintf (stderr, "0");
-  fflush (stdout);
-  GNUNET_SCHEDULER_add_now (&run, NULL);
+  fprintf(stderr, "0");
+  fflush(stdout);
+  GNUNET_SCHEDULER_add_now(&run, NULL);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   static char *const argvn[] = {
     "test-speedup",
-    "-c",  "test_speedup_data.conf",
+    "-c", "test_speedup_data.conf",
     NULL
   };
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
@@ -94,30 +94,30 @@ main (int argc, char *argv[])
   time_t end_real;
   struct GNUNET_TIME_Relative delta;
 
-  start_real = time (NULL);
+  start_real = time(NULL);
   start = GNUNET_TIME_absolute_get();
-  GNUNET_PROGRAM_run ((sizeof (argvn) / sizeof (char *)) - 1, argvn, "test-speedup",
-                      "nohelp", options, &check, NULL);
-
-  end_real = time (NULL);
-  delta = GNUNET_TIME_absolute_get_difference (start, end);
-
-  if (delta.rel_value_us >  ((end_real - start_real) * 1500LL * 1000LL))
-  {
-    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG,
-                 "Execution time in GNUnet time: %s\n",
-                 GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
-    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG,
-                 "Execution time in system time: %llu ms\n",
-                 (unsigned long long) ((end_real - start_real) * 1000LL));
-    return 0;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Execution time in GNUnet time: %s\n",
-              GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
-  GNUNET_log  (GNUNET_ERROR_TYPE_ERROR,
-               "Execution time in system time: %llu ms\n",
-               (unsigned long long) ((end_real - start_real) * 1000LL));
+  GNUNET_PROGRAM_run((sizeof(argvn) / sizeof(char *)) - 1, argvn, "test-speedup",
+                     "nohelp", options, &check, NULL);
+
+  end_real = time(NULL);
+  delta = GNUNET_TIME_absolute_get_difference(start, end);
+
+  if (delta.rel_value_us > ((end_real - start_real) * 1500LL * 1000LL))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Execution time in GNUnet time: %s\n",
+                 GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_YES));
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Execution time in system time: %llu ms\n",
+                 (unsigned long long)((end_real - start_real) * 1000LL));
+      return 0;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Execution time in GNUnet time: %s\n",
+             GNUNET_STRINGS_relative_time_to_string(delta, GNUNET_YES));
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Execution time in system time: %llu ms\n",
+             (unsigned long long)((end_real - start_real) * 1000LL));
   return 1;
 }
 
diff --git a/src/util/test_strings.c b/src/util/test_strings.c
index 9e4e808ef..4a7861965 100644
--- a/src/util/test_strings.c
+++ b/src/util/test_strings.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 util/test_strings.c
  * @brief testcase for strings.c
@@ -25,12 +25,12 @@
 #include "gnunet_util_lib.h"
 
 
-#define WANT(a,b) if (0 != strcmp(a,b)) { fprintf(stderr, "Got `%s', wanted `%s'\n", b, a); GNUNET_free(b); GNUNET_break(0); return 1;} else { GNUNET_free (b); }
-#define WANTNF(a,b) do { if (0 != strcmp(a,b)) { fprintf(stderr, "Got `%s', wanted `%s'\n", b, a); GNUNET_break(0); return 1;} } while (0)
-#define WANTB(a,b,l) if (0 != memcmp(a,b,l)) { GNUNET_break(0); return 1;} else { }
+#define WANT(a, b) if (0 != strcmp(a, b)) { fprintf(stderr, "Got `%s', wanted `%s'\n", b, a); GNUNET_free(b); GNUNET_break(0); return 1; } else { GNUNET_free(b); }
+#define WANTNF(a, b) do { if (0 != strcmp(a, b)) { fprintf(stderr, "Got `%s', wanted `%s'\n", b, a); GNUNET_break(0); return 1; } } while (0)
+#define WANTB(a, b, l) if (0 != memcmp(a, b, l)) { GNUNET_break(0); return 1; } else { }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   char buf[128];
   char *r;
@@ -42,103 +42,103 @@ main (int argc, char *argv[])
   struct GNUNET_TIME_Relative rtx;
   const char *hdir;
 
-  GNUNET_log_setup ("test_strings", "ERROR", NULL);
-  sprintf (buf, "4 %s", _( /* size unit */ "b"));
-  b = GNUNET_STRINGS_byte_size_fancy (4);
-  WANT (buf, b);
-  sprintf (buf, "10 %s", _( /* size unit */ "KiB"));
-  b = GNUNET_STRINGS_byte_size_fancy (10240);
-  WANT (buf, b);
-  sprintf (buf, "10 %s", _( /* size unit */ "TiB"));
-  b = GNUNET_STRINGS_byte_size_fancy (10240LL * 1024LL * 1024LL * 1024LL);
-  WANT (buf, b);
-  sprintf (buf, "4 %s", _( /* time unit */ "ms"));
-  bc = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
-                                               (GNUNET_TIME_UNIT_MILLISECONDS,
-                                                4), GNUNET_YES);
-  WANTNF (buf, bc);
-  sprintf (buf, "7 %s", _( /* time unit */ "s"));
-  bc = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
-                                               (GNUNET_TIME_UNIT_MILLISECONDS,
-                                                7 * 1000), GNUNET_YES);
-  WANTNF (buf, bc);
-  sprintf (buf, "7 %s", _( /* time unit */ "h"));
-  bc = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
-                                              (GNUNET_TIME_UNIT_MILLISECONDS,
-                                               7 * 60 * 60 * 1000), GNUNET_YES);
-  WANTNF (buf, bc);
+  GNUNET_log_setup("test_strings", "ERROR", NULL);
+  sprintf(buf, "4 %s", _(/* size unit */ "b"));
+  b = GNUNET_STRINGS_byte_size_fancy(4);
+  WANT(buf, b);
+  sprintf(buf, "10 %s", _(/* size unit */ "KiB"));
+  b = GNUNET_STRINGS_byte_size_fancy(10240);
+  WANT(buf, b);
+  sprintf(buf, "10 %s", _(/* size unit */ "TiB"));
+  b = GNUNET_STRINGS_byte_size_fancy(10240LL * 1024LL * 1024LL * 1024LL);
+  WANT(buf, b);
+  sprintf(buf, "4 %s", _(/* time unit */ "ms"));
+  bc = GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_relative_multiply
+                                                (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                4), GNUNET_YES);
+  WANTNF(buf, bc);
+  sprintf(buf, "7 %s", _(/* time unit */ "s"));
+  bc = GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_relative_multiply
+                                                (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                7 * 1000), GNUNET_YES);
+  WANTNF(buf, bc);
+  sprintf(buf, "7 %s", _(/* time unit */ "h"));
+  bc = GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_relative_multiply
+                                                (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                7 * 60 * 60 * 1000), GNUNET_YES);
+  WANTNF(buf, bc);
 #ifndef MINGW
-  hdir = getenv ("HOME");
+  hdir = getenv("HOME");
 #else
-  hdir = getenv ("USERPROFILE");
+  hdir = getenv("USERPROFILE");
 #endif
-  GNUNET_snprintf (buf, sizeof (buf), "%s%s", hdir, DIR_SEPARATOR_STR);
-  b = GNUNET_STRINGS_filename_expand ("~");
-  GNUNET_assert (b != NULL);
-  WANT (buf, b);
-  GNUNET_STRINGS_buffer_fill (buf, sizeof (buf), 3, "a", "btx", "c");
-  WANTB ("a\0btx\0c", buf, 8);
-  if (6 != GNUNET_STRINGS_buffer_tokenize (buf, sizeof (buf), 2, &r, &b))
+  GNUNET_snprintf(buf, sizeof(buf), "%s%s", hdir, DIR_SEPARATOR_STR);
+  b = GNUNET_STRINGS_filename_expand("~");
+  GNUNET_assert(b != NULL);
+  WANT(buf, b);
+  GNUNET_STRINGS_buffer_fill(buf, sizeof(buf), 3, "a", "btx", "c");
+  WANTB("a\0btx\0c", buf, 8);
+  if (6 != GNUNET_STRINGS_buffer_tokenize(buf, sizeof(buf), 2, &r, &b))
     return 1;
-  r = GNUNET_strdup (r);
-  WANT ("a", r);
-  b = GNUNET_strdup (b);
-  WANT ("btx", b);
-  if (0 != GNUNET_STRINGS_buffer_tokenize (buf, 2, 2, &r, &b))
+  r = GNUNET_strdup(r);
+  WANT("a", r);
+  b = GNUNET_strdup(b);
+  WANT("btx", b);
+  if (0 != GNUNET_STRINGS_buffer_tokenize(buf, 2, 2, &r, &b))
     return 1;
   at.abs_value_us = 5000000;
-  bc = GNUNET_STRINGS_absolute_time_to_string (at);
+  bc = GNUNET_STRINGS_absolute_time_to_string(at);
   /* bc should be something like "Wed Dec 31 17:00:05 1969"
    * where the details of the day and hour depend on the timezone;
    * however, the "0:05 19" should always be there; hence: */
-  if (NULL == strstr (bc, "0:05 19"))
-  {
-    fprintf (stderr, "Got %s\n", bc);
-    GNUNET_break (0);
-    return 1;
-  }
-  b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "ASCII");
-  WANT ("TEST", b);
+  if (NULL == strstr(bc, "0:05 19"))
+    {
+      fprintf(stderr, "Got %s\n", bc);
+      GNUNET_break(0);
+      return 1;
+    }
+  b = GNUNET_STRINGS_to_utf8("TEST", 4, "ASCII");
+  WANT("TEST", b);
 
   at = GNUNET_TIME_UNIT_FOREVER_ABS;
-  bc = GNUNET_STRINGS_absolute_time_to_string (at);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_STRINGS_fancy_time_to_absolute (bc, &atx));
-  GNUNET_assert (atx.abs_value_us == at.abs_value_us);
+  bc = GNUNET_STRINGS_absolute_time_to_string(at);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_STRINGS_fancy_time_to_absolute(bc, &atx));
+  GNUNET_assert(atx.abs_value_us == at.abs_value_us);
 
   at.abs_value_us = 50000000000;
-  bc = GNUNET_STRINGS_absolute_time_to_string (at);
+  bc = GNUNET_STRINGS_absolute_time_to_string(at);
 
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_STRINGS_fancy_time_to_absolute (bc, &atx));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_STRINGS_fancy_time_to_absolute(bc, &atx));
 
   if (atx.abs_value_us != at.abs_value_us)
-  {
-#ifdef WINDOWS
-    DWORD tzv;
-    TIME_ZONE_INFORMATION tzi;
-    tzv = GetTimeZoneInformation (&tzi);
-    if (TIME_ZONE_ID_INVALID != tzv)
     {
-      atx.abs_value_us -= 1000LL * 1000LL * tzi.Bias * 60LL;
-    }
-    if (atx.abs_value_us == at.abs_value_us)
-      fprintf (stderr,
-               "WARNING:  GNUNET_STRINGS_fancy_time_to_absolute() miscalculates timezone!\n");
+#ifdef WINDOWS
+      DWORD tzv;
+      TIME_ZONE_INFORMATION tzi;
+      tzv = GetTimeZoneInformation(&tzi);
+      if (TIME_ZONE_ID_INVALID != tzv)
+        {
+          atx.abs_value_us -= 1000LL * 1000LL * tzi.Bias * 60LL;
+        }
+      if (atx.abs_value_us == at.abs_value_us)
+        fprintf(stderr,
+                "WARNING:  GNUNET_STRINGS_fancy_time_to_absolute() miscalculates timezone!\n");
 #endif
-    GNUNET_assert (0);
-  }
-
-  GNUNET_log_skip (2, GNUNET_NO);
-  b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "unknown");
-  GNUNET_log_skip (0, GNUNET_YES);
-  WANT ("TEST", b);
-
-  GNUNET_assert (GNUNET_OK ==
-      GNUNET_STRINGS_fancy_time_to_relative ("15m", &rt));
-  GNUNET_assert (GNUNET_OK ==
-      GNUNET_STRINGS_fancy_time_to_relative ("15 m", &rtx));
-  GNUNET_assert (rt.rel_value_us == rtx.rel_value_us);
+      GNUNET_assert(0);
+    }
+
+  GNUNET_log_skip(2, GNUNET_NO);
+  b = GNUNET_STRINGS_to_utf8("TEST", 4, "unknown");
+  GNUNET_log_skip(0, GNUNET_YES);
+  WANT("TEST", b);
+
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_STRINGS_fancy_time_to_relative("15m", &rt));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_STRINGS_fancy_time_to_relative("15 m", &rtx));
+  GNUNET_assert(rt.rel_value_us == rtx.rel_value_us);
 
   return 0;
 }
diff --git a/src/util/test_strings_to_data.c b/src/util/test_strings_to_data.c
index f7d20441f..d719e950a 100644
--- a/src/util/test_strings_to_data.c
+++ b/src/util/test_strings_to_data.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 util/test_strings_to_data.c
  * @brief testcase for strings.c
@@ -26,7 +26,7 @@
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   char buf[1024];
   char *end;
@@ -35,26 +35,27 @@ main (int argc, char *argv[])
   unsigned int i;
   int ret = 0;
 
-  GNUNET_log_setup ("util", "DEBUG", NULL);
-  for (i=0;i<sizeof(src);i++)
-  {
-    memset (src, i, sizeof (src));
-    memset (dst, i+1, sizeof (dst));
-
-    end = GNUNET_STRINGS_data_to_string (&src, i, buf, sizeof (buf));
-    GNUNET_assert (NULL != end);
-    end[0] = '\0';
-    if (GNUNET_OK !=
-        GNUNET_STRINGS_string_to_data (buf, strlen (buf), dst, i))
-    {
-      fprintf (stderr, "%u failed decode (%u bytes)\n", i, (unsigned int) strlen (buf));
-      ret = 1;
-    } else if (0 != memcmp (src, dst, i))
+  GNUNET_log_setup("util", "DEBUG", NULL);
+  for (i = 0; i < sizeof(src); i++)
     {
-      fprintf (stderr, "%u wrong decode (%u bytes)\n", i, (unsigned int) strlen (buf));
-      ret = 1;
+      memset(src, i, sizeof(src));
+      memset(dst, i + 1, sizeof(dst));
+
+      end = GNUNET_STRINGS_data_to_string(&src, i, buf, sizeof(buf));
+      GNUNET_assert(NULL != end);
+      end[0] = '\0';
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_string_to_data(buf, strlen(buf), dst, i))
+        {
+          fprintf(stderr, "%u failed decode (%u bytes)\n", i, (unsigned int)strlen(buf));
+          ret = 1;
+        }
+      else if (0 != memcmp(src, dst, i))
+        {
+          fprintf(stderr, "%u wrong decode (%u bytes)\n", i, (unsigned int)strlen(buf));
+          ret = 1;
+        }
     }
-  }
   return ret;
 }
 
diff --git a/src/util/test_time.c b/src/util/test_time.c
index 6f4a6332b..b46cac34d 100644
--- a/src/util/test_time.c
+++ b/src/util/test_time.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 util/test_time.c
  * @brief testcase for time.c
@@ -26,7 +26,7 @@
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_AbsoluteNBO nown;
@@ -41,212 +41,212 @@ main (int argc, char *argv[])
   struct GNUNET_TIME_RelativeNBO reln;
   unsigned int i;
 
-  GNUNET_log_setup ("test-time", "WARNING", NULL);
+  GNUNET_log_setup("test-time", "WARNING", NULL);
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
   relForever = GNUNET_TIME_UNIT_FOREVER_REL;
   relUnit = GNUNET_TIME_UNIT_MILLISECONDS;
   zero.abs_value_us = 0;
 
-  last = now = GNUNET_TIME_absolute_get ();
+  last = now = GNUNET_TIME_absolute_get();
   while (now.abs_value_us == last.abs_value_us)
-    now = GNUNET_TIME_absolute_get ();
-  GNUNET_assert (now.abs_value_us > last.abs_value_us);
+    now = GNUNET_TIME_absolute_get();
+  GNUNET_assert(now.abs_value_us > last.abs_value_us);
 
   /* test overflow checking in multiply */
   rel = GNUNET_TIME_UNIT_MILLISECONDS;
-  GNUNET_log_skip (1, GNUNET_NO);
+  GNUNET_log_skip(1, GNUNET_NO);
   for (i = 0; i < 55; i++)
-    rel = GNUNET_TIME_relative_multiply (rel, 2);
-  GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
+    rel = GNUNET_TIME_relative_multiply(rel, 2);
+  GNUNET_log_skip(0, GNUNET_NO);
+  GNUNET_assert(rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
   /*check zero */
-  rel.rel_value_us = (UINT64_MAX) - 1024;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
-                 GNUNET_TIME_relative_multiply (rel, 0).rel_value_us);
+  rel.rel_value_us = (UINT64_MAX)-1024;
+  GNUNET_assert(GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                GNUNET_TIME_relative_multiply(rel, 0).rel_value_us);
 
   /* test infinity-check for relative to absolute */
-  GNUNET_log_skip (1, GNUNET_NO);
-  last = GNUNET_TIME_relative_to_absolute (rel);
-  GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
-  GNUNET_log_skip (0, GNUNET_YES);
+  GNUNET_log_skip(1, GNUNET_NO);
+  last = GNUNET_TIME_relative_to_absolute(rel);
+  GNUNET_assert(last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
+  GNUNET_log_skip(0, GNUNET_YES);
 
   /* check relative to absolute */
   rel.rel_value_us = 1000000;
-  GNUNET_assert (GNUNET_TIME_absolute_get ().abs_value_us <
-                 GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
+  GNUNET_assert(GNUNET_TIME_absolute_get().abs_value_us <
+                GNUNET_TIME_relative_to_absolute(rel).abs_value_us);
   /*check forever */
   rel.rel_value_us = UINT64_MAX;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
-                 GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
+                GNUNET_TIME_relative_to_absolute(rel).abs_value_us);
   /* check overflow for r2a */
-  rel.rel_value_us = (UINT64_MAX) - 1024;
-  GNUNET_log_skip (1, GNUNET_NO);
-  last = GNUNET_TIME_relative_to_absolute (rel);
-  GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
+  rel.rel_value_us = (UINT64_MAX)-1024;
+  GNUNET_log_skip(1, GNUNET_NO);
+  last = GNUNET_TIME_relative_to_absolute(rel);
+  GNUNET_log_skip(0, GNUNET_NO);
+  GNUNET_assert(last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
 
   /* check overflow for relative add */
-  GNUNET_log_skip (1, GNUNET_NO);
-  rel = GNUNET_TIME_relative_add (rel, rel);
-  GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
+  GNUNET_log_skip(1, GNUNET_NO);
+  rel = GNUNET_TIME_relative_add(rel, rel);
+  GNUNET_log_skip(0, GNUNET_NO);
+  GNUNET_assert(rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
 
-  GNUNET_log_skip (1, GNUNET_NO);
-  rel = GNUNET_TIME_relative_add (relForever, relForever);
-  GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value_us == relForever.rel_value_us);
+  GNUNET_log_skip(1, GNUNET_NO);
+  rel = GNUNET_TIME_relative_add(relForever, relForever);
+  GNUNET_log_skip(0, GNUNET_NO);
+  GNUNET_assert(rel.rel_value_us == relForever.rel_value_us);
 
-  GNUNET_log_skip (1, GNUNET_NO);
-  rel = GNUNET_TIME_relative_add (relUnit, relUnit);
-  GNUNET_assert (rel.rel_value_us == 2 * relUnit.rel_value_us);
+  GNUNET_log_skip(1, GNUNET_NO);
+  rel = GNUNET_TIME_relative_add(relUnit, relUnit);
+  GNUNET_assert(rel.rel_value_us == 2 * relUnit.rel_value_us);
 
   /* check relation check in get_duration */
   future.abs_value_us = now.abs_value_us + 1000000;
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).rel_value_us ==
-                 1000000);
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value_us ==
-                 0);
+  GNUNET_assert(GNUNET_TIME_absolute_get_difference(now, future).rel_value_us ==
+                1000000);
+  GNUNET_assert(GNUNET_TIME_absolute_get_difference(future, now).rel_value_us ==
+                0);
 
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value_us
-                 == forever.abs_value_us);
+  GNUNET_assert(GNUNET_TIME_absolute_get_difference(zero, forever).rel_value_us
+                == forever.abs_value_us);
 
   past.abs_value_us = now.abs_value_us - 1000000;
-  rel = GNUNET_TIME_absolute_get_duration (future);
-  GNUNET_assert (rel.rel_value_us == 0);
-  rel = GNUNET_TIME_absolute_get_duration (past);
-  GNUNET_assert (rel.rel_value_us >= 1000000);
+  rel = GNUNET_TIME_absolute_get_duration(future);
+  GNUNET_assert(rel.rel_value_us == 0);
+  rel = GNUNET_TIME_absolute_get_duration(past);
+  GNUNET_assert(rel.rel_value_us >= 1000000);
 
   /* check get remaining */
-  rel = GNUNET_TIME_absolute_get_remaining (now);
-  GNUNET_assert (rel.rel_value_us == 0);
-  rel = GNUNET_TIME_absolute_get_remaining (past);
-  GNUNET_assert (rel.rel_value_us == 0);
-  rel = GNUNET_TIME_absolute_get_remaining (future);
-  GNUNET_assert (rel.rel_value_us > 0);
-  GNUNET_assert (rel.rel_value_us <= 1000000);
+  rel = GNUNET_TIME_absolute_get_remaining(now);
+  GNUNET_assert(rel.rel_value_us == 0);
+  rel = GNUNET_TIME_absolute_get_remaining(past);
+  GNUNET_assert(rel.rel_value_us == 0);
+  rel = GNUNET_TIME_absolute_get_remaining(future);
+  GNUNET_assert(rel.rel_value_us > 0);
+  GNUNET_assert(rel.rel_value_us <= 1000000);
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
-                 GNUNET_TIME_absolute_get_remaining (forever).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                GNUNET_TIME_absolute_get_remaining(forever).rel_value_us);
 
   /* check endianess */
-  reln = GNUNET_TIME_relative_hton (rel);
-  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_relative_ntoh (reln).rel_value_us);
-  nown = GNUNET_TIME_absolute_hton (now);
-  GNUNET_assert (now.abs_value_us == GNUNET_TIME_absolute_ntoh (nown).abs_value_us);
+  reln = GNUNET_TIME_relative_hton(rel);
+  GNUNET_assert(rel.rel_value_us == GNUNET_TIME_relative_ntoh(reln).rel_value_us);
+  nown = GNUNET_TIME_absolute_hton(now);
+  GNUNET_assert(now.abs_value_us == GNUNET_TIME_absolute_ntoh(nown).abs_value_us);
 
   /* check absolute addition */
-  future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_SECONDS);
-  GNUNET_assert (future.abs_value_us == now.abs_value_us + 1000 * 1000LL);
+  future = GNUNET_TIME_absolute_add(now, GNUNET_TIME_UNIT_SECONDS);
+  GNUNET_assert(future.abs_value_us == now.abs_value_us + 1000 * 1000LL);
 
-  future = GNUNET_TIME_absolute_add (forever, GNUNET_TIME_UNIT_ZERO);
-  GNUNET_assert (future.abs_value_us == forever.abs_value_us);
+  future = GNUNET_TIME_absolute_add(forever, GNUNET_TIME_UNIT_ZERO);
+  GNUNET_assert(future.abs_value_us == forever.abs_value_us);
 
-  rel.rel_value_us = (UINT64_MAX) - 1024;
+  rel.rel_value_us = (UINT64_MAX)-1024;
   now.abs_value_us = rel.rel_value_us;
-  future = GNUNET_TIME_absolute_add (now, rel);
-  GNUNET_assert (future.abs_value_us == forever.abs_value_us);
+  future = GNUNET_TIME_absolute_add(now, rel);
+  GNUNET_assert(future.abs_value_us == forever.abs_value_us);
 
   /* check zero */
-  future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_ZERO);
-  GNUNET_assert (future.abs_value_us == now.abs_value_us);
+  future = GNUNET_TIME_absolute_add(now, GNUNET_TIME_UNIT_ZERO);
+  GNUNET_assert(future.abs_value_us == now.abs_value_us);
 
-  GNUNET_assert (forever.abs_value_us ==
-                 GNUNET_TIME_absolute_subtract (forever,
-                                                GNUNET_TIME_UNIT_MINUTES).abs_value_us);
+  GNUNET_assert(forever.abs_value_us ==
+                GNUNET_TIME_absolute_subtract(forever,
+                                              GNUNET_TIME_UNIT_MINUTES).abs_value_us);
   /*check absolute subtract */
   now.abs_value_us = 50000;
   rel.rel_value_us = 100000;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
-                 (GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
+                (GNUNET_TIME_absolute_subtract(now, rel)).abs_value_us);
   rel.rel_value_us = 10000;
-  GNUNET_assert (40000 == (GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
+  GNUNET_assert(40000 == (GNUNET_TIME_absolute_subtract(now, rel)).abs_value_us);
 
   /*check relative divide */
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
-                 (GNUNET_TIME_relative_divide (rel, 0)).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                (GNUNET_TIME_relative_divide(rel, 0)).rel_value_us);
 
   rel = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
-                 (GNUNET_TIME_relative_divide (rel, 2)).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                (GNUNET_TIME_relative_divide(rel, 2)).rel_value_us);
 
-  rel = GNUNET_TIME_relative_divide (relUnit, 2);
-  GNUNET_assert (rel.rel_value_us == relUnit.rel_value_us / 2);
+  rel = GNUNET_TIME_relative_divide(relUnit, 2);
+  GNUNET_assert(rel.rel_value_us == relUnit.rel_value_us / 2);
 
 
   /* check Return absolute time of 0ms */
   zero = GNUNET_TIME_UNIT_ZERO_ABS;
 
   /* check GNUNET_TIME_calculate_eta */
-  last.abs_value_us = GNUNET_TIME_absolute_get ().abs_value_us - 1024;
+  last.abs_value_us = GNUNET_TIME_absolute_get().abs_value_us - 1024;
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
   forever.abs_value_us = forever.abs_value_us - 1024;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
-                 GNUNET_TIME_calculate_eta (forever, 50000, 100000).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
+                GNUNET_TIME_calculate_eta(forever, 50000, 100000).rel_value_us);
   /* check zero */
-  GNUNET_log_skip (1, GNUNET_NO);
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
-                 (GNUNET_TIME_calculate_eta (last, 60000, 50000)).rel_value_us);
-  GNUNET_log_skip (0, GNUNET_YES);
+  GNUNET_log_skip(1, GNUNET_NO);
+  GNUNET_assert(GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                (GNUNET_TIME_calculate_eta(last, 60000, 50000)).rel_value_us);
+  GNUNET_log_skip(0, GNUNET_YES);
   /*check forever */
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
-                 (GNUNET_TIME_calculate_eta (last, 0, 50000)).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                (GNUNET_TIME_calculate_eta(last, 0, 50000)).rel_value_us);
 
   /*check relative subtract */
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   rel.rel_value_us = now.abs_value_us;
   relForever.rel_value_us = rel.rel_value_us + 1024;
-  GNUNET_assert (1024 ==
-                 GNUNET_TIME_relative_subtract (relForever, rel).rel_value_us);
+  GNUNET_assert(1024 ==
+                GNUNET_TIME_relative_subtract(relForever, rel).rel_value_us);
   /*check zero */
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
-                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                GNUNET_TIME_relative_subtract(rel, relForever).rel_value_us);
   /*check forever */
   rel.rel_value_us = UINT64_MAX;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
-                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
+  GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                GNUNET_TIME_relative_subtract(rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_relative_min */
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   rel.rel_value_us = now.abs_value_us;
   relForever.rel_value_us = rel.rel_value_us - 1024;
-  GNUNET_assert (relForever.rel_value_us ==
-                 GNUNET_TIME_relative_min (rel, relForever).rel_value_us);
+  GNUNET_assert(relForever.rel_value_us ==
+                GNUNET_TIME_relative_min(rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_relative_max */
-  GNUNET_assert (rel.rel_value_us ==
-                 GNUNET_TIME_relative_max (rel, relForever).rel_value_us);
+  GNUNET_assert(rel.rel_value_us ==
+                GNUNET_TIME_relative_max(rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_absolute_min */
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   last.abs_value_us = now.abs_value_us - 1024;
-  GNUNET_assert (last.abs_value_us ==
-                 GNUNET_TIME_absolute_min (now, last).abs_value_us);
+  GNUNET_assert(last.abs_value_us ==
+                GNUNET_TIME_absolute_min(now, last).abs_value_us);
 
   /*check  GNUNET_TIME_absolute_max */
-  GNUNET_assert (now.abs_value_us ==
-                 GNUNET_TIME_absolute_max (now, last).abs_value_us);
-  for (unsigned int i=0;i<30;i++)
-  {
-    struct GNUNET_CONFIGURATION_Handle *cfg;
-
-    cfg = GNUNET_CONFIGURATION_create ();
-    last = GNUNET_TIME_absolute_get_monotonic (cfg);
-    now = GNUNET_TIME_absolute_get_monotonic (cfg);
-    GNUNET_assert (now.abs_value_us > last.abs_value_us);
-    (void) GNUNET_TIME_absolute_get_monotonic (NULL);
-    GNUNET_CONFIGURATION_set_value_string (cfg,
-                                           "util",
-                                           "MONOTONIC_TIME_FILENAME",
-                                           "monotonic-time.dat");
-    last = GNUNET_TIME_absolute_get_monotonic (cfg);
-    now = GNUNET_TIME_absolute_get_monotonic (cfg);
-    (void) GNUNET_TIME_absolute_get_monotonic (NULL);
-    GNUNET_assert (now.abs_value_us > last.abs_value_us);
-    GNUNET_CONFIGURATION_destroy (cfg);
-  }
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_DISK_directory_remove ("monotonic-time.dat"));
-  
+  GNUNET_assert(now.abs_value_us ==
+                GNUNET_TIME_absolute_max(now, last).abs_value_us);
+  for (unsigned int i = 0; i < 30; i++)
+    {
+      struct GNUNET_CONFIGURATION_Handle *cfg;
+
+      cfg = GNUNET_CONFIGURATION_create();
+      last = GNUNET_TIME_absolute_get_monotonic(cfg);
+      now = GNUNET_TIME_absolute_get_monotonic(cfg);
+      GNUNET_assert(now.abs_value_us > last.abs_value_us);
+      (void)GNUNET_TIME_absolute_get_monotonic(NULL);
+      GNUNET_CONFIGURATION_set_value_string(cfg,
+                                            "util",
+                                            "MONOTONIC_TIME_FILENAME",
+                                            "monotonic-time.dat");
+      last = GNUNET_TIME_absolute_get_monotonic(cfg);
+      now = GNUNET_TIME_absolute_get_monotonic(cfg);
+      (void)GNUNET_TIME_absolute_get_monotonic(NULL);
+      GNUNET_assert(now.abs_value_us > last.abs_value_us);
+      GNUNET_CONFIGURATION_destroy(cfg);
+    }
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_DISK_directory_remove("monotonic-time.dat"));
+
   return 0;
 }
 
diff --git a/src/util/test_tun.c b/src/util/test_tun.c
index 391791c4b..f94e9c8ff 100644
--- a/src/util/test_tun.c
+++ b/src/util/test_tun.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 tun/test_tun.c
@@ -29,9 +29,9 @@
 static int ret;
 
 static void
-test_udp (size_t pll,
-          int pl_fill,
-          uint16_t crc)
+test_udp(size_t pll,
+         int pl_fill,
+         uint16_t crc)
 {
   struct GNUNET_TUN_IPv4Header ip;
   struct GNUNET_TUN_UdpHeader udp;
@@ -39,36 +39,36 @@ test_udp (size_t pll,
   struct in_addr src;
   struct in_addr dst;
 
-  GNUNET_assert (1 == inet_pton (AF_INET, "1.2.3.4", &src));
-  GNUNET_assert (1 == inet_pton (AF_INET, "122.2.3.5", &dst));
-  memset (payload, pl_fill, sizeof (payload));
-  GNUNET_TUN_initialize_ipv4_header (&ip,
-                                     IPPROTO_UDP,
-                                     pll + sizeof (udp),
-                                     &src,
-                                     &dst);
-  udp.source_port = htons (4242);
-  udp.destination_port = htons (4242);
-  udp.len = htons (pll);
-  GNUNET_TUN_calculate_udp4_checksum (&ip,
-                                      &udp,
-                                      payload,
-                                      pll);
-  if (crc != ntohs (udp.crc))
-  {
-    fprintf (stderr, "Got CRC: %u, wanted: %u\n",
-             ntohs (udp.crc),
-             crc);
-    ret = 1;
-  }
+  GNUNET_assert(1 == inet_pton(AF_INET, "1.2.3.4", &src));
+  GNUNET_assert(1 == inet_pton(AF_INET, "122.2.3.5", &dst));
+  memset(payload, pl_fill, sizeof(payload));
+  GNUNET_TUN_initialize_ipv4_header(&ip,
+                                    IPPROTO_UDP,
+                                    pll + sizeof(udp),
+                                    &src,
+                                    &dst);
+  udp.source_port = htons(4242);
+  udp.destination_port = htons(4242);
+  udp.len = htons(pll);
+  GNUNET_TUN_calculate_udp4_checksum(&ip,
+                                     &udp,
+                                     payload,
+                                     pll);
+  if (crc != ntohs(udp.crc))
+    {
+      fprintf(stderr, "Got CRC: %u, wanted: %u\n",
+              ntohs(udp.crc),
+              crc);
+      ret = 1;
+    }
 }
 
-int main (int argc,
-          char **argv)
+int main(int argc,
+         char **argv)
 {
-  test_udp (4, 3, 22439);
-  test_udp (4, 1, 23467);
-  test_udp (7, 17, 6516);
-  test_udp (12451, 251, 42771);
+  test_udp(4, 3, 22439);
+  test_udp(4, 1, 23467);
+  test_udp(7, 17, 6516);
+  test_udp(12451, 251, 42771);
   return ret;
 }
diff --git a/src/util/time.c b/src/util/time.c
index 85a781aff..3df7b469e 100644
--- a/src/util/time.c
+++ b/src/util/time.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 util/time.c
@@ -37,7 +37,7 @@
 #endif
 #endif
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "util-time", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-time", __VA_ARGS__)
 
 /**
  * Variable used to simulate clock skew.  Used for testing, never in production.
@@ -50,7 +50,7 @@ static long long timestamp_offset;
  * @param offset the offset to skew the locale time by
  */
 void
-GNUNET_TIME_set_offset (long long offset)
+GNUNET_TIME_set_offset(long long offset)
 {
   timestamp_offset = offset;
 }
@@ -62,7 +62,7 @@ GNUNET_TIME_set_offset (long long offset)
  * @return the offset we currently skew the locale time by
  */
 long long
-GNUNET_TIME_get_offset ()
+GNUNET_TIME_get_offset()
 {
   return timestamp_offset;
 }
@@ -77,7 +77,7 @@ GNUNET_TIME_get_offset ()
  *         it was just now rounded
  */
 int
-GNUNET_TIME_round_abs (struct GNUNET_TIME_Absolute *at)
+GNUNET_TIME_round_abs(struct GNUNET_TIME_Absolute *at)
 {
   if (at->abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     return GNUNET_OK;
@@ -97,7 +97,7 @@ GNUNET_TIME_round_abs (struct GNUNET_TIME_Absolute *at)
  *         it was just now rounded
  */
 int
-GNUNET_TIME_round_rel (struct GNUNET_TIME_Relative *rt)
+GNUNET_TIME_round_rel(struct GNUNET_TIME_Relative *rt)
 {
   if (rt->rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     return GNUNET_OK;
@@ -115,14 +115,14 @@ GNUNET_TIME_round_rel (struct GNUNET_TIME_Relative *rt)
  * @return the current time
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get ()
+GNUNET_TIME_absolute_get()
 {
   struct GNUNET_TIME_Absolute ret;
   struct timeval tv;
 
-  gettimeofday (&tv, NULL);
-  ret.abs_value_us = (uint64_t) (((uint64_t) tv.tv_sec * 1000LL * 1000LL) +
-                                 ((uint64_t) tv.tv_usec)) +
+  gettimeofday(&tv, NULL);
+  ret.abs_value_us = (uint64_t)(((uint64_t)tv.tv_sec * 1000LL * 1000LL) +
+                                ((uint64_t)tv.tv_usec)) +
                      timestamp_offset;
   return ret;
 }
@@ -132,7 +132,7 @@ GNUNET_TIME_absolute_get ()
  * Return relative time of 0ms.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_zero_ ()
+GNUNET_TIME_relative_get_zero_()
 {
   static struct GNUNET_TIME_Relative zero;
 
@@ -144,7 +144,7 @@ GNUNET_TIME_relative_get_zero_ ()
  * Return absolute time of 0ms.
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get_zero_ ()
+GNUNET_TIME_absolute_get_zero_()
 {
   static struct GNUNET_TIME_Absolute zero;
 
@@ -156,9 +156,9 @@ GNUNET_TIME_absolute_get_zero_ ()
  * Return relative time of 1us.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_unit_ ()
+GNUNET_TIME_relative_get_unit_()
 {
-  static struct GNUNET_TIME_Relative one = {1};
+  static struct GNUNET_TIME_Relative one = { 1 };
 
   return one;
 }
@@ -168,9 +168,9 @@ GNUNET_TIME_relative_get_unit_ ()
  * Return relative time of 1ms.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_millisecond_ ()
+GNUNET_TIME_relative_get_millisecond_()
 {
-  static struct GNUNET_TIME_Relative one = {1000};
+  static struct GNUNET_TIME_Relative one = { 1000 };
 
   return one;
 }
@@ -180,9 +180,9 @@ GNUNET_TIME_relative_get_millisecond_ ()
  * Return relative time of 1s.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_second_ ()
+GNUNET_TIME_relative_get_second_()
 {
-  static struct GNUNET_TIME_Relative one = {1000 * 1000LL};
+  static struct GNUNET_TIME_Relative one = { 1000 * 1000LL };
 
   return one;
 }
@@ -192,9 +192,9 @@ GNUNET_TIME_relative_get_second_ ()
  * Return relative time of 1 minute.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_minute_ ()
+GNUNET_TIME_relative_get_minute_()
 {
-  static struct GNUNET_TIME_Relative one = {60 * 1000 * 1000LL};
+  static struct GNUNET_TIME_Relative one = { 60 * 1000 * 1000LL };
 
   return one;
 }
@@ -204,9 +204,9 @@ GNUNET_TIME_relative_get_minute_ ()
  * Return relative time of 1 hour.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_hour_ ()
+GNUNET_TIME_relative_get_hour_()
 {
-  static struct GNUNET_TIME_Relative one = {60 * 60 * 1000 * 1000LL};
+  static struct GNUNET_TIME_Relative one = { 60 * 60 * 1000 * 1000LL };
 
   return one;
 }
@@ -216,9 +216,9 @@ GNUNET_TIME_relative_get_hour_ ()
  * Return "forever".
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_get_forever_ ()
+GNUNET_TIME_relative_get_forever_()
 {
-  static struct GNUNET_TIME_Relative forever = {UINT64_MAX};
+  static struct GNUNET_TIME_Relative forever = { UINT64_MAX };
 
   return forever;
 }
@@ -228,9 +228,10 @@ GNUNET_TIME_relative_get_forever_ ()
  * Return "forever".
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get_forever_ ()
+GNUNET_TIME_absolute_get_forever_()
 {
-  static struct GNUNET_TIME_Absolute forever = {UINT64_MAX};
+  static struct GNUNET_TIME_Absolute forever = { UINT64_MAX };
+
   return forever;
 }
 
@@ -242,19 +243,19 @@ GNUNET_TIME_absolute_get_forever_ ()
  * @return timestamp that is "rel" in the future, or FOREVER if rel==FOREVER (or if we would overflow)
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
+GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
 {
   struct GNUNET_TIME_Absolute ret;
 
   if (rel.rel_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_ABS;
-  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
 
   if (rel.rel_value_us + now.abs_value_us < rel.rel_value_us)
-  {
-    GNUNET_break (0); /* overflow... */
-    return GNUNET_TIME_UNIT_FOREVER_ABS;
-  }
+    {
+      GNUNET_break(0); /* overflow... */
+      return GNUNET_TIME_UNIT_FOREVER_ABS;
+    }
   ret.abs_value_us = rel.rel_value_us + now.abs_value_us;
   return ret;
 }
@@ -268,8 +269,8 @@ GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
  * @return timestamp that is smaller
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
-                          struct GNUNET_TIME_Relative t2)
+GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1,
+                         struct GNUNET_TIME_Relative t2)
 {
   return (t1.rel_value_us < t2.rel_value_us) ? t1 : t2;
 }
@@ -283,8 +284,8 @@ GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
  * @return timestamp that is larger
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
-                          struct GNUNET_TIME_Relative t2)
+GNUNET_TIME_relative_max(struct GNUNET_TIME_Relative t1,
+                         struct GNUNET_TIME_Relative t2)
 {
   return (t1.rel_value_us > t2.rel_value_us) ? t1 : t2;
 }
@@ -298,8 +299,8 @@ GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
  * @return timestamp that is smaller
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
-                          struct GNUNET_TIME_Absolute t2)
+GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1,
+                         struct GNUNET_TIME_Absolute t2)
 {
   return (t1.abs_value_us < t2.abs_value_us) ? t1 : t2;
 }
@@ -313,8 +314,8 @@ GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
  * @return timestamp that is bigger
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
-                          struct GNUNET_TIME_Absolute t2)
+GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1,
+                         struct GNUNET_TIME_Absolute t2)
 {
   return (t1.abs_value_us > t2.abs_value_us) ? t1 : t2;
 }
@@ -327,13 +328,13 @@ GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
  * @return future - now, or 0 if now >= future, or FOREVER if future==FOREVER.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
+GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
 {
   struct GNUNET_TIME_Relative ret;
 
   if (future.abs_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
 
   if (now.abs_value_us > future.abs_value_us)
     return GNUNET_TIME_UNIT_ZERO;
@@ -349,8 +350,8 @@ GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
  * @return 0 if start >= end; FOREVER if end==FOREVER; otherwise end - start
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
-                                     struct GNUNET_TIME_Absolute end)
+GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start,
+                                    struct GNUNET_TIME_Absolute end)
 {
   struct GNUNET_TIME_Relative ret;
 
@@ -369,12 +370,12 @@ GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
  * @return 0 if whence > now, otherwise now-whence.
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute whence)
+GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
 {
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Relative ret;
 
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   if (whence.abs_value_us > now.abs_value_us)
     return GNUNET_TIME_UNIT_ZERO;
   ret.rel_value_us = now.abs_value_us - whence.abs_value_us;
@@ -389,8 +390,8 @@ GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute whence)
  * @return FOREVER if either argument is FOREVER or on overflow; start+duration otherwise
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
-                          struct GNUNET_TIME_Relative duration)
+GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start,
+                         struct GNUNET_TIME_Relative duration)
 {
   struct GNUNET_TIME_Absolute ret;
 
@@ -398,10 +399,10 @@ GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
       (duration.rel_value_us == UINT64_MAX))
     return GNUNET_TIME_UNIT_FOREVER_ABS;
   if (start.abs_value_us + duration.rel_value_us < start.abs_value_us)
-  {
-    GNUNET_break (0);
-    return GNUNET_TIME_UNIT_FOREVER_ABS;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_TIME_UNIT_FOREVER_ABS;
+    }
   ret.abs_value_us = start.abs_value_us + duration.rel_value_us;
   return ret;
 }
@@ -416,8 +417,8 @@ GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
  * @return ZERO if start <= duration, or FOREVER if start time is FOREVER; start-duration otherwise
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
-                               struct GNUNET_TIME_Relative duration)
+GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start,
+                              struct GNUNET_TIME_Relative duration)
 {
   struct GNUNET_TIME_Absolute ret;
 
@@ -436,8 +437,8 @@ GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
  * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
-                               unsigned long long factor)
+GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel,
+                              unsigned long long factor)
 {
   struct GNUNET_TIME_Relative ret;
 
@@ -447,10 +448,10 @@ GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
     return GNUNET_TIME_UNIT_FOREVER_REL;
   ret.rel_value_us = rel.rel_value_us * factor;
   if (ret.rel_value_us / factor != rel.rel_value_us)
-  {
-    GNUNET_break (0);
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
   return ret;
 }
 
@@ -462,27 +463,27 @@ GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
  * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
  */
 struct GNUNET_TIME_Relative
-relative_multiply_double (struct GNUNET_TIME_Relative rel, double factor)
+relative_multiply_double(struct GNUNET_TIME_Relative rel, double factor)
 {
   struct GNUNET_TIME_Relative out;
   double m;
 
-  GNUNET_assert (0 <= factor);
+  GNUNET_assert(0 <= factor);
 
   if (0 == factor)
     return GNUNET_TIME_UNIT_ZERO;
   if (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     return GNUNET_TIME_UNIT_FOREVER_REL;
 
-  m = ((double) rel.rel_value_us) * factor;
+  m = ((double)rel.rel_value_us) * factor;
 
-  if (m >= (double) (GNUNET_TIME_UNIT_FOREVER_REL).rel_value_us)
-  {
-    GNUNET_break (0);
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
+  if (m >= (double)(GNUNET_TIME_UNIT_FOREVER_REL).rel_value_us)
+    {
+      GNUNET_break(0);
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
 
-  out.rel_value_us = (uint64_t) m;
+  out.rel_value_us = (uint64_t)m;
   return out;
 }
 
@@ -495,8 +496,8 @@ relative_multiply_double (struct GNUNET_TIME_Relative rel, double factor)
  * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_saturating_multiply (struct GNUNET_TIME_Relative rel,
-                                          unsigned long long factor)
+GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel,
+                                         unsigned long long factor)
 {
   struct GNUNET_TIME_Relative ret;
 
@@ -506,9 +507,9 @@ GNUNET_TIME_relative_saturating_multiply (struct GNUNET_TIME_Relative rel,
     return GNUNET_TIME_UNIT_FOREVER_REL;
   ret.rel_value_us = rel.rel_value_us * factor;
   if (ret.rel_value_us / factor != rel.rel_value_us)
-  {
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
+    {
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
   return ret;
 }
 
@@ -521,8 +522,8 @@ GNUNET_TIME_relative_saturating_multiply (struct GNUNET_TIME_Relative rel,
  * @return FOREVER if rel=FOREVER or factor==0; otherwise rel/factor
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
-                             unsigned long long factor)
+GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel,
+                            unsigned long long factor)
 {
   struct GNUNET_TIME_Relative ret;
 
@@ -545,22 +546,22 @@ GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
  *        assuming it continues at the same speed
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
-                           uint64_t finished,
-                           uint64_t total)
+GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start,
+                          uint64_t finished,
+                          uint64_t total)
 {
   struct GNUNET_TIME_Relative dur;
   double exp;
   struct GNUNET_TIME_Relative ret;
 
-  GNUNET_break (finished <= total);
+  GNUNET_break(finished <= total);
   if (finished >= total)
     return GNUNET_TIME_UNIT_ZERO;
   if (0 == finished)
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  dur = GNUNET_TIME_absolute_get_duration (start);
-  exp = ((double) dur.rel_value_us) * ((double) total) / ((double) finished);
-  ret.rel_value_us = ((uint64_t) exp) - dur.rel_value_us;
+  dur = GNUNET_TIME_absolute_get_duration(start);
+  exp = ((double)dur.rel_value_us) * ((double)total) / ((double)finished);
+  ret.rel_value_us = ((uint64_t)exp) - dur.rel_value_us;
   return ret;
 }
 
@@ -573,18 +574,18 @@ GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
  * @return FOREVER if either argument is FOREVER or on overflow; a1+a2 otherwise
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
-                          struct GNUNET_TIME_Relative a2)
+GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1,
+                         struct GNUNET_TIME_Relative a2)
 {
   struct GNUNET_TIME_Relative ret;
 
   if ((a1.rel_value_us == UINT64_MAX) || (a2.rel_value_us == UINT64_MAX))
     return GNUNET_TIME_UNIT_FOREVER_REL;
   if (a1.rel_value_us + a2.rel_value_us < a1.rel_value_us)
-  {
-    GNUNET_break (0);
-    return GNUNET_TIME_UNIT_FOREVER_REL;
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_TIME_UNIT_FOREVER_REL;
+    }
   ret.rel_value_us = a1.rel_value_us + a2.rel_value_us;
   return ret;
 }
@@ -598,8 +599,8 @@ GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
  * @return ZERO if a2>=a1 (including both FOREVER), FOREVER if a1 is FOREVER, a1-a2 otherwise
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
-                               struct GNUNET_TIME_Relative a2)
+GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1,
+                              struct GNUNET_TIME_Relative a2)
 {
   struct GNUNET_TIME_Relative ret;
 
@@ -619,11 +620,11 @@ GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
  * @return time in network byte order
  */
 struct GNUNET_TIME_RelativeNBO
-GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
+GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
 {
   struct GNUNET_TIME_RelativeNBO ret;
 
-  ret.rel_value_us__ = GNUNET_htonll (a.rel_value_us);
+  ret.rel_value_us__ = GNUNET_htonll(a.rel_value_us);
   return ret;
 }
 
@@ -635,11 +636,11 @@ GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
  * @return time in host byte order
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
+GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
 {
   struct GNUNET_TIME_Relative ret;
 
-  ret.rel_value_us = GNUNET_ntohll (a.rel_value_us__);
+  ret.rel_value_us = GNUNET_ntohll(a.rel_value_us__);
   return ret;
 }
 
@@ -651,11 +652,11 @@ GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
  * @return time in network byte order
  */
 struct GNUNET_TIME_AbsoluteNBO
-GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
+GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
 {
   struct GNUNET_TIME_AbsoluteNBO ret;
 
-  ret.abs_value_us__ = GNUNET_htonll (a.abs_value_us);
+  ret.abs_value_us__ = GNUNET_htonll(a.abs_value_us);
   return ret;
 }
 
@@ -667,11 +668,11 @@ GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
  * @return time in host byte order
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
+GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
 {
   struct GNUNET_TIME_Absolute ret;
 
-  ret.abs_value_us = GNUNET_ntohll (a.abs_value_us__);
+  ret.abs_value_us = GNUNET_ntohll(a.abs_value_us__);
   return ret;
 }
 
@@ -680,13 +681,13 @@ GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
  * Return the current year (i.e. '2011').
  */
 unsigned int
-GNUNET_TIME_get_current_year ()
+GNUNET_TIME_get_current_year()
 {
   time_t tp;
   struct tm *t;
 
-  tp = time (NULL);
-  t = gmtime (&tp);
+  tp = time(NULL);
+  t = gmtime(&tp);
   if (t == NULL)
     return 0;
   return t->tm_year + 1900;
@@ -700,13 +701,13 @@ GNUNET_TIME_get_current_year ()
  * @return year a year (after 1970), 0 on error
  */
 unsigned int
-GNUNET_TIME_time_to_year (struct GNUNET_TIME_Absolute at)
+GNUNET_TIME_time_to_year(struct GNUNET_TIME_Absolute at)
 {
   struct tm *t;
   time_t tp;
 
   tp = at.abs_value_us / 1000LL / 1000LL; /* microseconds to seconds */
-  t = gmtime (&tp);
+  t = gmtime(&tp);
   if (t == NULL)
     return 0;
   return t->tm_year + 1900;
@@ -720,25 +721,25 @@ GNUNET_TIME_time_to_year (struct GNUNET_TIME_Absolute at)
  * @return absolute time for January 1st of that year.
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_year_to_time (unsigned int year)
+GNUNET_TIME_year_to_time(unsigned int year)
 {
   struct GNUNET_TIME_Absolute ret;
   time_t tp;
   struct tm t;
 
-  memset (&t, 0, sizeof (t));
+  memset(&t, 0, sizeof(t));
   if (year < 1900)
-  {
-    GNUNET_break (0);
-    return GNUNET_TIME_absolute_get (); /* now */
-  }
+    {
+      GNUNET_break(0);
+      return GNUNET_TIME_absolute_get(); /* now */
+    }
   t.tm_year = year - 1900;
   t.tm_mday = 1;
   t.tm_mon = 0;
   t.tm_wday = 1;
   t.tm_yday = 1;
-  tp = mktime (&t);
-  GNUNET_break (tp != (time_t) -1);
+  tp = mktime(&t);
+  GNUNET_break(tp != (time_t)-1);
   ret.abs_value_us = tp * 1000LL * 1000LL; /* seconds to microseconds */
   return ret;
 }
@@ -754,16 +755,16 @@ GNUNET_TIME_year_to_time (unsigned int year)
  * @return the next backoff time
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_randomized_backoff (struct GNUNET_TIME_Relative rt,
-                                struct GNUNET_TIME_Relative threshold)
+GNUNET_TIME_randomized_backoff(struct GNUNET_TIME_Relative rt,
+                               struct GNUNET_TIME_Relative threshold)
 {
-  double r = (rand () % 500) / 1000.0;
+  double r = (rand() % 500) / 1000.0;
   struct GNUNET_TIME_Relative t;
 
-  t = relative_multiply_double (
-    GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_MILLISECONDS, rt),
+  t = relative_multiply_double(
+    GNUNET_TIME_relative_max(GNUNET_TIME_UNIT_MILLISECONDS, rt),
     2 + r);
-  return GNUNET_TIME_relative_min (threshold, t);
+  return GNUNET_TIME_relative_min(threshold, t);
 }
 
 
@@ -774,11 +775,11 @@ GNUNET_TIME_randomized_backoff (struct GNUNET_TIME_Relative rt,
  * @return randomized time
  */
 struct GNUNET_TIME_Relative
-GNUNET_TIME_randomize (struct GNUNET_TIME_Relative r)
+GNUNET_TIME_randomize(struct GNUNET_TIME_Relative r)
 {
-  double d = ((rand () % 1001) - 500) / 1000.0;
+  double d = ((rand() % 1001) - 500) / 1000.0;
 
-  return relative_multiply_double (r, d);
+  return relative_multiply_double(r, d);
 }
 
 
@@ -801,7 +802,7 @@ GNUNET_TIME_randomize (struct GNUNET_TIME_Relative r)
  * @return monotonically increasing time
  */
 struct GNUNET_TIME_Absolute
-GNUNET_TIME_absolute_get_monotonic (
+GNUNET_TIME_absolute_get_monotonic(
   const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   static const struct GNUNET_CONFIGURATION_Handle *last_cfg;
@@ -810,114 +811,114 @@ GNUNET_TIME_absolute_get_monotonic (
   static ATOMIC volatile uint64_t *map;
   struct GNUNET_TIME_Absolute now;
 
-  now = GNUNET_TIME_absolute_get ();
+  now = GNUNET_TIME_absolute_get();
   if (last_cfg != cfg)
-  {
-    char *filename;
-
-    if (NULL != map_handle)
     {
-      GNUNET_DISK_file_unmap (map_handle);
-      map_handle = NULL;
-    }
-    map = NULL;
-
-    last_cfg = cfg;
-    if ((NULL != cfg) &&
-        (GNUNET_OK ==
-         GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                  "util",
-                                                  "MONOTONIC_TIME_FILENAME",
-                                                  &filename)))
-    {
-      struct GNUNET_DISK_FileHandle *fh;
-
-      fh = GNUNET_DISK_file_open (filename,
-                                  GNUNET_DISK_OPEN_READWRITE |
-                                    GNUNET_DISK_OPEN_CREATE,
-                                  GNUNET_DISK_PERM_USER_WRITE |
-                                    GNUNET_DISK_PERM_GROUP_WRITE |
-                                    GNUNET_DISK_PERM_USER_READ |
-                                    GNUNET_DISK_PERM_GROUP_READ);
-      if (NULL == fh)
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    _ ("Failed to map `%s', cannot assure monotonic time!\n"),
-                    filename);
-      }
-      else
-      {
-        off_t size;
-
-        size = 0;
-        GNUNET_break (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &size));
-        if (size < (off_t) sizeof (*map))
-        {
-          struct GNUNET_TIME_AbsoluteNBO o;
+      char *filename;
 
-          o = GNUNET_TIME_absolute_hton (now);
-          if (sizeof (o) != GNUNET_DISK_file_write (fh, &o, sizeof (o)))
-            size = 0;
-          else
-            size = sizeof (o);
-        }
-        if (size == sizeof (*map))
+      if (NULL != map_handle)
         {
-          map = GNUNET_DISK_file_map (fh,
-                                      &map_handle,
-                                      GNUNET_DISK_MAP_TYPE_READWRITE,
-                                      sizeof (*map));
-          if (NULL == map)
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                        _ (
-                          "Failed to map `%s', cannot assure monotonic time!\n"),
-                        filename);
+          GNUNET_DISK_file_unmap(map_handle);
+          map_handle = NULL;
         }
-        else
+      map = NULL;
+
+      last_cfg = cfg;
+      if ((NULL != cfg) &&
+          (GNUNET_OK ==
+           GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                   "util",
+                                                   "MONOTONIC_TIME_FILENAME",
+                                                   &filename)))
         {
-          GNUNET_log (
-            GNUNET_ERROR_TYPE_WARNING,
-            _ (
-              "Failed to setup monotonic time file `%s', cannot assure monotonic time!\n"),
-            filename);
+          struct GNUNET_DISK_FileHandle *fh;
+
+          fh = GNUNET_DISK_file_open(filename,
+                                     GNUNET_DISK_OPEN_READWRITE |
+                                     GNUNET_DISK_OPEN_CREATE,
+                                     GNUNET_DISK_PERM_USER_WRITE |
+                                     GNUNET_DISK_PERM_GROUP_WRITE |
+                                     GNUNET_DISK_PERM_USER_READ |
+                                     GNUNET_DISK_PERM_GROUP_READ);
+          if (NULL == fh)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                         _("Failed to map `%s', cannot assure monotonic time!\n"),
+                         filename);
+            }
+          else
+            {
+              off_t size;
+
+              size = 0;
+              GNUNET_break(GNUNET_OK == GNUNET_DISK_file_handle_size(fh, &size));
+              if (size < (off_t)sizeof(*map))
+                {
+                  struct GNUNET_TIME_AbsoluteNBO o;
+
+                  o = GNUNET_TIME_absolute_hton(now);
+                  if (sizeof(o) != GNUNET_DISK_file_write(fh, &o, sizeof(o)))
+                    size = 0;
+                  else
+                    size = sizeof(o);
+                }
+              if (size == sizeof(*map))
+                {
+                  map = GNUNET_DISK_file_map(fh,
+                                             &map_handle,
+                                             GNUNET_DISK_MAP_TYPE_READWRITE,
+                                             sizeof(*map));
+                  if (NULL == map)
+                    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                               _(
+                                 "Failed to map `%s', cannot assure monotonic time!\n"),
+                               filename);
+                }
+              else
+                {
+                  GNUNET_log(
+                    GNUNET_ERROR_TYPE_WARNING,
+                    _(
+                      "Failed to setup monotonic time file `%s', cannot assure monotonic time!\n"),
+                    filename);
+                }
+            }
+          GNUNET_DISK_file_close(fh);
+          GNUNET_free(filename);
         }
-      }
-      GNUNET_DISK_file_close (fh);
-      GNUNET_free (filename);
     }
-  }
   if (NULL != map)
-  {
-    struct GNUNET_TIME_AbsoluteNBO mt;
+    {
+      struct GNUNET_TIME_AbsoluteNBO mt;
 
 #if __STDC_NO_ATOMICS__
 #if __GNUC__
-    mt.abs_value_us__ = __sync_fetch_and_or (map, 0);
+      mt.abs_value_us__ = __sync_fetch_and_or(map, 0);
 #else
-    mt.abs_value_us__ = *map; /* godspeed, pray this is atomic */
+      mt.abs_value_us__ = *map; /* godspeed, pray this is atomic */
 #endif
 #else
-    mt.abs_value_us__ = atomic_load (map);
+      mt.abs_value_us__ = atomic_load(map);
 #endif
-    last_time =
-      GNUNET_TIME_absolute_max (GNUNET_TIME_absolute_ntoh (mt), last_time);
-  }
+      last_time =
+        GNUNET_TIME_absolute_max(GNUNET_TIME_absolute_ntoh(mt), last_time);
+    }
   if (now.abs_value_us <= last_time.abs_value_us)
     now.abs_value_us = last_time.abs_value_us + 1;
   last_time = now;
   if (NULL != map)
-  {
-    uint64_t val = GNUNET_TIME_absolute_hton (now).abs_value_us__;
+    {
+      uint64_t val = GNUNET_TIME_absolute_hton(now).abs_value_us__;
 #if __STDC_NO_ATOMICS__
 #if __GNUC__
-    (void) __sync_lock_test_and_set (map, val);
+      (void)__sync_lock_test_and_set(map, val);
 #else
-    *map = val; /* godspeed, pray this is atomic */
+      *map = val; /* godspeed, pray this is atomic */
 #endif
 #else
-    atomic_store (map, val);
+      atomic_store(map, val);
 #endif
-  }
+    }
   return now;
 }
 
@@ -925,9 +926,9 @@ GNUNET_TIME_absolute_get_monotonic (
 /**
  * Destructor
  */
-void __attribute__ ((destructor)) GNUNET_util_time_fini ()
+void __attribute__ ((destructor)) GNUNET_util_time_fini()
 {
-  (void) GNUNET_TIME_absolute_get_monotonic (NULL);
+  (void)GNUNET_TIME_absolute_get_monotonic(NULL);
 }
 
 /* end of time.c */
diff --git a/src/util/tun.c b/src/util/tun.c
index e3643d0c6..f3b97b860 100644
--- a/src/util/tun.c
+++ b/src/util/tun.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 tun/tun.c
@@ -43,28 +43,28 @@
  * @param dst destination IP address to use
  */
 void
-GNUNET_TUN_initialize_ipv4_header (struct GNUNET_TUN_IPv4Header *ip,
-                                   uint8_t protocol,
-                                   uint16_t payload_length,
-                                   const struct in_addr *src,
-                                   const struct in_addr *dst)
+GNUNET_TUN_initialize_ipv4_header(struct GNUNET_TUN_IPv4Header *ip,
+                                  uint8_t protocol,
+                                  uint16_t payload_length,
+                                  const struct in_addr *src,
+                                  const struct in_addr *dst)
 {
-  GNUNET_assert (20 == sizeof (struct GNUNET_TUN_IPv4Header));
-  GNUNET_assert (payload_length <=
-                 UINT16_MAX - sizeof (struct GNUNET_TUN_IPv4Header));
-  memset (ip, 0, sizeof (struct GNUNET_TUN_IPv4Header));
-  ip->header_length = sizeof (struct GNUNET_TUN_IPv4Header) / 4;
+  GNUNET_assert(20 == sizeof(struct GNUNET_TUN_IPv4Header));
+  GNUNET_assert(payload_length <=
+                UINT16_MAX - sizeof(struct GNUNET_TUN_IPv4Header));
+  memset(ip, 0, sizeof(struct GNUNET_TUN_IPv4Header));
+  ip->header_length = sizeof(struct GNUNET_TUN_IPv4Header) / 4;
   ip->version = 4;
   ip->total_length =
-    htons (sizeof (struct GNUNET_TUN_IPv4Header) + payload_length);
+    htons(sizeof(struct GNUNET_TUN_IPv4Header) + payload_length);
   ip->identification =
-    (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 65536);
+    (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 65536);
   ip->ttl = FRESH_TTL;
   ip->protocol = protocol;
   ip->source_address = *src;
   ip->destination_address = *dst;
   ip->checksum =
-    GNUNET_CRYPTO_crc16_n (ip, sizeof (struct GNUNET_TUN_IPv4Header));
+    GNUNET_CRYPTO_crc16_n(ip, sizeof(struct GNUNET_TUN_IPv4Header));
 }
 
 
@@ -78,19 +78,19 @@ GNUNET_TUN_initialize_ipv4_header (struct GNUNET_TUN_IPv4Header *ip,
  * @param dst destination IP address to use
  */
 void
-GNUNET_TUN_initialize_ipv6_header (struct GNUNET_TUN_IPv6Header *ip,
-                                   uint8_t protocol,
-                                   uint16_t payload_length,
-                                   const struct in6_addr *src,
-                                   const struct in6_addr *dst)
+GNUNET_TUN_initialize_ipv6_header(struct GNUNET_TUN_IPv6Header *ip,
+                                  uint8_t protocol,
+                                  uint16_t payload_length,
+                                  const struct in6_addr *src,
+                                  const struct in6_addr *dst)
 {
-  GNUNET_assert (40 == sizeof (struct GNUNET_TUN_IPv6Header));
-  GNUNET_assert (payload_length <=
-                 UINT16_MAX - sizeof (struct GNUNET_TUN_IPv6Header));
-  memset (ip, 0, sizeof (struct GNUNET_TUN_IPv6Header));
+  GNUNET_assert(40 == sizeof(struct GNUNET_TUN_IPv6Header));
+  GNUNET_assert(payload_length <=
+                UINT16_MAX - sizeof(struct GNUNET_TUN_IPv6Header));
+  memset(ip, 0, sizeof(struct GNUNET_TUN_IPv6Header));
   ip->version = 6;
   ip->next_header = protocol;
-  ip->payload_length = htons ((uint16_t) payload_length);
+  ip->payload_length = htons((uint16_t)payload_length);
   ip->hop_limit = FRESH_TTL;
   ip->destination_address = *dst;
   ip->source_address = *src;
@@ -106,32 +106,32 @@ GNUNET_TUN_initialize_ipv6_header (struct GNUNET_TUN_IPv6Header *ip,
  * @param payload_length number of bytes of TCP payload
  */
 void
-GNUNET_TUN_calculate_tcp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
-                                    struct GNUNET_TUN_TcpHeader *tcp,
-                                    const void *payload,
-                                    uint16_t payload_length)
+GNUNET_TUN_calculate_tcp4_checksum(const struct GNUNET_TUN_IPv4Header *ip,
+                                   struct GNUNET_TUN_TcpHeader *tcp,
+                                   const void *payload,
+                                   uint16_t payload_length)
 {
   uint32_t sum;
   uint16_t tmp;
 
-  GNUNET_assert (20 == sizeof (struct GNUNET_TUN_TcpHeader));
-  GNUNET_assert (payload_length + sizeof (struct GNUNET_TUN_IPv4Header) +
-                   sizeof (struct GNUNET_TUN_TcpHeader) ==
-                 ntohs (ip->total_length));
-  GNUNET_assert (IPPROTO_TCP == ip->protocol);
+  GNUNET_assert(20 == sizeof(struct GNUNET_TUN_TcpHeader));
+  GNUNET_assert(payload_length + sizeof(struct GNUNET_TUN_IPv4Header) +
+                sizeof(struct GNUNET_TUN_TcpHeader) ==
+                ntohs(ip->total_length));
+  GNUNET_assert(IPPROTO_TCP == ip->protocol);
 
   tcp->crc = 0;
-  sum = GNUNET_CRYPTO_crc16_step (0,
-                                  &ip->source_address,
-                                  sizeof (struct in_addr) * 2);
-  tmp = htons (IPPROTO_TCP);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint16_t));
-  tmp = htons (payload_length + sizeof (struct GNUNET_TUN_TcpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint16_t));
+  sum = GNUNET_CRYPTO_crc16_step(0,
+                                 &ip->source_address,
+                                 sizeof(struct in_addr) * 2);
+  tmp = htons(IPPROTO_TCP);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint16_t));
+  tmp = htons(payload_length + sizeof(struct GNUNET_TUN_TcpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint16_t));
   sum =
-    GNUNET_CRYPTO_crc16_step (sum, tcp, sizeof (struct GNUNET_TUN_TcpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, payload, payload_length);
-  tcp->crc = GNUNET_CRYPTO_crc16_finish (sum);
+    GNUNET_CRYPTO_crc16_step(sum, tcp, sizeof(struct GNUNET_TUN_TcpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, payload, payload_length);
+  tcp->crc = GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -144,30 +144,30 @@ GNUNET_TUN_calculate_tcp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
  * @param payload_length number of bytes of TCP payload
  */
 void
-GNUNET_TUN_calculate_tcp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
-                                    struct GNUNET_TUN_TcpHeader *tcp,
-                                    const void *payload,
-                                    uint16_t payload_length)
+GNUNET_TUN_calculate_tcp6_checksum(const struct GNUNET_TUN_IPv6Header *ip,
+                                   struct GNUNET_TUN_TcpHeader *tcp,
+                                   const void *payload,
+                                   uint16_t payload_length)
 {
   uint32_t sum;
   uint32_t tmp;
 
-  GNUNET_assert (20 == sizeof (struct GNUNET_TUN_TcpHeader));
-  GNUNET_assert (payload_length + sizeof (struct GNUNET_TUN_TcpHeader) ==
-                 ntohs (ip->payload_length));
-  GNUNET_assert (IPPROTO_TCP == ip->next_header);
+  GNUNET_assert(20 == sizeof(struct GNUNET_TUN_TcpHeader));
+  GNUNET_assert(payload_length + sizeof(struct GNUNET_TUN_TcpHeader) ==
+                ntohs(ip->payload_length));
+  GNUNET_assert(IPPROTO_TCP == ip->next_header);
   tcp->crc = 0;
-  sum = GNUNET_CRYPTO_crc16_step (0,
-                                  &ip->source_address,
-                                  2 * sizeof (struct in6_addr));
-  tmp = htonl (sizeof (struct GNUNET_TUN_TcpHeader) + payload_length);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t));
-  tmp = htonl (IPPROTO_TCP);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t));
+  sum = GNUNET_CRYPTO_crc16_step(0,
+                                 &ip->source_address,
+                                 2 * sizeof(struct in6_addr));
+  tmp = htonl(sizeof(struct GNUNET_TUN_TcpHeader) + payload_length);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint32_t));
+  tmp = htonl(IPPROTO_TCP);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint32_t));
   sum =
-    GNUNET_CRYPTO_crc16_step (sum, tcp, sizeof (struct GNUNET_TUN_TcpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, payload, payload_length);
-  tcp->crc = GNUNET_CRYPTO_crc16_finish (sum);
+    GNUNET_CRYPTO_crc16_step(sum, tcp, sizeof(struct GNUNET_TUN_TcpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, payload, payload_length);
+  tcp->crc = GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -180,33 +180,33 @@ GNUNET_TUN_calculate_tcp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
  * @param payload_length number of bytes of UDP payload
  */
 void
-GNUNET_TUN_calculate_udp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
-                                    struct GNUNET_TUN_UdpHeader *udp,
-                                    const void *payload,
-                                    uint16_t payload_length)
+GNUNET_TUN_calculate_udp4_checksum(const struct GNUNET_TUN_IPv4Header *ip,
+                                   struct GNUNET_TUN_UdpHeader *udp,
+                                   const void *payload,
+                                   uint16_t payload_length)
 {
   uint32_t sum;
   uint16_t tmp;
 
-  GNUNET_assert (8 == sizeof (struct GNUNET_TUN_UdpHeader));
-  GNUNET_assert (payload_length + sizeof (struct GNUNET_TUN_IPv4Header) +
-                   sizeof (struct GNUNET_TUN_UdpHeader) ==
-                 ntohs (ip->total_length));
-  GNUNET_assert (IPPROTO_UDP == ip->protocol);
+  GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
+  GNUNET_assert(payload_length + sizeof(struct GNUNET_TUN_IPv4Header) +
+                sizeof(struct GNUNET_TUN_UdpHeader) ==
+                ntohs(ip->total_length));
+  GNUNET_assert(IPPROTO_UDP == ip->protocol);
 
   udp->crc =
     0; /* technically optional, but we calculate it anyway, just to be sure */
-  sum = GNUNET_CRYPTO_crc16_step (0,
-                                  &ip->source_address,
-                                  sizeof (struct in_addr) * 2);
-  tmp = htons (IPPROTO_UDP);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint16_t));
-  tmp = htons (sizeof (struct GNUNET_TUN_UdpHeader) + payload_length);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint16_t));
+  sum = GNUNET_CRYPTO_crc16_step(0,
+                                 &ip->source_address,
+                                 sizeof(struct in_addr) * 2);
+  tmp = htons(IPPROTO_UDP);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint16_t));
+  tmp = htons(sizeof(struct GNUNET_TUN_UdpHeader) + payload_length);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint16_t));
   sum =
-    GNUNET_CRYPTO_crc16_step (sum, udp, sizeof (struct GNUNET_TUN_UdpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, payload, payload_length);
-  udp->crc = GNUNET_CRYPTO_crc16_finish (sum);
+    GNUNET_CRYPTO_crc16_step(sum, udp, sizeof(struct GNUNET_TUN_UdpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, payload, payload_length);
+  udp->crc = GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -219,33 +219,33 @@ GNUNET_TUN_calculate_udp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
  * @param payload_length number of bytes of UDP payload
  */
 void
-GNUNET_TUN_calculate_udp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
-                                    struct GNUNET_TUN_UdpHeader *udp,
-                                    const void *payload,
-                                    uint16_t payload_length)
+GNUNET_TUN_calculate_udp6_checksum(const struct GNUNET_TUN_IPv6Header *ip,
+                                   struct GNUNET_TUN_UdpHeader *udp,
+                                   const void *payload,
+                                   uint16_t payload_length)
 {
   uint32_t sum;
   uint32_t tmp;
 
-  GNUNET_assert (payload_length + sizeof (struct GNUNET_TUN_UdpHeader) ==
-                 ntohs (ip->payload_length));
-  GNUNET_assert (payload_length + sizeof (struct GNUNET_TUN_UdpHeader) ==
-                 ntohs (udp->len));
-  GNUNET_assert (IPPROTO_UDP == ip->next_header);
+  GNUNET_assert(payload_length + sizeof(struct GNUNET_TUN_UdpHeader) ==
+                ntohs(ip->payload_length));
+  GNUNET_assert(payload_length + sizeof(struct GNUNET_TUN_UdpHeader) ==
+                ntohs(udp->len));
+  GNUNET_assert(IPPROTO_UDP == ip->next_header);
 
   udp->crc = 0;
-  sum = GNUNET_CRYPTO_crc16_step (0,
-                                  &ip->source_address,
-                                  sizeof (struct in6_addr) * 2);
-  tmp = htons (sizeof (struct GNUNET_TUN_UdpHeader) +
-               payload_length); /* aka udp->len */
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t));
-  tmp = htons (ip->next_header);
-  sum = GNUNET_CRYPTO_crc16_step (sum, &tmp, sizeof (uint32_t));
+  sum = GNUNET_CRYPTO_crc16_step(0,
+                                 &ip->source_address,
+                                 sizeof(struct in6_addr) * 2);
+  tmp = htons(sizeof(struct GNUNET_TUN_UdpHeader) +
+              payload_length);  /* aka udp->len */
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint32_t));
+  tmp = htons(ip->next_header);
+  sum = GNUNET_CRYPTO_crc16_step(sum, &tmp, sizeof(uint32_t));
   sum =
-    GNUNET_CRYPTO_crc16_step (sum, udp, sizeof (struct GNUNET_TUN_UdpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, payload, payload_length);
-  udp->crc = GNUNET_CRYPTO_crc16_finish (sum);
+    GNUNET_CRYPTO_crc16_step(sum, udp, sizeof(struct GNUNET_TUN_UdpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, payload, payload_length);
+  udp->crc = GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -257,18 +257,18 @@ GNUNET_TUN_calculate_udp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
  * @param payload_length number of bytes of ICMP payload
  */
 void
-GNUNET_TUN_calculate_icmp_checksum (struct GNUNET_TUN_IcmpHeader *icmp,
-                                    const void *payload,
-                                    uint16_t payload_length)
+GNUNET_TUN_calculate_icmp_checksum(struct GNUNET_TUN_IcmpHeader *icmp,
+                                   const void *payload,
+                                   uint16_t payload_length)
 {
   uint32_t sum;
 
-  GNUNET_assert (8 == sizeof (struct GNUNET_TUN_IcmpHeader));
+  GNUNET_assert(8 == sizeof(struct GNUNET_TUN_IcmpHeader));
   icmp->crc = 0;
   sum =
-    GNUNET_CRYPTO_crc16_step (0, icmp, sizeof (struct GNUNET_TUN_IcmpHeader));
-  sum = GNUNET_CRYPTO_crc16_step (sum, payload, payload_length);
-  icmp->crc = GNUNET_CRYPTO_crc16_finish (sum);
+    GNUNET_CRYPTO_crc16_step(0, icmp, sizeof(struct GNUNET_TUN_IcmpHeader));
+  sum = GNUNET_CRYPTO_crc16_step(sum, payload, payload_length);
+  icmp->crc = GNUNET_CRYPTO_crc16_finish(sum);
 }
 
 
@@ -281,35 +281,37 @@ GNUNET_TUN_calculate_icmp_checksum (struct GNUNET_TUN_IcmpHeader *icmp,
  * @return #GNUNET_YES if they are equal
  */
 int
-GNUNET_TUN_sockaddr_cmp (const struct sockaddr *sa,
-                         const struct sockaddr *sb,
-                         int include_port)
+GNUNET_TUN_sockaddr_cmp(const struct sockaddr *sa,
+                        const struct sockaddr *sb,
+                        int include_port)
 {
   if (sa->sa_family != sb->sa_family)
     return GNUNET_NO;
 
   switch (sa->sa_family)
-  {
-  case AF_INET: {
-    const struct sockaddr_in *sa4 = (const struct sockaddr_in *) sa;
-    const struct sockaddr_in *sb4 = (const struct sockaddr_in *) sb;
-    if ((include_port) && (sa4->sin_port != sb4->sin_port))
-      return GNUNET_NO;
-    return (sa4->sin_addr.s_addr == sb4->sin_addr.s_addr);
-  }
-  case AF_INET6: {
-    const struct sockaddr_in6 *sa6 = (const struct sockaddr_in6 *) sa;
-    const struct sockaddr_in6 *sb6 = (const struct sockaddr_in6 *) sb;
-
-    if ((include_port) && (sa6->sin6_port != sb6->sin6_port))
-      return GNUNET_NO;
-    return (
-      0 == memcmp (&sa6->sin6_addr, &sb6->sin6_addr, sizeof (struct in6_addr)));
-  }
-  default:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+    {
+    case AF_INET: {
+      const struct sockaddr_in *sa4 = (const struct sockaddr_in *)sa;
+      const struct sockaddr_in *sb4 = (const struct sockaddr_in *)sb;
+      if ((include_port) && (sa4->sin_port != sb4->sin_port))
+        return GNUNET_NO;
+      return(sa4->sin_addr.s_addr == sb4->sin_addr.s_addr);
+    }
+
+    case AF_INET6: {
+      const struct sockaddr_in6 *sa6 = (const struct sockaddr_in6 *)sa;
+      const struct sockaddr_in6 *sb6 = (const struct sockaddr_in6 *)sb;
+
+      if ((include_port) && (sa6->sin6_port != sb6->sin6_port))
+        return GNUNET_NO;
+      return(
+        0 == memcmp(&sa6->sin6_addr, &sb6->sin6_addr, sizeof(struct in6_addr)));
+    }
+
+    default:
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
 }
 
 
diff --git a/src/util/w32cat.c b/src/util/w32cat.c
index 8a48638aa..fa7637d38 100644
--- a/src/util/w32cat.c
+++ b/src/util/w32cat.c
@@ -18,7 +18,7 @@
      Boston, MA 02110-1301, USA.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 #include <stdio.h>
 #include <windows.h>
@@ -26,45 +26,46 @@
 #include <signal.h>
 
 DWORD WINAPI
-parent_control_thread (LPVOID lpParameter)
+parent_control_thread(LPVOID lpParameter)
 {
-  HANDLE h = (HANDLE) lpParameter;
+  HANDLE h = (HANDLE)lpParameter;
+
   while (TRUE)
-  {
-    DWORD dw;
-    BOOL b;
-    unsigned char c;
-    b = ReadFile (h, &c, 1, &dw, NULL);
-    if (!b)
     {
-      ExitProcess (0);
+      DWORD dw;
+      BOOL b;
+      unsigned char c;
+      b = ReadFile(h, &c, 1, &dw, NULL);
+      if (!b)
+        {
+          ExitProcess(0);
+        }
+      raise((int)c);
     }
-    raise ((int) c);
-  }
 }
 
 void
-install_parent_control_handler ()
+install_parent_control_handler()
 {
   const char *env_buf;
   char *env_buf_end;
   uint64_t pipe_fd;
   HANDLE pipe_handle;
 
-  env_buf = getenv ("GNUNET_OS_CONTROL_PIPE");
-  if ( (NULL == env_buf) || (strlen (env_buf) <= 0) )
+  env_buf = getenv("GNUNET_OS_CONTROL_PIPE");
+  if ((NULL == env_buf) || (strlen(env_buf) <= 0))
     return;
   errno = 0;
-  pipe_fd = strtoull (env_buf, &env_buf_end, 16);
+  pipe_fd = strtoull(env_buf, &env_buf_end, 16);
   if ((0 != errno) || (env_buf == env_buf_end))
     return;
   /* Gcc will issue a warning here. What to do with it? */
-  pipe_handle = (HANDLE) (uintptr_t) pipe_fd;
-  CreateThread (NULL, 0, parent_control_thread, (LPVOID) pipe_handle, 0, NULL);
+  pipe_handle = (HANDLE)(uintptr_t)pipe_fd;
+  CreateThread(NULL, 0, parent_control_thread, (LPVOID)pipe_handle, 0, NULL);
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
   HANDLE stdi, stdo;
   BOOL b;
@@ -72,81 +73,82 @@ main (int argc, char **argv)
   int argcw;
   int i;
 
-  stdo = GetStdHandle (STD_OUTPUT_HANDLE);
+  stdo = GetStdHandle(STD_OUTPUT_HANDLE);
   if (stdo == INVALID_HANDLE_VALUE || stdo == NULL)
     return 1;
 
-  commandlinew = GetCommandLineW ();
-  argvw = CommandLineToArgvW (commandlinew, &argcw);
+  commandlinew = GetCommandLineW();
+  argvw = CommandLineToArgvW(commandlinew, &argcw);
   if (argvw == NULL)
     return 1;
 
-  install_parent_control_handler ();
+  install_parent_control_handler();
 
   for (i = 1; i < argcw || argcw == 1; i++)
-  {
-    DWORD r, w;
-    int is_dash = wcscmp (NULL == argvw[i] ? L"-" : argvw[i], L"-") == 0;
-    if (argcw == 1 || is_dash)
-    {
-      stdi = GetStdHandle (STD_INPUT_HANDLE);
-      if (stdi == INVALID_HANDLE_VALUE)
-      {
-        fprintf (stderr, "cat: Failed to obtain stdin handle.\n");
-        return 4;
-      }
-      if (stdi == NULL)
-      {
-        fprintf (stderr, "cat: Have no stdin.\n");
-        return 5;
-      }
-    }
-    else
     {
-      stdi = CreateFileW (argvw[i], GENERIC_READ, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
-      if (stdi == INVALID_HANDLE_VALUE)
-      {
-        wchar_t *msgbuf;
-        DWORD le = GetLastError ();
-        if (0 < FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, le, 0, (wchar_t *) &msgbuf, 0, NULL))
+      DWORD r, w;
+      int is_dash = wcscmp(NULL == argvw[i] ? L"-" : argvw[i], L"-") == 0;
+      if (argcw == 1 || is_dash)
         {
-          fprintf (stderr, "cat: Failed to open file `%S'. Error %lu.\n", argvw[i], le);
-          return 3;
+          stdi = GetStdHandle(STD_INPUT_HANDLE);
+          if (stdi == INVALID_HANDLE_VALUE)
+            {
+              fprintf(stderr, "cat: Failed to obtain stdin handle.\n");
+              return 4;
+            }
+          if (stdi == NULL)
+            {
+              fprintf(stderr, "cat: Have no stdin.\n");
+              return 5;
+            }
         }
-        fprintf (stderr, "cat: Failed to open file `%S'. Error %lu: %S\n", argvw[i], le, msgbuf);
-        if (msgbuf != NULL)
-          LocalFree (msgbuf);
-        return 2;
-      }
-    }
-    do
-    {
-      unsigned char c;
-      b = ReadFile (stdi, &c, 1, &r, NULL);
-      if (b && r > 0)
-      {
-        b = WriteFile (stdo, &c, 1, &w, NULL);
-        if (b == 0)
+      else
         {
-          wchar_t *msgbuf;
-          DWORD le = GetLastError ();
-          if (0 < FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, le, 0, (wchar_t *) &msgbuf, 0, NULL))
-          {
-            fprintf (stderr, "cat: Failed to write into stdout. Error %lu.\n", le);
-            return 3;
-          }
-          fprintf (stderr, "cat: Failed to write into stdout. Error %lu: %S\n", le, msgbuf);
-          if (msgbuf != NULL)
-            LocalFree (msgbuf);
-          return 6;
+          stdi = CreateFileW(argvw[i], GENERIC_READ, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+          if (stdi == INVALID_HANDLE_VALUE)
+            {
+              wchar_t *msgbuf;
+              DWORD le = GetLastError();
+              if (0 < FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, le, 0, (wchar_t *)&msgbuf, 0, NULL))
+                {
+                  fprintf(stderr, "cat: Failed to open file `%S'. Error %lu.\n", argvw[i], le);
+                  return 3;
+                }
+              fprintf(stderr, "cat: Failed to open file `%S'. Error %lu: %S\n", argvw[i], le, msgbuf);
+              if (msgbuf != NULL)
+                LocalFree(msgbuf);
+              return 2;
+            }
         }
-      }
-    } while (b && r > 0);
-    if (argcw == 1)
-      break;
-    if (!is_dash)
-      CloseHandle (stdi);
-  }
-  LocalFree (argvw);
+      do
+        {
+          unsigned char c;
+          b = ReadFile(stdi, &c, 1, &r, NULL);
+          if (b && r > 0)
+            {
+              b = WriteFile(stdo, &c, 1, &w, NULL);
+              if (b == 0)
+                {
+                  wchar_t *msgbuf;
+                  DWORD le = GetLastError();
+                  if (0 < FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, le, 0, (wchar_t *)&msgbuf, 0, NULL))
+                    {
+                      fprintf(stderr, "cat: Failed to write into stdout. Error %lu.\n", le);
+                      return 3;
+                    }
+                  fprintf(stderr, "cat: Failed to write into stdout. Error %lu: %S\n", le, msgbuf);
+                  if (msgbuf != NULL)
+                    LocalFree(msgbuf);
+                  return 6;
+                }
+            }
+        }
+      while (b && r > 0);
+      if (argcw == 1)
+        break;
+      if (!is_dash)
+        CloseHandle(stdi);
+    }
+  LocalFree(argvw);
   return 0;
 }
diff --git a/src/util/win.c b/src/util/win.c
index ad6275cc4..39b276a6c 100644
--- a/src/util/win.c
+++ b/src/util/win.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 util/win.c
@@ -49,28 +49,28 @@ int plibc_conv_to_win_path(const char *pszUnix, char *pszWindows);
   };
 
 #define _IP_ADAPTER_UNICAST_ADDRESS_BASE \
-  SOCKET_ADDRESS                     Address; \
-  IP_PREFIX_ORIGIN                   PrefixOrigin; \
-  IP_SUFFIX_ORIGIN                   SuffixOrigin; \
-  IP_DAD_STATE                       DadState; \
-  ULONG                              ValidLifetime; \
-  ULONG                              PreferredLifetime; \
-  ULONG                              LeaseLifetime;
+  SOCKET_ADDRESS Address; \
+  IP_PREFIX_ORIGIN PrefixOrigin; \
+  IP_SUFFIX_ORIGIN SuffixOrigin; \
+  IP_DAD_STATE DadState; \
+  ULONG ValidLifetime; \
+  ULONG PreferredLifetime; \
+  ULONG LeaseLifetime;
 
 #define _IP_ADAPTER_UNICAST_ADDRESS_ADD_VISTA \
-  UINT8                              OnLinkPrefixLength;
+  UINT8 OnLinkPrefixLength;
 
 
-#define _IP_ADAPTER_UNICAST_ADDRESS_DEFINE(suffix,addition) \
-typedef struct _IP_ADAPTER_UNICAST_ADDRESS##suffix { \
-  _IP_ADAPTER_UNICAST_ADDRESS_HEAD \
-  struct _IP_ADAPTER_UNICAST_ADDRESS##suffix *Next; \
-  _IP_ADAPTER_UNICAST_ADDRESS_BASE \
-  addition \
-} IP_ADAPTER_UNICAST_ADDRESS##suffix, *PIP_ADAPTER_UNICAST_ADDRESS##suffix;
+#define _IP_ADAPTER_UNICAST_ADDRESS_DEFINE(suffix, addition) \
+  typedef struct _IP_ADAPTER_UNICAST_ADDRESS ## suffix { \
+    _IP_ADAPTER_UNICAST_ADDRESS_HEAD \
+    struct _IP_ADAPTER_UNICAST_ADDRESS ## suffix *Next; \
+    _IP_ADAPTER_UNICAST_ADDRESS_BASE \
+      addition \
+  } IP_ADAPTER_UNICAST_ADDRESS ## suffix, *PIP_ADAPTER_UNICAST_ADDRESS ## suffix;
 
 /* _IP_ADAPTER_UNICAST_ADDRESS_DEFINE(,) defined in w32api headers */
-_IP_ADAPTER_UNICAST_ADDRESS_DEFINE(_VISTA,_IP_ADAPTER_UNICAST_ADDRESS_ADD_VISTA)
+_IP_ADAPTER_UNICAST_ADDRESS_DEFINE(_VISTA, _IP_ADAPTER_UNICAST_ADDRESS_ADD_VISTA)
 
 
 #ifndef __MINGW64_VERSION_MAJOR
@@ -83,7 +83,7 @@ typedef struct _IP_ADAPTER_WINS_SERVER_ADDRESS {
     };
   };
   struct _IP_ADAPTER_WINS_SERVER_ADDRESS  *Next;
-  SOCKET_ADDRESS                         Address;
+  SOCKET_ADDRESS Address;
 } IP_ADAPTER_WINS_SERVER_ADDRESS, *PIP_ADAPTER_WINS_SERVER_ADDRESS, *PIP_ADAPTER_WINS_SERVER_ADDRESS_LH;
 
 typedef struct _IP_ADAPTER_GATEWAY_ADDRESS {
@@ -95,7 +95,7 @@ typedef struct _IP_ADAPTER_GATEWAY_ADDRESS {
     };
   };
   struct _IP_ADAPTER_GATEWAY_ADDRESS  *Next;
-  SOCKET_ADDRESS                     Address;
+  SOCKET_ADDRESS Address;
 } IP_ADAPTER_GATEWAY_ADDRESS, *PIP_ADAPTER_GATEWAY_ADDRESS, *PIP_ADAPTER_GATEWAY_ADDRESS_LH;
 #endif
 
@@ -122,20 +122,20 @@ typedef enum  {
 #endif
 
 /*
-A DUID consists of a two-octet type code represented in network byte
+   A DUID consists of a two-octet type code represented in network byte
    order, followed by a variable number of octets that make up the
    actual identifier.  A DUID can be no more than 128 octets long (not
    including the type code).
-*/
+ */
 #define MAX_DHCPV6_DUID_LENGTH 130
 
 #ifndef __MINGW64_VERSION_MAJOR
 typedef union _NET_LUID {
   ULONG64 Value;
   struct {
-    ULONG64 Reserved  :24;
-    ULONG64 NetLuidIndex  :24;
-    ULONG64 IfType  :16;
+    ULONG64 Reserved  : 24;
+    ULONG64 NetLuidIndex  : 24;
+    ULONG64 IfType  : 16;
   } Info;
 } NET_LUID, *PNET_LUID, IF_LUID;
 
@@ -143,7 +143,7 @@ typedef union _NET_LUID {
 
 typedef struct _IP_ADAPTER_DNS_SUFFIX {
   struct _IP_ADAPTER_DNS_SUFFIX  *Next;
-  WCHAR                         String[MAX_DNS_SUFFIX_STRING_LENGTH];
+  WCHAR String[MAX_DNS_SUFFIX_STRING_LENGTH];
 } IP_ADAPTER_DNS_SUFFIX, *PIP_ADAPTER_DNS_SUFFIX;
 #endif
 
@@ -159,72 +159,73 @@ typedef struct _IP_ADAPTER_DNS_SUFFIX {
   };
 
 #define _IP_ADAPTER_ADDRESSES_BASE \
-  PCHAR                              AdapterName; \
-  PIP_ADAPTER_UNICAST_ADDRESS        FirstUnicastAddress; \
-  PIP_ADAPTER_ANYCAST_ADDRESS        FirstAnycastAddress; \
-  PIP_ADAPTER_MULTICAST_ADDRESS      FirstMulticastAddress; \
-  PIP_ADAPTER_DNS_SERVER_ADDRESS     FirstDnsServerAddress; \
-  PWCHAR                             DnsSuffix; \
-  PWCHAR                             Description; \
-  PWCHAR                             FriendlyName; \
-  BYTE                               PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; \
-  DWORD                              PhysicalAddressLength; \
-  DWORD                              Flags; \
-  DWORD                              Mtu; \
-  DWORD                              IfType; \
-  IF_OPER_STATUS                     OperStatus;
+  PCHAR AdapterName; \
+  PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; \
+  PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; \
+  PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; \
+  PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; \
+  PWCHAR DnsSuffix; \
+  PWCHAR Description; \
+  PWCHAR FriendlyName; \
+  BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; \
+  DWORD PhysicalAddressLength; \
+  DWORD Flags; \
+  DWORD Mtu; \
+  DWORD IfType; \
+  IF_OPER_STATUS OperStatus;
 
 #define _IP_ADAPTER_ADDRESSES_ADD_XPSP1 \
-  DWORD                              Ipv6IfIndex; \
-  DWORD                              ZoneIndices[16]; \
-  PIP_ADAPTER_PREFIX                 FirstPrefix; \
+  DWORD Ipv6IfIndex; \
+  DWORD ZoneIndices[16]; \
+  PIP_ADAPTER_PREFIX FirstPrefix; \
 
 
 #define _IP_ADAPTER_ADDRESSES_ADD_VISTA \
   _IP_ADAPTER_ADDRESSES_ADD_XPSP1 \
-  ULONG64                            TransmitLinkSpeed; \
-  ULONG64                            ReceiveLinkSpeed; \
+  ULONG64 TransmitLinkSpeed; \
+  ULONG64 ReceiveLinkSpeed; \
   PIP_ADAPTER_WINS_SERVER_ADDRESS_LH FirstWinsServerAddress; \
-  PIP_ADAPTER_GATEWAY_ADDRESS_LH     FirstGatewayAddress; \
-  ULONG                              Ipv4Metric; \
-  ULONG                              Ipv6Metric; \
-  IF_LUID                            Luid; \
-  SOCKET_ADDRESS                     Dhcpv4Server; \
-  NET_IF_COMPARTMENT_ID              CompartmentId; \
-  NET_IF_NETWORK_GUID                NetworkGuid; \
-  NET_IF_CONNECTION_TYPE             ConnectionType; \
-  TUNNEL_TYPE                        TunnelType; \
-  SOCKET_ADDRESS                     Dhcpv6Server; \
-  BYTE                               Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH]; \
-  ULONG                              Dhcpv6ClientDuidLength; \
-  ULONG                              Dhcpv6Iaid;
+  PIP_ADAPTER_GATEWAY_ADDRESS_LH FirstGatewayAddress; \
+  ULONG Ipv4Metric; \
+  ULONG Ipv6Metric; \
+  IF_LUID Luid; \
+  SOCKET_ADDRESS Dhcpv4Server; \
+  NET_IF_COMPARTMENT_ID CompartmentId; \
+  NET_IF_NETWORK_GUID NetworkGuid; \
+  NET_IF_CONNECTION_TYPE ConnectionType; \
+  TUNNEL_TYPE TunnelType; \
+  SOCKET_ADDRESS Dhcpv6Server; \
+  BYTE Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH]; \
+  ULONG Dhcpv6ClientDuidLength; \
+  ULONG Dhcpv6Iaid;
 
 #define _IP_ADAPTER_ADDRESSES_ADD_2008_OR_VISTASP1 \
   _IP_ADAPTER_ADDRESSES_ADD_VISTA \
-  PIP_ADAPTER_DNS_SUFFIX             FirstDnsSuffix;
+  PIP_ADAPTER_DNS_SUFFIX FirstDnsSuffix;
 
-#define _IP_ADAPTER_ADDRESSES_DEFINE(suffix,addition) \
-typedef struct _IP_ADAPTER_ADDRESSES##suffix { \
-  _IP_ADAPTER_ADDRESSES_HEAD \
-  struct _IP_ADAPTER_ADDRESSES##suffix *Next; \
-  _IP_ADAPTER_ADDRESSES_BASE \
-  addition \
-} IP_ADAPTER_ADDRESSES##suffix, *PIP_ADAPTER_ADDRESSES##suffix;
+#define _IP_ADAPTER_ADDRESSES_DEFINE(suffix, addition) \
+  typedef struct _IP_ADAPTER_ADDRESSES ## suffix { \
+    _IP_ADAPTER_ADDRESSES_HEAD \
+    struct _IP_ADAPTER_ADDRESSES ## suffix *Next; \
+    _IP_ADAPTER_ADDRESSES_BASE \
+      addition \
+  } IP_ADAPTER_ADDRESSES ## suffix, *PIP_ADAPTER_ADDRESSES ## suffix;
 
 
 /* _IP_ADAPTER_ADDRESSES_DEFINE(,) defined in w32api headers */
-_IP_ADAPTER_ADDRESSES_DEFINE(_XPSP1,_IP_ADAPTER_ADDRESSES_ADD_XPSP1)
-_IP_ADAPTER_ADDRESSES_DEFINE(_VISTA,_IP_ADAPTER_ADDRESSES_ADD_VISTA)
-_IP_ADAPTER_ADDRESSES_DEFINE(_2008_OR_VISTASP1,_IP_ADAPTER_ADDRESSES_ADD_2008_OR_VISTASP1)
+_IP_ADAPTER_ADDRESSES_DEFINE(_XPSP1, _IP_ADAPTER_ADDRESSES_ADD_XPSP1)
+_IP_ADAPTER_ADDRESSES_DEFINE(_VISTA, _IP_ADAPTER_ADDRESSES_ADD_VISTA)
+_IP_ADAPTER_ADDRESSES_DEFINE(_2008_OR_VISTASP1, _IP_ADAPTER_ADDRESSES_ADD_2008_OR_VISTASP1)
 
 static int
-EnumNICs_IPv6_get_ifs_count (SOCKET s)
+EnumNICs_IPv6_get_ifs_count(SOCKET s)
 {
   DWORD dwret = 0, err;
   int iret;
-  iret = WSAIoctl (s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0,
-      &dwret, NULL, NULL);
-  err = GetLastError ();
+
+  iret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0,
+                  &dwret, NULL, NULL);
+  err = GetLastError();
   if (iret == SOCKET_ERROR && err == WSAEFAULT)
     return dwret;
   else if (iret == 0)
@@ -233,71 +234,73 @@ EnumNICs_IPv6_get_ifs_count (SOCKET s)
 }
 
 static int
-EnumNICs_IPv6_get_ifs (SOCKET s, SOCKET_ADDRESS_LIST *inf, int size)
+EnumNICs_IPv6_get_ifs(SOCKET s, SOCKET_ADDRESS_LIST *inf, int size)
 {
   int iret;
   DWORD dwret = 0;
-  iret = WSAIoctl (s, SIO_ADDRESS_LIST_QUERY, NULL, 0, inf, size,
-      &dwret, NULL, NULL);
+
+  iret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, inf, size,
+                  &dwret, NULL, NULL);
 
   if (iret != 0 || dwret != size)
-  {
-    /* It's supposed to succeed! And size should be the same */
-    return GNUNET_SYSERR;
-  }
+    {
+      /* It's supposed to succeed! And size should be the same */
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
 #undef GNUNET_malloc
-#define GNUNET_malloc(a) HeapAlloc(GetProcessHeap (), HEAP_ZERO_MEMORY | \
-    HEAP_GENERATE_EXCEPTIONS, a)
+#define GNUNET_malloc(a) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY | \
+                                   HEAP_GENERATE_EXCEPTIONS, a)
 
 #undef GNUNET_free
-#define GNUNET_free(a) HeapFree(GetProcessHeap (), 0, a)
+#define GNUNET_free(a) HeapFree(GetProcessHeap(), 0, a)
 
 #undef GNUNET_free_non_null
-#define GNUNET_free_non_null(a) do { if ((a) != NULL) GNUNET_free(a); } while (0)
+#define GNUNET_free_non_null(a) do { if ((a) != NULL) GNUNET_free (a); } while (0)
 
 static int
-EnumNICs_IPv4_get_ifs (SOCKET s, INTERFACE_INFO **inf, int *size)
+EnumNICs_IPv4_get_ifs(SOCKET s, INTERFACE_INFO **inf, int *size)
 {
   int iret;
   DWORD dwret = 0;
   DWORD error;
   INTERFACE_INFO *ii = NULL;
-  DWORD ii_size = sizeof (INTERFACE_INFO) * 15;
+  DWORD ii_size = sizeof(INTERFACE_INFO) * 15;
+
   while (TRUE)
-  {
-    if (ii_size >= sizeof (INTERFACE_INFO) * 1000)
-      return GNUNET_SYSERR;
-    ii = (INTERFACE_INFO *) GNUNET_malloc (ii_size);
-    dwret = 0;
-    iret = WSAIoctl (s, SIO_GET_INTERFACE_LIST, NULL, 0, ii, ii_size,
-        &dwret, NULL, NULL);
-    error = GetLastError ();
-    if (iret == SOCKET_ERROR)
     {
-      if (error == WSAEFAULT)
-      {
-        GNUNET_free (ii);
-        ii_size *= 2;
-        continue;
-      }
-      GNUNET_free (ii);
-      return GNUNET_SYSERR;
-    }
-    else
-    {
-      *inf = ii;
-      *size = dwret;
-      return GNUNET_OK;
+      if (ii_size >= sizeof(INTERFACE_INFO) * 1000)
+        return GNUNET_SYSERR;
+      ii = (INTERFACE_INFO *)GNUNET_malloc(ii_size);
+      dwret = 0;
+      iret = WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, ii, ii_size,
+                      &dwret, NULL, NULL);
+      error = GetLastError();
+      if (iret == SOCKET_ERROR)
+        {
+          if (error == WSAEFAULT)
+            {
+              GNUNET_free(ii);
+              ii_size *= 2;
+              continue;
+            }
+          GNUNET_free(ii);
+          return GNUNET_SYSERR;
+        }
+      else
+        {
+          *inf = ii;
+          *size = dwret;
+          return GNUNET_OK;
+        }
     }
-  }
   return GNUNET_SYSERR;
 }
 
 int
-EnumNICs2 (INTERFACE_INFO **ifs4, int *ifs4_len, SOCKET_ADDRESS_LIST **ifs6)
+EnumNICs2(INTERFACE_INFO **ifs4, int *ifs4_len, SOCKET_ADDRESS_LIST **ifs6)
 {
   int result = 0;
   SOCKET s4;
@@ -307,49 +310,49 @@ EnumNICs2 (INTERFACE_INFO **ifs4, int *ifs4_len, SOCKET_ADDRESS_LIST **ifs6)
   INTERFACE_INFO *interfaces4 = NULL;
   SOCKET_ADDRESS_LIST *interfaces6 = NULL;
 
-  SetLastError (0);
-  s4 = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  (void) GetLastError ();
-  SetLastError (0);
-  s6 = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP);
-  (void) GetLastError ();
+  SetLastError(0);
+  s4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  (void)GetLastError();
+  SetLastError(0);
+  s6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
+  (void)GetLastError();
   if (s6 != INVALID_SOCKET)
-  {
-    ifs6len = EnumNICs_IPv6_get_ifs_count (s6);
-    if (ifs6len > 0)
     {
-      interfaces6 = (SOCKET_ADDRESS_LIST *) GNUNET_malloc (ifs6len);
-      result = EnumNICs_IPv6_get_ifs (s6, interfaces6, ifs6len) || result;
+      ifs6len = EnumNICs_IPv6_get_ifs_count(s6);
+      if (ifs6len > 0)
+        {
+          interfaces6 = (SOCKET_ADDRESS_LIST *)GNUNET_malloc(ifs6len);
+          result = EnumNICs_IPv6_get_ifs(s6, interfaces6, ifs6len) || result;
+        }
+      closesocket(s6);
+      s6 = INVALID_SOCKET;
     }
-    closesocket (s6);
-    s6 = INVALID_SOCKET;
-  }
 
   if (s4 != INVALID_SOCKET)
-  {
-    result = EnumNICs_IPv4_get_ifs (s4, &interfaces4, &ifs4len) || result;
-    closesocket (s4);
-    s4 = INVALID_SOCKET;
-  }
+    {
+      result = EnumNICs_IPv4_get_ifs(s4, &interfaces4, &ifs4len) || result;
+      closesocket(s4);
+      s4 = INVALID_SOCKET;
+    }
   if (ifs6len + ifs4len == 0)
     goto error;
 
   if (!result)
-  {
-    *ifs4 = interfaces4;
-    *ifs4_len = ifs4len;
-    *ifs6 = interfaces6;
-    return GNUNET_OK;
-  }
+    {
+      *ifs4 = interfaces4;
+      *ifs4_len = ifs4len;
+      *ifs6 = interfaces6;
+      return GNUNET_OK;
+    }
 error:
   if (interfaces4 != NULL)
-    GNUNET_free (interfaces4);
+    GNUNET_free(interfaces4);
   if (interfaces6 != NULL)
-    GNUNET_free (interfaces6);
+    GNUNET_free(interfaces6);
   if (s4 != INVALID_SOCKET)
-    closesocket (s4);
+    closesocket(s4);
   if (s6 != INVALID_SOCKET)
-    closesocket (s6);
+    closesocket(s6);
   return GNUNET_SYSERR;
 }
 
@@ -358,12 +361,12 @@ error:
  * @returns #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-EnumNICs3 (struct EnumNICs3_results **results, int *results_count)
+EnumNICs3(struct EnumNICs3_results **results, int *results_count)
 {
   DWORD dwRetVal = 0;
   int count = 0;
   ULONG flags = /*GAA_FLAG_INCLUDE_PREFIX |*/ GAA_FLAG_SKIP_ANYCAST |
-      GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
+                GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
   struct sockaddr_in6 examplecom6;
   IPAddr examplecom;
   DWORD best_interface = 0;
@@ -374,54 +377,54 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count)
   int interfaces4_len = 0;
   SOCKET_ADDRESS_LIST *interfaces6 = NULL;
 
-  unsigned long outBufLen = sizeof (IP_ADAPTER_ADDRESSES);
+  unsigned long outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
   IP_ADAPTER_ADDRESSES *pCurrentAddress = NULL;
-  IP_ADAPTER_ADDRESSES *pAddresses = (IP_ADAPTER_ADDRESSES *) GNUNET_malloc (outBufLen);
+  IP_ADAPTER_ADDRESSES *pAddresses = (IP_ADAPTER_ADDRESSES *)GNUNET_malloc(outBufLen);
 
-  if (GetAdaptersAddresses (AF_UNSPEC, flags, NULL, pAddresses, &outBufLen)
+  if (GetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAddresses, &outBufLen)
       == ERROR_BUFFER_OVERFLOW)
-  {
-    GNUNET_free (pAddresses);
-    pAddresses = (IP_ADAPTER_ADDRESSES *) GNUNET_malloc (outBufLen);
-  }
+    {
+      GNUNET_free(pAddresses);
+      pAddresses = (IP_ADAPTER_ADDRESSES *)GNUNET_malloc(outBufLen);
+    }
 
-  dwRetVal = GetAdaptersAddresses (AF_UNSPEC, flags, NULL, pAddresses, &outBufLen);
+  dwRetVal = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAddresses, &outBufLen);
 
   if (dwRetVal != NO_ERROR)
-  {
-    GNUNET_free (pAddresses);
-    return GNUNET_SYSERR;
-  }
-
-  if (pAddresses->Length < sizeof (IP_ADAPTER_ADDRESSES_VISTA))
-  {
-    use_enum2 = 1;
-
-    /* Enumerate NICs using WSAIoctl() */
-    if (GNUNET_OK != EnumNICs2 (&interfaces4, &interfaces4_len, &interfaces6))
     {
-      GNUNET_free (pAddresses);
+      GNUNET_free(pAddresses);
       return GNUNET_SYSERR;
     }
-  }
+
+  if (pAddresses->Length < sizeof(IP_ADAPTER_ADDRESSES_VISTA))
+    {
+      use_enum2 = 1;
+
+      /* Enumerate NICs using WSAIoctl() */
+      if (GNUNET_OK != EnumNICs2(&interfaces4, &interfaces4_len, &interfaces6))
+        {
+          GNUNET_free(pAddresses);
+          return GNUNET_SYSERR;
+        }
+    }
 
   examplecom = inet_addr("192.0.34.166"); /* www.example.com */
-  if (GetBestInterface (examplecom, &best_interface) != NO_ERROR)
+  if (GetBestInterface(examplecom, &best_interface) != NO_ERROR)
     best_interface = 0;
 
   if (GNGetBestInterfaceEx != NULL)
-  {
-    examplecom6.sin6_family = AF_INET6;
-    examplecom6.sin6_port = 0;
-    examplecom6.sin6_flowinfo = 0;
-    examplecom6.sin6_scope_id = 0;
-    inet_pton (AF_INET6, "2001:500:88:200:0:0:0:10",
-        (struct sockaddr *) &examplecom6.sin6_addr);
-    dwRetVal = GNGetBestInterfaceEx ((struct sockaddr *) &examplecom6,
-        &best_interface6);
-    if (dwRetVal != NO_ERROR)
-      best_interface6 = 0;
-  }
+    {
+      examplecom6.sin6_family = AF_INET6;
+      examplecom6.sin6_port = 0;
+      examplecom6.sin6_flowinfo = 0;
+      examplecom6.sin6_scope_id = 0;
+      inet_pton(AF_INET6, "2001:500:88:200:0:0:0:10",
+                (struct sockaddr *)&examplecom6.sin6_addr);
+      dwRetVal = GNGetBestInterfaceEx((struct sockaddr *)&examplecom6,
+                                      &best_interface6);
+      if (dwRetVal != NO_ERROR)
+        best_interface6 = 0;
+    }
 
   /* Give IPv6 a priority */
   if (best_interface6 != 0)
@@ -429,200 +432,200 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count)
 
   count = 0;
   for (pCurrentAddress = pAddresses;
-      pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next)
-  {
-    if (pCurrentAddress->OperStatus == IfOperStatusUp)
+       pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next)
     {
-      IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL;
-      for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL;
-          unicast = unicast->Next)
-      {
-        if ((unicast->Address.lpSockaddr->sa_family == AF_INET ||
-            unicast->Address.lpSockaddr->sa_family == AF_INET6) &&
-            (unicast->DadState == IpDadStateDeprecated ||
-            unicast->DadState == IpDadStatePreferred))
-          count += 1;
-      }
+      if (pCurrentAddress->OperStatus == IfOperStatusUp)
+        {
+          IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL;
+          for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL;
+               unicast = unicast->Next)
+            {
+              if ((unicast->Address.lpSockaddr->sa_family == AF_INET ||
+                   unicast->Address.lpSockaddr->sa_family == AF_INET6) &&
+                  (unicast->DadState == IpDadStateDeprecated ||
+                   unicast->DadState == IpDadStatePreferred))
+                count += 1;
+            }
+        }
     }
-  }
 
   if (count == 0)
-  {
-    *results = NULL;
-    *results_count = 0;
-    GNUNET_free (pAddresses);
-    GNUNET_free_non_null (interfaces4);
-    GNUNET_free_non_null (interfaces6);
-    return GNUNET_OK;
-  }
-
-  *results = (struct EnumNICs3_results *) GNUNET_malloc (
-      sizeof (struct EnumNICs3_results) * count);
+    {
+      *results = NULL;
+      *results_count = 0;
+      GNUNET_free(pAddresses);
+      GNUNET_free_non_null(interfaces4);
+      GNUNET_free_non_null(interfaces6);
+      return GNUNET_OK;
+    }
+
+  *results = (struct EnumNICs3_results *)GNUNET_malloc(
+    sizeof(struct EnumNICs3_results) * count);
   *results_count = count;
 
   count = 0;
   for (pCurrentAddress = pAddresses;
-      pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next)
-  {
-    struct EnumNICs3_results *r;
-    IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL;
-    if (pCurrentAddress->OperStatus != IfOperStatusUp)
-      continue;
-    for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL;
-        unicast = unicast->Next)
+       pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next)
     {
-      int i, j;
-      int mask_length = -1;
-      char dst[INET6_ADDRSTRLEN + 1];
-
-      if ((unicast->Address.lpSockaddr->sa_family != AF_INET &&
-          unicast->Address.lpSockaddr->sa_family != AF_INET6) ||
-          (unicast->DadState != IpDadStateDeprecated &&
-          unicast->DadState != IpDadStatePreferred))
+      struct EnumNICs3_results *r;
+      IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL;
+      if (pCurrentAddress->OperStatus != IfOperStatusUp)
         continue;
-
-      r = &(*results)[count];
-      r->flags = 0;
-      if (pCurrentAddress->IfIndex > 0 &&
-          pCurrentAddress->IfIndex == best_interface &&
-          unicast->Address.lpSockaddr->sa_family == AF_INET)
-        r->is_default = 1;
-      else if (pCurrentAddress->Ipv6IfIndex > 0 &&
-          pCurrentAddress->Ipv6IfIndex == best_interface6 &&
-          unicast->Address.lpSockaddr->sa_family == AF_INET6)
-        r->is_default = 1;
-      else
-        r->is_default = 0;
-
-      /* Don't choose default interface twice */
-      if (r->is_default)
-        best_interface = best_interface6 = 0;
-
-      if (!use_enum2)
-      {
-        GNUNET_memcpy (&r->address, unicast->Address.lpSockaddr,
-            unicast->Address.iSockaddrLength);
-        memset (&r->mask, 0, sizeof (struct sockaddr));
-        mask_length = ((IP_ADAPTER_UNICAST_ADDRESS_VISTA *) unicast)->
-              OnLinkPrefixLength;
-        /* OnLinkPrefixLength is the number of leading 1s in the mask.
-         * OnLinkPrefixLength is available on Vista and later (hence use_enum2).
-         */
-        if (unicast->Address.lpSockaddr->sa_family == AF_INET)
-        {
-          struct sockaddr_in *m = (struct sockaddr_in *) &r->mask;
-          for (i = 0; i < mask_length; i++)
-              ((unsigned char *) &m->sin_addr)[i / 8] |= 0x80 >> (i % 8);
-        }
-        else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
-        {
-          struct sockaddr_in6 *m = (struct sockaddr_in6 *) &r->mask;
-          struct sockaddr_in6 *b = (struct sockaddr_in6 *) &r->broadcast;
-          for (i = 0; i < mask_length; i++)
-            ((unsigned char *) &m->sin6_addr)[i / 8] |= 0x80 >> (i % 8);
-          GNUNET_memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength);
-          for (i = mask_length; i < 128; i++)
-            ((unsigned char *) &b->sin6_addr)[i / 8] |= 0x80 >> (i % 8);
-        }
-        r->flags |= ENUMNICS3_MASK_OK;
-      }
-      else
-      {
-        int found = 0;
-        if (unicast->Address.lpSockaddr->sa_family == AF_INET)
+      for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL;
+           unicast = unicast->Next)
         {
-          for (i = 0; !found && i < interfaces4_len / sizeof (INTERFACE_INFO); i++)
-          {
-            struct sockaddr_in *m = (struct sockaddr_in *) &r->mask;
-            GNUNET_memcpy (&interfaces4[i].iiAddress.Address,
-                unicast->Address.lpSockaddr,
-                unicast->Address.iSockaddrLength);
-            found = 1;
-            GNUNET_memcpy (&r->address, &interfaces4[i].iiAddress.Address,
-                sizeof (struct sockaddr_in));
-            GNUNET_memcpy (&r->mask, &interfaces4[i].iiNetmask.Address,
-                sizeof (struct sockaddr_in));
-            for (mask_length = 0;
-                ((unsigned char *) &m->sin_addr)[mask_length / 8] &
-                0x80 >> (mask_length % 8); mask_length++)
+          int i, j;
+          int mask_length = -1;
+          char dst[INET6_ADDRSTRLEN + 1];
+
+          if ((unicast->Address.lpSockaddr->sa_family != AF_INET &&
+               unicast->Address.lpSockaddr->sa_family != AF_INET6) ||
+              (unicast->DadState != IpDadStateDeprecated &&
+               unicast->DadState != IpDadStatePreferred))
+            continue;
+
+          r = &(*results)[count];
+          r->flags = 0;
+          if (pCurrentAddress->IfIndex > 0 &&
+              pCurrentAddress->IfIndex == best_interface &&
+              unicast->Address.lpSockaddr->sa_family == AF_INET)
+            r->is_default = 1;
+          else if (pCurrentAddress->Ipv6IfIndex > 0 &&
+                   pCurrentAddress->Ipv6IfIndex == best_interface6 &&
+                   unicast->Address.lpSockaddr->sa_family == AF_INET6)
+            r->is_default = 1;
+          else
+            r->is_default = 0;
+
+          /* Don't choose default interface twice */
+          if (r->is_default)
+            best_interface = best_interface6 = 0;
+
+          if (!use_enum2)
             {
+              GNUNET_memcpy(&r->address, unicast->Address.lpSockaddr,
+                            unicast->Address.iSockaddrLength);
+              memset(&r->mask, 0, sizeof(struct sockaddr));
+              mask_length = ((IP_ADAPTER_UNICAST_ADDRESS_VISTA *)unicast)->
+                            OnLinkPrefixLength;
+              /* OnLinkPrefixLength is the number of leading 1s in the mask.
+               * OnLinkPrefixLength is available on Vista and later (hence use_enum2).
+               */
+              if (unicast->Address.lpSockaddr->sa_family == AF_INET)
+                {
+                  struct sockaddr_in *m = (struct sockaddr_in *)&r->mask;
+                  for (i = 0; i < mask_length; i++)
+                    ((unsigned char *)&m->sin_addr)[i / 8] |= 0x80 >> (i % 8);
+                }
+              else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
+                {
+                  struct sockaddr_in6 *m = (struct sockaddr_in6 *)&r->mask;
+                  struct sockaddr_in6 *b = (struct sockaddr_in6 *)&r->broadcast;
+                  for (i = 0; i < mask_length; i++)
+                    ((unsigned char *)&m->sin6_addr)[i / 8] |= 0x80 >> (i % 8);
+                  GNUNET_memcpy(&r->broadcast, &r->address, unicast->Address.iSockaddrLength);
+                  for (i = mask_length; i < 128; i++)
+                    ((unsigned char *)&b->sin6_addr)[i / 8] |= 0x80 >> (i % 8);
+                }
+              r->flags |= ENUMNICS3_MASK_OK;
             }
-            r->flags |= ENUMNICS3_MASK_OK;
-          }
-        }
-        else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
-        {
-          for (i = 0;
-              interfaces6 != NULL && !found && i < interfaces6->iAddressCount;
-              i++)
-          {
-            GNUNET_memcpy (interfaces6->Address[i].lpSockaddr,
-                unicast->Address.lpSockaddr,
-                unicast->Address.iSockaddrLength);
-            found = 1;
-            GNUNET_memcpy (&r->address, interfaces6->Address[i].lpSockaddr,
-                sizeof (struct sockaddr_in6));
-            /* TODO: Find a way to reliably get network mask for IPv6 on XP */
-            memset (&r->mask, 0, sizeof (struct sockaddr));
-            r->flags &= ~ENUMNICS3_MASK_OK;
-          }
-        }
-        if (!found)
-        {
-          DebugBreak ();
+          else
+            {
+              int found = 0;
+              if (unicast->Address.lpSockaddr->sa_family == AF_INET)
+                {
+                  for (i = 0; !found && i < interfaces4_len / sizeof(INTERFACE_INFO); i++)
+                    {
+                      struct sockaddr_in *m = (struct sockaddr_in *)&r->mask;
+                      GNUNET_memcpy(&interfaces4[i].iiAddress.Address,
+                                    unicast->Address.lpSockaddr,
+                                    unicast->Address.iSockaddrLength);
+                      found = 1;
+                      GNUNET_memcpy(&r->address, &interfaces4[i].iiAddress.Address,
+                                    sizeof(struct sockaddr_in));
+                      GNUNET_memcpy(&r->mask, &interfaces4[i].iiNetmask.Address,
+                                    sizeof(struct sockaddr_in));
+                      for (mask_length = 0;
+                           ((unsigned char *)&m->sin_addr)[mask_length / 8] &
+                           0x80 >> (mask_length % 8); mask_length++)
+                        {
+                        }
+                      r->flags |= ENUMNICS3_MASK_OK;
+                    }
+                }
+              else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
+                {
+                  for (i = 0;
+                       interfaces6 != NULL && !found && i < interfaces6->iAddressCount;
+                       i++)
+                    {
+                      GNUNET_memcpy(interfaces6->Address[i].lpSockaddr,
+                                    unicast->Address.lpSockaddr,
+                                    unicast->Address.iSockaddrLength);
+                      found = 1;
+                      GNUNET_memcpy(&r->address, interfaces6->Address[i].lpSockaddr,
+                                    sizeof(struct sockaddr_in6));
+                      /* TODO: Find a way to reliably get network mask for IPv6 on XP */
+                      memset(&r->mask, 0, sizeof(struct sockaddr));
+                      r->flags &= ~ENUMNICS3_MASK_OK;
+                    }
+                }
+              if (!found)
+                {
+                  DebugBreak();
+                }
+            }
+          if (unicast->Address.lpSockaddr->sa_family == AF_INET)
+            {
+              struct sockaddr_in *m = (struct sockaddr_in *)&r->mask;
+              struct sockaddr_in *a = (struct sockaddr_in *)&r->address;
+              /* copy address to broadcast, then flip all the trailing bits not
+               * falling under netmask to 1,
+               * so we get, 192.168.0.255 from, say, 192.168.0.43 with mask == 24.
+               */
+              GNUNET_memcpy(&r->broadcast, &r->address, unicast->Address.iSockaddrLength);
+              for (i = mask_length; i < 32; i++)
+                ((unsigned char *)&m->sin_addr)[i / 8] |= 0x80 >> (i % 8);
+              r->flags |= ENUMNICS3_BCAST_OK;
+              r->addr_size = sizeof(struct sockaddr_in);
+              inet_ntop(AF_INET, &a->sin_addr, dst, INET_ADDRSTRLEN);
+            }
+          else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
+            {
+              struct sockaddr_in6 *a = (struct sockaddr_in6 *)&r->address;
+              /* for IPv6 broadcast is not defined, zero it down */
+              memset(&r->broadcast, 0, sizeof(struct sockaddr));
+              r->flags &= ~ENUMNICS3_BCAST_OK;
+              r->addr_size = sizeof(struct sockaddr_in6);
+              inet_ntop(AF_INET6, &a->sin6_addr, dst, INET6_ADDRSTRLEN);
+            }
+
+          i = 0;
+          i += snprintf(&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0,
+                        "%S (%s", pCurrentAddress->FriendlyName, dst);
+          for (j = 0; j < pCurrentAddress->PhysicalAddressLength; j++)
+            i += snprintf(&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0,
+                          "%s%02X", j > 0 ? ":" : " - ", pCurrentAddress->PhysicalAddress[j]);
+          i += snprintf(&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0, ")");
+          r->pretty_name[1000] = '\0';
+          count += 1;
         }
-      }
-      if (unicast->Address.lpSockaddr->sa_family == AF_INET)
-      {
-        struct sockaddr_in *m = (struct sockaddr_in *) &r->mask;
-        struct sockaddr_in *a = (struct sockaddr_in *) &r->address;
-        /* copy address to broadcast, then flip all the trailing bits not
-         * falling under netmask to 1,
-         * so we get, 192.168.0.255 from, say, 192.168.0.43 with mask == 24.
-         */
-        GNUNET_memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength);
-        for (i = mask_length; i < 32; i++)
-          ((unsigned char *) &m->sin_addr)[i / 8] |= 0x80 >> (i % 8);
-        r->flags |= ENUMNICS3_BCAST_OK;
-        r->addr_size = sizeof (struct sockaddr_in);
-        inet_ntop (AF_INET, &a->sin_addr, dst, INET_ADDRSTRLEN);
-      }
-      else if (unicast->Address.lpSockaddr->sa_family == AF_INET6)
-      {
-        struct sockaddr_in6 *a = (struct sockaddr_in6 *) &r->address;
-        /* for IPv6 broadcast is not defined, zero it down */
-        memset (&r->broadcast, 0, sizeof (struct sockaddr));
-        r->flags &= ~ENUMNICS3_BCAST_OK;
-        r->addr_size = sizeof (struct sockaddr_in6);
-        inet_ntop (AF_INET6, &a->sin6_addr, dst, INET6_ADDRSTRLEN);
-      }
-
-      i = 0;
-      i += snprintf (&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0,
-          "%S (%s", pCurrentAddress->FriendlyName, dst);
-      for (j = 0; j < pCurrentAddress->PhysicalAddressLength; j++)
-        i += snprintf (&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0,
-            "%s%02X",j > 0 ? ":" : " - ", pCurrentAddress->PhysicalAddress[j]);
-      i += snprintf (&r->pretty_name[i], 1000 - i > 0 ? 1000 - i : 0, ")");
-      r->pretty_name[1000] = '\0';
-      count += 1;
     }
-  }
 
   if (use_enum2)
-  {
-    GNUNET_free_non_null (interfaces4);
-    GNUNET_free_non_null (interfaces6);
-  }
+    {
+      GNUNET_free_non_null(interfaces4);
+      GNUNET_free_non_null(interfaces6);
+    }
 
-  GNUNET_free (pAddresses);
+  GNUNET_free(pAddresses);
   return GNUNET_OK;
 }
 
 void
-EnumNICs3_free (struct EnumNICs3_results *r)
+EnumNICs3_free(struct EnumNICs3_results *r)
 {
-  GNUNET_free_non_null (r);
+  GNUNET_free_non_null(r);
 }
 
 
@@ -634,20 +637,20 @@ EnumNICs3_free (struct EnumNICs3_results *r)
  * @param callback_cls closure for callback
  */
 int
-ListNICs (void (*callback) (void *, const char *, int), void * callback_cls)
+ListNICs(void (*callback)(void *, const char *, int), void * callback_cls)
 {
   int r;
   int i;
   struct EnumNICs3_results *results = NULL;
   int results_count;
 
-  r = EnumNICs3 (&results, &results_count);
+  r = EnumNICs3(&results, &results_count);
   if (r != GNUNET_OK)
     return GNUNET_NO;
 
   for (i = 0; i < results_count; i++)
-    callback (callback_cls, results[i].pretty_name, results[i].is_default);
-  GNUNET_free_non_null (results);
+    callback(callback_cls, results[i].pretty_name, results[i].is_default);
+  GNUNET_free_non_null(results);
   return GNUNET_YES;
 }
 
@@ -667,29 +670,29 @@ int InstallAsService(char *servicename, char *application, char *username)
   char szEXE[_MAX_PATH + 17] = "\"";
   char *user = NULL;
 
-  if (! GNOpenSCManager)
+  if (!GNOpenSCManager)
     return 1;
 
   plibc_conv_to_win_path(application, szEXE + 1);
   strcat(szEXE, "\" --win-service");
   hManager = GNOpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
-  if (! hManager)
+  if (!hManager)
     return 2;
 
   if (username)
-  {
-        user = (char *) malloc(strlen(username) + 3);
-        sprintf(user, ".\\%s", username);
-  }
+    {
+      user = (char *)malloc(strlen(username) + 3);
+      sprintf(user, ".\\%s", username);
+    }
 
-  hService = GNCreateService(hManager, (LPCTSTR) servicename, (LPCTSTR) servicename, 0,
-    SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, (LPCTSTR) szEXE,
-    NULL, NULL, NULL, (LPCTSTR) user, (LPCTSTR) username);
+  hService = GNCreateService(hManager, (LPCTSTR)servicename, (LPCTSTR)servicename, 0,
+                             SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, (LPCTSTR)szEXE,
+                             NULL, NULL, NULL, (LPCTSTR)user, (LPCTSTR)username);
 
   if (user)
     free(user);
 
-  if (! hService)
+  if (!hService)
     return 3;
 
   GNCloseServiceHandle(hService);
@@ -712,22 +715,22 @@ UninstallService(char *servicename)
 {
   SC_HANDLE hManager, hService;
 
-  if (! GNOpenSCManager)
+  if (!GNOpenSCManager)
     return 1;
 
   hManager = GNOpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
-  if (! hManager)
+  if (!hManager)
     return 2;
 
-  if (! (hService = GNOpenService(hManager, (LPCTSTR) servicename, DELETE)))
-  {
-    if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
-      return 3;
-    else
-      goto closeSCM;
-  }
+  if (!(hService = GNOpenService(hManager, (LPCTSTR)servicename, DELETE)))
+    {
+      if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
+        return 3;
+      else
+        goto closeSCM;
+    }
 
-  if (! GNDeleteService(hService))
+  if (!GNDeleteService(hService))
     if (GetLastError() != ERROR_SERVICE_MARKED_FOR_DELETE)
       return 4;
 
@@ -747,18 +750,18 @@ _InitLsaString(PLSA_UNICODE_STRING LsaString, LPWSTR String)
 {
   DWORD StringLength;
 
-  if(String == NULL)
-  {
-    LsaString->Buffer = NULL;
-    LsaString->Length = 0;
-    LsaString->MaximumLength = 0;
-    return;
-  }
+  if (String == NULL)
+    {
+      LsaString->Buffer = NULL;
+      LsaString->Length = 0;
+      LsaString->MaximumLength = 0;
+      return;
+    }
 
   StringLength = wcslen(String);
   LsaString->Buffer = String;
-  LsaString->Length = (USHORT) StringLength *sizeof(WCHAR);
-  LsaString->MaximumLength = (USHORT) (StringLength + 1) * sizeof(WCHAR);
+  LsaString->Length = (USHORT)StringLength * sizeof(WCHAR);
+  LsaString->MaximumLength = (USHORT)(StringLength + 1) * sizeof(WCHAR);
 }
 
 
@@ -777,16 +780,16 @@ _OpenPolicy(LPWSTR ServerName, DWORD DesiredAccess, PLSA_HANDLE PolicyHandle)
   /* Always initialize the object attributes to all zeroes. */
   ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
 
-  if(ServerName != NULL)
-  {
-    /* Make a LSA_UNICODE_STRING out of the LPWSTR passed in */
-    _InitLsaString(&ServerString, ServerName);
-    Server = &ServerString;
-  }
+  if (ServerName != NULL)
+    {
+      /* Make a LSA_UNICODE_STRING out of the LPWSTR passed in */
+      _InitLsaString(&ServerString, ServerName);
+      Server = &ServerString;
+    }
 
   /* Attempt to open the policy. */
   return GNLsaOpenPolicy(Server,
-                       &ObjectAttributes, DesiredAccess, PolicyHandle);
+                         &ObjectAttributes, DesiredAccess, PolicyHandle);
 }
 
 /**
@@ -805,61 +808,61 @@ BOOL
 _GetAccountSid(LPCTSTR SystemName, LPCTSTR AccountName, PSID * Sid)
 {
   LPTSTR ReferencedDomain = NULL;
-  DWORD cbSid = 128;                                                    /* initial allocation attempt */
-  DWORD cchReferencedDomain = 16;       /* initial allocation size */
+  DWORD cbSid = 128;                                                    /* initial allocation attempt */
+  DWORD cchReferencedDomain = 16;       /* initial allocation size */
   SID_NAME_USE peUse;
-  BOOL bSuccess = FALSE;                                        /* assume this function will fail */
+  BOOL bSuccess = FALSE;                                        /* assume this function will fail */
 
   /* initial memory allocations */
-  if ((*Sid = HeapAlloc (GetProcessHeap (), 0, cbSid)) == NULL)
-        return FALSE;
-
-  if ((ReferencedDomain = (LPTSTR) HeapAlloc (GetProcessHeap (),
-                                    0,
-                                    cchReferencedDomain *
-                                    sizeof (TCHAR))) == NULL)
-        return FALSE;
-
-    /* Obtain the SID of the specified account on the specified system. */
-        while (!GNLookupAccountName(SystemName, /* machine to lookup account on */
-                   AccountName,                                                                                         /* account to lookup */
-                   *Sid,                                                                                                                        /* SID of interest */
-                   &cbSid,                                                                                                              /* size of SID */
-                   ReferencedDomain,                                                                    /* domain account was found on */
-                   &cchReferencedDomain, &peUse))
-        {
-                if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-                {
-                        /* reallocate memory */
-                        if ((*Sid = HeapReAlloc (GetProcessHeap (), 0, *Sid, cbSid)) == NULL)
-                                return FALSE;
-
-                        if ((ReferencedDomain = (LPTSTR) HeapReAlloc (GetProcessHeap (),
-                                              0,
-                                              ReferencedDomain,
-                                              cchReferencedDomain
-                                              * sizeof (TCHAR))) == NULL)
-                                return FALSE;
-      }
+  if ((*Sid = HeapAlloc(GetProcessHeap(), 0, cbSid)) == NULL)
+    return FALSE;
+
+  if ((ReferencedDomain = (LPTSTR)HeapAlloc(GetProcessHeap(),
+                                            0,
+                                            cchReferencedDomain *
+                                            sizeof(TCHAR))) == NULL)
+    return FALSE;
+
+  /* Obtain the SID of the specified account on the specified system. */
+  while (!GNLookupAccountName(SystemName,       /* machine to lookup account on */
+                              AccountName,                                                                              /* account to lookup */
+                              *Sid,                                                                                                             /* SID of interest */
+                              &cbSid,                                                                                                   /* size of SID */
+                              ReferencedDomain,                                                         /* domain account was found on */
+                              &cchReferencedDomain, &peUse))
+    {
+      if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+          /* reallocate memory */
+          if ((*Sid = HeapReAlloc(GetProcessHeap(), 0, *Sid, cbSid)) == NULL)
+            return FALSE;
+
+          if ((ReferencedDomain = (LPTSTR)HeapReAlloc(GetProcessHeap(),
+                                                      0,
+                                                      ReferencedDomain,
+                                                      cchReferencedDomain
+                                                      * sizeof(TCHAR))) == NULL)
+            return FALSE;
+        }
       else
         goto end;
-  }
+    }
 
   /* Indicate success. */
   bSuccess = TRUE;
 
 end:
   /* Cleanup and indicate failure, if appropriate. */
-  HeapFree (GetProcessHeap (), 0, ReferencedDomain);
+  HeapFree(GetProcessHeap(), 0, ReferencedDomain);
 
   if (!bSuccess)
-  {
-    if (*Sid != NULL)
     {
-                HeapFree (GetProcessHeap (), 0, *Sid);
-                *Sid = NULL;
+      if (*Sid != NULL)
+        {
+          HeapFree(GetProcessHeap(), 0, *Sid);
+          *Sid = NULL;
+        }
     }
-  }
 
   return bSuccess;
 }
@@ -871,10 +874,10 @@ end:
  */
 NTSTATUS
 _SetPrivilegeOnAccount(LSA_HANDLE PolicyHandle,/* open policy handle */
-                       PSID AccountSid,                         /* SID to grant privilege to */
-                       LPWSTR PrivilegeName,    /* privilege to grant (Unicode) */
-                       BOOL bEnable                                             /* enable or disable */
-  )
+                       PSID AccountSid,                         /* SID to grant privilege to */
+                       LPWSTR PrivilegeName,    /* privilege to grant (Unicode) */
+                       BOOL bEnable                                             /* enable or disable */
+                       )
 {
   LSA_UNICODE_STRING PrivilegeString;
 
@@ -882,26 +885,26 @@ _SetPrivilegeOnAccount(LSA_HANDLE PolicyHandle,/* open policy handle */
   _InitLsaString(&PrivilegeString, PrivilegeName);
 
   /* grant or revoke the privilege, accordingly */
-  if(bEnable)
-  {
-    NTSTATUS i;
-
-    i = GNLsaAddAccountRights(PolicyHandle,                             /* open policy handle */
-                               AccountSid,                              /* target SID */
-                               &PrivilegeString,        /* privileges */
-                               1                                                                                        /* privilege count */
-      );
-    return i;
-  }
+  if (bEnable)
+    {
+      NTSTATUS i;
+
+      i = GNLsaAddAccountRights(PolicyHandle,                           /* open policy handle */
+                                AccountSid,                             /* target SID */
+                                &PrivilegeString,       /* privileges */
+                                1                                                                                       /* privilege count */
+                                );
+      return i;
+    }
   else
-  {
-    return GNLsaRemoveAccountRights(PolicyHandle,                       /* open policy handle */
-                                  AccountSid,                           /* target SID */
-                                  FALSE,                                                        /* do not disable all rights */
-                                  &PrivilegeString,             /* privileges */
-                                  1                                                                             /* privilege count */
-      );
-  }
+    {
+      return GNLsaRemoveAccountRights(PolicyHandle,                     /* open policy handle */
+                                      AccountSid,                       /* target SID */
+                                      FALSE,                                                    /* do not disable all rights */
+                                      &PrivilegeString,         /* privileges */
+                                      1                                                                         /* privilege count */
+                                      );
+    }
 }
 
 /**
@@ -921,8 +924,8 @@ CreateServiceAccount(const char *pszName,
   LSA_HANDLE hPolicy;
   PSID pSID;
 
-  if (! GNNetUserAdd)
-        return 1;
+  if (!GNNetUserAdd)
+    return 1;
   mbstowcs(wszName, pszName, strlen(pszName) + 1);
   mbstowcs(wszDesc, pszDesc, strlen(pszDesc) + 1);
 
@@ -936,22 +939,22 @@ CreateServiceAccount(const char *pszName,
   nStatus = GNNetUserAdd(NULL, 1, (LPBYTE)&ui, NULL);
 
   if (nStatus != NERR_Success && nStatus != NERR_UserExists)
-        return 2;
+    return 2;
 
   ui2.usri1008_flags = UF_PASSWD_CANT_CHANGE | UF_DONT_EXPIRE_PASSWD;
   GNNetUserSetInfo(NULL, wszName, 1008, (LPBYTE)&ui2, NULL);
 
   if (!NT_SUCCESS(_OpenPolicy(NULL, POLICY_ALL_ACCESS, &hPolicy)))
-        return 3;
+    return 3;
 
-  _GetAccountSid(NULL, (LPCTSTR) pszName, &pSID);
+  _GetAccountSid(NULL, (LPCTSTR)pszName, &pSID);
 
-  if (!NT_SUCCESS(_SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR) L"SeServiceLogonRight", TRUE)))
-        return 4;
+  if (!NT_SUCCESS(_SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR)L"SeServiceLogonRight", TRUE)))
+    return 4;
 
-  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR) L"SeDenyInteractiveLogonRight", TRUE);
-  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR) L"SeDenyBatchLogonRight", TRUE);
-  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR) L"SeDenyNetworkLogonRight", TRUE);
+  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR)L"SeDenyInteractiveLogonRight", TRUE);
+  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR)L"SeDenyBatchLogonRight", TRUE);
+  _SetPrivilegeOnAccount(hPolicy, pSID, (LPWSTR)L"SeDenyNetworkLogonRight", TRUE);
 
   GNLsaClose(hPolicy);
 
@@ -967,113 +970,122 @@ CreateServiceAccount(const char *pszName,
  * @remark based on http://support.microsoft.com/default.aspx?scid=KB;EN-US;Q102102&
  */
 BOOL AddPathAccessRights(char *lpszFileName, char *lpszAccountName,
-      DWORD dwAccessMask)
+                         DWORD dwAccessMask)
 {
   /* SID variables. */
-  SID_NAME_USE   snuType;
-  TCHAR *        szDomain       = NULL;
-  DWORD          cbDomain       = 0;
-  LPVOID         pUserSID       = NULL;
-  DWORD          cbUserSID      = 0;
+  SID_NAME_USE snuType;
+  TCHAR *        szDomain = NULL;
+  DWORD cbDomain = 0;
+  LPVOID pUserSID = NULL;
+  DWORD cbUserSID = 0;
 
   /* File SD variables. */
-  PSECURITY_DESCRIPTOR pFileSD  = NULL;
-  DWORD          cbFileSD       = 0;
+  PSECURITY_DESCRIPTOR pFileSD = NULL;
+  DWORD cbFileSD = 0;
 
   /* New SD variables. */
-  SECURITY_DESCRIPTOR  newSD;
+  SECURITY_DESCRIPTOR newSD;
 
   /* ACL variables. */
-  PACL           pACL           = NULL;
-  BOOL           fDaclPresent;
-  BOOL           fDaclDefaulted;
+  PACL pACL = NULL;
+  BOOL fDaclPresent;
+  BOOL fDaclDefaulted;
   ACL_SIZE_INFORMATION AclInfo;
 
   /* New ACL variables. */
-  PACL           pNewACL        = NULL;
-  DWORD          cbNewACL       = 0;
+  PACL pNewACL = NULL;
+  DWORD cbNewACL = 0;
 
   /* Temporary ACE. */
-  LPVOID         pTempAce       = NULL;
-  UINT           CurrentAceIndex = 0;
+  LPVOID pTempAce = NULL;
+  UINT CurrentAceIndex = 0;
 
-  UINT           newAceIndex = 0;
+  UINT newAceIndex = 0;
 
   /* Assume function will fail. */
-  BOOL           fResult        = FALSE;
-  BOOL           fAPISuccess;
+  BOOL fResult = FALSE;
+  BOOL fAPISuccess;
 
   SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;
 
   /**
    * STEP 1: Get SID of the account name specified.
    */
-  fAPISuccess = GNLookupAccountName(NULL, (LPCTSTR) lpszAccountName,
-        pUserSID, &cbUserSID, (LPTSTR) szDomain, &cbDomain, &snuType);
+  fAPISuccess = GNLookupAccountName(NULL, (LPCTSTR)lpszAccountName,
+                                    pUserSID, &cbUserSID, (LPTSTR)szDomain, &cbDomain, &snuType);
 
   /* API should have failed with insufficient buffer. */
   if (fAPISuccess)
-     goto end;
-  else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-     goto end;
-  }
+    goto end;
+  else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+    {
+      goto end;
+    }
 
   pUserSID = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbUserSID);
-  if (!pUserSID) {
-     goto end;
-  }
+  if (!pUserSID)
+    {
+      goto end;
+    }
 
-  szDomain = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbDomain * sizeof(TCHAR));
-  if (!szDomain) {
-     goto end;
-  }
+  szDomain = (TCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbDomain * sizeof(TCHAR));
+  if (!szDomain)
+    {
+      goto end;
+    }
 
-  fAPISuccess = GNLookupAccountName(NULL, (LPCTSTR) lpszAccountName,
-        pUserSID, &cbUserSID, (LPTSTR) szDomain, &cbDomain, &snuType);
-  if (!fAPISuccess) {
-     goto end;
-  }
+  fAPISuccess = GNLookupAccountName(NULL, (LPCTSTR)lpszAccountName,
+                                    pUserSID, &cbUserSID, (LPTSTR)szDomain, &cbDomain, &snuType);
+  if (!fAPISuccess)
+    {
+      goto end;
+    }
 
   /**
    *  STEP 2: Get security descriptor (SD) of the file specified.
    */
-  fAPISuccess = GNGetFileSecurity((LPCTSTR) lpszFileName,
-        secInfo, pFileSD, 0, &cbFileSD);
+  fAPISuccess = GNGetFileSecurity((LPCTSTR)lpszFileName,
+                                  secInfo, pFileSD, 0, &cbFileSD);
 
   /* API should have failed with insufficient buffer. */
   if (fAPISuccess)
-     goto end;
-  else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-     goto end;
-  }
-
-  pFileSD = (PSECURITY_DESCRIPTOR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
-        cbFileSD);
-  if (!pFileSD) {
-     goto end;
-  }
-
-  fAPISuccess = GNGetFileSecurity((LPCTSTR) lpszFileName,
-        secInfo, pFileSD, cbFileSD, &cbFileSD);
-  if (!fAPISuccess) {
-     goto end;
-  }
+    goto end;
+  else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+    {
+      goto end;
+    }
+
+  pFileSD = (PSECURITY_DESCRIPTOR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                            cbFileSD);
+  if (!pFileSD)
+    {
+      goto end;
+    }
+
+  fAPISuccess = GNGetFileSecurity((LPCTSTR)lpszFileName,
+                                  secInfo, pFileSD, cbFileSD, &cbFileSD);
+  if (!fAPISuccess)
+    {
+      goto end;
+    }
 
   /**
    * STEP 3: Initialize new SD.
    */
   if (!GNInitializeSecurityDescriptor(&newSD,
-        SECURITY_DESCRIPTOR_REVISION)) {
-     goto end;
-  }
+                                      SECURITY_DESCRIPTOR_REVISION))
+    {
+      goto end;
+    }
 
   /**
    * STEP 4: Get DACL from the old SD.
    */
   if (!GNGetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL,
-        &fDaclDefaulted)) {
-     goto end;
-  }
+                                   &fDaclDefaulted))
+    {
+      goto end;
+    }
 
   /**
    * STEP 5: Get size information for DACL.
@@ -1083,37 +1095,40 @@ BOOL AddPathAccessRights(char *lpszFileName, char *lpszAccountName,
   AclInfo.AclBytesInUse = sizeof(ACL);
 
   if (pACL == NULL)
-     fDaclPresent = FALSE;
+    fDaclPresent = FALSE;
 
   /* If not NULL DACL, gather size information from DACL. */
-  if (fDaclPresent) {
-
-     if (!GNGetAclInformation(pACL, &AclInfo,
-           sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
-        goto end;
-     }
-  }
+  if (fDaclPresent)
+    {
+      if (!GNGetAclInformation(pACL, &AclInfo,
+                               sizeof(ACL_SIZE_INFORMATION), AclSizeInformation))
+        {
+          goto end;
+        }
+    }
 
   /**
    * STEP 6: Compute size needed for the new ACL.
    */
   cbNewACL = AclInfo.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE)
-        + GetLengthSid(pUserSID) - sizeof(DWORD);
+             + GetLengthSid(pUserSID) - sizeof(DWORD);
 
   /**
    * STEP 7: Allocate memory for new ACL.
    */
-  pNewACL = (PACL) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbNewACL);
-  if (!pNewACL) {
-     goto end;
-  }
+  pNewACL = (PACL)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbNewACL);
+  if (!pNewACL)
+    {
+      goto end;
+    }
 
   /**
    * STEP 8: Initialize the new ACL.
    */
-  if (!GNInitializeAcl(pNewACL, cbNewACL, ACL_REVISION2)) {
-     goto end;
-  }
+  if (!GNInitializeAcl(pNewACL, cbNewACL, ACL_REVISION2))
+    {
+      goto end;
+    }
 
   /**
    * STEP 9 If DACL is present, copy all the ACEs from the old DACL
@@ -1128,51 +1143,53 @@ BOOL AddPathAccessRights(char *lpszFileName, char *lpszAccountName,
 
   newAceIndex = 0;
 
-  if (fDaclPresent && AclInfo.AceCount) {
-
-     for (CurrentAceIndex = 0;
+  if (fDaclPresent && AclInfo.AceCount)
+    {
+      for (CurrentAceIndex = 0;
            CurrentAceIndex < AclInfo.AceCount;
-           CurrentAceIndex++) {
+           CurrentAceIndex++)
+        {
+          /**
+           * TEP 10: Get an ACE.
+           */
+          if (!GNGetAce(pACL, CurrentAceIndex, &pTempAce))
+            {
+              goto end;
+            }
 
-        /**
-         * TEP 10: Get an ACE.
-         */
-        if (!GNGetAce(pACL, CurrentAceIndex, &pTempAce)) {
-           goto end;
-        }
+          /**
+           * STEP 11: Check if it is a non-inherited ACE.
+           * If it is an inherited ACE, break from the loop so
+           * that the new access allowed non-inherited ACE can
+           * be added in the correct position, immediately after
+           * all non-inherited ACEs.
+           */
+          if (((ACCESS_ALLOWED_ACE *)pTempAce)->Header.AceFlags
+              & INHERITED_ACE)
+            break;
+
+          /**
+           * STEP 12: Skip adding the ACE, if the SID matches
+           * with the account specified, as we are going to
+           * add an access allowed ACE with a different access
+           * mask.
+           */
+          if (GNEqualSid(pUserSID,
+                         &(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
+            continue;
+
+          /**
+           * STEP 13: Add the ACE to the new ACL.
+           */
+          if (!GNAddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
+                        ((PACE_HEADER)pTempAce)->AceSize))
+            {
+              goto end;
+            }
 
-        /**
-         * STEP 11: Check if it is a non-inherited ACE.
-         * If it is an inherited ACE, break from the loop so
-         * that the new access allowed non-inherited ACE can
-         * be added in the correct position, immediately after
-         * all non-inherited ACEs.
-         */
-        if (((ACCESS_ALLOWED_ACE *)pTempAce)->Header.AceFlags
-           & INHERITED_ACE)
-           break;
-
-        /**
-         * STEP 12: Skip adding the ACE, if the SID matches
-         * with the account specified, as we are going to
-         * add an access allowed ACE with a different access
-         * mask.
-         */
-        if (GNEqualSid(pUserSID,
-           &(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
-           continue;
-
-        /**
-         * STEP 13: Add the ACE to the new ACL.
-         */
-        if (!GNAddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
-              ((PACE_HEADER) pTempAce)->AceSize)) {
-           goto end;
+          newAceIndex++;
         }
-
-        newAceIndex++;
-     }
-  }
+    }
 
   /**
    * STEP 14: Add the access-allowed ACE to the new DACL.
@@ -1180,9 +1197,10 @@ BOOL AddPathAccessRights(char *lpszFileName, char *lpszAccountName,
    * immediately after all existing non-inherited ACEs.
    */
   if (!GNAddAccessAllowedAce(pNewACL, ACL_REVISION2, dwAccessMask,
-        pUserSID)) {
-     goto end;
-  }
+                             pUserSID))
+    {
+      goto end;
+    }
 
   /**
    * STEP 14.5: Make new ACE inheritable
@@ -1197,36 +1215,39 @@ BOOL AddPathAccessRights(char *lpszFileName, char *lpszAccountName,
    * we will now copy the rest of inherited ACEs from the
    * old DACL to the new DACL.
    */
-  if (fDaclPresent && AclInfo.AceCount) {
-
-     for (;
-          CurrentAceIndex < AclInfo.AceCount;
-          CurrentAceIndex++) {
-
-        /**
-         * STEP 16: Get an ACE.
-         */
-        if (!GNGetAce(pACL, CurrentAceIndex, &pTempAce)) {
-           goto end;
-        }
+  if (fDaclPresent && AclInfo.AceCount)
+    {
+      for (;
+           CurrentAceIndex < AclInfo.AceCount;
+           CurrentAceIndex++)
+        {
+          /**
+           * STEP 16: Get an ACE.
+           */
+          if (!GNGetAce(pACL, CurrentAceIndex, &pTempAce))
+            {
+              goto end;
+            }
 
-        /**
-         * STEP 17: Add the ACE to the new ACL.
-         */
-        if (!GNAddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
-              ((PACE_HEADER) pTempAce)->AceSize)) {
-           goto end;
+          /**
+           * STEP 17: Add the ACE to the new ACL.
+           */
+          if (!GNAddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
+                        ((PACE_HEADER)pTempAce)->AceSize))
+            {
+              goto end;
+            }
         }
-     }
-  }
+    }
 
   /**
    * STEP 18: Set permissions
    */
-  if (GNSetNamedSecurityInfo((LPTSTR) lpszFileName, SE_FILE_OBJECT,
-    DACL_SECURITY_INFORMATION, NULL, NULL, pNewACL, NULL) != ERROR_SUCCESS) {
-        goto end;
-  }
+  if (GNSetNamedSecurityInfo((LPTSTR)lpszFileName, SE_FILE_OBJECT,
+                             DACL_SECURITY_INFORMATION, NULL, NULL, pNewACL, NULL) != ERROR_SUCCESS)
+    {
+      goto end;
+    }
 
   fResult = TRUE;
 
@@ -1236,16 +1257,16 @@ end:
    * STEP 19: Free allocated memory
    */
   if (pUserSID)
-     HeapFree(GetProcessHeap(), 0, pUserSID);
+    HeapFree(GetProcessHeap(), 0, pUserSID);
 
   if (szDomain)
-     HeapFree(GetProcessHeap(), 0, szDomain);
+    HeapFree(GetProcessHeap(), 0, szDomain);
 
   if (pFileSD)
-     HeapFree(GetProcessHeap(), 0, pFileSD);
+    HeapFree(GetProcessHeap(), 0, pFileSD);
 
   if (pNewACL)
-     HeapFree(GetProcessHeap(), 0, pNewACL);
+    HeapFree(GetProcessHeap(), 0, pNewACL);
 
   return fResult;
 }
@@ -1255,15 +1276,15 @@ char *winErrorStr(const char *prefix, int dwErr)
   char *err, *ret;
   int mem;
 
-  if (! FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-    NULL, (DWORD) dwErr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &err,
-    0, NULL ))
-  {
-    err = (char *) LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, 1);
-  }
+  if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+                     NULL, (DWORD)dwErr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&err,
+                     0, NULL))
+    {
+      err = (char *)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, 1);
+    }
 
   mem = strlen(err) + strlen(prefix) + 20;
-  ret = (char *) malloc(mem);
+  ret = (char *)malloc(mem);
 
   snprintf(ret, mem, "%s: %s (#%u)", prefix, err, dwErr);
 
@@ -1285,58 +1306,58 @@ char *winErrorStr(const char *prefix, int dwErr)
  * @return TRUE on success, FALSE on failure (check last error for the code)
  */
 BOOL
-SafeTerminateProcess (HANDLE hProcess, UINT uExitCode, DWORD dwTimeout)
+SafeTerminateProcess(HANDLE hProcess, UINT uExitCode, DWORD dwTimeout)
 {
   DWORD dwTID, dwCode, dwErr = 0;
   HANDLE hProcessDup = INVALID_HANDLE_VALUE;
   HANDLE hRT = NULL;
-  HINSTANCE hKernel = GetModuleHandle ("Kernel32");
+  HINSTANCE hKernel = GetModuleHandle("Kernel32");
   BOOL bSuccess = FALSE;
 
-  BOOL bDup = DuplicateHandle (GetCurrentProcess (), hProcess,
-      GetCurrentProcess (), &hProcessDup, PROCESS_ALL_ACCESS,
-      FALSE, 0);
+  BOOL bDup = DuplicateHandle(GetCurrentProcess(), hProcess,
+                              GetCurrentProcess(), &hProcessDup, PROCESS_ALL_ACCESS,
+                              FALSE, 0);
 
   /* Detect the special case where the process is
    * already dead...
    */
-  if (GetExitCodeProcess (bDup ? hProcessDup : hProcess, &dwCode) &&
-      (STILL_ACTIVE ==  dwCode))
-  {
-    FARPROC pfnExitProc;
+  if (GetExitCodeProcess(bDup ? hProcessDup : hProcess, &dwCode) &&
+      (STILL_ACTIVE == dwCode))
+    {
+      FARPROC pfnExitProc;
 
-    pfnExitProc = GetProcAddress (hKernel, "ExitProcess");
+      pfnExitProc = GetProcAddress(hKernel, "ExitProcess");
 
-    hRT = CreateRemoteThread ((bDup) ? hProcessDup : hProcess, NULL, 0,
-        (LPTHREAD_START_ROUTINE) pfnExitProc, (PVOID) uExitCode, 0, &dwTID);
+      hRT = CreateRemoteThread((bDup) ? hProcessDup : hProcess, NULL, 0,
+                               (LPTHREAD_START_ROUTINE)pfnExitProc, (PVOID)uExitCode, 0, &dwTID);
 
-    dwErr = GetLastError ();
-  }
+      dwErr = GetLastError();
+    }
   else
-  {
-    dwErr = ERROR_PROCESS_ABORTED;
-  }
+    {
+      dwErr = ERROR_PROCESS_ABORTED;
+    }
 
   if (hRT)
-  {
-    /* Must wait process to terminate to
-     * guarantee that it has exited...
-     */
-    DWORD dwWaitResult = WaitForSingleObject ((bDup) ? hProcessDup : hProcess,
-        dwTimeout);
-    if (dwWaitResult == WAIT_TIMEOUT)
-      dwErr = WAIT_TIMEOUT;
-    else
-      dwErr = GetLastError ();
-
-    CloseHandle (hRT);
-    bSuccess = dwErr == NO_ERROR;
-  }
+    {
+      /* Must wait process to terminate to
+       * guarantee that it has exited...
+       */
+      DWORD dwWaitResult = WaitForSingleObject((bDup) ? hProcessDup : hProcess,
+                                               dwTimeout);
+      if (dwWaitResult == WAIT_TIMEOUT)
+        dwErr = WAIT_TIMEOUT;
+      else
+        dwErr = GetLastError();
+
+      CloseHandle(hRT);
+      bSuccess = dwErr == NO_ERROR;
+    }
 
   if (bDup)
-    CloseHandle (hProcessDup);
+    CloseHandle(hProcessDup);
 
-  SetLastError (dwErr);
+  SetLastError(dwErr);
 
   return bSuccess;
 }
diff --git a/src/util/winproc.c b/src/util/winproc.c
index 2781b901f..f2e4de4df 100644
--- a/src/util/winproc.c
+++ b/src/util/winproc.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 util/winproc.c
@@ -69,15 +69,15 @@ TAddAce GNAddAce;
 TAddAccessAllowedAce GNAddAccessAllowedAce;
 TSetNamedSecurityInfo GNSetNamedSecurityInfo;
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util-winproc", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "util-winproc", __VA_ARGS__)
 /**
  * Log (panic) messages from PlibC
  */
 void
-plibc_panic (int err, char *msg)
+plibc_panic(int err, char *msg)
 {
-  LOG (((err == INT_MAX) ? GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_ERROR),
-       "%s", msg);
+  LOG(((err == INT_MAX) ? GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_ERROR),
+      "%s", msg);
 }
 
 #ifdef W32_VEH
@@ -91,45 +91,46 @@ plibc_panic (int err, char *msg)
  * only way out of WaitForSingleObject() is to time out after 1 minute).
  */
 LONG __stdcall
-GNWinVEH (PEXCEPTION_POINTERS ExceptionInfo)
+GNWinVEH(PEXCEPTION_POINTERS ExceptionInfo)
 {
   char debugger[MAX_PATH + 1];
   char *debugger_env = NULL;
-  if (IsDebuggerPresent ())
-  {
-    DebugBreak ();
-    return EXCEPTION_CONTINUE_EXECUTION;
-  }
-  debugger_env = getenv ("GNUNET_DEBUGGER");
+
+  if (IsDebuggerPresent())
+    {
+      DebugBreak();
+      return EXCEPTION_CONTINUE_EXECUTION;
+    }
+  debugger_env = getenv("GNUNET_DEBUGGER");
   if (debugger_env != NULL)
-  {
-    STARTUPINFO si;
-    PROCESS_INFORMATION pi;
-    HANDLE event;
-    SECURITY_ATTRIBUTES sa;
-    memset (&si, 0, sizeof (si));
-    si.cb = sizeof (si);
-    memset (&pi, 0, sizeof (pi));
-    memset (&sa, 0, sizeof (sa));
-    sa.nLength = sizeof (sa);
-    sa.bInheritHandle = TRUE;
-    event = CreateEvent (&sa, FALSE, FALSE, NULL);
-    snprintf (debugger, MAX_PATH + 1, debugger_env, GetCurrentProcessId (), (uintptr_t) event);
-    debugger[MAX_PATH] = '\0';
-    if (0 != CreateProcessA (NULL, debugger, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
     {
-      CloseHandle (pi.hProcess);
-      CloseHandle (pi.hThread);
-      WaitForSingleObject (event, 60000);
-      CloseHandle (event);
-      if (IsDebuggerPresent ())
-      {
-        return EXCEPTION_CONTINUE_EXECUTION;
-      }
+      STARTUPINFO si;
+      PROCESS_INFORMATION pi;
+      HANDLE event;
+      SECURITY_ATTRIBUTES sa;
+      memset(&si, 0, sizeof(si));
+      si.cb = sizeof(si);
+      memset(&pi, 0, sizeof(pi));
+      memset(&sa, 0, sizeof(sa));
+      sa.nLength = sizeof(sa);
+      sa.bInheritHandle = TRUE;
+      event = CreateEvent(&sa, FALSE, FALSE, NULL);
+      snprintf(debugger, MAX_PATH + 1, debugger_env, GetCurrentProcessId(), (uintptr_t)event);
+      debugger[MAX_PATH] = '\0';
+      if (0 != CreateProcessA(NULL, debugger, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
+        {
+          CloseHandle(pi.hProcess);
+          CloseHandle(pi.hThread);
+          WaitForSingleObject(event, 60000);
+          CloseHandle(event);
+          if (IsDebuggerPresent())
+            {
+              return EXCEPTION_CONTINUE_EXECUTION;
+            }
+        }
+      else
+        CloseHandle(event);
     }
-    else
-      CloseHandle (event);
-  }
   return EXCEPTION_CONTINUE_SEARCH;
 }
 #endif
@@ -138,168 +139,168 @@ GNWinVEH (PEXCEPTION_POINTERS ExceptionInfo)
  * @brief Initialize PlibC and set up Windows environment
  * @param logging context, NULL means stderr
  * @return Error code from winerror.h, ERROR_SUCCESS on success
-*/
+ */
 int
-GNInitWinEnv ()
+GNInitWinEnv()
 {
   int ret;
 
-  plibc_initialized ();
-  plibc_set_panic_proc (plibc_panic);
-  ret = plibc_init_utf8 ("GNU", PACKAGE, 1);
-  plibc_set_stat_size_size (sizeof (((struct stat *) 0)->st_size));
-  plibc_set_stat_time_size (sizeof (((struct stat *) 0)->st_mtime));
+  plibc_initialized();
+  plibc_set_panic_proc(plibc_panic);
+  ret = plibc_init_utf8("GNU", PACKAGE, 1);
+  plibc_set_stat_size_size(sizeof(((struct stat *)0)->st_size));
+  plibc_set_stat_time_size(sizeof(((struct stat *)0)->st_mtime));
   /* don't load other DLLs twice */
   if (hNTDLL)
     return ret;
 
 #ifdef W32_VEH
   if (GNWinVEH_handle == NULL)
-  {
-    GNWinVEH_handle = AddVectoredExceptionHandler (1, &GNWinVEH);
-    if (GNWinVEH_handle == NULL)
     {
-      /* This is bad, but what can we do? */
-      printf ("Failed to set up an exception handler!\n");
+      GNWinVEH_handle = AddVectoredExceptionHandler(1, &GNWinVEH);
+      if (GNWinVEH_handle == NULL)
+        {
+          /* This is bad, but what can we do? */
+          printf("Failed to set up an exception handler!\n");
+        }
     }
-  }
 #endif
 
-  hNTDLL = LoadLibrary ("ntdll.dll");
+  hNTDLL = LoadLibrary("ntdll.dll");
 
   /* Function to get CPU usage under Win NT */
   if (hNTDLL)
-  {
-    GNNtQuerySystemInformation =
-        (TNtQuerySystemInformation) GetProcAddress (hNTDLL,
-                                                    "NtQuerySystemInformation");
-  }
+    {
+      GNNtQuerySystemInformation =
+        (TNtQuerySystemInformation)GetProcAddress(hNTDLL,
+                                                  "NtQuerySystemInformation");
+    }
   else
-  {
-    GNNtQuerySystemInformation = NULL;
-  }
+    {
+      GNNtQuerySystemInformation = NULL;
+    }
 
   /* Functions to get information about a network adapter */
-  hIphlpapi = LoadLibrary ("iphlpapi.dll");
+  hIphlpapi = LoadLibrary("iphlpapi.dll");
   if (hIphlpapi)
-  {
-    GNGetIfEntry = (TGetIfEntry) GetProcAddress (hIphlpapi, "GetIfEntry");
-    GNGetIpAddrTable =
-        (TGetIpAddrTable) GetProcAddress (hIphlpapi, "GetIpAddrTable");
-    GNGetIfTable = (TGetIfTable) GetProcAddress (hIphlpapi, "GetIfTable");
-    GNGetBestInterfaceEx =
-        (TGetBestInterfaceEx) GetProcAddress (hIphlpapi, "GetBestInterfaceEx");
-    GNGetAdaptersInfo =
-        (TGetAdaptersInfo) GetProcAddress (hIphlpapi, "GetAdaptersInfo");
-  }
+    {
+      GNGetIfEntry = (TGetIfEntry)GetProcAddress(hIphlpapi, "GetIfEntry");
+      GNGetIpAddrTable =
+        (TGetIpAddrTable)GetProcAddress(hIphlpapi, "GetIpAddrTable");
+      GNGetIfTable = (TGetIfTable)GetProcAddress(hIphlpapi, "GetIfTable");
+      GNGetBestInterfaceEx =
+        (TGetBestInterfaceEx)GetProcAddress(hIphlpapi, "GetBestInterfaceEx");
+      GNGetAdaptersInfo =
+        (TGetAdaptersInfo)GetProcAddress(hIphlpapi, "GetAdaptersInfo");
+    }
   else
-  {
-    GNGetIfEntry = NULL;
-    GNGetIpAddrTable = NULL;
-    GNGetIfTable = NULL;
-    GNGetBestInterfaceEx = NULL;
-    GNGetAdaptersInfo = NULL;
-  }
+    {
+      GNGetIfEntry = NULL;
+      GNGetIpAddrTable = NULL;
+      GNGetIfTable = NULL;
+      GNGetBestInterfaceEx = NULL;
+      GNGetAdaptersInfo = NULL;
+    }
 
   /* Service & Account functions */
-  hAdvapi = LoadLibrary ("advapi32.dll");
+  hAdvapi = LoadLibrary("advapi32.dll");
   if (hAdvapi)
-  {
-    GNOpenSCManager =
-        (TOpenSCManager) GetProcAddress (hAdvapi, "OpenSCManagerA");
-    GNCreateService =
-        (TCreateService) GetProcAddress (hAdvapi, "CreateServiceA");
-    GNCloseServiceHandle =
-        (TCloseServiceHandle) GetProcAddress (hAdvapi, "CloseServiceHandle");
-    GNDeleteService =
-        (TDeleteService) GetProcAddress (hAdvapi, "DeleteService");
-    GNRegisterServiceCtrlHandler =
-        (TRegisterServiceCtrlHandler) GetProcAddress (hAdvapi,
-                                                      "RegisterServiceCtrlHandlerA");
-    GNSetServiceStatus =
-        (TSetServiceStatus) GetProcAddress (hAdvapi, "SetServiceStatus");
-    GNStartServiceCtrlDispatcher =
-        (TStartServiceCtrlDispatcher) GetProcAddress (hAdvapi,
-                                                      "StartServiceCtrlDispatcherA");
-    GNControlService =
-        (TControlService) GetProcAddress (hAdvapi, "ControlService");
-    GNOpenService = (TOpenService) GetProcAddress (hAdvapi, "OpenServiceA");
-
-    GNLsaOpenPolicy =
-        (TLsaOpenPolicy) GetProcAddress (hAdvapi, "LsaOpenPolicy");
-    GNLsaAddAccountRights =
-        (TLsaAddAccountRights) GetProcAddress (hAdvapi, "LsaAddAccountRights");
-    GNLsaRemoveAccountRights =
-        (TLsaRemoveAccountRights) GetProcAddress (hAdvapi,
-                                                  "LsaRemoveAccountRights");
-    GNLsaClose = (TLsaClose) GetProcAddress (hAdvapi, "LsaClose");
-    GNLookupAccountName =
-        (TLookupAccountName) GetProcAddress (hAdvapi, "LookupAccountNameA");
-
-    GNGetFileSecurity =
-        (TGetFileSecurity) GetProcAddress (hAdvapi, "GetFileSecurityA");
-    GNInitializeSecurityDescriptor =
-        (TInitializeSecurityDescriptor) GetProcAddress (hAdvapi,
-                                                        "InitializeSecurityDescriptor");
-    GNGetSecurityDescriptorDacl =
-        (TGetSecurityDescriptorDacl) GetProcAddress (hAdvapi,
-                                                     "GetSecurityDescriptorDacl");
-    GNGetAclInformation =
-        (TGetAclInformation) GetProcAddress (hAdvapi, "GetAclInformation");
-    GNInitializeAcl =
-        (TInitializeAcl) GetProcAddress (hAdvapi, "InitializeAcl");
-    GNGetAce = (TGetAce) GetProcAddress (hAdvapi, "GetAce");
-    GNEqualSid = (TEqualSid) GetProcAddress (hAdvapi, "EqualSid");
-    GNAddAce = (TAddAce) GetProcAddress (hAdvapi, "AddAce");
-    GNAddAccessAllowedAce =
-        (TAddAccessAllowedAce) GetProcAddress (hAdvapi, "AddAccessAllowedAce");
-    GNSetNamedSecurityInfo =
-        (TSetNamedSecurityInfo) GetProcAddress (hAdvapi,
-                                                "SetNamedSecurityInfoA");
-  }
+    {
+      GNOpenSCManager =
+        (TOpenSCManager)GetProcAddress(hAdvapi, "OpenSCManagerA");
+      GNCreateService =
+        (TCreateService)GetProcAddress(hAdvapi, "CreateServiceA");
+      GNCloseServiceHandle =
+        (TCloseServiceHandle)GetProcAddress(hAdvapi, "CloseServiceHandle");
+      GNDeleteService =
+        (TDeleteService)GetProcAddress(hAdvapi, "DeleteService");
+      GNRegisterServiceCtrlHandler =
+        (TRegisterServiceCtrlHandler)GetProcAddress(hAdvapi,
+                                                    "RegisterServiceCtrlHandlerA");
+      GNSetServiceStatus =
+        (TSetServiceStatus)GetProcAddress(hAdvapi, "SetServiceStatus");
+      GNStartServiceCtrlDispatcher =
+        (TStartServiceCtrlDispatcher)GetProcAddress(hAdvapi,
+                                                    "StartServiceCtrlDispatcherA");
+      GNControlService =
+        (TControlService)GetProcAddress(hAdvapi, "ControlService");
+      GNOpenService = (TOpenService)GetProcAddress(hAdvapi, "OpenServiceA");
+
+      GNLsaOpenPolicy =
+        (TLsaOpenPolicy)GetProcAddress(hAdvapi, "LsaOpenPolicy");
+      GNLsaAddAccountRights =
+        (TLsaAddAccountRights)GetProcAddress(hAdvapi, "LsaAddAccountRights");
+      GNLsaRemoveAccountRights =
+        (TLsaRemoveAccountRights)GetProcAddress(hAdvapi,
+                                                "LsaRemoveAccountRights");
+      GNLsaClose = (TLsaClose)GetProcAddress(hAdvapi, "LsaClose");
+      GNLookupAccountName =
+        (TLookupAccountName)GetProcAddress(hAdvapi, "LookupAccountNameA");
+
+      GNGetFileSecurity =
+        (TGetFileSecurity)GetProcAddress(hAdvapi, "GetFileSecurityA");
+      GNInitializeSecurityDescriptor =
+        (TInitializeSecurityDescriptor)GetProcAddress(hAdvapi,
+                                                      "InitializeSecurityDescriptor");
+      GNGetSecurityDescriptorDacl =
+        (TGetSecurityDescriptorDacl)GetProcAddress(hAdvapi,
+                                                   "GetSecurityDescriptorDacl");
+      GNGetAclInformation =
+        (TGetAclInformation)GetProcAddress(hAdvapi, "GetAclInformation");
+      GNInitializeAcl =
+        (TInitializeAcl)GetProcAddress(hAdvapi, "InitializeAcl");
+      GNGetAce = (TGetAce)GetProcAddress(hAdvapi, "GetAce");
+      GNEqualSid = (TEqualSid)GetProcAddress(hAdvapi, "EqualSid");
+      GNAddAce = (TAddAce)GetProcAddress(hAdvapi, "AddAce");
+      GNAddAccessAllowedAce =
+        (TAddAccessAllowedAce)GetProcAddress(hAdvapi, "AddAccessAllowedAce");
+      GNSetNamedSecurityInfo =
+        (TSetNamedSecurityInfo)GetProcAddress(hAdvapi,
+                                              "SetNamedSecurityInfoA");
+    }
   else
-  {
-    GNOpenSCManager = NULL;
-    GNCreateService = NULL;
-    GNCloseServiceHandle = NULL;
-    GNDeleteService = NULL;
-    GNRegisterServiceCtrlHandler = NULL;
-    GNSetServiceStatus = NULL;
-    GNStartServiceCtrlDispatcher = NULL;
-    GNControlService = NULL;
-    GNOpenService = NULL;
-
-    GNLsaOpenPolicy = NULL;
-    GNLsaAddAccountRights = NULL;
-    GNLsaRemoveAccountRights = NULL;
-    GNLsaClose = NULL;
-    GNLookupAccountName = NULL;
-
-    GNGetFileSecurity = NULL;
-    GNInitializeSecurityDescriptor = NULL;
-    GNGetSecurityDescriptorDacl = NULL;
-    GNGetAclInformation = NULL;
-    GNInitializeAcl = NULL;
-    GNGetAce = NULL;
-    GNEqualSid = NULL;
-    GNAddAce = NULL;
-    GNAddAccessAllowedAce = NULL;
-    GNSetNamedSecurityInfo = NULL;
-  }
+    {
+      GNOpenSCManager = NULL;
+      GNCreateService = NULL;
+      GNCloseServiceHandle = NULL;
+      GNDeleteService = NULL;
+      GNRegisterServiceCtrlHandler = NULL;
+      GNSetServiceStatus = NULL;
+      GNStartServiceCtrlDispatcher = NULL;
+      GNControlService = NULL;
+      GNOpenService = NULL;
+
+      GNLsaOpenPolicy = NULL;
+      GNLsaAddAccountRights = NULL;
+      GNLsaRemoveAccountRights = NULL;
+      GNLsaClose = NULL;
+      GNLookupAccountName = NULL;
+
+      GNGetFileSecurity = NULL;
+      GNInitializeSecurityDescriptor = NULL;
+      GNGetSecurityDescriptorDacl = NULL;
+      GNGetAclInformation = NULL;
+      GNInitializeAcl = NULL;
+      GNGetAce = NULL;
+      GNEqualSid = NULL;
+      GNAddAce = NULL;
+      GNAddAccessAllowedAce = NULL;
+      GNSetNamedSecurityInfo = NULL;
+    }
 
   /* Account function */
-  hNetapi = LoadLibrary ("netapi32.dll");
+  hNetapi = LoadLibrary("netapi32.dll");
   if (hNetapi)
-  {
-    GNNetUserAdd = (TNetUserAdd) GetProcAddress (hNetapi, "NetUserAdd");
-    GNNetUserSetInfo =
-        (TNetUserSetInfo) GetProcAddress (hNetapi, "NetUserSetInfo");
-  }
+    {
+      GNNetUserAdd = (TNetUserAdd)GetProcAddress(hNetapi, "NetUserAdd");
+      GNNetUserSetInfo =
+        (TNetUserSetInfo)GetProcAddress(hNetapi, "NetUserSetInfo");
+    }
   else
-  {
-    GNNetUserAdd = NULL;
-    GNNetUserSetInfo = NULL;
-  }
+    {
+      GNNetUserAdd = NULL;
+      GNNetUserSetInfo = NULL;
+    }
 
   return ret;
 }
@@ -308,32 +309,32 @@ GNInitWinEnv ()
  * Clean up Windows environment
  */
 void
-GNShutdownWinEnv ()
+GNShutdownWinEnv()
 {
-  plibc_shutdown ();
+  plibc_shutdown();
 
 #ifdef W32_VEH
   if (GNWinVEH_handle != NULL)
-  {
-    RemoveVectoredExceptionHandler (GNWinVEH_handle);
-    GNWinVEH_handle = NULL;
-  }
+    {
+      RemoveVectoredExceptionHandler(GNWinVEH_handle);
+      GNWinVEH_handle = NULL;
+    }
 #endif
 
-  FreeLibrary (hNTDLL);
-  FreeLibrary (hIphlpapi);
-  FreeLibrary (hAdvapi);
-  FreeLibrary (hNetapi);
+  FreeLibrary(hNTDLL);
+  FreeLibrary(hIphlpapi);
+  FreeLibrary(hAdvapi);
+  FreeLibrary(hNetapi);
 
-  CoUninitialize ();
+  CoUninitialize();
 }
 
 #endif /* MINGW */
 
 #if !HAVE_ATOLL
 long long
-atoll (const char *nptr)
+atoll(const char *nptr)
 {
-  return atol (nptr);
+  return atol(nptr);
 }
 #endif