uncrustify as demanded.

8 files changed, 1203 insertions, 1208 deletions

diff --git a/src/nse/gnunet-nse-profiler.c b/src/nse/gnunet-nse-profiler.c
index 12f5f37fb..eaa06b8ed 100644
--- a/src/nse/gnunet-nse-profiler.c
+++ b/src/nse/gnunet-nse-profiler.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 nse/gnunet-nse-profiler.c
  *
@@ -36,19 +36,18 @@
 /**
  * Generic loggins shorthand
  */
-#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
 
 /**
  * Debug logging shorthand
  */
-#define LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+#define LOG_DEBUG(...) LOG(GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 
 
 /**
  * Information we track for a peer in the testbed.
  */
-struct NSEPeer
-{
+struct NSEPeer {
   /**
    * Prev reference in DLL.
    */
@@ -84,8 +83,7 @@ struct NSEPeer
 /**
  * Operation map entry
  */
-struct OpListEntry
-{
+struct OpListEntry {
   /**
    * DLL next ptr
    */
@@ -208,7 +206,7 @@ static char *data_filename;
  * How long to wait before triggering next round?
  * Default: 60 s.
  */
-static struct GNUNET_TIME_Relative wait_time = {60 * 1000};
+static struct GNUNET_TIME_Relative wait_time = { 60 * 1000 };
 
 /**
  * DLL head for operation list
@@ -231,26 +229,26 @@ static struct GNUNET_SCHEDULER_Task *round_task;
  * STATISTICS that we keep to selected peers.
  */
 static void
-close_monitor_connections ()
+close_monitor_connections()
 {
   struct NSEPeer *pos;
   struct OpListEntry *oplist_entry;
 
   while (NULL != (pos = peer_head))
-  {
-    if (NULL != pos->nse_op)
-      GNUNET_TESTBED_operation_done (pos->nse_op);
-    if (NULL != pos->stat_op)
-      GNUNET_TESTBED_operation_done (pos->stat_op);
-    GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
-    GNUNET_free (pos);
-  }
+    {
+      if (NULL != pos->nse_op)
+        GNUNET_TESTBED_operation_done(pos->nse_op);
+      if (NULL != pos->stat_op)
+        GNUNET_TESTBED_operation_done(pos->stat_op);
+      GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, pos);
+      GNUNET_free(pos);
+    }
   while (NULL != (oplist_entry = oplist_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, oplist_entry);
-    GNUNET_TESTBED_operation_done (oplist_entry->op);
-    GNUNET_free (oplist_entry);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(oplist_head, oplist_tail, oplist_entry);
+      GNUNET_TESTBED_operation_done(oplist_entry->op);
+      GNUNET_free(oplist_entry);
+    }
 }
 
 
@@ -260,30 +258,30 @@ close_monitor_connections ()
  * @param cls unused
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  LOG_DEBUG ("Ending test.\n");
-  close_monitor_connections ();
+  LOG_DEBUG("Ending test.\n");
+  close_monitor_connections();
   if (NULL != round_task)
-  {
-    GNUNET_SCHEDULER_cancel (round_task);
-    round_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(round_task);
+      round_task = NULL;
+    }
   if (NULL != data_file)
-  {
-    GNUNET_DISK_file_close (data_file);
-    data_file = NULL;
-  }
+    {
+      GNUNET_DISK_file_close(data_file);
+      data_file = NULL;
+    }
   if (NULL != output_file)
-  {
-    GNUNET_DISK_file_close (output_file);
-    output_file = NULL;
-  }
+    {
+      GNUNET_DISK_file_close(output_file);
+      output_file = NULL;
+    }
   if (NULL != testing_cfg)
-  {
-    GNUNET_CONFIGURATION_destroy (testing_cfg);
-    testing_cfg = NULL;
-  }
+    {
+      GNUNET_CONFIGURATION_destroy(testing_cfg);
+      testing_cfg = NULL;
+    }
 }
 
 
@@ -297,35 +295,35 @@ shutdown_task (void *cls)
  *                of the size estimation values seen
  */
 static void
-handle_estimate (void *cls,
-                 struct GNUNET_TIME_Absolute timestamp,
-                 double estimate,
-                 double std_dev)
+handle_estimate(void *cls,
+                struct GNUNET_TIME_Absolute timestamp,
+                double estimate,
+                double std_dev)
 {
   struct NSEPeer *peer = cls;
   char output_buffer[512];
   size_t size;
 
   if (NULL == output_file)
-  {
-    fprintf (stderr,
-             "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
-             peer,
-             estimate,
-             std_dev);
-    return;
-  }
-  size = GNUNET_snprintf (output_buffer,
-                          sizeof (output_buffer),
-                          "%p %llu %llu %f %f %f\n",
-                          peer,
-                          peers_running,
-                          (unsigned long long) timestamp.abs_value_us,
-                          GNUNET_NSE_log_estimate_to_n (estimate),
-                          estimate,
-                          std_dev);
-  if (size != GNUNET_DISK_file_write (output_file, output_buffer, size))
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+    {
+      fprintf(stderr,
+              "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
+              peer,
+              estimate,
+              std_dev);
+      return;
+    }
+  size = GNUNET_snprintf(output_buffer,
+                         sizeof(output_buffer),
+                         "%p %llu %llu %f %f %f\n",
+                         peer,
+                         peers_running,
+                         (unsigned long long)timestamp.abs_value_us,
+                         GNUNET_NSE_log_estimate_to_n(estimate),
+                         estimate,
+                         std_dev);
+  if (size != GNUNET_DISK_file_write(output_file, output_buffer, size))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
 }
 
 
@@ -340,11 +338,11 @@ handle_estimate (void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-nse_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+nse_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct NSEPeer *current_peer = cls;
 
-  return GNUNET_NSE_connect (cfg, &handle_estimate, current_peer);
+  return GNUNET_NSE_connect(cfg, &handle_estimate, current_peer);
 }
 
 
@@ -356,9 +354,9 @@ nse_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op_result service handle returned from the connect adapter
  */
 static void
-nse_disconnect_adapter (void *cls, void *op_result)
+nse_disconnect_adapter(void *cls, void *op_result)
 {
-  GNUNET_NSE_disconnect (op_result);
+  GNUNET_NSE_disconnect(op_result);
 }
 
 
@@ -373,40 +371,40 @@ nse_disconnect_adapter (void *cls, void *op_result)
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-stat_iterator (void *cls,
-               const char *subsystem,
-               const char *name,
-               uint64_t value,
-               int is_persistent)
+stat_iterator(void *cls,
+              const char *subsystem,
+              const char *name,
+              uint64_t value,
+              int is_persistent)
 {
   char *output_buffer;
   struct GNUNET_TIME_Absolute now;
   int size;
   unsigned int flag;
 
-  GNUNET_assert (NULL != data_file);
-  now = GNUNET_TIME_absolute_get ();
-  flag = strcasecmp (subsystem, "core");
+  GNUNET_assert(NULL != data_file);
+  now = GNUNET_TIME_absolute_get();
+  flag = strcasecmp(subsystem, "core");
   if (0 != flag)
     flag = 1;
-  size = GNUNET_asprintf (&output_buffer,
-                          "%llu %llu %u\n",
-                          now.abs_value_us / 1000LL / 1000LL,
-                          value,
-                          flag);
+  size = GNUNET_asprintf(&output_buffer,
+                         "%llu %llu %u\n",
+                         now.abs_value_us / 1000LL / 1000LL,
+                         value,
+                         flag);
   if (0 > size)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
-    GNUNET_free (output_buffer);
-    return GNUNET_SYSERR;
-  }
-  if (size != GNUNET_DISK_file_write (data_file, output_buffer, (size_t) size))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
-    GNUNET_free (output_buffer);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_free (output_buffer);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
+      GNUNET_free(output_buffer);
+      return GNUNET_SYSERR;
+    }
+  if (size != GNUNET_DISK_file_write(data_file, output_buffer, (size_t)size))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+      GNUNET_free(output_buffer);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free(output_buffer);
   return GNUNET_OK;
 }
 
@@ -421,11 +419,11 @@ stat_iterator (void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-stat_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+stat_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct NSEPeer *peer = cls;
 
-  peer->sh = GNUNET_STATISTICS_create ("nse-profiler", cfg);
+  peer->sh = GNUNET_STATISTICS_create("nse-profiler", cfg);
   return peer->sh;
 }
 
@@ -437,23 +435,23 @@ stat_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op_result service handle returned from the connect adapter
  */
 static void
-stat_disconnect_adapter (void *cls, void *op_result)
+stat_disconnect_adapter(void *cls, void *op_result)
 {
   struct NSEPeer *peer = cls;
 
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_STATISTICS_watch_cancel (peer->sh,
-                                                "core",
-                                                "# peers connected",
-                                                stat_iterator,
-                                                peer));
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_STATISTICS_watch_cancel (peer->sh,
-                                                "nse",
-                                                "# peers connected",
-                                                stat_iterator,
-                                                peer));
-  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_STATISTICS_watch_cancel(peer->sh,
+                                              "core",
+                                              "# peers connected",
+                                              stat_iterator,
+                                              peer));
+  GNUNET_break(GNUNET_OK ==
+               GNUNET_STATISTICS_watch_cancel(peer->sh,
+                                              "nse",
+                                              "# peers connected",
+                                              stat_iterator,
+                                              peer));
+  GNUNET_STATISTICS_destroy(op_result, GNUNET_NO);
   peer->sh = NULL;
 }
 
@@ -469,29 +467,29 @@ stat_disconnect_adapter (void *cls, void *op_result)
  *          operation has executed successfully.
  */
 static void
-stat_comp_cb (void *cls,
-              struct GNUNET_TESTBED_Operation *op,
-              void *ca_result,
-              const char *emsg)
+stat_comp_cb(void *cls,
+             struct GNUNET_TESTBED_Operation *op,
+             void *ca_result,
+             const char *emsg)
 {
   struct GNUNET_STATISTICS_Handle *sh = ca_result;
   struct NSEPeer *peer = cls;
 
   if (NULL != emsg)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
-                                                      "core",
-                                                      "# peers connected",
-                                                      stat_iterator,
-                                                      peer));
-  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
-                                                      "nse",
-                                                      "# peers connected",
-                                                      stat_iterator,
-                                                      peer));
+    {
+      GNUNET_break(0);
+      return;
+    }
+  GNUNET_break(GNUNET_OK == GNUNET_STATISTICS_watch(sh,
+                                                    "core",
+                                                    "# peers connected",
+                                                    stat_iterator,
+                                                    peer));
+  GNUNET_break(GNUNET_OK == GNUNET_STATISTICS_watch(sh,
+                                                    "nse",
+                                                    "# peers connected",
+                                                    stat_iterator,
+                                                    peer));
 }
 
 
@@ -500,7 +498,7 @@ stat_comp_cb (void *cls,
  * all of the running peers.
  */
 static void
-connect_nse_service ()
+connect_nse_service()
 {
   struct NSEPeer *current_peer;
   unsigned int i;
@@ -508,39 +506,39 @@ connect_nse_service ()
 
   if (0 == connection_limit)
     return;
-  LOG_DEBUG ("Connecting to nse service of peers\n");
+  LOG_DEBUG("Connecting to nse service of peers\n");
   connections = 0;
   for (i = 0; i < num_peers_in_round[current_round]; i++)
-  {
-    if ((num_peers_in_round[current_round] > connection_limit) &&
-        (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
-      continue;
-    LOG_DEBUG ("Connecting to nse service of peer %d\n", i);
-    current_peer = GNUNET_new (struct NSEPeer);
-    current_peer->daemon = daemons[i];
-    current_peer->nse_op =
-      GNUNET_TESTBED_service_connect (NULL,
-                                      current_peer->daemon,
-                                      "nse",
-                                      NULL,
-                                      NULL,
-                                      &nse_connect_adapter,
-                                      &nse_disconnect_adapter,
-                                      current_peer);
-    if (NULL != data_file)
-      current_peer->stat_op =
-        GNUNET_TESTBED_service_connect (NULL,
-                                        current_peer->daemon,
-                                        "statistics",
-                                        stat_comp_cb,
-                                        current_peer,
-                                        &stat_connect_adapter,
-                                        &stat_disconnect_adapter,
-                                        current_peer);
-    GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
-    if (++connections == connection_limit)
-      break;
-  }
+    {
+      if ((num_peers_in_round[current_round] > connection_limit) &&
+          (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
+        continue;
+      LOG_DEBUG("Connecting to nse service of peer %d\n", i);
+      current_peer = GNUNET_new(struct NSEPeer);
+      current_peer->daemon = daemons[i];
+      current_peer->nse_op =
+        GNUNET_TESTBED_service_connect(NULL,
+                                       current_peer->daemon,
+                                       "nse",
+                                       NULL,
+                                       NULL,
+                                       &nse_connect_adapter,
+                                       &nse_disconnect_adapter,
+                                       current_peer);
+      if (NULL != data_file)
+        current_peer->stat_op =
+          GNUNET_TESTBED_service_connect(NULL,
+                                         current_peer->daemon,
+                                         "statistics",
+                                         stat_comp_cb,
+                                         current_peer,
+                                         &stat_connect_adapter,
+                                         &stat_disconnect_adapter,
+                                         current_peer);
+      GNUNET_CONTAINER_DLL_insert(peer_head, peer_tail, current_peer);
+      if (++connections == connection_limit)
+        break;
+    }
 }
 
 
@@ -550,7 +548,7 @@ connect_nse_service ()
  * @param cls NULL, unused
  */
 static void
-next_round (void *cls);
+next_round(void *cls);
 
 
 /**
@@ -561,11 +559,11 @@ next_round (void *cls);
  * @param cls unused, NULL
  */
 static void
-finish_round (void *cls)
+finish_round(void *cls)
 {
-  LOG (GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
-  close_monitor_connections ();
-  round_task = GNUNET_SCHEDULER_add_now (&next_round, NULL);
+  LOG(GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
+  close_monitor_connections();
+  round_task = GNUNET_SCHEDULER_add_now(&next_round, NULL);
 }
 
 
@@ -575,11 +573,11 @@ finish_round (void *cls)
  * specified delay before finishing the round).
  */
 static void
-run_round ()
+run_round()
 {
-  LOG_DEBUG ("Running round %u\n", current_round);
-  connect_nse_service ();
-  GNUNET_SCHEDULER_add_delayed (wait_time, &finish_round, NULL);
+  LOG_DEBUG("Running round %u\n", current_round);
+  connect_nse_service();
+  GNUNET_SCHEDULER_add_delayed(wait_time, &finish_round, NULL);
 }
 
 
@@ -587,12 +585,12 @@ run_round ()
  * Creates an oplist entry and adds it to the oplist DLL
  */
 static struct OpListEntry *
-make_oplist_entry ()
+make_oplist_entry()
 {
   struct OpListEntry *entry;
 
-  entry = GNUNET_new (struct OpListEntry);
-  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
+  entry = GNUNET_new(struct OpListEntry);
+  GNUNET_CONTAINER_DLL_insert_tail(oplist_head, oplist_tail, entry);
   return entry;
 }
 
@@ -605,25 +603,25 @@ make_oplist_entry ()
  * @param emsg NULL on success; otherwise an error description
  */
 static void
-manage_service_cb (void *cls,
-                   struct GNUNET_TESTBED_Operation *op,
-                   const char *emsg)
+manage_service_cb(void *cls,
+                  struct GNUNET_TESTBED_Operation *op,
+                  const char *emsg)
 {
   struct OpListEntry *entry = cls;
 
-  GNUNET_TESTBED_operation_done (entry->op);
+  GNUNET_TESTBED_operation_done(entry->op);
   if (NULL != emsg)
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_assert (0 != entry->delta);
+    {
+      LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_assert(0 != entry->delta);
   peers_running += entry->delta;
-  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
-  GNUNET_free (entry);
+  GNUNET_CONTAINER_DLL_remove(oplist_head, oplist_tail, entry);
+  GNUNET_free(entry);
   if (num_peers_in_round[current_round] == peers_running)
-    run_round ();
+    run_round();
 }
 
 
@@ -632,35 +630,35 @@ manage_service_cb (void *cls,
  * peers for the round
  */
 static void
-adjust_running_peers ()
+adjust_running_peers()
 {
   struct OpListEntry *entry;
   unsigned int i;
 
   /* start peers if we have too few */
   for (i = peers_running; i < num_peers_in_round[current_round]; i++)
-  {
-    entry = make_oplist_entry ();
-    entry->delta = 1;
-    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
-                                                    daemons[i],
-                                                    "nse",
-                                                    &manage_service_cb,
-                                                    entry,
-                                                    1);
-  }
+    {
+      entry = make_oplist_entry();
+      entry->delta = 1;
+      entry->op = GNUNET_TESTBED_peer_manage_service(NULL,
+                                                     daemons[i],
+                                                     "nse",
+                                                     &manage_service_cb,
+                                                     entry,
+                                                     1);
+    }
   /* stop peers if we have too many */
   for (i = num_peers_in_round[current_round]; i < peers_running; i++)
-  {
-    entry = make_oplist_entry ();
-    entry->delta = -1;
-    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
-                                                    daemons[i],
-                                                    "nse",
-                                                    &manage_service_cb,
-                                                    entry,
-                                                    0);
-  }
+    {
+      entry = make_oplist_entry();
+      entry->delta = -1;
+      entry->op = GNUNET_TESTBED_peer_manage_service(NULL,
+                                                     daemons[i],
+                                                     "nse",
+                                                     &manage_service_cb,
+                                                     entry,
+                                                     0);
+    }
 }
 
 
@@ -671,25 +669,25 @@ adjust_running_peers ()
  * @param cls NULL, unused
  */
 static void
-next_round (void *cls)
+next_round(void *cls)
 {
   round_task = NULL;
-  LOG_DEBUG ("Disconnecting nse service of peers\n");
+  LOG_DEBUG("Disconnecting nse service of peers\n");
   current_round++;
   if (current_round == num_rounds)
-  {
-    /* this was the last round, terminate */
-    ok = 0;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      /* this was the last round, terminate */
+      ok = 0;
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   if (num_peers_in_round[current_round] == peers_running)
-  {
-    /* no need to churn, just run next round */
-    run_round ();
-    return;
-  }
-  adjust_running_peers ();
+    {
+      /* no need to churn, just run next round */
+      run_round();
+      return;
+    }
+  adjust_running_peers();
 }
 
 
@@ -701,20 +699,22 @@ next_round (void *cls)
  * @param event information on what is happening
  */
 static void
-master_controller_cb (void *cls,
-                      const struct GNUNET_TESTBED_EventInformation *event)
+master_controller_cb(void *cls,
+                     const struct GNUNET_TESTBED_EventInformation *event)
 {
   switch (event->type)
-  {
-  case GNUNET_TESTBED_ET_CONNECT:
-    total_connections++;
-    break;
-  case GNUNET_TESTBED_ET_DISCONNECT:
-    total_connections--;
-    break;
-  default:
-    break;
-  }
+    {
+    case GNUNET_TESTBED_ET_CONNECT:
+      total_connections++;
+      break;
+
+    case GNUNET_TESTBED_ET_DISCONNECT:
+      total_connections--;
+      break;
+
+    default:
+      break;
+    }
 }
 
 
@@ -732,28 +732,28 @@ master_controller_cb (void *cls,
  *          failed
  */
 static void
-test_master (void *cls,
-             struct GNUNET_TESTBED_RunHandle *h,
-             unsigned int num_peers_,
-             struct GNUNET_TESTBED_Peer **peers,
-             unsigned int links_succeeded,
-             unsigned int links_failed)
+test_master(void *cls,
+            struct GNUNET_TESTBED_RunHandle *h,
+            unsigned int num_peers_,
+            struct GNUNET_TESTBED_Peer **peers,
+            unsigned int links_succeeded,
+            unsigned int links_failed)
 {
   if (NULL == peers)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+    {
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
   daemons = peers;
-  GNUNET_break (num_peers_ == num_peers);
+  GNUNET_break(num_peers_ == num_peers);
   peers_running = num_peers;
   if (num_peers_in_round[current_round] == peers_running)
-  {
-    /* no need to churn, just run the starting round */
-    run_round ();
-    return;
-  }
-  adjust_running_peers ();
+    {
+      /* no need to churn, just run the starting round */
+      run_round();
+      return;
+    }
+  adjust_running_peers();
 }
 
 
@@ -766,75 +766,75 @@ test_master (void *cls,
  * @param cfg configuration handle
  */
 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 *tok;
   uint64_t event_mask;
   unsigned int num;
 
   ok = 1;
-  testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
-  LOG_DEBUG ("Starting daemons.\n");
+  testing_cfg = GNUNET_CONFIGURATION_dup(cfg);
+  LOG_DEBUG("Starting daemons.\n");
   if (NULL == num_peer_spec)
-  {
-    fprintf (stderr, "You need to specify the number of peers to run\n");
-    return;
-  }
-  for (tok = strtok (num_peer_spec, ","); NULL != tok; tok = strtok (NULL, ","))
-  {
-    if (1 != sscanf (tok, "%u", &num))
     {
-      fprintf (stderr, "You need to specify numbers, not `%s'\n", tok);
+      fprintf(stderr, "You need to specify the number of peers to run\n");
       return;
     }
-    if (0 == num)
+  for (tok = strtok(num_peer_spec, ","); NULL != tok; tok = strtok(NULL, ","))
     {
-      fprintf (stderr, "Refusing to run a round with 0 peers\n");
-      return;
+      if (1 != sscanf(tok, "%u", &num))
+        {
+          fprintf(stderr, "You need to specify numbers, not `%s'\n", tok);
+          return;
+        }
+      if (0 == num)
+        {
+          fprintf(stderr, "Refusing to run a round with 0 peers\n");
+          return;
+        }
+      GNUNET_array_append(num_peers_in_round, num_rounds, num);
+      num_peers = GNUNET_MAX(num_peers, num);
     }
-    GNUNET_array_append (num_peers_in_round, num_rounds, num);
-    num_peers = GNUNET_MAX (num_peers, num);
-  }
   if (0 == num_peers)
-  {
-    fprintf (stderr, "Refusing to run a testbed with no rounds\n");
-    return;
-  }
+    {
+      fprintf(stderr, "Refusing to run a testbed with no rounds\n");
+      return;
+    }
   if ((NULL != data_filename) &&
       (NULL ==
-       (data_file = GNUNET_DISK_file_open (data_filename,
-                                           GNUNET_DISK_OPEN_READWRITE |
-                                             GNUNET_DISK_OPEN_TRUNCATE |
-                                             GNUNET_DISK_OPEN_CREATE,
-                                           GNUNET_DISK_PERM_USER_READ |
-                                             GNUNET_DISK_PERM_USER_WRITE))))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", data_filename);
+       (data_file = GNUNET_DISK_file_open(data_filename,
+                                          GNUNET_DISK_OPEN_READWRITE |
+                                          GNUNET_DISK_OPEN_TRUNCATE |
+                                          GNUNET_DISK_OPEN_CREATE,
+                                          GNUNET_DISK_PERM_USER_READ |
+                                          GNUNET_DISK_PERM_USER_WRITE))))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", data_filename);
 
   if ((NULL != output_filename) &&
       (NULL ==
-       (output_file = GNUNET_DISK_file_open (output_filename,
-                                             GNUNET_DISK_OPEN_READWRITE |
-                                               GNUNET_DISK_OPEN_CREATE,
-                                             GNUNET_DISK_PERM_USER_READ |
-                                               GNUNET_DISK_PERM_USER_WRITE))))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", output_filename);
+       (output_file = GNUNET_DISK_file_open(output_filename,
+                                            GNUNET_DISK_OPEN_READWRITE |
+                                            GNUNET_DISK_OPEN_CREATE,
+                                            GNUNET_DISK_PERM_USER_READ |
+                                            GNUNET_DISK_PERM_USER_WRITE))))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", output_filename);
   event_mask = 0LL;
   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
   event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
   event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
-  GNUNET_TESTBED_run (hosts_file,
-                      cfg,
-                      num_peers,
-                      event_mask,
-                      master_controller_cb,
-                      NULL, /* master_controller_cb cls */
-                      &test_master,
-                      NULL); /* test_master cls */
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  GNUNET_TESTBED_run(hosts_file,
+                     cfg,
+                     num_peers,
+                     event_mask,
+                     master_controller_cb,
+                     NULL,  /* master_controller_cb cls */
+                     &test_master,
+                     NULL);  /* test_master cls */
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
 }
 
 
@@ -844,72 +844,73 @@ run (void *cls,
  * @return 0 on success
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-    {GNUNET_GETOPT_option_uint (
-       'C',
-       "connections",
-       "COUNT",
-       gettext_noop (
-         "limit to the number of connections to NSE services, 0 for none"),
-       &connection_limit),
-     GNUNET_GETOPT_option_string (
-       'd',
-       "details",
-       "FILENAME",
-       gettext_noop (
-         "name of the file for writing connection information and statistics"),
-       &data_filename),
-
-     GNUNET_GETOPT_option_string (
-       'H',
-       "hosts",
-       "FILENAME",
-       gettext_noop (
-         "name of the file with the login information for the testbed"),
-       &hosts_file),
-
-     GNUNET_GETOPT_option_string (
-       'o',
-       "output",
-       "FILENAME",
-       gettext_noop ("name of the file for writing the main results"),
-       &output_filename),
-
-
-     GNUNET_GETOPT_option_string (
-       'p',
-       "peers",
-       "NETWORKSIZESPEC",
-       gettext_noop (
-         "Number of peers to run in each round, separated by commas"),
-       &num_peer_spec),
-
-     GNUNET_GETOPT_option_increment_uint (
-       'V',
-       "verbose",
-       gettext_noop ("be verbose (print progress information)"),
-       &verbose),
-
-     GNUNET_GETOPT_option_relative_time ('w',
-                                         "wait",
-                                         "DELAY",
-                                         gettext_noop ("delay between rounds"),
-                                         &wait_time),
-     GNUNET_GETOPT_OPTION_END};
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+  { GNUNET_GETOPT_option_uint(
+      'C',
+      "connections",
+      "COUNT",
+      gettext_noop(
+        "limit to the number of connections to NSE services, 0 for none"),
+      &connection_limit),
+    GNUNET_GETOPT_option_string(
+      'd',
+      "details",
+      "FILENAME",
+      gettext_noop(
+        "name of the file for writing connection information and statistics"),
+      &data_filename),
+
+    GNUNET_GETOPT_option_string(
+      'H',
+      "hosts",
+      "FILENAME",
+      gettext_noop(
+        "name of the file with the login information for the testbed"),
+      &hosts_file),
+
+    GNUNET_GETOPT_option_string(
+      'o',
+      "output",
+      "FILENAME",
+      gettext_noop("name of the file for writing the main results"),
+      &output_filename),
+
+
+    GNUNET_GETOPT_option_string(
+      'p',
+      "peers",
+      "NETWORKSIZESPEC",
+      gettext_noop(
+        "Number of peers to run in each round, separated by commas"),
+      &num_peer_spec),
+
+    GNUNET_GETOPT_option_increment_uint(
+      'V',
+      "verbose",
+      gettext_noop("be verbose (print progress information)"),
+      &verbose),
+
+    GNUNET_GETOPT_option_relative_time('w',
+                                       "wait",
+                                       "DELAY",
+                                       gettext_noop("delay between rounds"),
+                                       &wait_time),
+    GNUNET_GETOPT_OPTION_END };
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
     return 2;
   if (
     GNUNET_OK !=
-    GNUNET_PROGRAM_run (argc,
-                        argv,
-                        "nse-profiler",
-                        gettext_noop (
-                          "Measure quality and performance of the NSE service."),
-                        options,
-                        &run,
-                        NULL))
+    GNUNET_PROGRAM_run(argc,
+                       argv,
+                       "nse-profiler",
+                       gettext_noop(
+                         "Measure quality and performance of the NSE service."),
+                       options,
+                       &run,
+                       NULL))
     ok = 1;
   return ok;
 }
diff --git a/src/nse/gnunet-nse.c b/src/nse/gnunet-nse.c
index 73b80e28b..3735373b5 100644
--- a/src/nse/gnunet-nse.c
+++ b/src/nse/gnunet-nse.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 nse/gnunet-nse.c
@@ -44,14 +44,14 @@ static int status;
  * @param cls NULL
  */
 static void
-do_shutdown (void *cls)
+do_shutdown(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != nse)
-  {
-    GNUNET_NSE_disconnect (nse);
-    nse = NULL;
-  }
+    {
+      GNUNET_NSE_disconnect(nse);
+      nse = NULL;
+    }
 }
 
 
@@ -65,19 +65,19 @@ do_shutdown (void *cls)
  *                of the size estimation values seen
  */
 static void
-handle_estimate (void *cls,
-                 struct GNUNET_TIME_Absolute timestamp,
-                 double estimate,
-                 double std_dev)
+handle_estimate(void *cls,
+                struct GNUNET_TIME_Absolute timestamp,
+                double estimate,
+                double std_dev)
 {
-  (void) cls;
+  (void)cls;
   status = 0;
-  fprintf (stdout,
-           "%llu %f %f %f\n",
-           (unsigned long long) timestamp.abs_value_us,
-           GNUNET_NSE_log_estimate_to_n (estimate),
-           estimate,
-           std_dev);
+  fprintf(stdout,
+          "%llu %f %f %f\n",
+          (unsigned long long)timestamp.abs_value_us,
+          GNUNET_NSE_log_estimate_to_n(estimate),
+          estimate,
+          std_dev);
 }
 
 
@@ -90,16 +90,16 @@ handle_estimate (void *cls,
  * @param cfg configuration handle
  */
 static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+run(void *cls,
+    char *const *args,
+    const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  (void) cls;
-  (void) args;
-  (void) cfgfile;
-  nse = GNUNET_NSE_connect (cfg, &handle_estimate, NULL);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  (void)cls;
+  (void)args;
+  (void)cfgfile;
+  nse = GNUNET_NSE_connect(cfg, &handle_estimate, NULL);
+  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
 }
 
 
@@ -109,21 +109,22 @@ run (void *cls,
  * @return 0 on success
  */
 int
-main (int argc, char *const *argv)
+main(int argc, char *const *argv)
 {
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END};
+    GNUNET_GETOPT_OPTION_END
+  };
 
   status = 1;
   if (GNUNET_OK !=
-      GNUNET_PROGRAM_run (argc,
-                          argv,
-                          "gnunet-nse",
-                          gettext_noop (
-                            "Show network size estimates from NSE service."),
-                          options,
-                          &run,
-                          NULL))
+      GNUNET_PROGRAM_run(argc,
+                         argv,
+                         "gnunet-nse",
+                         gettext_noop(
+                           "Show network size estimates from NSE service."),
+                         options,
+                         &run,
+                         NULL))
     return 2;
   return status;
 }
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index fd83d2b67..d71c62541 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -1,19 +1,19 @@
 /*
-  This file is part of GNUnet.
-  Copyright (C) 2009, 2010, 2011, 2012, 2013, 2016 GNUnet e.V.
+   This file is part of GNUnet.
+   Copyright (C) 2009, 2010, 2011, 2012, 2013, 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 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
  */
@@ -76,7 +76,7 @@
    GNUNET_MQ_PREF_CORK_ALLOWED)
 
 #if FREEBSD
-#define log2(a) (log (a) / log (2))
+#define log2(a) (log(a) / log(2))
 #endif
 
 /**
@@ -117,9 +117,7 @@ static struct GNUNET_BIO_WriteHandle *histogram;
 /**
  * Per-peer information.
  */
-struct NSEPeerEntry
-{
-
+struct NSEPeerEntry {
   /**
    * Core handle for sending messages to this peer.
    */
@@ -143,7 +141,6 @@ struct NSEPeerEntry
   int previous_round;
 
 #if ENABLE_NSE_HISTOGRAM
-
   /**
    * Amount of messages received from this peer on this round.
    */
@@ -158,7 +155,6 @@ struct NSEPeerEntry
    * Which size did we tell the peer the network is?
    */
   unsigned int last_transmitted_size;
-
 #endif
 };
 
@@ -170,8 +166,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * peer's timer has run out before receiving a
  * valid reply from another peer.
  */
-struct GNUNET_NSE_FloodMessage
-{
+struct GNUNET_NSE_FloodMessage {
   /**
    * Type: #GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD
    */
@@ -322,7 +317,7 @@ static uint64_t my_proof;
  * @param em message to fill in
  */
 static void
-setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
+setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
 {
   double mean;
   double sum;
@@ -345,19 +340,19 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
   sumweight = 0.0;
   variance = 0.0;
   for (unsigned int i = 0; i < estimate_count; i++)
-  {
-    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
+    {
+      unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
-    val = htonl (size_estimate_messages[j].matching_bits);
-    weight = estimate_count + 1 - i;
+      val = htonl(size_estimate_messages[j].matching_bits);
+      weight = estimate_count + 1 - i;
 
-    temp = weight + sumweight;
-    q = val - mean;
-    r = q * weight / temp;
-    mean += r;
-    sum += sumweight * q * r;
-    sumweight = temp;
-  }
+      temp = weight + sumweight;
+      q = val - mean;
+      r = q * weight / temp;
+      mean += r;
+      sum += sumweight * q * r;
+      sumweight = temp;
+    }
   if (estimate_count > 0)
     variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
 #else
@@ -371,44 +366,44 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
   mean = 0.0;
 
   for (unsigned int i = 0; i < estimate_count; i++)
-  {
-    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
+    {
+      unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
-    val = htonl (size_estimate_messages[j].matching_bits);
-    sum += val;
-    vsq += val * val;
-  }
+      val = htonl(size_estimate_messages[j].matching_bits);
+      sum += val;
+      vsq += val * val;
+    }
   if (0 != estimate_count)
-  {
-    mean = sum / estimate_count;
-    variance = (vsq - mean * sum) /
-               (estimate_count - 1.0); // terrible for numerical stability...
-  }
+    {
+      mean = sum / estimate_count;
+      variance = (vsq - mean * sum) /
+                 (estimate_count - 1.0); // terrible for numerical stability...
+    }
 #endif
   if (variance >= 0)
-    std_dev = sqrt (variance);
+    std_dev = sqrt(variance);
   else
     std_dev = variance; /* must be infinity due to estimate_count == 0 */
   current_std_dev = std_dev;
   current_size_estimate = mean;
 
-  em->header.size = htons (sizeof (struct GNUNET_NSE_ClientMessage));
-  em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
-  em->reserved = htonl (0);
-  em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
+  em->header.size = htons(sizeof(struct GNUNET_NSE_ClientMessage));
+  em->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
+  em->reserved = htonl(0);
+  em->timestamp = GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get());
   {
     double se = mean - 0.332747;
-    unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers);
+    unsigned int j = GNUNET_CONTAINER_multipeermap_size(peers);
     if (0 == j)
       j = 1; /* Avoid log2(0); can only happen if CORE didn't report
-                connection to self yet */
-    nsize = log2 (j);
-    em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
-    em->std_deviation = GNUNET_hton_double (std_dev);
-    GNUNET_STATISTICS_set (stats,
-                           "# nodes in the network (estimate)",
-                           (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
-                           GNUNET_NO);
+                connection to self yet */
+    nsize = log2(j);
+    em->size_estimate = GNUNET_hton_double(GNUNET_MAX(se, nsize));
+    em->std_deviation = GNUNET_hton_double(std_dev);
+    GNUNET_STATISTICS_set(stats,
+                          "# nodes in the network (estimate)",
+                          (uint64_t)pow(2, GNUNET_MAX(se, nsize)),
+                          GNUNET_NO);
   }
 }
 
@@ -423,21 +418,21 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
  * @param message the message received
  */
 static void
-handle_start (void *cls, const struct GNUNET_MessageHeader *message)
+handle_start(void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_MQ_Handle *mq;
   struct GNUNET_NSE_ClientMessage em;
   struct GNUNET_MQ_Envelope *env;
 
-  (void) message;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
-  mq = GNUNET_SERVICE_client_get_mq (client);
-  GNUNET_notification_context_add (nc, mq);
-  setup_estimate_message (&em);
-  env = GNUNET_MQ_msg_copy (&em.header);
-  GNUNET_MQ_send (mq, env);
-  GNUNET_SERVICE_client_continue (client);
+  (void)message;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
+  mq = GNUNET_SERVICE_client_get_mq(client);
+  GNUNET_notification_context_add(nc, mq);
+  setup_estimate_message(&em);
+  env = GNUNET_MQ_msg_copy(&em.header);
+  GNUNET_MQ_send(mq, env);
+  GNUNET_SERVICE_client_continue(client);
 }
 
 
@@ -448,16 +443,16 @@ handle_start (void *cls, const struct GNUNET_MessageHeader *message)
  * @param matching_bits number of matching bits to consider
  */
 static double
-get_matching_bits_delay (uint32_t matching_bits)
+get_matching_bits_delay(uint32_t matching_bits)
 {
   /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
   // S is next_timestamp (ignored in return value)
   // f is frequency (gnunet_nse_interval)
   // x is matching_bits
   // p' is current_size_estimate
-  return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0) -
+  return ((double)gnunet_nse_interval.rel_value_us / (double)2.0) -
          ((gnunet_nse_interval.rel_value_us / M_PI) *
-          atan (matching_bits - current_size_estimate));
+          atan(matching_bits - current_size_estimate));
 }
 
 
@@ -468,21 +463,21 @@ get_matching_bits_delay (uint32_t matching_bits)
  * @return random delay to apply
  */
 static struct GNUNET_TIME_Relative
-get_delay_randomization (uint32_t matching_bits)
+get_delay_randomization(uint32_t matching_bits)
 {
 #if USE_RANDOM_DELAYS
   struct GNUNET_TIME_Relative ret;
   uint32_t i;
   double d;
 
-  d = get_matching_bits_delay (matching_bits);
-  i = (uint32_t) (d / (double) (hop_count_max + 1));
+  d = get_matching_bits_delay(matching_bits);
+  i = (uint32_t)(d / (double)(hop_count_max + 1));
   ret.rel_value_us = i;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Randomizing flood using latencies up to %s\n",
-              GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Randomizing flood using latencies up to %s\n",
+             GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
   ret.rel_value_us =
-    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
+    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
   return ret;
 #else
   return GNUNET_TIME_UNIT_ZERO;
@@ -498,18 +493,18 @@ get_delay_randomization (uint32_t matching_bits)
  * @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));
 }
 
 
@@ -521,17 +516,17 @@ pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
  * @return number of matching bits
  */
 static uint32_t
-get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
-                   const struct GNUNET_PeerIdentity *id)
+get_matching_bits(struct GNUNET_TIME_Absolute timestamp,
+                  const struct GNUNET_PeerIdentity *id)
 {
   struct GNUNET_HashCode timestamp_hash;
   struct GNUNET_HashCode pid_hash;
 
-  GNUNET_CRYPTO_hash (&timestamp.abs_value_us,
-                      sizeof (timestamp.abs_value_us),
-                      &timestamp_hash);
-  GNUNET_CRYPTO_hash (id, sizeof (struct GNUNET_PeerIdentity), &pid_hash);
-  return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &pid_hash);
+  GNUNET_CRYPTO_hash(&timestamp.abs_value_us,
+                     sizeof(timestamp.abs_value_us),
+                     &timestamp_hash);
+  GNUNET_CRYPTO_hash(id, sizeof(struct GNUNET_PeerIdentity), &pid_hash);
+  return GNUNET_CRYPTO_hash_matching_bits(&timestamp_hash, &pid_hash);
 }
 
 
@@ -544,7 +539,7 @@ get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
  * @return delay that should be applied
  */
 static struct GNUNET_TIME_Relative
-get_transmit_delay (int round_offset)
+get_transmit_delay(int round_offset)
 {
   struct GNUNET_TIME_Relative ret;
   struct GNUNET_TIME_Absolute tgt;
@@ -552,36 +547,37 @@ get_transmit_delay (int round_offset)
   uint32_t matching_bits;
 
   switch (round_offset)
-  {
-  case -1:
-    /* previous round is randomized between 0 and 50 ms */
+    {
+    case -1:
+      /* previous round is randomized between 0 and 50 ms */
 #if USE_RANDOM_DELAYS
-    ret.rel_value_us =
-      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
+      ret.rel_value_us =
+        GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, 50);
 #else
-    ret = GNUNET_TIME_UNIT_ZERO;
+      ret = GNUNET_TIME_UNIT_ZERO;
 #endif
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Transmitting previous round behind schedule in %s\n",
-                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
-    return ret;
-  case 0:
-    /* current round is based on best-known matching_bits */
-    matching_bits =
-      ntohl (size_estimate_messages[estimate_index].matching_bits);
-    dist_delay = get_matching_bits_delay (matching_bits);
-    dist_delay += get_delay_randomization (matching_bits).rel_value_us;
-    ret.rel_value_us = (uint64_t) dist_delay;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "For round %s, delay for %u matching bits is %s\n",
-                GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
-                (unsigned int) matching_bits,
-                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
-    /* now consider round start time and add delay to it */
-    tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
-    return GNUNET_TIME_absolute_get_remaining (tgt);
-  }
-  GNUNET_break (0);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Transmitting previous round behind schedule in %s\n",
+                 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
+      return ret;
+
+    case 0:
+      /* current round is based on best-known matching_bits */
+      matching_bits =
+        ntohl(size_estimate_messages[estimate_index].matching_bits);
+      dist_delay = get_matching_bits_delay(matching_bits);
+      dist_delay += get_delay_randomization(matching_bits).rel_value_us;
+      ret.rel_value_us = (uint64_t)dist_delay;
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "For round %s, delay for %u matching bits is %s\n",
+                 GNUNET_STRINGS_absolute_time_to_string(current_timestamp),
+                 (unsigned int)matching_bits,
+                 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
+      /* now consider round start time and add delay to it */
+      tgt = GNUNET_TIME_absolute_add(current_timestamp, ret);
+      return GNUNET_TIME_absolute_get_remaining(tgt);
+    }
+  GNUNET_break(0);
   return GNUNET_TIME_UNIT_FOREVER_REL;
 }
 
@@ -592,7 +588,7 @@ get_transmit_delay (int round_offset)
  * @param cls the `struct NSEPeerEntry *`
  */
 static void
-transmit_task_cb (void *cls)
+transmit_task_cb(void *cls)
 {
   struct NSEPeerEntry *peer_entry = cls;
   unsigned int idx;
@@ -601,51 +597,51 @@ transmit_task_cb (void *cls)
   peer_entry->transmit_task = NULL;
   idx = estimate_index;
   if (GNUNET_NO == peer_entry->previous_round)
-  {
-    idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
-    peer_entry->previous_round = GNUNET_YES;
-    peer_entry->transmit_task =
-      GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
-                                    &transmit_task_cb,
-                                    peer_entry);
-  }
-  if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
+    {
+      idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
+      peer_entry->previous_round = GNUNET_YES;
+      peer_entry->transmit_task =
+        GNUNET_SCHEDULER_add_delayed(get_transmit_delay(0),
+                                     &transmit_task_cb,
+                                     peer_entry);
+    }
+  if ((0 == ntohl(size_estimate_messages[idx].hop_count)) &&
       (NULL != proof_task))
-  {
-    GNUNET_STATISTICS_update (stats,
-                              "# flood messages not generated (no proof yet)",
-                              1,
-                              GNUNET_NO);
-    return;
-  }
-  if (0 == ntohs (size_estimate_messages[idx].header.size))
-  {
-    GNUNET_STATISTICS_update (stats,
-                              "# flood messages not generated (lack of history)",
-                              1,
-                              GNUNET_NO);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "In round %s, sending to `%s' estimate with %u bits\n",
-              GNUNET_STRINGS_absolute_time_to_string (
-                GNUNET_TIME_absolute_ntoh (
-                  size_estimate_messages[idx].timestamp)),
-              GNUNET_i2s (peer_entry->id),
-              (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
-  if (0 == ntohl (size_estimate_messages[idx].hop_count))
-    GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
-  GNUNET_STATISTICS_update (stats,
-                            "# flood messages transmitted",
-                            1,
-                            GNUNET_NO);
+    {
+      GNUNET_STATISTICS_update(stats,
+                               "# flood messages not generated (no proof yet)",
+                               1,
+                               GNUNET_NO);
+      return;
+    }
+  if (0 == ntohs(size_estimate_messages[idx].header.size))
+    {
+      GNUNET_STATISTICS_update(stats,
+                               "# flood messages not generated (lack of history)",
+                               1,
+                               GNUNET_NO);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "In round %s, sending to `%s' estimate with %u bits\n",
+             GNUNET_STRINGS_absolute_time_to_string(
+               GNUNET_TIME_absolute_ntoh(
+                 size_estimate_messages[idx].timestamp)),
+             GNUNET_i2s(peer_entry->id),
+             (unsigned int)ntohl(size_estimate_messages[idx].matching_bits));
+  if (0 == ntohl(size_estimate_messages[idx].hop_count))
+    GNUNET_STATISTICS_update(stats, "# flood messages started", 1, GNUNET_NO);
+  GNUNET_STATISTICS_update(stats,
+                           "# flood messages transmitted",
+                           1,
+                           GNUNET_NO);
 #if ENABLE_NSE_HISTOGRAM
   peer_entry->transmitted_messages++;
   peer_entry->last_transmitted_size =
-    ntohl (size_estimate_messages[idx].matching_bits);
+    ntohl(size_estimate_messages[idx].matching_bits);
 #endif
-  env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header);
-  GNUNET_MQ_send (peer_entry->mq, env);
+  env = GNUNET_MQ_msg_copy(&size_estimate_messages[idx].header);
+  GNUNET_MQ_send(peer_entry->mq, env);
 }
 
 
@@ -656,12 +652,12 @@ transmit_task_cb (void *cls)
  * clients.
  */
 static void
-update_network_size_estimate ()
+update_network_size_estimate()
 {
   struct GNUNET_NSE_ClientMessage em;
 
-  setup_estimate_message (&em);
-  GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES);
+  setup_estimate_message(&em);
+  GNUNET_notification_context_broadcast(nc, &em.header, GNUNET_YES);
 }
 
 
@@ -673,31 +669,31 @@ update_network_size_estimate ()
  * @param ts timestamp to use
  */
 static void
-setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
+setup_flood_message(unsigned int slot, struct GNUNET_TIME_Absolute ts)
 {
   struct GNUNET_NSE_FloodMessage *fm;
   uint32_t matching_bits;
 
-  matching_bits = get_matching_bits (ts, &my_identity);
+  matching_bits = get_matching_bits(ts, &my_identity);
   fm = &size_estimate_messages[slot];
-  fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage));
-  fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
-  fm->hop_count = htonl (0);
-  fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
+  fm->header.size = htons(sizeof(struct GNUNET_NSE_FloodMessage));
+  fm->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
+  fm->hop_count = htonl(0);
+  fm->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
   fm->purpose.size =
-    htonl (sizeof (struct GNUNET_NSE_FloodMessage) -
-           sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) -
-           sizeof (struct GNUNET_CRYPTO_EddsaSignature));
-  fm->matching_bits = htonl (matching_bits);
-  fm->timestamp = GNUNET_TIME_absolute_hton (ts);
+    htonl(sizeof(struct GNUNET_NSE_FloodMessage) -
+          sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t) -
+          sizeof(struct GNUNET_CRYPTO_EddsaSignature));
+  fm->matching_bits = htonl(matching_bits);
+  fm->timestamp = GNUNET_TIME_absolute_hton(ts);
   fm->origin = my_identity;
   fm->proof_of_work = my_proof;
   if (nse_work_required > 0)
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
-                                                          &fm->purpose,
-                                                          &fm->signature));
+    GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
+                                                        &fm->purpose,
+                                                        &fm->signature));
   else
-    memset (&fm->signature, 0, sizeof (fm->signature));
+    memset(&fm->signature, 0, sizeof(fm->signature));
 }
 
 
@@ -711,34 +707,34 @@ setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-schedule_current_round (void *cls,
-                        const struct GNUNET_PeerIdentity *key,
-                        void *value)
+schedule_current_round(void *cls,
+                       const struct GNUNET_PeerIdentity *key,
+                       void *value)
 {
   struct NSEPeerEntry *peer_entry = value;
   struct GNUNET_TIME_Relative delay;
 
-  (void) cls;
-  (void) key;
+  (void)cls;
+  (void)key;
   if (NULL != peer_entry->transmit_task)
-  {
-    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
-    peer_entry->previous_round = GNUNET_NO;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
+      peer_entry->previous_round = GNUNET_NO;
+    }
 #if ENABLE_NSE_HISTOGRAM
   if (peer_entry->received_messages > 1)
-    GNUNET_STATISTICS_update (stats,
-                              "# extra messages",
-                              peer_entry->received_messages - 1,
-                              GNUNET_NO);
+    GNUNET_STATISTICS_update(stats,
+                             "# extra messages",
+                             peer_entry->received_messages - 1,
+                             GNUNET_NO);
   peer_entry->transmitted_messages = 0;
   peer_entry->last_transmitted_size = 0;
   peer_entry->received_messages = 0;
 #endif
   delay =
-    get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
+    get_transmit_delay((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
+    GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
   return GNUNET_OK;
 }
 
@@ -749,46 +745,46 @@ schedule_current_round (void *cls,
  * @param cls unused
  */
 static void
-update_flood_message (void *cls)
+update_flood_message(void *cls)
 {
   struct GNUNET_TIME_Relative offset;
 
-  (void) cls;
+  (void)cls;
   flood_task = NULL;
-  offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
+  offset = GNUNET_TIME_absolute_get_remaining(next_timestamp);
   if (0 != offset.rel_value_us)
-  {
-    /* somehow run early, delay more */
-    flood_task =
-      GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
-    return;
-  }
+    {
+      /* somehow run early, delay more */
+      flood_task =
+        GNUNET_SCHEDULER_add_delayed(offset, &update_flood_message, NULL);
+      return;
+    }
   estimate_index = (estimate_index + 1) % HISTORY_SIZE;
   if (estimate_count < HISTORY_SIZE)
     estimate_count++;
   current_timestamp = next_timestamp;
   next_timestamp =
-    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
+    GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
   if ((current_timestamp.abs_value_us ==
-       GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
-      (get_matching_bits (current_timestamp, &my_identity) <
-       ntohl (next_message.matching_bits)))
-  {
-    /* we received a message for this round way early, use it! */
-    size_estimate_messages[estimate_index] = next_message;
-    size_estimate_messages[estimate_index].hop_count =
-      htonl (1 + ntohl (next_message.hop_count));
-  }
+       GNUNET_TIME_absolute_ntoh(next_message.timestamp).abs_value_us) &&
+      (get_matching_bits(current_timestamp, &my_identity) <
+       ntohl(next_message.matching_bits)))
+    {
+      /* we received a message for this round way early, use it! */
+      size_estimate_messages[estimate_index] = next_message;
+      size_estimate_messages[estimate_index].hop_count =
+        htonl(1 + ntohl(next_message.hop_count));
+    }
   else
-    setup_flood_message (estimate_index, current_timestamp);
-  next_message.matching_bits = htonl (0); /* reset for 'next' round */
+    setup_flood_message(estimate_index, current_timestamp);
+  next_message.matching_bits = htonl(0);  /* reset for 'next' round */
   hop_count_max = 0;
   for (unsigned int i = 0; i < HISTORY_SIZE; i++)
     hop_count_max =
-      GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
-  GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
+      GNUNET_MAX(ntohl(size_estimate_messages[i].hop_count), hop_count_max);
+  GNUNET_CONTAINER_multipeermap_iterate(peers, &schedule_current_round, NULL);
   flood_task =
-    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
+    GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
 }
 
 
@@ -799,12 +795,12 @@ update_flood_message (void *cls)
  * @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;
 }
@@ -819,20 +815,20 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
  * @return #GNUNET_YES if valid, #GNUNET_NO if not
  */
 static int
-check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
-                     uint64_t val)
+check_proof_of_work(const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
+                    uint64_t val)
 {
-  char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
-           sizeof (val)] GNUNET_ALIGN;
+  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
+           sizeof(val)] GNUNET_ALIGN;
   struct GNUNET_HashCode result;
 
-  GNUNET_memcpy (buf, &val, sizeof (val));
-  GNUNET_memcpy (&buf[sizeof (val)],
-                 pkey,
-                 sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
-  pow_hash (buf, sizeof (buf), &result);
-  return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES
-                                                               : GNUNET_NO;
+  GNUNET_memcpy(buf, &val, sizeof(val));
+  GNUNET_memcpy(&buf[sizeof(val)],
+                pkey,
+                sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
+  pow_hash(buf, sizeof(buf), &result);
+  return (count_leading_zeroes(&result) >= nse_work_required) ? GNUNET_YES
+         : GNUNET_NO;
 }
 
 
@@ -840,20 +836,20 @@ check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
  * Write our current proof to disk.
  */
 static void
-write_proof ()
+write_proof()
 {
   char *proof;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
     return;
-  if (sizeof (my_proof) != GNUNET_DISK_fn_write (proof,
-                                                 &my_proof,
-                                                 sizeof (my_proof),
-                                                 GNUNET_DISK_PERM_USER_READ |
-                                                   GNUNET_DISK_PERM_USER_WRITE))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof);
-  GNUNET_free (proof);
+  if (sizeof(my_proof) != GNUNET_DISK_fn_write(proof,
+                                               &my_proof,
+                                               sizeof(my_proof),
+                                               GNUNET_DISK_PERM_USER_READ |
+                                               GNUNET_DISK_PERM_USER_WRITE))
+    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "write", proof);
+  GNUNET_free(proof);
 }
 
 
@@ -863,57 +859,57 @@ write_proof ()
  * @param cls closure (unused)
  */
 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;
 
-  (void) cls;
+  (void)cls;
   proof_task = NULL;
-  GNUNET_memcpy (&buf[sizeof (uint64_t)],
-                 &my_identity,
-                 sizeof (struct GNUNET_PeerIdentity));
+  GNUNET_memcpy(&buf[sizeof(uint64_t)],
+                &my_identity,
+                sizeof(struct GNUNET_PeerIdentity));
   i = 0;
   counter = my_proof;
   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))
     {
-      my_proof = counter;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Proof of work found: %llu!\n",
-                  (unsigned long long) GNUNET_ntohll (counter));
-      write_proof ();
-      setup_flood_message (estimate_index, current_timestamp);
-      return;
+      GNUNET_memcpy(buf, &counter, sizeof(uint64_t));
+      pow_hash(buf, sizeof(buf), &result);
+      if (nse_work_required <= count_leading_zeroes(&result))
+        {
+          my_proof = counter;
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Proof of work found: %llu!\n",
+                     (unsigned long long)GNUNET_ntohll(counter));
+          write_proof();
+          setup_flood_message(estimate_index, current_timestamp);
+          return;
+        }
+      counter++;
+      i++;
     }
-    counter++;
-    i++;
-  }
   if (my_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 */
-    my_proof = counter;
-    write_proof ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Testing proofs currently at %llu\n",
+                 (unsigned long long)counter);
+      /* remember progress every 100 rounds */
+      my_proof = counter;
+      write_proof();
+    }
   else
-  {
-    my_proof = counter;
-  }
+    {
+      my_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);
 }
 
 
@@ -927,28 +923,28 @@ find_proof (void *cls)
  *         #GNUNET_NO if the key/signature don't verify
  */
 static int
-verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
+verify_message_crypto(const struct GNUNET_NSE_FloodMessage *incoming_flood)
 {
-  if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
-                                         incoming_flood->proof_of_work))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Proof of work invalid: %llu!\n",
-                (unsigned long long) GNUNET_ntohll (
-                  incoming_flood->proof_of_work));
-    GNUNET_break_op (0);
-    return GNUNET_NO;
-  }
+  if (GNUNET_YES != check_proof_of_work(&incoming_flood->origin.public_key,
+                                        incoming_flood->proof_of_work))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Proof of work invalid: %llu!\n",
+                 (unsigned long long)GNUNET_ntohll(
+                   incoming_flood->proof_of_work));
+      GNUNET_break_op(0);
+      return GNUNET_NO;
+    }
   if ((nse_work_required > 0) &&
       (GNUNET_OK !=
-       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
-                                   &incoming_flood->purpose,
-                                   &incoming_flood->signature,
-                                   &incoming_flood->origin.public_key)))
-  {
-    GNUNET_break_op (0);
-    return GNUNET_NO;
-  }
+       GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
+                                  &incoming_flood->purpose,
+                                  &incoming_flood->signature,
+                                  &incoming_flood->origin.public_key)))
+    {
+      GNUNET_break_op(0);
+      return GNUNET_NO;
+    }
   return GNUNET_YES;
 }
 
@@ -963,35 +959,35 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-update_flood_times (void *cls,
-                    const struct GNUNET_PeerIdentity *key,
-                    void *value)
+update_flood_times(void *cls,
+                   const struct GNUNET_PeerIdentity *key,
+                   void *value)
 {
   struct NSEPeerEntry *exclude = cls;
   struct NSEPeerEntry *peer_entry = value;
   struct GNUNET_TIME_Relative delay;
 
-  (void) key;
+  (void)key;
   if (peer_entry == exclude)
     return GNUNET_OK; /* trigger of the update */
   if (GNUNET_NO == peer_entry->previous_round)
-  {
-    /* still stuck in previous round, no point to update, check that
-     * we are active here though... */
-    if (NULL == peer_entry->transmit_task)
     {
-      GNUNET_break (0);
+      /* still stuck in previous round, no point to update, check that
+       * we are active here though... */
+      if (NULL == peer_entry->transmit_task)
+        {
+          GNUNET_break(0);
+        }
+      return GNUNET_OK;
     }
-    return GNUNET_OK;
-  }
   if (NULL != peer_entry->transmit_task)
-  {
-    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
-    peer_entry->transmit_task = NULL;
-  }
-  delay = get_transmit_delay (0);
+    {
+      GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
+      peer_entry->transmit_task = NULL;
+    }
+  delay = get_transmit_delay(0);
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
+    GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
   return GNUNET_OK;
 }
 
@@ -1003,8 +999,8 @@ update_flood_times (void *cls,
  * @param incoming_flood received message
  */
 static void
-handle_p2p_estimate (void *cls,
-                     const struct GNUNET_NSE_FloodMessage *incoming_flood)
+handle_p2p_estimate(void *cls,
+                    const struct GNUNET_NSE_FloodMessage *incoming_flood)
 {
   struct NSEPeerEntry *peer_entry = cls;
   struct GNUNET_TIME_Absolute ts;
@@ -1015,34 +1011,34 @@ handle_p2p_estimate (void *cls,
   {
     uint64_t t;
 
-    t = GNUNET_TIME_absolute_get ().abs_value_us;
+    t = GNUNET_TIME_absolute_get().abs_value_us;
     if (NULL != lh)
-      GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t));
+      GNUNET_TESTBED_LOGGER_write(lh, &t, sizeof(uint64_t));
     if (NULL != histogram)
-      GNUNET_BIO_write_int64 (histogram, t);
+      GNUNET_BIO_write_int64(histogram, t);
   }
 #endif
-  GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
-  matching_bits = ntohl (incoming_flood->matching_bits);
+  GNUNET_STATISTICS_update(stats, "# flood messages received", 1, GNUNET_NO);
+  matching_bits = ntohl(incoming_flood->matching_bits);
 #if DEBUG_NSE
   {
     char origin[5];
     char pred[5];
     struct GNUNET_PeerIdentity os;
 
-    GNUNET_snprintf (origin,
-                     sizeof (origin),
-                     "%s",
-                     GNUNET_i2s (&incoming_flood->origin));
-    GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer_entry->id));
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
-                GNUNET_STRINGS_absolute_time_to_string (
-                  GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
-                origin,
-                pred,
-                GNUNET_i2s (&my_identity),
-                (unsigned int) matching_bits);
+    GNUNET_snprintf(origin,
+                    sizeof(origin),
+                    "%s",
+                    GNUNET_i2s(&incoming_flood->origin));
+    GNUNET_snprintf(pred, sizeof(pred), "%s", GNUNET_i2s(peer_entry->id));
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
+               GNUNET_STRINGS_absolute_time_to_string(
+                 GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp)),
+               origin,
+               pred,
+               GNUNET_i2s(&my_identity),
+               (unsigned int)matching_bits);
   }
 #endif
 
@@ -1050,122 +1046,122 @@ handle_p2p_estimate (void *cls,
   peer_entry->received_messages++;
   if (peer_entry->transmitted_messages > 0 &&
       peer_entry->last_transmitted_size >= matching_bits)
-    GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
+    GNUNET_STATISTICS_update(stats, "# cross messages", 1, GNUNET_NO);
 #endif
 
-  ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
+  ts = GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp);
   if (ts.abs_value_us == current_timestamp.abs_value_us)
     idx = estimate_index;
   else if (ts.abs_value_us ==
            current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us)
     idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
   else if (ts.abs_value_us == next_timestamp.abs_value_us)
-  {
-    if (matching_bits <= ntohl (next_message.matching_bits))
-      return; /* ignore, simply too early/late */
-    if (GNUNET_YES != verify_message_crypto (incoming_flood))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Peer %s is likely ill-configured!\n",
-                  GNUNET_i2s (peer_entry->id));
-      GNUNET_break_op (0);
+      if (matching_bits <= ntohl(next_message.matching_bits))
+        return; /* ignore, simply too early/late */
+      if (GNUNET_YES != verify_message_crypto(incoming_flood))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                     "Peer %s is likely ill-configured!\n",
+                     GNUNET_i2s(peer_entry->id));
+          GNUNET_break_op(0);
+          return;
+        }
+      next_message = *incoming_flood;
       return;
     }
-    next_message = *incoming_flood;
-    return;
-  }
   else
-  {
-    GNUNET_STATISTICS_update (stats,
-                              "# flood messages discarded (clock skew too large)",
-                              1,
-                              GNUNET_NO);
-    return;
-  }
-  if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity)))
-  {
-    /* send to self, update our own estimate IF this also comes from us! */
-    if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity))
-      update_network_size_estimate ();
-    return;
-  }
-  if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
-  {
-    /* Cancel transmission in the other direction, as this peer clearly has
-       up-to-date information already. Even if we didn't talk to this peer in
-       the previous round, we should no longer send it stale information as it
-       told us about the current round! */
-    peer_entry->previous_round = GNUNET_YES;
-    if (idx != estimate_index)
     {
-      /* do not transmit information for the previous round to this peer
-         anymore (but allow current round) */
+      GNUNET_STATISTICS_update(stats,
+                               "# flood messages discarded (clock skew too large)",
+                               1,
+                               GNUNET_NO);
       return;
     }
-    /* got up-to-date information for current round, cancel transmission to
-     * this peer altogether */
-    if (NULL != peer_entry->transmit_task)
+  if (0 == (GNUNET_memcmp(peer_entry->id, &my_identity)))
     {
-      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
-      peer_entry->transmit_task = NULL;
+      /* send to self, update our own estimate IF this also comes from us! */
+      if (0 == GNUNET_memcmp(&incoming_flood->origin, &my_identity))
+        update_network_size_estimate();
+      return;
     }
-    return;
-  }
-  if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
-  {
-    if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
+  if (matching_bits == ntohl(size_estimate_messages[idx].matching_bits))
     {
-      peer_entry->previous_round = GNUNET_NO;
+      /* Cancel transmission in the other direction, as this peer clearly has
+         up-to-date information already. Even if we didn't talk to this peer in
+         the previous round, we should no longer send it stale information as it
+         told us about the current round! */
+      peer_entry->previous_round = GNUNET_YES;
+      if (idx != estimate_index)
+        {
+          /* do not transmit information for the previous round to this peer
+             anymore (but allow current round) */
+          return;
+        }
+      /* got up-to-date information for current round, cancel transmission to
+       * this peer altogether */
+      if (NULL != peer_entry->transmit_task)
+        {
+          GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
+          peer_entry->transmit_task = NULL;
+        }
+      return;
     }
-    /* push back our result now, that peer is spreading bad information... */
-    if (NULL != peer_entry->transmit_task)
-      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
-    peer_entry->transmit_task =
-      GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
-    /* Not closer than our most recent message, no need to do work here */
-    GNUNET_STATISTICS_update (stats,
-                              "# flood messages ignored (had closer already)",
-                              1,
-                              GNUNET_NO);
-    return;
-  }
-  if (GNUNET_YES != verify_message_crypto (incoming_flood))
-  {
-    GNUNET_break_op (0);
-    return;
-  }
-  GNUNET_assert (matching_bits >
-                 ntohl (size_estimate_messages[idx].matching_bits));
+  if (matching_bits < ntohl(size_estimate_messages[idx].matching_bits))
+    {
+      if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
+        {
+          peer_entry->previous_round = GNUNET_NO;
+        }
+      /* push back our result now, that peer is spreading bad information... */
+      if (NULL != peer_entry->transmit_task)
+        GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
+      peer_entry->transmit_task =
+        GNUNET_SCHEDULER_add_now(&transmit_task_cb, peer_entry);
+      /* Not closer than our most recent message, no need to do work here */
+      GNUNET_STATISTICS_update(stats,
+                               "# flood messages ignored (had closer already)",
+                               1,
+                               GNUNET_NO);
+      return;
+    }
+  if (GNUNET_YES != verify_message_crypto(incoming_flood))
+    {
+      GNUNET_break_op(0);
+      return;
+    }
+  GNUNET_assert(matching_bits >
+                ntohl(size_estimate_messages[idx].matching_bits));
   /* Cancel transmission in the other direction, as this peer clearly has
    * up-to-date information already.
    */
   peer_entry->previous_round = GNUNET_YES;
   if (idx == estimate_index)
-  {
-    /* cancel any activity for current round */
-    if (NULL != peer_entry->transmit_task)
     {
-      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
-      peer_entry->transmit_task = NULL;
+      /* cancel any activity for current round */
+      if (NULL != peer_entry->transmit_task)
+        {
+          GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
+          peer_entry->transmit_task = NULL;
+        }
     }
-  }
   size_estimate_messages[idx] = *incoming_flood;
   size_estimate_messages[idx].hop_count =
-    htonl (ntohl (incoming_flood->hop_count) + 1);
+    htonl(ntohl(incoming_flood->hop_count) + 1);
   hop_count_max =
-    GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
-  GNUNET_STATISTICS_set (stats,
-                         "# estimated network diameter",
-                         hop_count_max,
-                         GNUNET_NO);
+    GNUNET_MAX(ntohl(incoming_flood->hop_count) + 1, hop_count_max);
+  GNUNET_STATISTICS_set(stats,
+                        "# estimated network diameter",
+                        hop_count_max,
+                        GNUNET_NO);
 
   /* have a new, better size estimate, inform clients */
-  update_network_size_estimate ();
+  update_network_size_estimate();
 
   /* flood to rest */
-  GNUNET_CONTAINER_multipeermap_iterate (peers,
-                                         &update_flood_times,
-                                         peer_entry);
+  GNUNET_CONTAINER_multipeermap_iterate(peers,
+                                        &update_flood_times,
+                                        peer_entry);
 }
 
 
@@ -1177,33 +1173,33 @@ handle_p2p_estimate (void *cls,
  * @param peer peer identity this notification is about
  */
 static void *
-handle_core_connect (void *cls,
-                     const struct GNUNET_PeerIdentity *peer,
-                     struct GNUNET_MQ_Handle *mq)
+handle_core_connect(void *cls,
+                    const struct GNUNET_PeerIdentity *peer,
+                    struct GNUNET_MQ_Handle *mq)
 {
   struct NSEPeerEntry *peer_entry;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%s' connected to us\n",
-              GNUNET_i2s (peer));
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Peer `%s' connected to us\n",
+             GNUNET_i2s(peer));
   /* set our default transmission options */
-  GNUNET_MQ_set_options (mq, NSE_PRIORITY);
+  GNUNET_MQ_set_options(mq, NSE_PRIORITY);
   /* create our peer entry for this peer */
-  peer_entry = GNUNET_new (struct NSEPeerEntry);
+  peer_entry = GNUNET_new(struct NSEPeerEntry);
   peer_entry->id = peer;
   peer_entry->mq = mq;
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multipeermap_put (
-                   peers,
-                   peer_entry->id,
-                   peer_entry,
-                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONTAINER_multipeermap_put(
+                  peers,
+                  peer_entry->id,
+                  peer_entry,
+                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   peer_entry->transmit_task =
-    GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
-                                  &transmit_task_cb,
-                                  peer_entry);
-  GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
+    GNUNET_SCHEDULER_add_delayed(get_transmit_delay(-1),
+                                 &transmit_task_cb,
+                                 peer_entry);
+  GNUNET_STATISTICS_update(stats, "# peers connected", 1, GNUNET_NO);
   return peer_entry;
 }
 
@@ -1217,25 +1213,25 @@ handle_core_connect (void *cls,
  * @parma internal_cls the `struct NSEPeerEntry` for the @a peer
  */
 static void
-handle_core_disconnect (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        void *internal_cls)
+handle_core_disconnect(void *cls,
+                       const struct GNUNET_PeerIdentity *peer,
+                       void *internal_cls)
 {
   struct NSEPeerEntry *pos = internal_cls;
 
-  (void) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%s' disconnected from us\n",
-              GNUNET_i2s (peer));
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos));
+  (void)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Peer `%s' disconnected from us\n",
+             GNUNET_i2s(peer));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_multipeermap_remove(peers, peer, pos));
   if (NULL != pos->transmit_task)
-  {
-    GNUNET_SCHEDULER_cancel (pos->transmit_task);
-    pos->transmit_task = NULL;
-  }
-  GNUNET_free (pos);
-  GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
+    {
+      GNUNET_SCHEDULER_cancel(pos->transmit_task);
+      pos->transmit_task = NULL;
+    }
+  GNUNET_free(pos);
+  GNUNET_STATISTICS_update(stats, "# peers connected", -1, GNUNET_NO);
 }
 
 
@@ -1248,11 +1244,11 @@ handle_core_disconnect (void *cls,
  * @param size the amount of data sent (ignored)
  */
 static void
-flush_comp_cb (void *cls, size_t size)
+flush_comp_cb(void *cls, size_t size)
 {
-  (void) cls;
-  (void) size;
-  GNUNET_TESTBED_LOGGER_disconnect (lh);
+  (void)cls;
+  (void)size;
+  GNUNET_TESTBED_LOGGER_disconnect(lh);
   lh = NULL;
 }
 #endif
@@ -1264,60 +1260,60 @@ flush_comp_cb (void *cls, size_t size)
  * @param cls unused
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) cls;
+  (void)cls;
   if (NULL != flood_task)
-  {
-    GNUNET_SCHEDULER_cancel (flood_task);
-    flood_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(flood_task);
+      flood_task = NULL;
+    }
   if (NULL != proof_task)
-  {
-    GNUNET_SCHEDULER_cancel (proof_task);
-    proof_task = NULL;
-    write_proof (); /* remember progress */
-  }
+    {
+      GNUNET_SCHEDULER_cancel(proof_task);
+      proof_task = NULL;
+      write_proof(); /* remember progress */
+    }
   if (NULL != nc)
-  {
-    GNUNET_notification_context_destroy (nc);
-    nc = NULL;
-  }
+    {
+      GNUNET_notification_context_destroy(nc);
+      nc = NULL;
+    }
   if (NULL != core_api)
-  {
-    GNUNET_CORE_disconnect (core_api);
-    core_api = NULL;
-  }
+    {
+      GNUNET_CORE_disconnect(core_api);
+      core_api = NULL;
+    }
   if (NULL != stats)
-  {
-    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-    stats = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+      stats = NULL;
+    }
   if (NULL != peers)
-  {
-    GNUNET_CONTAINER_multipeermap_destroy (peers);
-    peers = NULL;
-  }
+    {
+      GNUNET_CONTAINER_multipeermap_destroy(peers);
+      peers = NULL;
+    }
   if (NULL != my_private_key)
-  {
-    GNUNET_free (my_private_key);
-    my_private_key = NULL;
-  }
+    {
+      GNUNET_free(my_private_key);
+      my_private_key = NULL;
+    }
 #if ENABLE_NSE_HISTOGRAM
   if (NULL != logger_test)
-  {
-    GNUNET_CLIENT_service_test_cancel (logger_test);
-    logger_test = NULL;
-  }
+    {
+      GNUNET_CLIENT_service_test_cancel(logger_test);
+      logger_test = NULL;
+    }
   if (NULL != lh)
-  {
-    GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
-  }
+    {
+      GNUNET_TESTBED_LOGGER_flush(lh, &flush_comp_cb, NULL);
+    }
   if (NULL != histogram)
-  {
-    GNUNET_BIO_write_close (histogram);
-    histogram = NULL;
-  }
+    {
+      GNUNET_BIO_write_close(histogram);
+      histogram = NULL;
+    }
 #endif
 }
 
@@ -1329,38 +1325,38 @@ shutdown_task (void *cls)
  * @param identity the public identity of this peer
  */
 static void
-core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
+core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
 {
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Absolute prev_time;
 
-  (void) cls;
+  (void)cls;
   if (NULL == identity)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  GNUNET_assert (0 == GNUNET_memcmp (&my_identity, identity));
-  now = GNUNET_TIME_absolute_get ();
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  GNUNET_assert(0 == GNUNET_memcmp(&my_identity, identity));
+  now = GNUNET_TIME_absolute_get();
   current_timestamp.abs_value_us =
     (now.abs_value_us / gnunet_nse_interval.rel_value_us) *
     gnunet_nse_interval.rel_value_us;
   next_timestamp =
-    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
+    GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
   estimate_index = HISTORY_SIZE - 1;
   estimate_count = 0;
-  if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof))
-  {
-    int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
-    prev_time.abs_value_us =
-      current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
-    setup_flood_message (idx, prev_time);
-    setup_flood_message (estimate_index, current_timestamp);
-    estimate_count++;
-  }
+  if (GNUNET_YES == check_proof_of_work(&my_identity.public_key, my_proof))
+    {
+      int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
+      prev_time.abs_value_us =
+        current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
+      setup_flood_message(idx, prev_time);
+      setup_flood_message(estimate_index, current_timestamp);
+      estimate_count++;
+    }
   flood_task =
-    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
+    GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
 }
 
 
@@ -1374,21 +1370,21 @@ core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
  *               #GNUNET_SYSERR if the configuration is invalid
  */
 static void
-status_cb (void *cls, int status)
+status_cb(void *cls, int status)
 {
-  (void) cls;
+  (void)cls;
   logger_test = NULL;
   if (GNUNET_YES != status)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
-    return;
-  }
-  if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Cannot connect to the testbed logger.  Exiting.\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
+      return;
+    }
+  if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect(cfg)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Cannot connect to the testbed logger.  Exiting.\n");
+      GNUNET_SCHEDULER_shutdown();
+    }
 }
 #endif
 
@@ -1401,127 +1397,127 @@ status_cb (void *cls, int status)
  * @param service the initialized service
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *c,
-     struct GNUNET_SERVICE_Handle *service)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *c,
+    struct GNUNET_SERVICE_Handle *service)
 {
   struct GNUNET_MQ_MessageHandler core_handlers[] =
-    {GNUNET_MQ_hd_fixed_size (p2p_estimate,
-                              GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
-                              struct GNUNET_NSE_FloodMessage,
-                              NULL),
-     GNUNET_MQ_handler_end ()};
+  { GNUNET_MQ_hd_fixed_size(p2p_estimate,
+                            GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
+                            struct GNUNET_NSE_FloodMessage,
+                            NULL),
+    GNUNET_MQ_handler_end() };
   char *proof;
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
 
-  (void) cls;
-  (void) service;
+  (void)cls;
+  (void)service;
   cfg = c;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
-                                                        "NSE",
-                                                        "INTERVAL",
-                                                        &gnunet_nse_interval))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
-                                                        "NSE",
-                                                        "WORKDELAY",
-                                                        &proof_find_delay))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
-    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;
-  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
+                                                       "NSE",
+                                                       "INTERVAL",
+                                                       &gnunet_nse_interval))
+    {
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
+                                                       "NSE",
+                                                       "WORKDELAY",
+                                                       &proof_find_delay))
+    {
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
+      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;
+    }
 
 #if ENABLE_NSE_HISTOGRAM
   {
     char *histogram_dir;
     char *histogram_fn;
 
-    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                              "NSE",
-                                                              "HISTOGRAM_DIR",
-                                                              &histogram_dir))
-    {
-      GNUNET_assert (
-        0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
-      GNUNET_free (histogram_dir);
-      histogram = GNUNET_BIO_write_open (histogram_fn);
-      if (NULL == histogram)
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                    "Unable to open histogram file `%s'\n",
-                    histogram_fn);
-      GNUNET_free (histogram_fn);
-    }
-    logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
-                                              cfg,
-                                              GNUNET_TIME_UNIT_SECONDS,
-                                              &status_cb,
-                                              NULL);
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
+                                                             "NSE",
+                                                             "HISTOGRAM_DIR",
+                                                             &histogram_dir))
+      {
+        GNUNET_assert(
+          0 < GNUNET_asprintf(&histogram_fn, "%s/timestamps", histogram_dir));
+        GNUNET_free(histogram_dir);
+        histogram = GNUNET_BIO_write_open(histogram_fn);
+        if (NULL == histogram)
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Unable to open histogram file `%s'\n",
+                     histogram_fn);
+        GNUNET_free(histogram_fn);
+      }
+    logger_test = GNUNET_CLIENT_service_test("testbed-logger",
+                                             cfg,
+                                             GNUNET_TIME_UNIT_SECONDS,
+                                             &status_cb,
+                                             NULL);
   }
 #endif
 
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
-  pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
-  GNUNET_assert (NULL != pk);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
+  GNUNET_assert(NULL != pk);
   my_private_key = pk;
-  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+  GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
-    GNUNET_free (my_private_key);
-    my_private_key = NULL;
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
-      (sizeof (my_proof) !=
-       GNUNET_DISK_fn_read (proof, &my_proof, sizeof (my_proof))))
+      GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
+    {
+      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
+      GNUNET_free(my_private_key);
+      my_private_key = NULL;
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if ((GNUNET_YES != GNUNET_DISK_file_test(proof)) ||
+      (sizeof(my_proof) !=
+       GNUNET_DISK_fn_read(proof, &my_proof, sizeof(my_proof))))
     my_proof = 0;
-  GNUNET_free (proof);
+  GNUNET_free(proof);
   proof_task =
-    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                        &find_proof,
-                                        NULL);
+    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                       &find_proof,
+                                       NULL);
 
-  peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
-  nc = GNUNET_notification_context_create (1);
+  peers = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES);
+  nc = GNUNET_notification_context_create(1);
   /* Connect to core service and register core handlers */
   core_api =
-    GNUNET_CORE_connect (cfg, /* Main configuration */
-                         NULL, /* Closure passed to functions */
-                         &core_init, /* Call core_init once connected */
-                         &handle_core_connect, /* Handle connects */
-                         &handle_core_disconnect, /* Handle disconnects */
-                         core_handlers); /* Register these handlers */
+    GNUNET_CORE_connect(cfg,  /* Main configuration */
+                        NULL,  /* Closure passed to functions */
+                        &core_init,  /* Call core_init once connected */
+                        &handle_core_connect,  /* Handle connects */
+                        &handle_core_disconnect,  /* Handle disconnects */
+                        core_handlers);  /* Register these handlers */
   if (NULL == core_api)
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
-  stats = GNUNET_STATISTICS_create ("nse", cfg);
+    {
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  stats = GNUNET_STATISTICS_create("nse", cfg);
 }
 
 
@@ -1534,12 +1530,12 @@ run (void *cls,
  * @return @a c
  */
 static void *
-client_connect_cb (void *cls,
-                   struct GNUNET_SERVICE_Client *c,
-                   struct GNUNET_MQ_Handle *mq)
+client_connect_cb(void *cls,
+                  struct GNUNET_SERVICE_Client *c,
+                  struct GNUNET_MQ_Handle *mq)
 {
-  (void) cls;
-  (void) mq;
+  (void)cls;
+  (void)mq;
   return c;
 }
 
@@ -1552,29 +1548,29 @@ client_connect_cb (void *cls,
  * @param internal_cls should be equal to @a c
  */
 static void
-client_disconnect_cb (void *cls,
-                      struct GNUNET_SERVICE_Client *c,
-                      void *internal_cls)
+client_disconnect_cb(void *cls,
+                     struct GNUNET_SERVICE_Client *c,
+                     void *internal_cls)
 {
-  (void) cls;
-  GNUNET_assert (c == internal_cls);
+  (void)cls;
+  GNUNET_assert(c == internal_cls);
 }
 
 
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN ("nse",
-                     GNUNET_SERVICE_OPTION_NONE,
-                     &run,
-                     &client_connect_cb,
-                     &client_disconnect_cb,
-                     NULL,
-                     GNUNET_MQ_hd_fixed_size (start,
-                                              GNUNET_MESSAGE_TYPE_NSE_START,
-                                              struct GNUNET_MessageHeader,
-                                              NULL),
-                     GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN("nse",
+                    GNUNET_SERVICE_OPTION_NONE,
+                    &run,
+                    &client_connect_cb,
+                    &client_disconnect_cb,
+                    NULL,
+                    GNUNET_MQ_hd_fixed_size(start,
+                                            GNUNET_MESSAGE_TYPE_NSE_START,
+                                            struct GNUNET_MessageHeader,
+                                            NULL),
+                    GNUNET_MQ_handler_end());
 
 
 #if defined(LINUX) && defined(__GLIBC__)
@@ -1583,11 +1579,11 @@ GNUNET_SERVICE_MAIN ("nse",
 /**
  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
  */
-void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
+void __attribute__ ((constructor)) GNUNET_ARM_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/nse/nse.h b/src/nse/nse.h
index efff57679..b0129addd 100644
--- a/src/nse/nse.h
+++ b/src/nse/nse.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 Nathan Evans
@@ -39,8 +39,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * standard deviation of known estimates.
  *
  */
-struct GNUNET_NSE_ClientMessage
-{
+struct GNUNET_NSE_ClientMessage {
   /**
    * Type: GNUNET_MESSAGE_TYPE_NSE_ESTIMATE
    */
diff --git a/src/nse/nse_api.c b/src/nse/nse_api.c
index 259be75ed..93716eb5f 100644
--- a/src/nse/nse_api.c
+++ b/src/nse/nse_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 nse/nse_api.c
@@ -32,13 +32,12 @@
 #include "gnunet_nse_service.h"
 #include "nse.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "nse-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "nse-api", __VA_ARGS__)
 
 /**
  * Handle for talking with the NSE service.
  */
-struct GNUNET_NSE_Handle
-{
+struct GNUNET_NSE_Handle {
   /**
    * Configuration to use.
    */
@@ -77,7 +76,7 @@ struct GNUNET_NSE_Handle
  * @param cls closure with the `struct GNUNET_NSE_Handle *`
  */
 static void
-reconnect (void *cls);
+reconnect(void *cls);
 
 
 /**
@@ -90,16 +89,16 @@ reconnect (void *cls);
  * @param error error code
  */
 static void
-mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_NSE_Handle *h = cls;
 
-  (void) error;
-  GNUNET_MQ_destroy (h->mq);
+  (void)error;
+  GNUNET_MQ_destroy(h->mq);
   h->mq = NULL;
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
-  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
+    GNUNET_SCHEDULER_add_delayed(h->reconnect_delay, &reconnect, h);
+  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF(h->reconnect_delay);
 }
 
 
@@ -111,15 +110,15 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param client_msg message received
  */
 static void
-handle_estimate (void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
+handle_estimate(void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
 {
   struct GNUNET_NSE_Handle *h = cls;
 
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  h->recv_cb (h->recv_cb_cls,
-              GNUNET_TIME_absolute_ntoh (client_msg->timestamp),
-              GNUNET_ntoh_double (client_msg->size_estimate),
-              GNUNET_ntoh_double (client_msg->std_deviation));
+  h->recv_cb(h->recv_cb_cls,
+             GNUNET_TIME_absolute_ntoh(client_msg->timestamp),
+             GNUNET_ntoh_double(client_msg->size_estimate),
+             GNUNET_ntoh_double(client_msg->std_deviation));
 }
 
 
@@ -129,27 +128,27 @@ handle_estimate (void *cls, const struct GNUNET_NSE_ClientMessage *client_msg)
  * @param cls the `struct GNUNET_NSE_Handle *`
  */
 static void
-reconnect (void *cls)
+reconnect(void *cls)
 {
   struct GNUNET_NSE_Handle *h = cls;
   struct GNUNET_MQ_MessageHandler handlers[] =
-    {GNUNET_MQ_hd_fixed_size (estimate,
-                              GNUNET_MESSAGE_TYPE_NSE_ESTIMATE,
-                              struct GNUNET_NSE_ClientMessage,
-                              h),
-     GNUNET_MQ_handler_end ()};
+  { GNUNET_MQ_hd_fixed_size(estimate,
+                            GNUNET_MESSAGE_TYPE_NSE_ESTIMATE,
+                            struct GNUNET_NSE_ClientMessage,
+                            h),
+    GNUNET_MQ_handler_end() };
   struct GNUNET_MessageHeader *msg;
   struct GNUNET_MQ_Envelope *env;
 
   h->reconnect_task = NULL;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Connecting to network size estimation service.\n");
-  GNUNET_assert (NULL == h->mq);
-  h->mq = GNUNET_CLIENT_connect (h->cfg, "nse", handlers, &mq_error_handler, h);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Connecting to network size estimation service.\n");
+  GNUNET_assert(NULL == h->mq);
+  h->mq = GNUNET_CLIENT_connect(h->cfg, "nse", handlers, &mq_error_handler, h);
   if (NULL == h->mq)
     return;
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NSE_START);
-  GNUNET_MQ_send (h->mq, env);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NSE_START);
+  GNUNET_MQ_send(h->mq, env);
 }
 
 
@@ -162,24 +161,24 @@ reconnect (void *cls)
  * @return handle to use
  */
 struct GNUNET_NSE_Handle *
-GNUNET_NSE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                    GNUNET_NSE_Callback func,
-                    void *func_cls)
+GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                   GNUNET_NSE_Callback func,
+                   void *func_cls)
 {
   struct GNUNET_NSE_Handle *h;
 
-  GNUNET_assert (NULL != func);
-  h = GNUNET_new (struct GNUNET_NSE_Handle);
+  GNUNET_assert(NULL != func);
+  h = GNUNET_new(struct GNUNET_NSE_Handle);
   h->cfg = cfg;
   h->recv_cb = func;
   h->recv_cb_cls = func_cls;
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  reconnect (h);
+  reconnect(h);
   if (NULL == h->mq)
-  {
-    GNUNET_free (h);
-    return NULL;
-  }
+    {
+      GNUNET_free(h);
+      return NULL;
+    }
   return h;
 }
 
@@ -190,19 +189,19 @@ GNUNET_NSE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param h handle to destroy
  */
 void
-GNUNET_NSE_disconnect (struct GNUNET_NSE_Handle *h)
+GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
 {
   if (NULL != h->reconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(h->reconnect_task);
+      h->reconnect_task = NULL;
+    }
   if (NULL != h->mq)
-  {
-    GNUNET_MQ_destroy (h->mq);
-    h->mq = NULL;
-  }
-  GNUNET_free (h);
+    {
+      GNUNET_MQ_destroy(h->mq);
+      h->mq = NULL;
+    }
+  GNUNET_free(h);
 }
 
 /* end of nse_api.c */
diff --git a/src/nse/perf_kdf.c b/src/nse/perf_kdf.c
index 5178f178b..bf4dbe0b2 100644
--- a/src/nse/perf_kdf.c
+++ b/src/nse/perf_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
-*/
+ */
 
 /**
  * @author Christian Grothoff
@@ -38,47 +38,47 @@
  * @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));
 }
 
 
 static void
-perfHash ()
+perfHash()
 {
   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++)
-    pow_hash (buf, sizeof (buf), &hc);
+    pow_hash(buf, sizeof(buf), &hc);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   struct GNUNET_TIME_Absolute start;
 
-  start = GNUNET_TIME_absolute_get ();
-  perfHash ();
-  printf ("Hash perf took %s\n",
-          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
-                                                  GNUNET_YES));
-  GAUGER ("NSE", "Proof-of-work hashing",
-          1024.0 / (1.0 +
-                  GNUNET_TIME_absolute_get_duration
-                  (start).rel_value_us / 1000.0), "hashes/ms");
+  start = GNUNET_TIME_absolute_get();
+  perfHash();
+  printf("Hash perf took %s\n",
+         GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration(start),
+                                                GNUNET_YES));
+  GAUGER("NSE", "Proof-of-work hashing",
+         1024.0 / (1.0 +
+                   GNUNET_TIME_absolute_get_duration
+                     (start).rel_value_us / 1000.0), "hashes/ms");
   return 0;
 }
 
diff --git a/src/nse/test_nse_api.c b/src/nse/test_nse_api.c
index 67ca17127..b739e05a2 100644
--- a/src/nse/test_nse_api.c
+++ b/src/nse/test_nse_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 nse/test_nse_api.c
  * @brief testcase for nse_api.c
@@ -38,13 +38,13 @@ static struct GNUNET_SCHEDULER_Task * die_task;
  * @param cls closure
  */
 static void
-end_test (void *cls)
+end_test(void *cls)
 {
   if (h != NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from NSE service.\n");
-    GNUNET_NSE_disconnect (h);
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from NSE service.\n");
+      GNUNET_NSE_disconnect(h);
+    }
 }
 
 /**
@@ -58,46 +58,46 @@ end_test (void *cls)
  *
  */
 static void
-check_nse_message (void *cls, struct GNUNET_TIME_Absolute timestamp,
-                   double estimate, double std_dev)
+check_nse_message(void *cls, struct GNUNET_TIME_Absolute timestamp,
+                  double estimate, double std_dev)
 {
   int *ok = cls;
 
-  fprintf (stderr,
-           "Received NSE message, estimate %f, standard deviation %f.\n",
-           estimate, std_dev);
+  fprintf(stderr,
+          "Received NSE message, estimate %f, standard deviation %f.\n",
+          estimate, std_dev);
   /* Fantastic check below. Expect NaN, the only thing not equal to itself. */
   (*ok) = 0;
   if (die_task != NULL)
-    GNUNET_SCHEDULER_cancel (die_task);
-  die_task = GNUNET_SCHEDULER_add_now (&end_test, NULL);
+    GNUNET_SCHEDULER_cancel(die_task);
+  die_task = GNUNET_SCHEDULER_add_now(&end_test, NULL);
 }
 
 
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run(void *cls,
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    struct GNUNET_TESTING_Peer *peer)
 {
   die_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_MINUTES, 1), &end_test,
-                                    NULL);
+    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_MINUTES, 1), &end_test,
+                                 NULL);
 
-  h = GNUNET_NSE_connect (cfg, &check_nse_message, cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to NSE service.\n");
-  GNUNET_assert (h != NULL);
+  h = GNUNET_NSE_connect(cfg, &check_nse_message, cls);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to NSE service.\n");
+  GNUNET_assert(h != NULL);
 }
 
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   int ok = 1;
 
-  if (0 != GNUNET_TESTING_peer_run ("test_nse_api",
-                                    "test_nse.conf",
-                                    &run, &ok))
+  if (0 != GNUNET_TESTING_peer_run("test_nse_api",
+                                   "test_nse.conf",
+                                   &run, &ok))
     return 1;
   return ok;
 }
diff --git a/src/nse/test_nse_multipeer.c b/src/nse/test_nse_multipeer.c
index ec5a94f76..88ced26d2 100644
--- a/src/nse/test_nse_multipeer.c
+++ b/src/nse/test_nse_multipeer.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 nse/test_nse_multipeer.c
  * @brief Testcase for the network size estimation service.  Starts
@@ -37,14 +37,13 @@
 /**
  * How long do we run the test?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
 
 
 /**
  * Information we track for each peer.
  */
-struct NSEPeer
-{
+struct NSEPeer {
   /**
    * Handle for NSE connect operation.
    */
@@ -72,13 +71,13 @@ static int ok;
  * Task run on timeout to shut everything down.
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
   unsigned int i;
 
-  for (i=0;i<NUM_PEERS;i++)
-    GNUNET_TESTBED_operation_done (nse_peers[i].op);
-  GNUNET_SCHEDULER_shutdown ();
+  for (i = 0; i < NUM_PEERS; i++)
+    GNUNET_TESTBED_operation_done(nse_peers[i].op);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -93,17 +92,17 @@ shutdown_task (void *cls)
  *
  */
 static void
-handle_estimate (void *cls, struct GNUNET_TIME_Absolute timestamp,
-                 double estimate, double std_dev)
+handle_estimate(void *cls, struct GNUNET_TIME_Absolute timestamp,
+                double estimate, double std_dev)
 {
   struct NSEPeer *peer = cls;
 
-  fprintf (stderr,
-           "Received network size estimate from peer %u. logSize: %f std.dev. %f (%f/%u)\n",
-           (unsigned int) (peer - nse_peers),
-           estimate, std_dev,
-           GNUNET_NSE_log_estimate_to_n (estimate),
-           NUM_PEERS);
+  fprintf(stderr,
+          "Received network size estimate from peer %u. logSize: %f std.dev. %f (%f/%u)\n",
+          (unsigned int)(peer - nse_peers),
+          estimate, std_dev,
+          GNUNET_NSE_log_estimate_to_n(estimate),
+          NUM_PEERS);
   ok = 0;
 }
 
@@ -118,22 +117,22 @@ handle_estimate (void *cls, struct GNUNET_TIME_Absolute timestamp,
  *          operation has executed successfully.
  */
 static void
-nse_connect_complete_cb (void *cls,
-                         struct GNUNET_TESTBED_Operation *op,
-                         void *ca_result,
-                         const char *emsg)
+nse_connect_complete_cb(void *cls,
+                        struct GNUNET_TESTBED_Operation *op,
+                        void *ca_result,
+                        const char *emsg)
 {
   struct NSEPeer *peer = cls;
   struct GNUNET_NSE_Handle *nse = ca_result;
 
-  GNUNET_assert (op == peer->op);
+  GNUNET_assert(op == peer->op);
   if (NULL != emsg)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to connect to NSE service: %s\n",
-                  emsg);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Failed to connect to NSE service: %s\n",
+                 emsg);
       ok = 1;
-      GNUNET_SCHEDULER_shutdown ();
+      GNUNET_SCHEDULER_shutdown();
       return;
     }
   peer->nse_handle = nse;
@@ -151,12 +150,12 @@ nse_connect_complete_cb (void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-nse_connect_adapter (void *cls,
-                     const struct GNUNET_CONFIGURATION_Handle *cfg)
+nse_connect_adapter(void *cls,
+                    const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_NSE_connect (cfg,
-                             &handle_estimate,
-                             cls);
+  return GNUNET_NSE_connect(cfg,
+                            &handle_estimate,
+                            cls);
 }
 
 
@@ -168,10 +167,10 @@ nse_connect_adapter (void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-nse_disconnect_adapter (void *cls,
-                        void *op_result)
+nse_disconnect_adapter(void *cls,
+                       void *op_result)
 {
-  GNUNET_NSE_disconnect (op_result);
+  GNUNET_NSE_disconnect(op_result);
 }
 
 
@@ -188,27 +187,27 @@ nse_disconnect_adapter (void *cls,
  *          failed
  */
 static void
-run (void *cls,
-     struct GNUNET_TESTBED_RunHandle *h,
-     unsigned int num_peers,
-     struct GNUNET_TESTBED_Peer **peers,
-     unsigned int links_succeeded,
-     unsigned int links_failed)
+run(void *cls,
+    struct GNUNET_TESTBED_RunHandle *h,
+    unsigned int num_peers,
+    struct GNUNET_TESTBED_Peer **peers,
+    unsigned int links_succeeded,
+    unsigned int links_failed)
 {
   unsigned int i;
 
-  GNUNET_assert (NUM_PEERS == num_peers);
-  for (i=0;i<num_peers;i++)
-    nse_peers[i].op = GNUNET_TESTBED_service_connect (&nse_peers[i],
-                                                      peers[i],
-                                                      "nse",
-                                                      &nse_connect_complete_cb,
-                                                      &nse_peers[i],
-                                                      &nse_connect_adapter,
-                                                      &nse_disconnect_adapter,
-                                                      &nse_peers[i]);
-  GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                &shutdown_task, NULL);
+  GNUNET_assert(NUM_PEERS == num_peers);
+  for (i = 0; i < num_peers; i++)
+    nse_peers[i].op = GNUNET_TESTBED_service_connect(&nse_peers[i],
+                                                     peers[i],
+                                                     "nse",
+                                                     &nse_connect_complete_cb,
+                                                     &nse_peers[i],
+                                                     &nse_connect_adapter,
+                                                     &nse_disconnect_adapter,
+                                                     &nse_peers[i]);
+  GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                               &shutdown_task, NULL);
 }
 
 
@@ -220,14 +219,14 @@ run (void *cls,
  * @return 0 on success
  */
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
   ok = 1;
-  (void) GNUNET_TESTBED_test_run ("test-nse-multipeer",
-                                  "test_nse.conf",
-                                  NUM_PEERS,
-                                  0, NULL, NULL,
-                                  &run, NULL);
+  (void)GNUNET_TESTBED_test_run("test-nse-multipeer",
+                                "test_nse.conf",
+                                NUM_PEERS,
+                                0, NULL, NULL,
+                                &run, NULL);
   return ok;
 }