global reindent, now with uncrustify hook enabled

7 files changed, 2092 insertions, 1978 deletions

diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index f110b23b2..888213d55 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -34,7 +34,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Sent by the client to the service,
  * when the client wants the service to join a consensus session.
  */
-struct GNUNET_CONSENSUS_JoinMessage {
+struct GNUNET_CONSENSUS_JoinMessage
+{
   /**
    * Type: GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN
    */
@@ -68,7 +69,8 @@ struct GNUNET_CONSENSUS_JoinMessage {
 /**
  * Message with an element
  */
-struct GNUNET_CONSENSUS_ElementMessage {
+struct GNUNET_CONSENSUS_ElementMessage
+{
   /**
    * Type:
    * Either GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT
diff --git a/src/consensus/consensus_api.c b/src/consensus/consensus_api.c
index 2da145932..c4350adaf 100644
--- a/src/consensus/consensus_api.c
+++ b/src/consensus/consensus_api.c
@@ -31,13 +31,14 @@
 #include "consensus.h"
 
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "consensus-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "consensus-api", __VA_ARGS__)
 
 
 /**
  * Handle for the service.
  */
-struct GNUNET_CONSENSUS_Handle {
+struct GNUNET_CONSENSUS_Handle
+{
   /**
    * Configuration to use.
    */
@@ -89,7 +90,8 @@ struct GNUNET_CONSENSUS_Handle {
  * FIXME: this should not bee necessary when the API
  * issue has been fixed
  */
-struct InsertDoneInfo {
+struct InsertDoneInfo
+{
   GNUNET_CONSENSUS_InsertDoneCallback idc;
   void *cls;
 };
@@ -102,8 +104,8 @@ struct InsertDoneInfo {
  * @param msg element message
  */
 static int
-check_new_element(void *cls,
-                  const struct GNUNET_CONSENSUS_ElementMessage *msg)
+check_new_element (void *cls,
+                   const struct GNUNET_CONSENSUS_ElementMessage *msg)
 {
   /* any size is fine, elements are variable-size */
   return GNUNET_OK;
@@ -117,19 +119,20 @@ check_new_element(void *cls,
  * @param msg element message
  */
 static void
-handle_new_element(void *cls,
-                   const struct GNUNET_CONSENSUS_ElementMessage *msg)
+handle_new_element (void *cls,
+                    const struct GNUNET_CONSENSUS_ElementMessage *msg)
 {
   struct GNUNET_CONSENSUS_Handle *consensus = cls;
   struct GNUNET_SET_Element element;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "received new element\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "received new element\n");
   element.element_type = msg->element_type;
-  element.size = ntohs(msg->header.size) - sizeof(struct GNUNET_CONSENSUS_ElementMessage);
+  element.size = ntohs (msg->header.size) - sizeof(struct
+                                                   GNUNET_CONSENSUS_ElementMessage);
   element.data = &msg[1];
-  consensus->new_element_cb(consensus->new_element_cls,
-                            &element);
+  consensus->new_element_cb (consensus->new_element_cls,
+                             &element);
 }
 
 
@@ -141,17 +144,17 @@ handle_new_element(void *cls,
  * @param msg conclude done message
  */
 static void
-handle_conclude_done(void *cls,
-                     const struct GNUNET_MessageHeader *msg)
+handle_conclude_done (void *cls,
+                      const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CONSENSUS_Handle *consensus = cls;
   GNUNET_CONSENSUS_ConcludeCallback cc;
 
-  GNUNET_MQ_destroy(consensus->mq);
+  GNUNET_MQ_destroy (consensus->mq);
   consensus->mq = NULL;
-  GNUNET_assert(NULL != (cc = consensus->conclude_cb));
+  GNUNET_assert (NULL != (cc = consensus->conclude_cb));
   consensus->conclude_cb = NULL;
-  cc(consensus->conclude_cls);
+  cc (consensus->conclude_cls);
 }
 
 
@@ -165,11 +168,11 @@ handle_conclude_done(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)
 {
-  LOG(GNUNET_ERROR_TYPE_WARNING,
-      "consensus service disconnected us\n");
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "consensus service disconnected us\n");
 }
 
 
@@ -191,27 +194,27 @@ mq_error_handler(void *cls,
  * @return handle to use, NULL on error
  */
 struct GNUNET_CONSENSUS_Handle *
-GNUNET_CONSENSUS_create(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                        unsigned int num_peers,
-                        const struct GNUNET_PeerIdentity *peers,
-                        const struct GNUNET_HashCode *session_id,
-                        struct GNUNET_TIME_Absolute start,
-                        struct GNUNET_TIME_Absolute deadline,
-                        GNUNET_CONSENSUS_ElementCallback new_element_cb,
-                        void *new_element_cls)
+GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                         unsigned int num_peers,
+                         const struct GNUNET_PeerIdentity *peers,
+                         const struct GNUNET_HashCode *session_id,
+                         struct GNUNET_TIME_Absolute start,
+                         struct GNUNET_TIME_Absolute deadline,
+                         GNUNET_CONSENSUS_ElementCallback new_element_cb,
+                         void *new_element_cls)
 {
   struct GNUNET_CONSENSUS_Handle *consensus
-    = GNUNET_new(struct GNUNET_CONSENSUS_Handle);
+    = GNUNET_new (struct GNUNET_CONSENSUS_Handle);
   struct GNUNET_MQ_MessageHandler mq_handlers[] = {
-    GNUNET_MQ_hd_var_size(new_element,
-                          GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT,
-                          struct GNUNET_CONSENSUS_ElementMessage,
-                          consensus),
-    GNUNET_MQ_hd_fixed_size(conclude_done,
-                            GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE,
-                            struct GNUNET_MessageHeader,
-                            consensus),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (new_element,
+                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT,
+                           struct GNUNET_CONSENSUS_ElementMessage,
+                           consensus),
+    GNUNET_MQ_hd_fixed_size (conclude_done,
+                             GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE,
+                             struct GNUNET_MessageHeader,
+                             consensus),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_CONSENSUS_JoinMessage *join_msg;
   struct GNUNET_MQ_Envelope *ev;
@@ -220,40 +223,40 @@ GNUNET_CONSENSUS_create(const struct GNUNET_CONFIGURATION_Handle *cfg,
   consensus->new_element_cb = new_element_cb;
   consensus->new_element_cls = new_element_cls;
   consensus->session_id = *session_id;
-  consensus->mq = GNUNET_CLIENT_connect(cfg,
-                                        "consensus",
-                                        mq_handlers,
-                                        &mq_error_handler,
-                                        consensus);
+  consensus->mq = GNUNET_CLIENT_connect (cfg,
+                                         "consensus",
+                                         mq_handlers,
+                                         &mq_error_handler,
+                                         consensus);
   if (NULL == consensus->mq)
-    {
-      GNUNET_free(consensus);
-      return NULL;
-    }
-  ev = GNUNET_MQ_msg_extra(join_msg,
-                           (num_peers * sizeof(struct GNUNET_PeerIdentity)),
-                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN);
+  {
+    GNUNET_free (consensus);
+    return NULL;
+  }
+  ev = GNUNET_MQ_msg_extra (join_msg,
+                            (num_peers * sizeof(struct GNUNET_PeerIdentity)),
+                            GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN);
 
   join_msg->session_id = consensus->session_id;
-  join_msg->start = GNUNET_TIME_absolute_hton(start);
-  join_msg->deadline = GNUNET_TIME_absolute_hton(deadline);
-  join_msg->num_peers = htonl(num_peers);
-  GNUNET_memcpy(&join_msg[1],
-                peers,
-                num_peers * sizeof(struct GNUNET_PeerIdentity));
-
-  GNUNET_MQ_send(consensus->mq, ev);
+  join_msg->start = GNUNET_TIME_absolute_hton (start);
+  join_msg->deadline = GNUNET_TIME_absolute_hton (deadline);
+  join_msg->num_peers = htonl (num_peers);
+  GNUNET_memcpy (&join_msg[1],
+                 peers,
+                 num_peers * sizeof(struct GNUNET_PeerIdentity));
+
+  GNUNET_MQ_send (consensus->mq, ev);
   return consensus;
 }
 
 
 static void
-idc_adapter(void *cls)
+idc_adapter (void *cls)
 {
   struct InsertDoneInfo *i = cls;
 
-  i->idc(i->cls, GNUNET_OK);
-  GNUNET_free(i);
+  i->idc (i->cls, GNUNET_OK);
+  GNUNET_free (i);
 }
 
 /**
@@ -267,30 +270,30 @@ idc_adapter(void *cls)
  * @param idc_cls closure for 'idc'
  */
 void
-GNUNET_CONSENSUS_insert(struct GNUNET_CONSENSUS_Handle *consensus,
-                        const struct GNUNET_SET_Element *element,
-                        GNUNET_CONSENSUS_InsertDoneCallback idc,
-                        void *idc_cls)
+GNUNET_CONSENSUS_insert (struct GNUNET_CONSENSUS_Handle *consensus,
+                         const struct GNUNET_SET_Element *element,
+                         GNUNET_CONSENSUS_InsertDoneCallback idc,
+                         void *idc_cls)
 {
   struct GNUNET_CONSENSUS_ElementMessage *element_msg;
   struct GNUNET_MQ_Envelope *ev;
   struct InsertDoneInfo *i;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size);
 
-  ev = GNUNET_MQ_msg_extra(element_msg, element->size,
-                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT);
+  ev = GNUNET_MQ_msg_extra (element_msg, element->size,
+                            GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT);
 
-  GNUNET_memcpy(&element_msg[1], element->data, element->size);
+  GNUNET_memcpy (&element_msg[1], element->data, element->size);
 
   if (NULL != idc)
-    {
-      i = GNUNET_new(struct InsertDoneInfo);
-      i->idc = idc;
-      i->cls = idc_cls;
-      GNUNET_MQ_notify_sent(ev, idc_adapter, i);
-    }
-  GNUNET_MQ_send(consensus->mq, ev);
+  {
+    i = GNUNET_new (struct InsertDoneInfo);
+    i->idc = idc;
+    i->cls = idc_cls;
+    GNUNET_MQ_notify_sent (ev, idc_adapter, i);
+  }
+  GNUNET_MQ_send (consensus->mq, ev);
 }
 
 
@@ -307,20 +310,20 @@ GNUNET_CONSENSUS_insert(struct GNUNET_CONSENSUS_Handle *consensus,
  * @param conclude_cls closure for the conclude callback
  */
 void
-GNUNET_CONSENSUS_conclude(struct GNUNET_CONSENSUS_Handle *consensus,
-                          GNUNET_CONSENSUS_ConcludeCallback conclude,
-                          void *conclude_cls)
+GNUNET_CONSENSUS_conclude (struct GNUNET_CONSENSUS_Handle *consensus,
+                           GNUNET_CONSENSUS_ConcludeCallback conclude,
+                           void *conclude_cls)
 {
   struct GNUNET_MQ_Envelope *ev;
 
-  GNUNET_assert(NULL != conclude);
-  GNUNET_assert(NULL == consensus->conclude_cb);
+  GNUNET_assert (NULL != conclude);
+  GNUNET_assert (NULL == consensus->conclude_cb);
 
   consensus->conclude_cls = conclude_cls;
   consensus->conclude_cb = conclude;
 
-  ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE);
-  GNUNET_MQ_send(consensus->mq, ev);
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE);
+  GNUNET_MQ_send (consensus->mq, ev);
 }
 
 
@@ -331,14 +334,14 @@ GNUNET_CONSENSUS_conclude(struct GNUNET_CONSENSUS_Handle *consensus,
  * @param consensus handle to destroy
  */
 void
-GNUNET_CONSENSUS_destroy(struct GNUNET_CONSENSUS_Handle *consensus)
+GNUNET_CONSENSUS_destroy (struct GNUNET_CONSENSUS_Handle *consensus)
 {
   if (NULL != consensus->mq)
-    {
-      GNUNET_MQ_destroy(consensus->mq);
-      consensus->mq = NULL;
-    }
-  GNUNET_free(consensus);
+  {
+    GNUNET_MQ_destroy (consensus->mq);
+    consensus->mq = NULL;
+  }
+  GNUNET_free (consensus);
 }
 
 /* end of consensus_api.c */
diff --git a/src/consensus/consensus_protocol.h b/src/consensus/consensus_protocol.h
index fc8ae7533..a40162fb8 100644
--- a/src/consensus/consensus_protocol.h
+++ b/src/consensus/consensus_protocol.h
@@ -42,7 +42,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Essentially contains all the fields
  * from 'struct TaskKey', but in NBO.
  */
-struct GNUNET_CONSENSUS_RoundContextMessage {
+struct GNUNET_CONSENSUS_RoundContextMessage
+{
   /**
    * Type: #GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT
    */
@@ -88,7 +89,8 @@ struct GNUNET_CONSENSUS_RoundContextMessage {
 };
 
 
-enum {
+enum
+{
   CONSENSUS_MARKER_CONTESTED = 1,
   CONSENSUS_MARKER_SIZE = 2,
 };
@@ -97,7 +99,8 @@ enum {
 /**
  * Consensus element, either marker or payload.
  */
-struct ConsensusElement {
+struct ConsensusElement
+{
   /**
    * Payload element_type, only valid
    * if this is not a marker element.
@@ -113,14 +116,16 @@ struct ConsensusElement {
 };
 
 
-struct ConsensusSizeElement {
+struct ConsensusSizeElement
+{
   struct ConsensusElement ce;
 
   uint64_t size GNUNET_PACKED;
   uint8_t sender_index;
 };
 
-struct ConsensusStuffedElement {
+struct ConsensusStuffedElement
+{
   struct ConsensusElement ce;
   struct GNUNET_HashCode rand GNUNET_PACKED;
 };
diff --git a/src/consensus/gnunet-consensus-profiler.c b/src/consensus/gnunet-consensus-profiler.c
index 9feee87cd..65fc23d8f 100644
--- a/src/consensus/gnunet-consensus-profiler.c
+++ b/src/consensus/gnunet-consensus-profiler.c
@@ -92,26 +92,26 @@ static struct GNUNET_TIME_Absolute deadline;
  * @param event information about the event
  */
 static void
-controller_cb(void *cls,
-              const struct GNUNET_TESTBED_EventInformation *event)
+controller_cb (void *cls,
+               const struct GNUNET_TESTBED_EventInformation *event)
 {
-  GNUNET_assert(0);
+  GNUNET_assert (0);
 }
 
 
 static void
-statistics_done_cb(void *cls,
-                   struct
-                   GNUNET_TESTBED_Operation
-                   *op,
-                   const char *emsg)
+statistics_done_cb (void *cls,
+                    struct
+                    GNUNET_TESTBED_Operation
+                    *op,
+                    const char *emsg)
 {
-  GNUNET_assert(NULL == emsg);
-  GNUNET_TESTBED_operation_done(op);
+  GNUNET_assert (NULL == emsg);
+  GNUNET_TESTBED_operation_done (op);
   if (NULL != statistics_file)
-    fclose(statistics_file);
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "got statistics, shutting down\n");
-  GNUNET_SCHEDULER_shutdown();
+    fclose (statistics_file);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got statistics, shutting down\n");
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -127,47 +127,48 @@ statistics_done_cb(void *cls,
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-statistics_cb(void *cls,
-              const struct GNUNET_TESTBED_Peer *peer,
-              const char *subsystem,
-              const char *name,
-              uint64_t value,
-              int is_persistent)
+statistics_cb (void *cls,
+               const struct GNUNET_TESTBED_Peer *peer,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
 {
   if (NULL != statistics_file)
-    {
-      fprintf(statistics_file, "P%u\t%s\t%s\t%lu\n", GNUNET_TESTBED_get_index(peer), subsystem, name, (unsigned long)value);
-    }
+  {
+    fprintf (statistics_file, "P%u\t%s\t%s\t%lu\n", GNUNET_TESTBED_get_index (
+               peer), subsystem, name, (unsigned long) value);
+  }
   return GNUNET_OK;
 }
 
 
 static void
-destroy(void *cls)
+destroy (void *cls)
 {
   struct GNUNET_CONSENSUS_Handle *consensus = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "destroying consensus\n");
-  GNUNET_CONSENSUS_destroy(consensus);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "destroying consensus\n");
+  GNUNET_CONSENSUS_destroy (consensus);
   peers_done++;
   if (peers_done == num_peers)
-    {
-      unsigned int i;
-      for (i = 0; i < num_peers; i++)
-        GNUNET_TESTBED_operation_done(testbed_operations[i]);
-      for (i = 0; i < num_peers; i++)
-        printf("P%u got %u of %u elements\n",
-               i,
-               results_for_peer[i],
-               num_values);
-      if (NULL != statistics_filename)
-        statistics_file = fopen(statistics_filename, "w");
-      GNUNET_TESTBED_get_statistics(num_peers, peers, NULL, NULL,
-                                    statistics_cb,
-                                    statistics_done_cb,
-                                    NULL);
-    }
+  {
+    unsigned int i;
+    for (i = 0; i < num_peers; i++)
+      GNUNET_TESTBED_operation_done (testbed_operations[i]);
+    for (i = 0; i < num_peers; i++)
+      printf ("P%u got %u of %u elements\n",
+              i,
+              results_for_peer[i],
+              num_values);
+    if (NULL != statistics_filename)
+      statistics_file = fopen (statistics_filename, "w");
+    GNUNET_TESTBED_get_statistics (num_peers, peers, NULL, NULL,
+                                   statistics_cb,
+                                   statistics_done_cb,
+                                   NULL);
+  }
 }
 
 
@@ -179,44 +180,44 @@ destroy(void *cls)
  *         #GNUNET_NO if not
  */
 static void
-conclude_cb(void *cls)
+conclude_cb (void *cls)
 {
   struct GNUNET_CONSENSUS_Handle **chp = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "consensus %d done\n",
-             (int)(chp - consensus_handles));
-  GNUNET_SCHEDULER_add_now(destroy, *chp);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "consensus %d done\n",
+              (int) (chp - consensus_handles));
+  GNUNET_SCHEDULER_add_now (destroy, *chp);
 }
 
 
 static void
-generate_indices(int *indices)
+generate_indices (int *indices)
 {
   int j;
 
   j = 0;
   while (j < replication)
-    {
-      int n;
-      int k;
-      int repeat;
-      n = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
-      repeat = GNUNET_NO;
-      for (k = 0; k < j; k++)
-        if (indices[k] == n)
-          {
-            repeat = GNUNET_YES;
-            break;
-          }
-      if (GNUNET_NO == repeat)
-        indices[j++] = n;
-    }
+  {
+    int n;
+    int k;
+    int repeat;
+    n = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
+    repeat = GNUNET_NO;
+    for (k = 0; k < j; k++)
+      if (indices[k] == n)
+      {
+        repeat = GNUNET_YES;
+        break;
+      }
+    if (GNUNET_NO == repeat)
+      indices[j++] = n;
+  }
 }
 
 
 static void
-do_consensus()
+do_consensus ()
 {
   int unique_indices[replication];
   unsigned int i;
@@ -225,48 +226,48 @@ do_consensus()
   struct GNUNET_SET_Element element;
 
   if (dist_static)
+  {
+    for (i = 0; i < num_values; i++)
     {
-      for (i = 0; i < num_values; i++)
-        {
-          GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &val);
-
-          element.data = &val;
-          element.size = sizeof(val);
-          for (j = 0; j < replication; j++)
-            {
-              GNUNET_CONSENSUS_insert(consensus_handles[j],
-                                      &element,
-                                      NULL, NULL);
-            }
-        }
+      GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val);
+
+      element.data = &val;
+      element.size = sizeof(val);
+      for (j = 0; j < replication; j++)
+      {
+        GNUNET_CONSENSUS_insert (consensus_handles[j],
+                                 &element,
+                                 NULL, NULL);
+      }
     }
+  }
   else
+  {
+    for (i = 0; i < num_values; i++)
     {
-      for (i = 0; i < num_values; i++)
-        {
-          generate_indices(unique_indices);
-          GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &val);
-
-          element.data = &val;
-          element.size = sizeof(val);
-          for (j = 0; j < replication; j++)
-            {
-              int cid;
-
-              cid = unique_indices[j];
-              GNUNET_CONSENSUS_insert(consensus_handles[cid],
-                                      &element,
-                                      NULL, NULL);
-            }
-        }
+      generate_indices (unique_indices);
+      GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val);
+
+      element.data = &val;
+      element.size = sizeof(val);
+      for (j = 0; j < replication; j++)
+      {
+        int cid;
+
+        cid = unique_indices[j];
+        GNUNET_CONSENSUS_insert (consensus_handles[cid],
+                                 &element,
+                                 NULL, NULL);
+      }
     }
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "all elements inserted, calling conclude\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "all elements inserted, calling conclude\n");
 
   for (i = 0; i < num_peers; i++)
-    GNUNET_CONSENSUS_conclude(consensus_handles[i],
-                              conclude_cb, &consensus_handles[i]);
+    GNUNET_CONSENSUS_conclude (consensus_handles[i],
+                               conclude_cb, &consensus_handles[i]);
 }
 
 
@@ -280,50 +281,50 @@ do_consensus()
  *          operation has executed successfully.
  */
 static void
-connect_complete(void *cls,
-                 struct GNUNET_TESTBED_Operation *op,
-                 void *ca_result,
-                 const char *emsg)
+connect_complete (void *cls,
+                  struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result,
+                  const char *emsg)
 {
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "testbed connect emsg: %s\n",
-                 emsg);
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "testbed connect emsg: %s\n",
+                emsg);
+    GNUNET_assert (0);
+  }
 
   num_connected_handles++;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "connect complete\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "connect complete\n");
 
   if (num_connected_handles == num_peers)
-    {
-      do_consensus();
-    }
+  {
+    do_consensus ();
+  }
 }
 
 
 static void
-new_element_cb(void *cls,
-               const struct GNUNET_SET_Element *element)
+new_element_cb (void *cls,
+                const struct GNUNET_SET_Element *element)
 {
   struct GNUNET_CONSENSUS_Handle **chp = cls;
   int idx = chp - consensus_handles;
 
-  GNUNET_assert(NULL != cls);
+  GNUNET_assert (NULL != cls);
 
   results_for_peer[idx]++;
 
-  GNUNET_assert(sizeof(struct GNUNET_HashCode) == element->size);
+  GNUNET_assert (sizeof(struct GNUNET_HashCode) == element->size);
 
   if (GNUNET_YES == verbose)
-    {
-      printf("P%d received %s\n",
-             idx,
-             GNUNET_h2s((struct GNUNET_HashCode *)element->data));
-    }
+  {
+    printf ("P%d received %s\n",
+            idx,
+            GNUNET_h2s ((struct GNUNET_HashCode *) element->data));
+  }
 }
 
 
@@ -338,24 +339,24 @@ new_element_cb(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-connect_adapter(void *cls,
-                const struct GNUNET_CONFIGURATION_Handle *cfg)
+connect_adapter (void *cls,
+                 const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_CONSENSUS_Handle **chp = cls;
   struct GNUNET_CONSENSUS_Handle *consensus;
 
-  chp = (struct GNUNET_CONSENSUS_Handle **)cls;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "connect adapter, %d peers\n",
-             num_peers);
-  consensus = GNUNET_CONSENSUS_create(cfg,
-                                      num_peers, peer_ids,
-                                      &session_id,
-                                      start,
-                                      deadline,
-                                      &new_element_cb, chp);
-  *chp = (struct GNUNET_CONSENSUS_Handle *)consensus;
+  chp = (struct GNUNET_CONSENSUS_Handle **) cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "connect adapter, %d peers\n",
+              num_peers);
+  consensus = GNUNET_CONSENSUS_create (cfg,
+                                       num_peers, peer_ids,
+                                       &session_id,
+                                       start,
+                                       deadline,
+                                       &new_element_cb, chp);
+  *chp = (struct GNUNET_CONSENSUS_Handle *) consensus;
   return consensus;
 }
 
@@ -368,11 +369,11 @@ connect_adapter(void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-disconnect_adapter(void *cls, void *op_result)
+disconnect_adapter (void *cls, void *op_result)
 {
   /* FIXME: what to do here? */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "disconnect adapter called\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "disconnect adapter called\n");
 }
 
 
@@ -386,34 +387,36 @@ disconnect_adapter(void *cls, void *op_result)
  *          operation is successfull
  */
 static void
-peer_info_cb(void *cb_cls,
-             struct GNUNET_TESTBED_Operation *op,
-             const struct GNUNET_TESTBED_PeerInformation *pinfo,
-             const char *emsg)
+peer_info_cb (void *cb_cls,
+              struct GNUNET_TESTBED_Operation *op,
+              const struct GNUNET_TESTBED_PeerInformation *pinfo,
+              const char *emsg)
 {
   struct GNUNET_PeerIdentity *p;
   int i;
 
-  GNUNET_assert(NULL == emsg);
+  GNUNET_assert (NULL == emsg);
 
-  p = (struct GNUNET_PeerIdentity *)cb_cls;
+  p = (struct GNUNET_PeerIdentity *) cb_cls;
 
   if (pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY)
-    {
-      *p = *pinfo->result.id;
-      num_retrieved_peer_ids++;
-      if (num_retrieved_peer_ids == num_peers)
-        for (i = 0; i < num_peers; i++)
-          testbed_operations[i] =
-            GNUNET_TESTBED_service_connect(NULL, peers[i], "consensus", connect_complete, NULL,
-                                           connect_adapter, disconnect_adapter, &consensus_handles[i]);
-    }
+  {
+    *p = *pinfo->result.id;
+    num_retrieved_peer_ids++;
+    if (num_retrieved_peer_ids == num_peers)
+      for (i = 0; i < num_peers; i++)
+        testbed_operations[i] =
+          GNUNET_TESTBED_service_connect (NULL, peers[i], "consensus",
+                                          connect_complete, NULL,
+                                          connect_adapter, disconnect_adapter,
+                                          &consensus_handles[i]);
+  }
   else
-    {
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_assert (0);
+  }
 
-  GNUNET_TESTBED_operation_done(op);
+  GNUNET_TESTBED_operation_done (op);
 }
 
 
@@ -431,144 +434,153 @@ peer_info_cb(void *cb_cls,
  *          failed
  */
 static void
-test_master(void *cls,
-            struct GNUNET_TESTBED_RunHandle *h,
-            unsigned int num_peers,
-            struct GNUNET_TESTBED_Peer **started_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 **started_peers,
+             unsigned int links_succeeded,
+             unsigned int links_failed)
 {
   int i;
 
-  GNUNET_log_setup("gnunet-consensus", "INFO", NULL);
+  GNUNET_log_setup ("gnunet-consensus", "INFO", NULL);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "test master\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "test master\n");
 
   peers = started_peers;
 
-  peer_ids = GNUNET_malloc(num_peers * sizeof(struct GNUNET_PeerIdentity));
+  peer_ids = GNUNET_malloc (num_peers * sizeof(struct GNUNET_PeerIdentity));
 
-  results_for_peer = GNUNET_malloc(num_peers * sizeof(unsigned int));
-  consensus_handles = GNUNET_malloc(num_peers * sizeof(struct ConsensusHandle *));
-  testbed_operations = GNUNET_malloc(num_peers * sizeof(struct ConsensusHandle *));
+  results_for_peer = GNUNET_malloc (num_peers * sizeof(unsigned int));
+  consensus_handles = GNUNET_malloc (num_peers * sizeof(struct
+                                                        ConsensusHandle *));
+  testbed_operations = GNUNET_malloc (num_peers * sizeof(struct
+                                                         ConsensusHandle *));
 
   for (i = 0; i < num_peers; i++)
-    GNUNET_TESTBED_peer_get_information(peers[i],
-                                        GNUNET_TESTBED_PIT_IDENTITY,
-                                        peer_info_cb,
-                                        &peer_ids[i]);
+    GNUNET_TESTBED_peer_get_information (peers[i],
+                                         GNUNET_TESTBED_PIT_IDENTITY,
+                                         peer_info_cb,
+                                         &peer_ids[i]);
 }
 
 
 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)
 {
   static char *session_str = "gnunet-consensus/test";
   char *topology;
   int topology_cmp_result;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "testbed", "OVERLAY_TOPOLOGY", &topology))
-    {
-      fprintf(stderr,
-              "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, "
-              "seems like you passed the wrong configuration file\n");
-      return;
-    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
+                                                          "OVERLAY_TOPOLOGY",
+                                                          &topology))
+  {
+    fprintf (stderr,
+             "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, "
+             "seems like you passed the wrong configuration file\n");
+    return;
+  }
 
-  topology_cmp_result = strcasecmp(topology, "NONE");
-  GNUNET_free(topology);
+  topology_cmp_result = strcasecmp (topology, "NONE");
+  GNUNET_free (topology);
 
   if (0 == topology_cmp_result)
-    {
-      fprintf(stderr,
-              "'OVERLAY_TOPOLOGY' set to 'NONE', "
-              "seems like you passed the wrong configuration file\n");
-      return;
-    }
+  {
+    fprintf (stderr,
+             "'OVERLAY_TOPOLOGY' set to 'NONE', "
+             "seems like you passed the wrong configuration file\n");
+    return;
+  }
 
   if (num_peers < replication)
-    {
-      fprintf(stderr, "k must be <=n\n");
-      return;
-    }
-
-  start = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), consensus_delay);
-  deadline = GNUNET_TIME_absolute_add(start, conclude_timeout);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "running gnunet-consensus\n");
-
-  GNUNET_CRYPTO_hash(session_str, strlen(session_str), &session_id);
-
-  (void)GNUNET_TESTBED_test_run("gnunet-consensus",
-                                cfgfile,
-                                num_peers,
-                                0,
-                                controller_cb,
-                                NULL,
-                                test_master,
-                                NULL);
+  {
+    fprintf (stderr, "k must be <=n\n");
+    return;
+  }
+
+  start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+                                    consensus_delay);
+  deadline = GNUNET_TIME_absolute_add (start, conclude_timeout);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "running gnunet-consensus\n");
+
+  GNUNET_CRYPTO_hash (session_str, strlen (session_str), &session_id);
+
+  (void) GNUNET_TESTBED_test_run ("gnunet-consensus",
+                                  cfgfile,
+                                  num_peers,
+                                  0,
+                                  controller_cb,
+                                  NULL,
+                                  test_master,
+                                  NULL);
 }
 
 
 int
-main(int argc, char **argv)
+main (int argc, char **argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint('n',
-                              "num-peers",
-                              NULL,
-                              gettext_noop("number of peers in consensus"),
-                              &num_peers),
-
-    GNUNET_GETOPT_option_uint('k',
-                              "value-replication",
-                              NULL,
-                              gettext_noop("how many peers (random selection without replacement) receive one value?"),
-                              &replication),
-
-    GNUNET_GETOPT_option_uint('x',
-                              "num-values",
-                              NULL,
-                              gettext_noop("number of values"),
-                              &num_values),
-
-    GNUNET_GETOPT_option_relative_time('t',
-                                       "timeout",
-                                       NULL,
-                                       gettext_noop("consensus timeout"),
-                                       &conclude_timeout),
-
-
-    GNUNET_GETOPT_option_relative_time('d',
-                                       "delay",
-                                       NULL,
-                                       gettext_noop("delay until consensus starts"),
-                                       &consensus_delay),
-
-    GNUNET_GETOPT_option_filename('s',
-                                  "statistics",
-                                  "FILENAME",
-                                  gettext_noop("write statistics to file"),
-                                  &statistics_filename),
-
-    GNUNET_GETOPT_option_flag('S',
-                              "dist-static",
-                              gettext_noop("distribute elements to a static subset of good peers"),
-                              &dist_static),
-
-    GNUNET_GETOPT_option_flag('V',
-                              "verbose",
-                              gettext_noop("be more verbose (print received values)"),
-                              &verbose),
+    GNUNET_GETOPT_option_uint ('n',
+                               "num-peers",
+                               NULL,
+                               gettext_noop ("number of peers in consensus"),
+                               &num_peers),
+
+    GNUNET_GETOPT_option_uint ('k',
+                               "value-replication",
+                               NULL,
+                               gettext_noop (
+                                 "how many peers (random selection without replacement) receive one value?"),
+                               &replication),
+
+    GNUNET_GETOPT_option_uint ('x',
+                               "num-values",
+                               NULL,
+                               gettext_noop ("number of values"),
+                               &num_values),
+
+    GNUNET_GETOPT_option_relative_time ('t',
+                                        "timeout",
+                                        NULL,
+                                        gettext_noop ("consensus timeout"),
+                                        &conclude_timeout),
+
+
+    GNUNET_GETOPT_option_relative_time ('d',
+                                        "delay",
+                                        NULL,
+                                        gettext_noop (
+                                          "delay until consensus starts"),
+                                        &consensus_delay),
+
+    GNUNET_GETOPT_option_filename ('s',
+                                   "statistics",
+                                   "FILENAME",
+                                   gettext_noop ("write statistics to file"),
+                                   &statistics_filename),
+
+    GNUNET_GETOPT_option_flag ('S',
+                               "dist-static",
+                               gettext_noop (
+                                 "distribute elements to a static subset of good peers"),
+                               &dist_static),
+
+    GNUNET_GETOPT_option_flag ('V',
+                               "verbose",
+                               gettext_noop (
+                                 "be more verbose (print received values)"),
+                               &verbose),
 
     GNUNET_GETOPT_OPTION_END
   };
 
   conclude_timeout = GNUNET_TIME_UNIT_SECONDS;
-  GNUNET_PROGRAM_run2(argc, argv, "gnunet-consensus-profiler",
-                      "help",
-                      options, &run, NULL, GNUNET_YES);
+  GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus-profiler",
+                       "help",
+                       options, &run, NULL, GNUNET_YES);
   return 0;
 }
diff --git a/src/consensus/gnunet-service-consensus.c b/src/consensus/gnunet-service-consensus.c
index 98fd551b2..8ef70eee8 100644
--- a/src/consensus/gnunet-service-consensus.c
+++ b/src/consensus/gnunet-service-consensus.c
@@ -36,7 +36,8 @@
 #include "consensus.h"
 
 
-enum ReferendumVote {
+enum ReferendumVote
+{
   /**
    * Vote that nothing should change.
    * This option is never voted explicitly.
@@ -53,7 +54,8 @@ enum ReferendumVote {
 };
 
 
-enum EarlyStoppingPhase {
+enum EarlyStoppingPhase
+{
   EARLY_STOPPING_NONE = 0,
   EARLY_STOPPING_ONE_MORE = 1,
   EARLY_STOPPING_DONE = 2,
@@ -66,7 +68,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Tuple of integers that together
  * identify a task uniquely.
  */
-struct TaskKey {
+struct TaskKey
+{
   /**
    * A value from 'enum PhaseKind'.
    */
@@ -98,14 +101,16 @@ struct TaskKey {
 
 
 
-struct SetKey {
+struct SetKey
+{
   int set_kind GNUNET_PACKED;
   int k1 GNUNET_PACKED;
   int k2 GNUNET_PACKED;
 };
 
 
-struct SetEntry {
+struct SetEntry
+{
   struct SetKey key;
   struct GNUNET_SET_Handle *h;
   /**
@@ -117,13 +122,15 @@ struct SetEntry {
 };
 
 
-struct DiffKey {
+struct DiffKey
+{
   int diff_kind GNUNET_PACKED;
   int k1 GNUNET_PACKED;
   int k2 GNUNET_PACKED;
 };
 
-struct RfnKey {
+struct RfnKey
+{
   int rfn_kind GNUNET_PACKED;
   int k1 GNUNET_PACKED;
   int k2 GNUNET_PACKED;
@@ -132,7 +139,8 @@ struct RfnKey {
 
 GNUNET_NETWORK_STRUCT_END
 
-enum PhaseKind {
+enum PhaseKind
+{
   PHASE_KIND_ALL_TO_ALL,
   PHASE_KIND_ALL_TO_ALL_2,
   PHASE_KIND_GRADECAST_LEADER,
@@ -149,7 +157,8 @@ enum PhaseKind {
 };
 
 
-enum SetKind {
+enum SetKind
+{
   SET_KIND_NONE = 0,
   SET_KIND_CURRENT,
   /**
@@ -160,14 +169,16 @@ enum SetKind {
   SET_KIND_ECHO_RESULT,
 };
 
-enum DiffKind {
+enum DiffKind
+{
   DIFF_KIND_NONE = 0,
   DIFF_KIND_LEADER_PROPOSAL,
   DIFF_KIND_LEADER_CONSENSUS,
   DIFF_KIND_GRADECAST_RESULT,
 };
 
-enum RfnKind {
+enum RfnKind
+{
   RFN_KIND_NONE = 0,
   RFN_KIND_ECHO,
   RFN_KIND_CONFIRM,
@@ -175,7 +186,8 @@ enum RfnKind {
 };
 
 
-struct SetOpCls {
+struct SetOpCls
+{
   struct SetKey input_set;
 
   struct SetKey output_set;
@@ -190,7 +202,8 @@ struct SetOpCls {
 };
 
 
-struct FinishCls {
+struct FinishCls
+{
   struct SetKey input_set;
 };
 
@@ -198,7 +211,8 @@ struct FinishCls {
  * Closure for both @a start_task
  * and @a cancel_task.
  */
-union TaskFuncCls {
+union TaskFuncCls
+{
   struct SetOpCls setop;
   struct FinishCls finish;
 };
@@ -210,7 +224,8 @@ typedef void (*TaskFunc) (struct TaskEntry *task);
 /*
  * Node in the consensus task graph.
  */
-struct TaskEntry {
+struct TaskEntry
+{
   struct TaskKey key;
 
   struct Step *step;
@@ -226,7 +241,8 @@ struct TaskEntry {
 };
 
 
-struct Step {
+struct Step
+{
   /**
    * All steps of one session are in a
    * linked list for easier deallocation.
@@ -304,7 +320,8 @@ struct Step {
 };
 
 
-struct RfnElementInfo {
+struct RfnElementInfo
+{
   const struct GNUNET_SET_Element *element;
 
   /*
@@ -320,7 +337,8 @@ struct RfnElementInfo {
 };
 
 
-struct ReferendumEntry {
+struct ReferendumEntry
+{
   struct RfnKey key;
 
   /*
@@ -355,7 +373,8 @@ struct ReferendumEntry {
 };
 
 
-struct DiffElementInfo {
+struct DiffElementInfo
+{
   const struct GNUNET_SET_Element *element;
 
   /**
@@ -369,12 +388,14 @@ struct DiffElementInfo {
 /**
  * Weighted diff.
  */
-struct DiffEntry {
+struct DiffEntry
+{
   struct DiffKey key;
   struct GNUNET_CONTAINER_MultiHashMap *changes;
 };
 
-struct SetHandle {
+struct SetHandle
+{
   struct SetHandle *prev;
   struct SetHandle *next;
 
@@ -386,7 +407,8 @@ struct SetHandle {
 /**
  * A consensus session consists of one local client and the remote authorities.
  */
-struct ConsensusSession {
+struct ConsensusSession
+{
   /**
    * Consensus sessions are kept in a DLL.
    */
@@ -518,147 +540,147 @@ struct GNUNET_STATISTICS_Handle *statistics;
 
 
 static void
-finish_task(struct TaskEntry *task);
+finish_task (struct TaskEntry *task);
 
 
 static void
-run_ready_steps(struct ConsensusSession *session);
+run_ready_steps (struct ConsensusSession *session);
 
 
 static const char *
-phasename(uint16_t phase)
+phasename (uint16_t phase)
 {
   switch (phase)
-    {
-    case PHASE_KIND_ALL_TO_ALL: return "ALL_TO_ALL";
+  {
+  case PHASE_KIND_ALL_TO_ALL: return "ALL_TO_ALL";
 
-    case PHASE_KIND_ALL_TO_ALL_2: return "ALL_TO_ALL_2";
+  case PHASE_KIND_ALL_TO_ALL_2: return "ALL_TO_ALL_2";
 
-    case PHASE_KIND_FINISH: return "FINISH";
+  case PHASE_KIND_FINISH: return "FINISH";
 
-    case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER";
+  case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER";
 
-    case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO";
+  case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO";
 
-    case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE";
+  case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE";
 
-    case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM";
+  case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM";
 
-    case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE";
+  case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE";
 
-    case PHASE_KIND_APPLY_REP: return "APPLY_REP";
+  case PHASE_KIND_APPLY_REP: return "APPLY_REP";
 
-    default: return "(unknown)";
-    }
+  default: return "(unknown)";
+  }
 }
 
 
 static const char *
-setname(uint16_t kind)
+setname (uint16_t kind)
 {
   switch (kind)
-    {
-    case SET_KIND_CURRENT: return "CURRENT";
+  {
+  case SET_KIND_CURRENT: return "CURRENT";
 
-    case SET_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
+  case SET_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
 
-    case SET_KIND_NONE: return "NONE";
+  case SET_KIND_NONE: return "NONE";
 
-    default: return "(unknown)";
-    }
+  default: return "(unknown)";
+  }
 }
 
 static const char *
-rfnname(uint16_t kind)
+rfnname (uint16_t kind)
 {
   switch (kind)
-    {
-    case RFN_KIND_NONE: return "NONE";
+  {
+  case RFN_KIND_NONE: return "NONE";
 
-    case RFN_KIND_ECHO: return "ECHO";
+  case RFN_KIND_ECHO: return "ECHO";
 
-    case RFN_KIND_CONFIRM: return "CONFIRM";
+  case RFN_KIND_CONFIRM: return "CONFIRM";
 
-    default: return "(unknown)";
-    }
+  default: return "(unknown)";
+  }
 }
 
 static const char *
-diffname(uint16_t kind)
+diffname (uint16_t kind)
 {
   switch (kind)
-    {
-    case DIFF_KIND_NONE: return "NONE";
+  {
+  case DIFF_KIND_NONE: return "NONE";
 
-    case DIFF_KIND_LEADER_CONSENSUS: return "LEADER_CONSENSUS";
+  case DIFF_KIND_LEADER_CONSENSUS: return "LEADER_CONSENSUS";
 
-    case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT";
+  case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT";
 
-    case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
+  case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
 
-    default: return "(unknown)";
-    }
+  default: return "(unknown)";
+  }
 }
 
 #ifdef GNUNET_EXTRA_LOGGING
 
 
 static const char *
-debug_str_element(const struct GNUNET_SET_Element *el)
+debug_str_element (const struct GNUNET_SET_Element *el)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_SET_element_hash(el, &hash);
+  GNUNET_SET_element_hash (el, &hash);
 
-  return GNUNET_h2s(&hash);
+  return GNUNET_h2s (&hash);
 }
 
 static const char *
-debug_str_task_key(struct TaskKey *tk)
+debug_str_task_key (struct TaskKey *tk)
 {
   static char buf[256];
 
-  snprintf(buf, sizeof(buf),
-           "TaskKey kind=%s, p1=%d, p2=%d, l=%d, rep=%d",
-           phasename(tk->kind), tk->peer1, tk->peer2,
-           tk->leader, tk->repetition);
+  snprintf (buf, sizeof(buf),
+            "TaskKey kind=%s, p1=%d, p2=%d, l=%d, rep=%d",
+            phasename (tk->kind), tk->peer1, tk->peer2,
+            tk->leader, tk->repetition);
 
   return buf;
 }
 
 static const char *
-debug_str_diff_key(struct DiffKey *dk)
+debug_str_diff_key (struct DiffKey *dk)
 {
   static char buf[256];
 
-  snprintf(buf, sizeof(buf),
-           "DiffKey kind=%s, k1=%d, k2=%d",
-           diffname(dk->diff_kind), dk->k1, dk->k2);
+  snprintf (buf, sizeof(buf),
+            "DiffKey kind=%s, k1=%d, k2=%d",
+            diffname (dk->diff_kind), dk->k1, dk->k2);
 
   return buf;
 }
 
 static const char *
-debug_str_set_key(const struct SetKey *sk)
+debug_str_set_key (const struct SetKey *sk)
 {
   static char buf[256];
 
-  snprintf(buf, sizeof(buf),
-           "SetKey kind=%s, k1=%d, k2=%d",
-           setname(sk->set_kind), sk->k1, sk->k2);
+  snprintf (buf, sizeof(buf),
+            "SetKey kind=%s, k1=%d, k2=%d",
+            setname (sk->set_kind), sk->k1, sk->k2);
 
   return buf;
 }
 
 
 static const char *
-debug_str_rfn_key(const struct RfnKey *rk)
+debug_str_rfn_key (const struct RfnKey *rk)
 {
   static char buf[256];
 
-  snprintf(buf, sizeof(buf),
-           "RfnKey kind=%s, k1=%d, k2=%d",
-           rfnname(rk->rfn_kind), rk->k1, rk->k2);
+  snprintf (buf, sizeof(buf),
+            "RfnKey kind=%s, k1=%d, k2=%d",
+            rfnname (rk->rfn_kind), rk->k1, rk->k2);
 
   return buf;
 }
@@ -676,164 +698,170 @@ debug_str_rfn_key(const struct RfnKey *rk)
  * @return #GNUNET_YES to continue iterating, #GNUNET_NO to stop.
  */
 static int
-send_to_client_iter(void *cls,
-                    const struct GNUNET_SET_Element *element)
+send_to_client_iter (void *cls,
+                     const struct GNUNET_SET_Element *element)
 {
-  struct TaskEntry *task = (struct TaskEntry *)cls;
+  struct TaskEntry *task = (struct TaskEntry *) cls;
   struct ConsensusSession *session = task->step->session;
   struct GNUNET_MQ_Envelope *ev;
 
   if (NULL != element)
-    {
-      struct GNUNET_CONSENSUS_ElementMessage *m;
-      const struct ConsensusElement *ce;
-
-      GNUNET_assert(GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == element->element_type);
-      ce = element->data;
-
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n", (unsigned)ce->marker);
-
-      if (0 != ce->marker)
-        return GNUNET_YES;
-
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%d: sending element %s to client\n",
-                 session->local_peer_idx,
-                 debug_str_element(element));
-
-      ev = GNUNET_MQ_msg_extra(m, element->size - sizeof(struct ConsensusElement),
-                               GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT);
-      m->element_type = ce->payload_type;
-      GNUNET_memcpy(&m[1], &ce[1], element->size - sizeof(struct ConsensusElement));
-      GNUNET_MQ_send(session->client_mq, ev);
-    }
+  {
+    struct GNUNET_CONSENSUS_ElementMessage *m;
+    const struct ConsensusElement *ce;
+
+    GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT ==
+                   element->element_type);
+    ce = element->data;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n",
+                (unsigned) ce->marker);
+
+    if (0 != ce->marker)
+      return GNUNET_YES;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%d: sending element %s to client\n",
+                session->local_peer_idx,
+                debug_str_element (element));
+
+    ev = GNUNET_MQ_msg_extra (m, element->size - sizeof(struct
+                                                        ConsensusElement),
+                              GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT);
+    m->element_type = ce->payload_type;
+    GNUNET_memcpy (&m[1], &ce[1], element->size - sizeof(struct
+                                                         ConsensusElement));
+    GNUNET_MQ_send (session->client_mq, ev);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%d: finished iterating elements for client\n",
-                 session->local_peer_idx);
-      ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE);
-      GNUNET_MQ_send(session->client_mq, ev);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%d: finished iterating elements for client\n",
+                session->local_peer_idx);
+    ev = GNUNET_MQ_msg_header (
+      GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE);
+    GNUNET_MQ_send (session->client_mq, ev);
+  }
   return GNUNET_YES;
 }
 
 
 static struct SetEntry *
-lookup_set(struct ConsensusSession *session, struct SetKey *key)
+lookup_set (struct ConsensusSession *session, struct SetKey *key)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "P%u: looking up set {%s}\n",
-             session->local_peer_idx,
-             debug_str_set_key(key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up set {%s}\n",
+              session->local_peer_idx,
+              debug_str_set_key (key));
 
-  GNUNET_assert(SET_KIND_NONE != key->set_kind);
-  GNUNET_CRYPTO_hash(key, sizeof(struct SetKey), &hash);
-  return GNUNET_CONTAINER_multihashmap_get(session->setmap, &hash);
+  GNUNET_assert (SET_KIND_NONE != key->set_kind);
+  GNUNET_CRYPTO_hash (key, sizeof(struct SetKey), &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->setmap, &hash);
 }
 
 
 static struct DiffEntry *
-lookup_diff(struct ConsensusSession *session, struct DiffKey *key)
+lookup_diff (struct ConsensusSession *session, struct DiffKey *key)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "P%u: looking up diff {%s}\n",
-             session->local_peer_idx,
-             debug_str_diff_key(key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up diff {%s}\n",
+              session->local_peer_idx,
+              debug_str_diff_key (key));
 
-  GNUNET_assert(DIFF_KIND_NONE != key->diff_kind);
-  GNUNET_CRYPTO_hash(key, sizeof(struct DiffKey), &hash);
-  return GNUNET_CONTAINER_multihashmap_get(session->diffmap, &hash);
+  GNUNET_assert (DIFF_KIND_NONE != key->diff_kind);
+  GNUNET_CRYPTO_hash (key, sizeof(struct DiffKey), &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->diffmap, &hash);
 }
 
 
 static struct ReferendumEntry *
-lookup_rfn(struct ConsensusSession *session, struct RfnKey *key)
+lookup_rfn (struct ConsensusSession *session, struct RfnKey *key)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "P%u: looking up rfn {%s}\n",
-             session->local_peer_idx,
-             debug_str_rfn_key(key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up rfn {%s}\n",
+              session->local_peer_idx,
+              debug_str_rfn_key (key));
 
-  GNUNET_assert(RFN_KIND_NONE != key->rfn_kind);
-  GNUNET_CRYPTO_hash(key, sizeof(struct RfnKey), &hash);
-  return GNUNET_CONTAINER_multihashmap_get(session->rfnmap, &hash);
+  GNUNET_assert (RFN_KIND_NONE != key->rfn_kind);
+  GNUNET_CRYPTO_hash (key, sizeof(struct RfnKey), &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->rfnmap, &hash);
 }
 
 
 static void
-diff_insert(struct DiffEntry *diff,
-            int weight,
-            const struct GNUNET_SET_Element *element)
+diff_insert (struct DiffEntry *diff,
+             int weight,
+             const struct GNUNET_SET_Element *element)
 {
   struct DiffElementInfo *di;
   struct GNUNET_HashCode hash;
 
-  GNUNET_assert((1 == weight) || (-1 == weight));
+  GNUNET_assert ((1 == weight) || (-1 == weight));
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "diff_insert with element size %u\n",
-             element->size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "diff_insert with element size %u\n",
+              element->size);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "hashing element\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "hashing element\n");
 
-  GNUNET_SET_element_hash(element, &hash);
+  GNUNET_SET_element_hash (element, &hash);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "hashed element\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "hashed element\n");
 
-  di = GNUNET_CONTAINER_multihashmap_get(diff->changes, &hash);
+  di = GNUNET_CONTAINER_multihashmap_get (diff->changes, &hash);
 
   if (NULL == di)
-    {
-      di = GNUNET_new(struct DiffElementInfo);
-      di->element = GNUNET_SET_element_dup(element);
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_put(diff->changes,
+  {
+    di = GNUNET_new (struct DiffElementInfo);
+    di->element = GNUNET_SET_element_dup (element);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (diff->changes,
                                                       &hash, di,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-    }
+  }
 
   di->weight = weight;
 }
 
 
 static void
-rfn_commit(struct ReferendumEntry *rfn,
-           uint16_t commit_peer)
+rfn_commit (struct ReferendumEntry *rfn,
+            uint16_t commit_peer)
 {
-  GNUNET_assert(commit_peer < rfn->num_peers);
+  GNUNET_assert (commit_peer < rfn->num_peers);
 
   rfn->peer_commited[commit_peer] = GNUNET_YES;
 }
 
 
 static void
-rfn_contest(struct ReferendumEntry *rfn,
-            uint16_t contested_peer)
+rfn_contest (struct ReferendumEntry *rfn,
+             uint16_t contested_peer)
 {
-  GNUNET_assert(contested_peer < rfn->num_peers);
+  GNUNET_assert (contested_peer < rfn->num_peers);
 
   rfn->peer_contested[contested_peer] = GNUNET_YES;
 }
 
 
 static uint16_t
-rfn_noncontested(struct ReferendumEntry *rfn)
+rfn_noncontested (struct ReferendumEntry *rfn)
 {
   uint16_t i;
   uint16_t ret;
 
   ret = 0;
   for (i = 0; i < rfn->num_peers; i++)
-    if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO == rfn->peer_contested[i]))
+    if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO ==
+                                                  rfn->peer_contested[i]))
       ret++;
 
   return ret;
@@ -841,33 +869,33 @@ rfn_noncontested(struct ReferendumEntry *rfn)
 
 
 static void
-rfn_vote(struct ReferendumEntry *rfn,
-         uint16_t voting_peer,
-         enum ReferendumVote vote,
-         const struct GNUNET_SET_Element *element)
+rfn_vote (struct ReferendumEntry *rfn,
+          uint16_t voting_peer,
+          enum ReferendumVote vote,
+          const struct GNUNET_SET_Element *element)
 {
   struct RfnElementInfo *ri;
   struct GNUNET_HashCode hash;
 
-  GNUNET_assert(voting_peer < rfn->num_peers);
+  GNUNET_assert (voting_peer < rfn->num_peers);
 
   /* Explicit voting only makes sense with VOTE_ADD or VOTE_REMOTE,
      since VOTE_KEEP is implicit in not voting. */
-  GNUNET_assert((VOTE_ADD == vote) || (VOTE_REMOVE == vote));
+  GNUNET_assert ((VOTE_ADD == vote) || (VOTE_REMOVE == vote));
 
-  GNUNET_SET_element_hash(element, &hash);
-  ri = GNUNET_CONTAINER_multihashmap_get(rfn->rfn_elements, &hash);
+  GNUNET_SET_element_hash (element, &hash);
+  ri = GNUNET_CONTAINER_multihashmap_get (rfn->rfn_elements, &hash);
 
   if (NULL == ri)
-    {
-      ri = GNUNET_new(struct RfnElementInfo);
-      ri->element = GNUNET_SET_element_dup(element);
-      ri->votes = GNUNET_new_array(rfn->num_peers, int);
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_put(rfn->rfn_elements,
+  {
+    ri = GNUNET_new (struct RfnElementInfo);
+    ri->element = GNUNET_SET_element_dup (element);
+    ri->votes = GNUNET_new_array (rfn->num_peers, int);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (rfn->rfn_elements,
                                                       &hash, ri,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-    }
+  }
 
   ri->votes[voting_peer] = GNUNET_YES;
   ri->proposal = vote;
@@ -875,7 +903,7 @@ rfn_vote(struct ReferendumEntry *rfn,
 
 
 static uint16_t
-task_other_peer(struct TaskEntry *task)
+task_other_peer (struct TaskEntry *task)
 {
   uint16_t me = task->step->session->local_peer_idx;
 
@@ -886,10 +914,10 @@ task_other_peer(struct TaskEntry *task)
 
 
 static int
-cmp_uint64_t(const void *pa, const void *pb)
+cmp_uint64_t (const void *pa, const void *pb)
 {
-  uint64_t a = *(uint64_t *)pa;
-  uint64_t b = *(uint64_t *)pb;
+  uint64_t a = *(uint64_t *) pa;
+  uint64_t b = *(uint64_t *) pb;
 
   if (a == b)
     return 0;
@@ -909,10 +937,10 @@ cmp_uint64_t(const void *pa, const void *pb)
  * @param status see enum GNUNET_SET_Status
  */
 static void
-set_result_cb(void *cls,
-              const struct GNUNET_SET_Element *element,
-              uint64_t current_size,
-              enum GNUNET_SET_Status status)
+set_result_cb (void *cls,
+               const struct GNUNET_SET_Element *element,
+               uint64_t current_size,
+               enum GNUNET_SET_Status status)
 {
   struct TaskEntry *task = cls;
   struct ConsensusSession *session = task->step->session;
@@ -924,246 +952,250 @@ set_result_cb(void *cls,
   const struct ConsensusElement *consensus_element = NULL;
 
   if (NULL != element)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%u: got element of type %u, status %u\n",
-                 session->local_peer_idx,
-                 (unsigned)element->element_type,
-                 (unsigned)status);
-      GNUNET_assert(GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == element->element_type);
-      consensus_element = element->data;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: got element of type %u, status %u\n",
+                session->local_peer_idx,
+                (unsigned) element->element_type,
+                (unsigned) status);
+    GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT ==
+                   element->element_type);
+    consensus_element = element->data;
+  }
 
   setop = &task->cls.setop;
 
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "P%u: got set result for {%s}, status %u\n",
-             session->local_peer_idx,
-             debug_str_task_key(&task->key),
-             status);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: got set result for {%s}, status %u\n",
+              session->local_peer_idx,
+              debug_str_task_key (&task->key),
+              status);
 
   if (GNUNET_NO == task->is_started)
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
   if (GNUNET_YES == task->is_finished)
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
-  other_idx = task_other_peer(task);
+  other_idx = task_other_peer (task);
 
   if (SET_KIND_NONE != setop->output_set.set_kind)
-    {
-      output_set = lookup_set(session, &setop->output_set);
-      GNUNET_assert(NULL != output_set);
-    }
+  {
+    output_set = lookup_set (session, &setop->output_set);
+    GNUNET_assert (NULL != output_set);
+  }
 
   if (DIFF_KIND_NONE != setop->output_diff.diff_kind)
-    {
-      output_diff = lookup_diff(session, &setop->output_diff);
-      GNUNET_assert(NULL != output_diff);
-    }
+  {
+    output_diff = lookup_diff (session, &setop->output_diff);
+    GNUNET_assert (NULL != output_diff);
+  }
 
   if (RFN_KIND_NONE != setop->output_rfn.rfn_kind)
-    {
-      output_rfn = lookup_rfn(session, &setop->output_rfn);
-      GNUNET_assert(NULL != output_rfn);
-    }
+  {
+    output_rfn = lookup_rfn (session, &setop->output_rfn);
+    GNUNET_assert (NULL != output_rfn);
+  }
 
   if (GNUNET_YES == session->peers_blacklisted[other_idx])
-    {
-      /* Peer might have been blacklisted
-         by a gradecast running in parallel, ignore elements from now */
-      if (GNUNET_SET_STATUS_ADD_LOCAL == status)
-        return;
-      if (GNUNET_SET_STATUS_ADD_REMOTE == status)
-        return;
-    }
+  {
+    /* Peer might have been blacklisted
+       by a gradecast running in parallel, ignore elements from now */
+    if (GNUNET_SET_STATUS_ADD_LOCAL == status)
+      return;
+    if (GNUNET_SET_STATUS_ADD_REMOTE == status)
+      return;
+  }
 
   if ((NULL != consensus_element) && (0 != consensus_element->marker))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: got some marker\n",
+                session->local_peer_idx);
+    if ((GNUNET_YES == setop->transceive_contested) &&
+        (CONSENSUS_MARKER_CONTESTED == consensus_element->marker))
+    {
+      GNUNET_assert (NULL != output_rfn);
+      rfn_contest (output_rfn, task_other_peer (task));
+      return;
+    }
+
+    if (CONSENSUS_MARKER_SIZE == consensus_element->marker)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%u: got some marker\n",
-                 session->local_peer_idx);
-      if ((GNUNET_YES == setop->transceive_contested) &&
-          (CONSENSUS_MARKER_CONTESTED == consensus_element->marker))
-        {
-          GNUNET_assert(NULL != output_rfn);
-          rfn_contest(output_rfn, task_other_peer(task));
-          return;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: got size marker\n",
+                  session->local_peer_idx);
 
-      if (CONSENSUS_MARKER_SIZE == consensus_element->marker)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: got size marker\n",
-                     session->local_peer_idx);
-
-
-          struct ConsensusSizeElement *cse = (void *)consensus_element;
-
-          if (cse->sender_index == other_idx)
-            {
-              if (NULL == session->first_sizes_received)
-                session->first_sizes_received = GNUNET_new_array(session->num_peers, uint64_t);
-              session->first_sizes_received[other_idx] = GNUNET_ntohll(cse->size);
-
-              uint64_t *copy = GNUNET_memdup(session->first_sizes_received, sizeof(uint64_t) * session->num_peers);
-              qsort(copy, session->num_peers, sizeof(uint64_t), cmp_uint64_t);
-              session->lower_bound = copy[session->num_peers / 3 + 1];
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                         "P%u: lower bound %llu\n",
-                         session->local_peer_idx,
-                         (long long)session->lower_bound);
-              GNUNET_free(copy);
-            }
-          return;
-        }
 
+      struct ConsensusSizeElement *cse = (void *) consensus_element;
+
+      if (cse->sender_index == other_idx)
+      {
+        if (NULL == session->first_sizes_received)
+          session->first_sizes_received = GNUNET_new_array (session->num_peers,
+                                                            uint64_t);
+        session->first_sizes_received[other_idx] = GNUNET_ntohll (cse->size);
+
+        uint64_t *copy = GNUNET_memdup (session->first_sizes_received,
+                                        sizeof(uint64_t) * session->num_peers);
+        qsort (copy, session->num_peers, sizeof(uint64_t), cmp_uint64_t);
+        session->lower_bound = copy[session->num_peers / 3 + 1];
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "P%u: lower bound %llu\n",
+                    session->local_peer_idx,
+                    (long long) session->lower_bound);
+        GNUNET_free (copy);
+      }
       return;
     }
 
+    return;
+  }
+
   switch (status)
-    {
-    case GNUNET_SET_STATUS_ADD_LOCAL:
-      GNUNET_assert(NULL != consensus_element);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Adding element in Task {%s}\n",
-                 debug_str_task_key(&task->key));
-      if (NULL != output_set)
-        {
-          // FIXME: record pending adds, use callback
-          GNUNET_SET_add_element(output_set->h,
-                                 element,
-                                 NULL,
-                                 NULL);
+  {
+  case GNUNET_SET_STATUS_ADD_LOCAL:
+    GNUNET_assert (NULL != consensus_element);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Adding element in Task {%s}\n",
+                debug_str_task_key (&task->key));
+    if (NULL != output_set)
+    {
+      // FIXME: record pending adds, use callback
+      GNUNET_SET_add_element (output_set->h,
+                              element,
+                              NULL,
+                              NULL);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: adding element %s into set {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_set_key(&setop->output_set),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into set {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_set_key (&setop->output_set),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      if (NULL != output_diff)
-        {
-          diff_insert(output_diff, 1, element);
+    }
+    if (NULL != output_diff)
+    {
+      diff_insert (output_diff, 1, element);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: adding element %s into diff {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_diff_key(&setop->output_diff),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into diff {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_diff_key (&setop->output_diff),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      if (NULL != output_rfn)
-        {
-          rfn_vote(output_rfn, task_other_peer(task), VOTE_ADD, element);
+    }
+    if (NULL != output_rfn)
+    {
+      rfn_vote (output_rfn, task_other_peer (task), VOTE_ADD, element);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: adding element %s into rfn {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_rfn_key(&setop->output_rfn),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into rfn {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_rfn_key (&setop->output_rfn),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      // XXX: add result to structures in task
-      break;
+    }
+    // XXX: add result to structures in task
+    break;
 
-    case GNUNET_SET_STATUS_ADD_REMOTE:
-      GNUNET_assert(NULL != consensus_element);
-      if (GNUNET_YES == setop->do_not_remove)
-        break;
-      if (CONSENSUS_MARKER_CONTESTED == consensus_element->marker)
-        break;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Removing element in Task {%s}\n",
-                 debug_str_task_key(&task->key));
-      if (NULL != output_set)
-        {
-          // FIXME: record pending adds, use callback
-          GNUNET_SET_remove_element(output_set->h,
-                                    element,
-                                    NULL,
-                                    NULL);
+  case GNUNET_SET_STATUS_ADD_REMOTE:
+    GNUNET_assert (NULL != consensus_element);
+    if (GNUNET_YES == setop->do_not_remove)
+      break;
+    if (CONSENSUS_MARKER_CONTESTED == consensus_element->marker)
+      break;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing element in Task {%s}\n",
+                debug_str_task_key (&task->key));
+    if (NULL != output_set)
+    {
+      // FIXME: record pending adds, use callback
+      GNUNET_SET_remove_element (output_set->h,
+                                 element,
+                                 NULL,
+                                 NULL);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: removing element %s from set {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_set_key(&setop->output_set),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from set {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_set_key (&setop->output_set),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      if (NULL != output_diff)
-        {
-          diff_insert(output_diff, -1, element);
+    }
+    if (NULL != output_diff)
+    {
+      diff_insert (output_diff, -1, element);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: removing element %s from diff {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_diff_key(&setop->output_diff),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from diff {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_diff_key (&setop->output_diff),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      if (NULL != output_rfn)
-        {
-          rfn_vote(output_rfn, task_other_peer(task), VOTE_REMOVE, element);
+    }
+    if (NULL != output_rfn)
+    {
+      rfn_vote (output_rfn, task_other_peer (task), VOTE_REMOVE, element);
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: removing element %s from rfn {%s} of task {%s}\n",
-                     session->local_peer_idx,
-                     debug_str_element(element),
-                     debug_str_rfn_key(&setop->output_rfn),
-                     debug_str_task_key(&task->key));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from rfn {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_rfn_key (&setop->output_rfn),
+                  debug_str_task_key (&task->key));
 #endif
-        }
-      break;
+    }
+    break;
 
-    case GNUNET_SET_STATUS_DONE:
-      // XXX: check first if any changes to the underlying
-      // set are still pending
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%u: Finishing setop in Task {%s} (%u/%u)\n",
-                 session->local_peer_idx,
-                 debug_str_task_key(&task->key),
-                 (unsigned int)task->step->finished_tasks,
-                 (unsigned int)task->step->tasks_len);
-      if (NULL != output_rfn)
-        {
-          rfn_commit(output_rfn, task_other_peer(task));
-        }
-      if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
-        {
-          session->first_size = current_size;
-        }
-      finish_task(task);
-      break;
+  case GNUNET_SET_STATUS_DONE:
+    // XXX: check first if any changes to the underlying
+    // set are still pending
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: Finishing setop in Task {%s} (%u/%u)\n",
+                session->local_peer_idx,
+                debug_str_task_key (&task->key),
+                (unsigned int) task->step->finished_tasks,
+                (unsigned int) task->step->tasks_len);
+    if (NULL != output_rfn)
+    {
+      rfn_commit (output_rfn, task_other_peer (task));
+    }
+    if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
+    {
+      session->first_size = current_size;
+    }
+    finish_task (task);
+    break;
 
-    case GNUNET_SET_STATUS_FAILURE:
-      // XXX: cleanup
-      GNUNET_break_op(0);
-      finish_task(task);
-      return;
+  case GNUNET_SET_STATUS_FAILURE:
+    // XXX: cleanup
+    GNUNET_break_op (0);
+    finish_task (task);
+    return;
 
-    default:
-      /* not reached */
-      GNUNET_assert(0);
-    }
+  default:
+    /* not reached */
+    GNUNET_assert (0);
+  }
 }
 
 #ifdef EVIL
 
-enum EvilnessType {
+enum EvilnessType
+{
   EVILNESS_NONE,
   EVILNESS_CRAM_ALL,
   EVILNESS_CRAM_LEAD,
@@ -1172,13 +1204,15 @@ enum EvilnessType {
   EVILNESS_SLACK_A2A,
 };
 
-enum EvilnessSubType {
+enum EvilnessSubType
+{
   EVILNESS_SUB_NONE,
   EVILNESS_SUB_REPLACEMENT,
   EVILNESS_SUB_NO_REPLACEMENT,
 };
 
-struct Evilness {
+struct Evilness
+{
   enum EvilnessType type;
   enum EvilnessSubType subtype;
   unsigned int num;
@@ -1186,129 +1220,133 @@ struct Evilness {
 
 
 static int
-parse_evilness_cram_subtype(const char *evil_subtype_str, struct Evilness *evil)
+parse_evilness_cram_subtype (const char *evil_subtype_str, struct
+                             Evilness *evil)
 {
-  if (0 == strcmp("replace", evil_subtype_str))
-    {
-      evil->subtype = EVILNESS_SUB_REPLACEMENT;
-    }
-  else if (0 == strcmp("noreplace", evil_subtype_str))
-    {
-      evil->subtype = EVILNESS_SUB_NO_REPLACEMENT;
-    }
+  if (0 == strcmp ("replace", evil_subtype_str))
+  {
+    evil->subtype = EVILNESS_SUB_REPLACEMENT;
+  }
+  else if (0 == strcmp ("noreplace", evil_subtype_str))
+  {
+    evil->subtype = EVILNESS_SUB_NO_REPLACEMENT;
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Malformed field '%s' in EVIL_SPEC (unknown subtype), behaving like a good peer.\n",
-                 evil_subtype_str);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Malformed field '%s' in EVIL_SPEC (unknown subtype), behaving like a good peer.\n",
+                evil_subtype_str);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
 
 static void
-get_evilness(struct ConsensusSession *session, struct Evilness *evil)
+get_evilness (struct ConsensusSession *session, struct Evilness *evil)
 {
   char *evil_spec;
   char *field;
   char *evil_type_str = NULL;
   char *evil_subtype_str = NULL;
 
-  GNUNET_assert(NULL != evil);
+  GNUNET_assert (NULL != evil);
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "consensus", "EVIL_SPEC", &evil_spec))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%u: no evilness\n",
-                 session->local_peer_idx);
-      evil->type = EVILNESS_NONE;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "P%u: got evilness spec\n",
-             session->local_peer_idx);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "consensus",
+                                                          "EVIL_SPEC",
+                                                          &evil_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: no evilness\n",
+                session->local_peer_idx);
+    evil->type = EVILNESS_NONE;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: got evilness spec\n",
+              session->local_peer_idx);
 
-  for (field = strtok(evil_spec, "/");
+  for (field = strtok (evil_spec, "/");
        NULL != field;
-       field = strtok(NULL, "/"))
-    {
-      unsigned int peer_num;
-      unsigned int evil_num;
-      int ret;
+       field = strtok (NULL, "/"))
+  {
+    unsigned int peer_num;
+    unsigned int evil_num;
+    int ret;
 
-      evil_type_str = NULL;
-      evil_subtype_str = NULL;
+    evil_type_str = NULL;
+    evil_subtype_str = NULL;
 
-      ret = sscanf(field, "%u;%m[a-z-];%m[a-z-];%u", &peer_num, &evil_type_str, &evil_subtype_str, &evil_num);
+    ret = sscanf (field, "%u;%m[a-z-];%m[a-z-];%u", &peer_num, &evil_type_str,
+                  &evil_subtype_str, &evil_num);
 
-      if (ret != 4)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Malformed field '%s' in EVIL_SPEC (expected 4 components got %d), behaving like a good peer.\n",
-                     field,
-                     ret);
-          goto not_evil;
-        }
+    if (ret != 4)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Malformed field '%s' in EVIL_SPEC (expected 4 components got %d), behaving like a good peer.\n",
+                  field,
+                  ret);
+      goto not_evil;
+    }
 
-      GNUNET_assert(NULL != evil_type_str);
-      GNUNET_assert(NULL != evil_subtype_str);
+    GNUNET_assert (NULL != evil_type_str);
+    GNUNET_assert (NULL != evil_subtype_str);
 
-      if (peer_num == session->local_peer_idx)
-        {
-          if (0 == strcmp("slack", evil_type_str))
-            {
-              evil->type = EVILNESS_SLACK;
-            }
-          if (0 == strcmp("slack-a2a", evil_type_str))
-            {
-              evil->type = EVILNESS_SLACK_A2A;
-            }
-          else if (0 == strcmp("cram-all", evil_type_str))
-            {
-              evil->type = EVILNESS_CRAM_ALL;
-              evil->num = evil_num;
-              if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil))
-                goto not_evil;
-            }
-          else if (0 == strcmp("cram-lead", evil_type_str))
-            {
-              evil->type = EVILNESS_CRAM_LEAD;
-              evil->num = evil_num;
-              if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil))
-                goto not_evil;
-            }
-          else if (0 == strcmp("cram-echo", evil_type_str))
-            {
-              evil->type = EVILNESS_CRAM_ECHO;
-              evil->num = evil_num;
-              if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil))
-                goto not_evil;
-            }
-          else
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Malformed field '%s' in EVIL_SPEC (unknown type), behaving like a good peer.\n",
-                         evil_type_str);
-              goto not_evil;
-            }
-          goto cleanup;
-        }
-      /* No GNUNET_free since memory was allocated by libc */
-      free(evil_type_str);
-      evil_type_str = NULL;
-      evil_subtype_str = NULL;
+    if (peer_num == session->local_peer_idx)
+    {
+      if (0 == strcmp ("slack", evil_type_str))
+      {
+        evil->type = EVILNESS_SLACK;
+      }
+      if (0 == strcmp ("slack-a2a", evil_type_str))
+      {
+        evil->type = EVILNESS_SLACK_A2A;
+      }
+      else if (0 == strcmp ("cram-all", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_ALL;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else if (0 == strcmp ("cram-lead", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_LEAD;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else if (0 == strcmp ("cram-echo", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_ECHO;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Malformed field '%s' in EVIL_SPEC (unknown type), behaving like a good peer.\n",
+                    evil_type_str);
+        goto not_evil;
+      }
+      goto cleanup;
     }
+    /* No GNUNET_free since memory was allocated by libc */
+    free (evil_type_str);
+    evil_type_str = NULL;
+    evil_subtype_str = NULL;
+  }
 not_evil:
   evil->type = EVILNESS_NONE;
 cleanup:
-  GNUNET_free(evil_spec);
+  GNUNET_free (evil_spec);
   /* no GNUNET_free_non_null since it wasn't
    * allocated with GNUNET_malloc */
   if (NULL != evil_type_str)
-    free(evil_type_str);
+    free (evil_type_str);
   if (NULL != evil_subtype_str)
-    free(evil_subtype_str);
+    free (evil_subtype_str);
 }
 
 #endif
@@ -1319,301 +1357,312 @@ cleanup:
  * task.
  */
 static void
-commit_set(struct ConsensusSession *session,
-           struct TaskEntry *task)
+commit_set (struct ConsensusSession *session,
+            struct TaskEntry *task)
 {
   struct SetEntry *set;
   struct SetOpCls *setop = &task->cls.setop;
 
-  GNUNET_assert(NULL != setop->op);
-  set = lookup_set(session, &setop->input_set);
-  GNUNET_assert(NULL != set);
+  GNUNET_assert (NULL != setop->op);
+  set = lookup_set (session, &setop->input_set);
+  GNUNET_assert (NULL != set);
 
-  if ((GNUNET_YES == setop->transceive_contested) && (GNUNET_YES == set->is_contested))
-    {
-      struct GNUNET_SET_Element element;
-      struct ConsensusElement ce = { 0 };
-      ce.marker = CONSENSUS_MARKER_CONTESTED;
-      element.data = &ce;
-      element.size = sizeof(struct ConsensusElement);
-      element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
-      GNUNET_SET_add_element(set->h, &element, NULL, NULL);
-    }
+  if ((GNUNET_YES == setop->transceive_contested) && (GNUNET_YES ==
+                                                      set->is_contested))
+  {
+    struct GNUNET_SET_Element element;
+    struct ConsensusElement ce = { 0 };
+    ce.marker = CONSENSUS_MARKER_CONTESTED;
+    element.data = &ce;
+    element.size = sizeof(struct ConsensusElement);
+    element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+    GNUNET_SET_add_element (set->h, &element, NULL, NULL);
+  }
 
   if (PHASE_KIND_ALL_TO_ALL_2 == task->key.kind)
-    {
-      struct GNUNET_SET_Element element;
-      struct ConsensusSizeElement cse = {
-        .size = 0,
-        .sender_index = 0
-      };
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "inserting size marker\n");
-      cse.ce.marker = CONSENSUS_MARKER_SIZE;
-      cse.size = GNUNET_htonll(session->first_size);
-      cse.sender_index = session->local_peer_idx;
-      element.data = &cse;
-      element.size = sizeof(struct ConsensusSizeElement);
-      element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
-      GNUNET_SET_add_element(set->h, &element, NULL, NULL);
-    }
+  {
+    struct GNUNET_SET_Element element;
+    struct ConsensusSizeElement cse = {
+      .size = 0,
+      .sender_index = 0
+    };
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "inserting size marker\n");
+    cse.ce.marker = CONSENSUS_MARKER_SIZE;
+    cse.size = GNUNET_htonll (session->first_size);
+    cse.sender_index = session->local_peer_idx;
+    element.data = &cse;
+    element.size = sizeof(struct ConsensusSizeElement);
+    element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+    GNUNET_SET_add_element (set->h, &element, NULL, NULL);
+  }
 
 #ifdef EVIL
   {
     unsigned int i;
     struct Evilness evil;
 
-    get_evilness(session, &evil);
+    get_evilness (session, &evil);
     if (EVILNESS_NONE != evil.type)
+    {
+      /* Useful for evaluation */
+      GNUNET_STATISTICS_set (statistics,
+                             "is evil",
+                             1,
+                             GNUNET_NO);
+    }
+    switch (evil.type)
+    {
+    case EVILNESS_CRAM_ALL:
+    case EVILNESS_CRAM_LEAD:
+    case EVILNESS_CRAM_ECHO:
+      /* We're not cramming elements in the
+         all-to-all round, since that would just
+         add more elements to the result set, but
+         wouldn't test robustness. */
+      if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
       {
-        /* Useful for evaluation */
-        GNUNET_STATISTICS_set(statistics,
-                              "is evil",
-                              1,
-                              GNUNET_NO);
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
       }
-    switch (evil.type)
+      if ((EVILNESS_CRAM_LEAD == evil.type) &&
+          ((PHASE_KIND_GRADECAST_LEADER != task->key.kind) ||
+           (SET_KIND_CURRENT != set->key.set_kind) ))
+      {
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
+      }
+      if ((EVILNESS_CRAM_ECHO == evil.type) && (PHASE_KIND_GRADECAST_ECHO !=
+                                                task->key.kind))
       {
-      case EVILNESS_CRAM_ALL:
-      case EVILNESS_CRAM_LEAD:
-      case EVILNESS_CRAM_ECHO:
-        /* We're not cramming elements in the
-           all-to-all round, since that would just
-           add more elements to the result set, but
-           wouldn't test robustness. */
-        if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
-          {
-            GNUNET_SET_commit(setop->op, set->h);
-            break;
-          }
-        if ((EVILNESS_CRAM_LEAD == evil.type) &&
-            ((PHASE_KIND_GRADECAST_LEADER != task->key.kind) || SET_KIND_CURRENT != set->key.set_kind))
-          {
-            GNUNET_SET_commit(setop->op, set->h);
-            break;
-          }
-        if (EVILNESS_CRAM_ECHO == evil.type && (PHASE_KIND_GRADECAST_ECHO != task->key.kind))
-          {
-            GNUNET_SET_commit(setop->op, set->h);
-            break;
-          }
-        for (i = 0; i < evil.num; i++)
-          {
-            struct GNUNET_SET_Element element;
-            struct ConsensusStuffedElement se = {
-              .ce.payload_type = 0,
-              .ce.marker = 0,
-            };
-            element.data = &se;
-            element.size = sizeof(struct ConsensusStuffedElement);
-            element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
-
-            if (EVILNESS_SUB_REPLACEMENT == evil.subtype)
-              {
-                /* Always generate a new element. */
-                GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &se.rand);
-              }
-            else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype)
-              {
-                /* Always cram the same elements, derived from counter. */
-                GNUNET_CRYPTO_hash(&i, sizeof(i), &se.rand);
-              }
-            else
-              {
-                GNUNET_assert(0);
-              }
-            GNUNET_SET_add_element(set->h, &element, NULL, NULL);
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
+      }
+      for (i = 0; i < evil.num; i++)
+      {
+        struct GNUNET_SET_Element element;
+        struct ConsensusStuffedElement se = {
+          .ce.payload_type = 0,
+          .ce.marker = 0,
+        };
+        element.data = &se;
+        element.size = sizeof(struct ConsensusStuffedElement);
+        element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+
+        if (EVILNESS_SUB_REPLACEMENT == evil.subtype)
+        {
+          /* Always generate a new element. */
+          GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+                                            &se.rand);
+        }
+        else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype)
+        {
+          /* Always cram the same elements, derived from counter. */
+          GNUNET_CRYPTO_hash (&i, sizeof(i), &se.rand);
+        }
+        else
+        {
+          GNUNET_assert (0);
+        }
+        GNUNET_SET_add_element (set->h, &element, NULL, NULL);
 #ifdef GNUNET_EXTRA_LOGGING
-            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                       "P%u: evil peer: cramming element %s into set {%s} of task {%s}\n",
-                       session->local_peer_idx,
-                       debug_str_element(&element),
-                       debug_str_set_key(&setop->input_set),
-                       debug_str_task_key(&task->key));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "P%u: evil peer: cramming element %s into set {%s} of task {%s}\n",
+                    session->local_peer_idx,
+                    debug_str_element (&element),
+                    debug_str_set_key (&setop->input_set),
+                    debug_str_task_key (&task->key));
 #endif
-          }
-        GNUNET_STATISTICS_update(statistics,
-                                 "# stuffed elements",
-                                 evil.num,
-                                 GNUNET_NO);
-        GNUNET_SET_commit(setop->op, set->h);
-        break;
+      }
+      GNUNET_STATISTICS_update (statistics,
+                                "# stuffed elements",
+                                evil.num,
+                                GNUNET_NO);
+      GNUNET_SET_commit (setop->op, set->h);
+      break;
 
-      case EVILNESS_SLACK:
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                   "P%u: evil peer: slacking\n",
-                   (unsigned int)session->local_peer_idx);
-
-      /* Do nothing. */
-      case EVILNESS_SLACK_A2A:
-        if ((PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) ||
-            (PHASE_KIND_ALL_TO_ALL == task->key.kind))
-          {
-            struct GNUNET_SET_Handle *empty_set;
-            empty_set = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION);
-            GNUNET_SET_commit(setop->op, empty_set);
-            GNUNET_SET_destroy(empty_set);
-          }
-        else
-          {
-            GNUNET_SET_commit(setop->op, set->h);
-          }
-        break;
+    case EVILNESS_SLACK:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: evil peer: slacking\n",
+                  (unsigned int) session->local_peer_idx);
 
-      case EVILNESS_NONE:
-        GNUNET_SET_commit(setop->op, set->h);
-        break;
+    /* Do nothing. */
+    case EVILNESS_SLACK_A2A:
+      if ((PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) ||
+          (PHASE_KIND_ALL_TO_ALL == task->key.kind))
+      {
+        struct GNUNET_SET_Handle *empty_set;
+        empty_set = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+        GNUNET_SET_commit (setop->op, empty_set);
+        GNUNET_SET_destroy (empty_set);
       }
+      else
+      {
+        GNUNET_SET_commit (setop->op, set->h);
+      }
+      break;
+
+    case EVILNESS_NONE:
+      GNUNET_SET_commit (setop->op, set->h);
+      break;
+    }
   }
 #else
-  if (GNUNET_NO == session->peers_blacklisted[task_other_peer(task)])
-    {
-      GNUNET_SET_commit(setop->op, set->h);
-    }
+  if (GNUNET_NO == session->peers_blacklisted[task_other_peer (task)])
+  {
+    GNUNET_SET_commit (setop->op, set->h);
+  }
   else
-    {
-      /* For our testcases, we don't want the blacklisted
-         peers to wait. */
-      GNUNET_SET_operation_cancel(setop->op);
-      setop->op = NULL;
-      finish_task(task);
-    }
+  {
+    /* For our testcases, we don't want the blacklisted
+       peers to wait. */
+    GNUNET_SET_operation_cancel (setop->op);
+    setop->op = NULL;
+    finish_task (task);
+  }
 #endif
 }
 
 
 static void
-put_diff(struct ConsensusSession *session,
-         struct DiffEntry *diff)
+put_diff (struct ConsensusSession *session,
+          struct DiffEntry *diff)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_assert(NULL != diff);
+  GNUNET_assert (NULL != diff);
 
-  GNUNET_CRYPTO_hash(&diff->key, sizeof(struct DiffKey), &hash);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put(session->diffmap, &hash, diff,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_CRYPTO_hash (&diff->key, sizeof(struct DiffKey), &hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (session->diffmap, &hash,
+                                                    diff,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
 
 static void
-put_set(struct ConsensusSession *session,
-        struct SetEntry *set)
+put_set (struct ConsensusSession *session,
+         struct SetEntry *set)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_assert(NULL != set->h);
+  GNUNET_assert (NULL != set->h);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Putting set %s\n",
-             debug_str_set_key(&set->key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Putting set %s\n",
+              debug_str_set_key (&set->key));
 
-  GNUNET_CRYPTO_hash(&set->key, sizeof(struct SetKey), &hash);
-  GNUNET_assert(GNUNET_SYSERR !=
-                GNUNET_CONTAINER_multihashmap_put(session->setmap, &hash, set,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  GNUNET_CRYPTO_hash (&set->key, sizeof(struct SetKey), &hash);
+  GNUNET_assert (GNUNET_SYSERR !=
+                 GNUNET_CONTAINER_multihashmap_put (session->setmap, &hash, set,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
 }
 
 
 static void
-put_rfn(struct ConsensusSession *session,
-        struct ReferendumEntry *rfn)
+put_rfn (struct ConsensusSession *session,
+         struct ReferendumEntry *rfn)
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_CRYPTO_hash(&rfn->key, sizeof(struct RfnKey), &hash);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put(session->rfnmap, &hash, rfn,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_CRYPTO_hash (&rfn->key, sizeof(struct RfnKey), &hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (session->rfnmap, &hash, rfn,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
 
 
 
 static void
-task_cancel_reconcile(struct TaskEntry *task)
+task_cancel_reconcile (struct TaskEntry *task)
 {
   /* not implemented yet */
-  GNUNET_assert(0);
+  GNUNET_assert (0);
 }
 
 
 static void
-apply_diff_to_rfn(struct DiffEntry *diff,
-                  struct ReferendumEntry *rfn,
-                  uint16_t voting_peer,
-                  uint16_t num_peers)
+apply_diff_to_rfn (struct DiffEntry *diff,
+                   struct ReferendumEntry *rfn,
+                   uint16_t voting_peer,
+                   uint16_t num_peers)
 {
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
   struct DiffElementInfo *di;
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff->changes);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff->changes);
 
   while (GNUNET_YES ==
-         GNUNET_CONTAINER_multihashmap_iterator_next(iter,
-                                                     NULL,
-                                                     (const void **)&di))
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
+  {
+    if (di->weight > 0)
     {
-      if (di->weight > 0)
-        {
-          rfn_vote(rfn, voting_peer, VOTE_ADD, di->element);
-        }
-      if (di->weight < 0)
-        {
-          rfn_vote(rfn, voting_peer, VOTE_REMOVE, di->element);
-        }
+      rfn_vote (rfn, voting_peer, VOTE_ADD, di->element);
     }
+    if (di->weight < 0)
+    {
+      rfn_vote (rfn, voting_peer, VOTE_REMOVE, di->element);
+    }
+  }
 
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 }
 
 
 struct DiffEntry *
-diff_create()
+diff_create ()
 {
-  struct DiffEntry *d = GNUNET_new(struct DiffEntry);
+  struct DiffEntry *d = GNUNET_new (struct DiffEntry);
 
-  d->changes = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
+  d->changes = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
   return d;
 }
 
 
 struct DiffEntry *
-diff_compose(struct DiffEntry *diff_1,
-             struct DiffEntry *diff_2)
+diff_compose (struct DiffEntry *diff_1,
+              struct DiffEntry *diff_2)
 {
   struct DiffEntry *diff_new;
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
   struct DiffElementInfo *di;
 
-  diff_new = diff_create();
+  diff_new = diff_create ();
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff_1->changes);
-  while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, (const void **)&di))
-    {
-      diff_insert(diff_new, di->weight, di->element);
-    }
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_1->changes);
+  while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
+                                                                    (const
+                                                                     void **) &
+                                                                    di))
+  {
+    diff_insert (diff_new, di->weight, di->element);
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff_2->changes);
-  while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, (const void **)&di))
-    {
-      diff_insert(diff_new, di->weight, di->element);
-    }
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_2->changes);
+  while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
+                                                                    (const
+                                                                     void **) &
+                                                                    di))
+  {
+    diff_insert (diff_new, di->weight, di->element);
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
   return diff_new;
 }
 
 
 struct ReferendumEntry *
-rfn_create(uint16_t size)
+rfn_create (uint16_t size)
 {
   struct ReferendumEntry *rfn;
 
-  rfn = GNUNET_new(struct ReferendumEntry);
-  rfn->rfn_elements = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
-  rfn->peer_commited = GNUNET_new_array(size, int);
-  rfn->peer_contested = GNUNET_new_array(size, int);
+  rfn = GNUNET_new (struct ReferendumEntry);
+  rfn->rfn_elements = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  rfn->peer_commited = GNUNET_new_array (size, int);
+  rfn->peer_contested = GNUNET_new_array (size, int);
   rfn->num_peers = size;
 
   return rfn;
@@ -1622,10 +1671,10 @@ rfn_create(uint16_t size)
 
 #if UNUSED
 static void
-diff_destroy(struct DiffEntry *diff)
+diff_destroy (struct DiffEntry *diff)
 {
-  GNUNET_CONTAINER_multihashmap_destroy(diff->changes);
-  GNUNET_free(diff);
+  GNUNET_CONTAINER_multihashmap_destroy (diff->changes);
+  GNUNET_free (diff);
 }
 #endif
 
@@ -1636,70 +1685,71 @@ diff_destroy(struct DiffEntry *diff)
  * of peers that voted for this outcome.
  */
 static void
-rfn_majority(const struct ReferendumEntry *rfn,
-             const struct RfnElementInfo *ri,
-             uint16_t *ret_majority,
-             enum ReferendumVote *ret_vote)
+rfn_majority (const struct ReferendumEntry *rfn,
+              const struct RfnElementInfo *ri,
+              uint16_t *ret_majority,
+              enum ReferendumVote *ret_vote)
 {
   uint16_t votes_yes = 0;
   uint16_t num_commited = 0;
   uint16_t i;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Computing rfn majority for element %s of rfn {%s}\n",
-             debug_str_element(ri->element),
-             debug_str_rfn_key(&rfn->key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Computing rfn majority for element %s of rfn {%s}\n",
+              debug_str_element (ri->element),
+              debug_str_rfn_key (&rfn->key));
 
   for (i = 0; i < rfn->num_peers; i++)
-    {
-      if (GNUNET_NO == rfn->peer_commited[i])
-        continue;
-      num_commited++;
+  {
+    if (GNUNET_NO == rfn->peer_commited[i])
+      continue;
+    num_commited++;
 
-      if (GNUNET_YES == ri->votes[i])
-        votes_yes++;
-    }
+    if (GNUNET_YES == ri->votes[i])
+      votes_yes++;
+  }
 
   if (votes_yes > (num_commited) / 2)
-    {
-      *ret_vote = ri->proposal;
-      *ret_majority = votes_yes;
-    }
+  {
+    *ret_vote = ri->proposal;
+    *ret_majority = votes_yes;
+  }
   else
-    {
-      *ret_vote = VOTE_STAY;
-      *ret_majority = num_commited - votes_yes;
-    }
+  {
+    *ret_vote = VOTE_STAY;
+    *ret_majority = num_commited - votes_yes;
+  }
 }
 
 
-struct SetCopyCls {
+struct SetCopyCls
+{
   struct TaskEntry *task;
   struct SetKey dst_set_key;
 };
 
 
 static void
-set_copy_cb(void *cls, struct GNUNET_SET_Handle *copy)
+set_copy_cb (void *cls, struct GNUNET_SET_Handle *copy)
 {
   struct SetCopyCls *scc = cls;
   struct TaskEntry *task = scc->task;
   struct SetKey dst_set_key = scc->dst_set_key;
   struct SetEntry *set;
-  struct SetHandle *sh = GNUNET_new(struct SetHandle);
+  struct SetHandle *sh = GNUNET_new (struct SetHandle);
 
   sh->h = copy;
-  GNUNET_CONTAINER_DLL_insert(task->step->session->set_handles_head,
-                              task->step->session->set_handles_tail,
-                              sh);
+  GNUNET_CONTAINER_DLL_insert (task->step->session->set_handles_head,
+                               task->step->session->set_handles_tail,
+                               sh);
 
-  GNUNET_free(scc);
-  set = GNUNET_new(struct SetEntry);
+  GNUNET_free (scc);
+  set = GNUNET_new (struct SetEntry);
   set->h = copy;
   set->key = dst_set_key;
-  put_set(task->step->session, set);
+  put_set (task->step->session, set);
 
-  task->start(task);
+  task->start (task);
 }
 
 
@@ -1708,30 +1758,31 @@ set_copy_cb(void *cls, struct GNUNET_SET_Handle *copy)
  * task again after we created a copy of the given set.
  */
 static void
-create_set_copy_for_task(struct TaskEntry *task,
-                         struct SetKey *src_set_key,
-                         struct SetKey *dst_set_key)
+create_set_copy_for_task (struct TaskEntry *task,
+                          struct SetKey *src_set_key,
+                          struct SetKey *dst_set_key)
 {
   struct SetEntry *src_set;
-  struct SetCopyCls *scc = GNUNET_new(struct SetCopyCls);
+  struct SetCopyCls *scc = GNUNET_new (struct SetCopyCls);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Copying set {%s} to {%s} for task {%s}\n",
-             debug_str_set_key(src_set_key),
-             debug_str_set_key(dst_set_key),
-             debug_str_task_key(&task->key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Copying set {%s} to {%s} for task {%s}\n",
+              debug_str_set_key (src_set_key),
+              debug_str_set_key (dst_set_key),
+              debug_str_task_key (&task->key));
 
   scc->task = task;
   scc->dst_set_key = *dst_set_key;
-  src_set = lookup_set(task->step->session, src_set_key);
-  GNUNET_assert(NULL != src_set);
-  GNUNET_SET_copy_lazy(src_set->h,
-                       set_copy_cb,
-                       scc);
+  src_set = lookup_set (task->step->session, src_set_key);
+  GNUNET_assert (NULL != src_set);
+  GNUNET_SET_copy_lazy (src_set->h,
+                        set_copy_cb,
+                        scc);
 }
 
 
-struct SetMutationProgressCls {
+struct SetMutationProgressCls
+{
   int num_pending;
   /**
    * Task to finish once all changes are through.
@@ -1741,25 +1792,25 @@ struct SetMutationProgressCls {
 
 
 static void
-set_mutation_done(void *cls)
+set_mutation_done (void *cls)
 {
   struct SetMutationProgressCls *pc = cls;
 
-  GNUNET_assert(pc->num_pending > 0);
+  GNUNET_assert (pc->num_pending > 0);
 
   pc->num_pending--;
 
   if (0 == pc->num_pending)
-    {
-      struct TaskEntry *task = pc->task;
-      GNUNET_free(pc);
-      finish_task(task);
-    }
+  {
+    struct TaskEntry *task = pc->task;
+    GNUNET_free (pc);
+    finish_task (task);
+  }
 }
 
 
 static void
-try_finish_step_early(struct Step *step)
+try_finish_step_early (struct Step *step)
 {
   unsigned int i;
 
@@ -1773,61 +1824,61 @@ try_finish_step_early(struct Step *step)
   step->is_finished = GNUNET_YES;
 
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finishing step `%s' early.\n",
-             step->debug_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finishing step `%s' early.\n",
+              step->debug_name);
 #endif
 
   for (i = 0; i < step->subordinates_len; i++)
-    {
-      GNUNET_assert(step->subordinates[i]->pending_prereq > 0);
-      step->subordinates[i]->pending_prereq--;
+  {
+    GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
+    step->subordinates[i]->pending_prereq--;
 #ifdef GNUNET_EXTRA_LOGGING
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Decreased pending_prereq to %u for step `%s'.\n",
-                 (unsigned int)step->subordinates[i]->pending_prereq,
-                 step->subordinates[i]->debug_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Decreased pending_prereq to %u for step `%s'.\n",
+                (unsigned int) step->subordinates[i]->pending_prereq,
+                step->subordinates[i]->debug_name);
 #endif
-      try_finish_step_early(step->subordinates[i]);
-    }
+    try_finish_step_early (step->subordinates[i]);
+  }
 
   // XXX: maybe schedule as task to avoid recursion?
-  run_ready_steps(step->session);
+  run_ready_steps (step->session);
 }
 
 
 static void
-finish_step(struct Step *step)
+finish_step (struct Step *step)
 {
   unsigned int i;
 
-  GNUNET_assert(step->finished_tasks == step->tasks_len);
-  GNUNET_assert(GNUNET_YES == step->is_running);
-  GNUNET_assert(GNUNET_NO == step->is_finished);
+  GNUNET_assert (step->finished_tasks == step->tasks_len);
+  GNUNET_assert (GNUNET_YES == step->is_running);
+  GNUNET_assert (GNUNET_NO == step->is_finished);
 
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "All tasks of step `%s' with %u subordinates finished.\n",
-             step->debug_name,
-             step->subordinates_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All tasks of step `%s' with %u subordinates finished.\n",
+              step->debug_name,
+              step->subordinates_len);
 #endif
 
   for (i = 0; i < step->subordinates_len; i++)
-    {
-      GNUNET_assert(step->subordinates[i]->pending_prereq > 0);
-      step->subordinates[i]->pending_prereq--;
+  {
+    GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
+    step->subordinates[i]->pending_prereq--;
 #ifdef GNUNET_EXTRA_LOGGING
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Decreased pending_prereq to %u for step `%s'.\n",
-                 (unsigned int)step->subordinates[i]->pending_prereq,
-                 step->subordinates[i]->debug_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Decreased pending_prereq to %u for step `%s'.\n",
+                (unsigned int) step->subordinates[i]->pending_prereq,
+                step->subordinates[i]->debug_name);
 #endif
-    }
+  }
 
   step->is_finished = GNUNET_YES;
 
   // XXX: maybe schedule as task to avoid recursion?
-  run_ready_steps(step->session);
+  run_ready_steps (step->session);
 }
 
 
@@ -1839,7 +1890,7 @@ finish_step(struct Step *step)
  * @param task the task with context information
  */
 static void
-task_start_apply_round(struct TaskEntry *task)
+task_start_apply_round (struct TaskEntry *task)
 {
   struct ConsensusSession *session = task->step->session;
   struct SetKey sk_in;
@@ -1856,136 +1907,138 @@ task_start_apply_round(struct TaskEntry *task)
   rk_in = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition };
   sk_out = (struct SetKey) { SET_KIND_CURRENT, task->key.repetition + 1 };
 
-  set_out = lookup_set(session, &sk_out);
+  set_out = lookup_set (session, &sk_out);
   if (NULL == set_out)
-    {
-      create_set_copy_for_task(task, &sk_in, &sk_out);
-      return;
-    }
+  {
+    create_set_copy_for_task (task, &sk_in, &sk_out);
+    return;
+  }
 
-  rfn_in = lookup_rfn(session, &rk_in);
-  GNUNET_assert(NULL != rfn_in);
+  rfn_in = lookup_rfn (session, &rk_in);
+  GNUNET_assert (NULL != rfn_in);
 
-  progress_cls = GNUNET_new(struct SetMutationProgressCls);
+  progress_cls = GNUNET_new (struct SetMutationProgressCls);
   progress_cls->task = task;
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(rfn_in->rfn_elements);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (rfn_in->rfn_elements);
 
   while (GNUNET_YES ==
-         GNUNET_CONTAINER_multihashmap_iterator_next(iter,
-                                                     NULL,
-                                                     (const void **)&ri))
-    {
-      uint16_t majority_num;
-      enum ReferendumVote majority_vote;
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    uint16_t majority_num;
+    enum ReferendumVote majority_vote;
+
+    rfn_majority (rfn_in, ri, &majority_num, &majority_vote);
+
+    if (worst_majority > majority_num)
+      worst_majority = majority_num;
+
+    switch (majority_vote)
+    {
+    case VOTE_ADD:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_add_element (set_out->h,
+                                             ri->element,
+                                             &set_mutation_done,
+                                             progress_cls));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: adding element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      break;
 
-      rfn_majority(rfn_in, ri, &majority_num, &majority_vote);
+    case VOTE_REMOVE:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_remove_element (set_out->h,
+                                                ri->element,
+                                                &set_mutation_done,
+                                                progress_cls));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: deleting element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      break;
 
-      if (worst_majority > majority_num)
-        worst_majority = majority_num;
+    case VOTE_STAY:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: keeping element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      // do nothing
+      break;
 
-      switch (majority_vote)
-        {
-        case VOTE_ADD:
-          progress_cls->num_pending++;
-          GNUNET_assert(GNUNET_OK ==
-                        GNUNET_SET_add_element(set_out->h,
-                                               ri->element,
-                                               &set_mutation_done,
-                                               progress_cls));
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: apply round: adding element %s with %u-majority.\n",
-                     session->local_peer_idx,
-                     debug_str_element(ri->element), majority_num);
-          break;
-
-        case VOTE_REMOVE:
-          progress_cls->num_pending++;
-          GNUNET_assert(GNUNET_OK ==
-                        GNUNET_SET_remove_element(set_out->h,
-                                                  ri->element,
-                                                  &set_mutation_done,
-                                                  progress_cls));
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: apply round: deleting element %s with %u-majority.\n",
-                     session->local_peer_idx,
-                     debug_str_element(ri->element), majority_num);
-          break;
-
-        case VOTE_STAY:
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: apply round: keeping element %s with %u-majority.\n",
-                     session->local_peer_idx,
-                     debug_str_element(ri->element), majority_num);
-          // do nothing
-          break;
-
-        default:
-          GNUNET_assert(0);
-          break;
-        }
+    default:
+      GNUNET_assert (0);
+      break;
     }
+  }
 
   if (0 == progress_cls->num_pending)
-    {
-      // call closure right now, no pending ops
-      GNUNET_free(progress_cls);
-      finish_task(task);
-    }
+  {
+    // call closure right now, no pending ops
+    GNUNET_free (progress_cls);
+    finish_task (task);
+  }
 
   {
     uint16_t thresh = (session->num_peers / 3) * 2;
 
     if (worst_majority >= thresh)
+    {
+      switch (session->early_stopping)
       {
-        switch (session->early_stopping)
-          {
-          case EARLY_STOPPING_NONE:
-            session->early_stopping = EARLY_STOPPING_ONE_MORE;
-            GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                       "P%u: Stopping early (after one more superround)\n",
-                       session->local_peer_idx);
-            break;
-
-          case EARLY_STOPPING_ONE_MORE:
-            GNUNET_log(GNUNET_ERROR_TYPE_INFO, "P%u: finishing steps due to early finish\n",
-                       session->local_peer_idx);
-            session->early_stopping = EARLY_STOPPING_DONE;
-            {
-              struct Step *step;
-              for (step = session->steps_head; NULL != step; step = step->next)
-                try_finish_step_early(step);
-            }
-            break;
-
-          case EARLY_STOPPING_DONE:
-            /* We shouldn't be here anymore after early stopping */
-            GNUNET_break(0);
-            break;
-
-          default:
-            GNUNET_assert(0);
-            break;
-          }
+      case EARLY_STOPPING_NONE:
+        session->early_stopping = EARLY_STOPPING_ONE_MORE;
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "P%u: Stopping early (after one more superround)\n",
+                    session->local_peer_idx);
+        break;
+
+      case EARLY_STOPPING_ONE_MORE:
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "P%u: finishing steps due to early finish\n",
+                    session->local_peer_idx);
+        session->early_stopping = EARLY_STOPPING_DONE;
+        {
+          struct Step *step;
+          for (step = session->steps_head; NULL != step; step = step->next)
+            try_finish_step_early (step);
+        }
+        break;
+
+      case EARLY_STOPPING_DONE:
+        /* We shouldn't be here anymore after early stopping */
+        GNUNET_break (0);
+        break;
+
+      default:
+        GNUNET_assert (0);
+        break;
       }
+    }
     else if (EARLY_STOPPING_NONE != session->early_stopping)
-      {
-        // Our assumption about the number of bad peers
-        // has been broken.
-        GNUNET_break_op(0);
-      }
+    {
+      // Our assumption about the number of bad peers
+      // has been broken.
+      GNUNET_break_op (0);
+    }
     else
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO, "P%u: NOT finishing early (majority not good enough)\n",
-                   session->local_peer_idx);
-      }
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "P%u: NOT finishing early (majority not good enough)\n",
+                  session->local_peer_idx);
+    }
   }
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 }
 
 
 static void
-task_start_grade(struct TaskEntry *task)
+task_start_grade (struct TaskEntry *task)
 {
   struct ConsensusSession *session = task->step->session;
   struct ReferendumEntry *output_rfn;
@@ -1998,93 +2051,97 @@ task_start_grade(struct TaskEntry *task)
   unsigned int gradecast_confidence = 2;
 
   rfn_key = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition };
-  output_rfn = lookup_rfn(session, &rfn_key);
+  output_rfn = lookup_rfn (session, &rfn_key);
   if (NULL == output_rfn)
-    {
-      output_rfn = rfn_create(session->num_peers);
-      output_rfn->key = rfn_key;
-      put_rfn(session, output_rfn);
-    }
+  {
+    output_rfn = rfn_create (session->num_peers);
+    output_rfn->key = rfn_key;
+    put_rfn (session, output_rfn);
+  }
 
-  diff_key = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, task->key.repetition, task->key.leader };
-  input_diff = lookup_diff(session, &diff_key);
-  GNUNET_assert(NULL != input_diff);
+  diff_key = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, task->key.repetition,
+                                task->key.leader };
+  input_diff = lookup_diff (session, &diff_key);
+  GNUNET_assert (NULL != input_diff);
 
-  rfn_key = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, task->key.leader };
-  input_rfn = lookup_rfn(session, &rfn_key);
-  GNUNET_assert(NULL != input_rfn);
+  rfn_key = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition,
+                              task->key.leader };
+  input_rfn = lookup_rfn (session, &rfn_key);
+  GNUNET_assert (NULL != input_rfn);
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(input_rfn->rfn_elements);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (
+    input_rfn->rfn_elements);
 
-  apply_diff_to_rfn(input_diff, output_rfn, task->key.leader, session->num_peers);
+  apply_diff_to_rfn (input_diff, output_rfn, task->key.leader,
+                     session->num_peers);
 
   while (GNUNET_YES ==
-         GNUNET_CONTAINER_multihashmap_iterator_next(iter,
-                                                     NULL,
-                                                     (const void **)&ri))
-    {
-      uint16_t majority_num;
-      enum ReferendumVote majority_vote;
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    uint16_t majority_num;
+    enum ReferendumVote majority_vote;
 
-      // XXX: we need contested votes and non-contested votes here
-      rfn_majority(input_rfn, ri, &majority_num, &majority_vote);
+    // XXX: we need contested votes and non-contested votes here
+    rfn_majority (input_rfn, ri, &majority_num, &majority_vote);
 
-      if (majority_num <= session->num_peers / 3)
-        majority_vote = VOTE_REMOVE;
+    if (majority_num <= session->num_peers / 3)
+      majority_vote = VOTE_REMOVE;
 
-      switch (majority_vote)
-        {
-        case VOTE_STAY:
-          break;
+    switch (majority_vote)
+    {
+    case VOTE_STAY:
+      break;
 
-        case VOTE_ADD:
-          rfn_vote(output_rfn, task->key.leader, VOTE_ADD, ri->element);
-          break;
+    case VOTE_ADD:
+      rfn_vote (output_rfn, task->key.leader, VOTE_ADD, ri->element);
+      break;
 
-        case VOTE_REMOVE:
-          rfn_vote(output_rfn, task->key.leader, VOTE_REMOVE, ri->element);
-          break;
+    case VOTE_REMOVE:
+      rfn_vote (output_rfn, task->key.leader, VOTE_REMOVE, ri->element);
+      break;
 
-        default:
-          GNUNET_assert(0);
-          break;
-        }
+    default:
+      GNUNET_assert (0);
+      break;
     }
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
   {
     uint16_t noncontested;
-    noncontested = rfn_noncontested(input_rfn);
+    noncontested = rfn_noncontested (input_rfn);
     if (noncontested < (session->num_peers / 3) * 2)
-      {
-        gradecast_confidence = GNUNET_MIN(1, gradecast_confidence);
-      }
+    {
+      gradecast_confidence = GNUNET_MIN (1, gradecast_confidence);
+    }
     if (noncontested < (session->num_peers / 3) + 1)
-      {
-        gradecast_confidence = 0;
-      }
+    {
+      gradecast_confidence = 0;
+    }
   }
 
   if (gradecast_confidence >= 1)
-    rfn_commit(output_rfn, task->key.leader);
+    rfn_commit (output_rfn, task->key.leader);
 
   if (gradecast_confidence <= 1)
     session->peers_blacklisted[task->key.leader] = GNUNET_YES;
 
-  finish_task(task);
+  finish_task (task);
 }
 
 
 static void
-task_start_reconcile(struct TaskEntry *task)
+task_start_reconcile (struct TaskEntry *task)
 {
   struct SetEntry *input;
   struct SetOpCls *setop = &task->cls.setop;
   struct ConsensusSession *session = task->step->session;
 
-  input = lookup_set(session, &setop->input_set);
-  GNUNET_assert(NULL != input);
-  GNUNET_assert(NULL != input->h);
+  input = lookup_set (session, &setop->input_set);
+  GNUNET_assert (NULL != input);
+  GNUNET_assert (NULL != input->h);
 
   /* We create the outputs for the operation here
      (rather than in the set operation callback)
@@ -2092,113 +2149,117 @@ task_start_reconcile(struct TaskEntry *task)
      if the other peer doesn't talk to us */
 
   if (SET_KIND_NONE != setop->output_set.set_kind)
+  {
+    /* If we don't have an existing output set,
+       we clone the input set. */
+    if (NULL == lookup_set (session, &setop->output_set))
     {
-      /* If we don't have an existing output set,
-         we clone the input set. */
-      if (NULL == lookup_set(session, &setop->output_set))
-        {
-          create_set_copy_for_task(task, &setop->input_set, &setop->output_set);
-          return;
-        }
+      create_set_copy_for_task (task, &setop->input_set, &setop->output_set);
+      return;
     }
+  }
 
   if (RFN_KIND_NONE != setop->output_rfn.rfn_kind)
+  {
+    if (NULL == lookup_rfn (session, &setop->output_rfn))
     {
-      if (NULL == lookup_rfn(session, &setop->output_rfn))
-        {
-          struct ReferendumEntry *rfn;
+      struct ReferendumEntry *rfn;
 
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "P%u: output rfn <%s> missing, creating.\n",
-                     session->local_peer_idx,
-                     debug_str_rfn_key(&setop->output_rfn));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: output rfn <%s> missing, creating.\n",
+                  session->local_peer_idx,
+                  debug_str_rfn_key (&setop->output_rfn));
 
-          rfn = rfn_create(session->num_peers);
-          rfn->key = setop->output_rfn;
-          put_rfn(session, rfn);
-        }
+      rfn = rfn_create (session->num_peers);
+      rfn->key = setop->output_rfn;
+      put_rfn (session, rfn);
     }
+  }
 
   if (DIFF_KIND_NONE != setop->output_diff.diff_kind)
+  {
+    if (NULL == lookup_diff (session, &setop->output_diff))
     {
-      if (NULL == lookup_diff(session, &setop->output_diff))
-        {
-          struct DiffEntry *diff;
+      struct DiffEntry *diff;
 
-          diff = diff_create();
-          diff->key = setop->output_diff;
-          put_diff(session, diff);
-        }
+      diff = diff_create ();
+      diff->key = setop->output_diff;
+      put_diff (session, diff);
     }
+  }
 
-  if ((task->key.peer1 == session->local_peer_idx) && (task->key.peer2 == session->local_peer_idx))
-    {
-      /* XXX: mark the corresponding rfn as commited if necessary */
-      finish_task(task);
-      return;
-    }
+  if ((task->key.peer1 == session->local_peer_idx) && (task->key.peer2 ==
+                                                       session->local_peer_idx))
+  {
+    /* XXX: mark the corresponding rfn as commited if necessary */
+    finish_task (task);
+    return;
+  }
 
   if (task->key.peer1 == session->local_peer_idx)
-    {
-      struct GNUNET_CONSENSUS_RoundContextMessage rcm;
-
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "P%u: Looking up set {%s} to run remote union\n",
-                 session->local_peer_idx,
-                 debug_str_set_key(&setop->input_set));
-
-      rcm.header.type = htons(GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT);
-      rcm.header.size = htons(sizeof(struct GNUNET_CONSENSUS_RoundContextMessage));
-
-      rcm.kind = htons(task->key.kind);
-      rcm.peer1 = htons(task->key.peer1);
-      rcm.peer2 = htons(task->key.peer2);
-      rcm.leader = htons(task->key.leader);
-      rcm.repetition = htons(task->key.repetition);
-      rcm.is_contested = htons(0);
-
-      GNUNET_assert(NULL == setop->op);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: initiating set op with P%u, our set is %s\n",
-                 session->local_peer_idx, task->key.peer2, debug_str_set_key(&setop->input_set));
-
-      struct GNUNET_SET_Option opts[] = {
-        { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } },
-        { GNUNET_SET_OPTION_END },
-      };
-
-      // XXX: maybe this should be done while
-      // setting up tasks alreays?
-      setop->op = GNUNET_SET_prepare(&session->peers[task->key.peer2],
-                                     &session->global_id,
-                                     &rcm.header,
-                                     GNUNET_SET_RESULT_SYMMETRIC,
-                                     opts,
-                                     set_result_cb,
-                                     task);
-
-      commit_set(session, task);
-    }
+  {
+    struct GNUNET_CONSENSUS_RoundContextMessage rcm;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: Looking up set {%s} to run remote union\n",
+                session->local_peer_idx,
+                debug_str_set_key (&setop->input_set));
+
+    rcm.header.type = htons (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT);
+    rcm.header.size = htons (sizeof(struct
+                                    GNUNET_CONSENSUS_RoundContextMessage));
+
+    rcm.kind = htons (task->key.kind);
+    rcm.peer1 = htons (task->key.peer1);
+    rcm.peer2 = htons (task->key.peer2);
+    rcm.leader = htons (task->key.leader);
+    rcm.repetition = htons (task->key.repetition);
+    rcm.is_contested = htons (0);
+
+    GNUNET_assert (NULL == setop->op);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: initiating set op with P%u, our set is %s\n",
+                session->local_peer_idx, task->key.peer2, debug_str_set_key (
+                  &setop->input_set));
+
+    struct GNUNET_SET_Option opts[] = {
+      { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } },
+      { GNUNET_SET_OPTION_END },
+    };
+
+    // XXX: maybe this should be done while
+    // setting up tasks alreays?
+    setop->op = GNUNET_SET_prepare (&session->peers[task->key.peer2],
+                                    &session->global_id,
+                                    &rcm.header,
+                                    GNUNET_SET_RESULT_SYMMETRIC,
+                                    opts,
+                                    set_result_cb,
+                                    task);
+
+    commit_set (session, task);
+  }
   else if (task->key.peer2 == session->local_peer_idx)
-    {
-      /* Wait for the other peer to contact us */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: waiting set op with P%u\n",
-                 session->local_peer_idx, task->key.peer1);
+  {
+    /* Wait for the other peer to contact us */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: waiting set op with P%u\n",
+                session->local_peer_idx, task->key.peer1);
 
-      if (NULL != setop->op)
-        {
-          commit_set(session, task);
-        }
-    }
-  else
+    if (NULL != setop->op)
     {
-      /* We made an error while constructing the task graph. */
-      GNUNET_assert(0);
+      commit_set (session, task);
     }
+  }
+  else
+  {
+    /* We made an error while constructing the task graph. */
+    GNUNET_assert (0);
+  }
 }
 
 
 static void
-task_start_eval_echo(struct TaskEntry *task)
+task_start_eval_echo (struct TaskEntry *task)
 {
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
   struct ReferendumEntry *input_rfn;
@@ -2210,128 +2271,133 @@ task_start_eval_echo(struct TaskEntry *task)
   struct SetKey sk_out;
   struct RfnKey rk_in;
 
-  sk_in = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, task->key.repetition, task->key.leader };
-  sk_out = (struct SetKey) { SET_KIND_ECHO_RESULT, task->key.repetition, task->key.leader };
-  output_set = lookup_set(session, &sk_out);
+  sk_in = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, task->key.repetition,
+                            task->key.leader };
+  sk_out = (struct SetKey) { SET_KIND_ECHO_RESULT, task->key.repetition,
+                             task->key.leader };
+  output_set = lookup_set (session, &sk_out);
   if (NULL == output_set)
-    {
-      create_set_copy_for_task(task, &sk_in, &sk_out);
-      return;
-    }
+  {
+    create_set_copy_for_task (task, &sk_in, &sk_out);
+    return;
+  }
 
 
   {
     // FIXME: should be marked as a shallow copy, so
     // we can destroy everything correctly
-    struct SetEntry *last_set = GNUNET_new(struct SetEntry);
+    struct SetEntry *last_set = GNUNET_new (struct SetEntry);
     last_set->h = output_set->h;
     last_set->key = (struct SetKey) { SET_KIND_LAST_GRADECAST };
-    put_set(session, last_set);
+    put_set (session, last_set);
   }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Evaluating referendum in Task {%s}\n",
-             debug_str_task_key(&task->key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Evaluating referendum in Task {%s}\n",
+              debug_str_task_key (&task->key));
 
-  progress_cls = GNUNET_new(struct SetMutationProgressCls);
+  progress_cls = GNUNET_new (struct SetMutationProgressCls);
   progress_cls->task = task;
 
-  rk_in = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, task->key.leader };
-  input_rfn = lookup_rfn(session, &rk_in);
+  rk_in = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition,
+                            task->key.leader };
+  input_rfn = lookup_rfn (session, &rk_in);
 
-  GNUNET_assert(NULL != input_rfn);
+  GNUNET_assert (NULL != input_rfn);
 
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(input_rfn->rfn_elements);
-  GNUNET_assert(NULL != iter);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (
+    input_rfn->rfn_elements);
+  GNUNET_assert (NULL != iter);
 
   while (GNUNET_YES ==
-         GNUNET_CONTAINER_multihashmap_iterator_next(iter,
-                                                     NULL,
-                                                     (const void **)&ri))
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    enum ReferendumVote majority_vote;
+    uint16_t majority_num;
+
+    rfn_majority (input_rfn, ri, &majority_num, &majority_vote);
+
+    if (majority_num < session->num_peers / 3)
     {
-      enum ReferendumVote majority_vote;
-      uint16_t majority_num;
+      /* It is not the case that all nonfaulty peers
+         echoed the same value.  Since we're doing a set reconciliation, we
+         can't simply send "nothing" for the value.  Thus we mark our 'confirm'
+         reconciliation as contested.  Other peers might not know that the
+         leader is faulty, thus we still re-distribute in the confirmation
+         round. */
+      output_set->is_contested = GNUNET_YES;
+    }
 
-      rfn_majority(input_rfn, ri, &majority_num, &majority_vote);
+    switch (majority_vote)
+    {
+    case VOTE_ADD:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_add_element (output_set->h,
+                                             ri->element,
+                                             set_mutation_done,
+                                             progress_cls));
+      break;
 
-      if (majority_num < session->num_peers / 3)
-        {
-          /* It is not the case that all nonfaulty peers
-             echoed the same value.  Since we're doing a set reconciliation, we
-             can't simply send "nothing" for the value.  Thus we mark our 'confirm'
-             reconciliation as contested.  Other peers might not know that the
-             leader is faulty, thus we still re-distribute in the confirmation
-             round. */
-          output_set->is_contested = GNUNET_YES;
-        }
+    case VOTE_REMOVE:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_remove_element (output_set->h,
+                                                ri->element,
+                                                set_mutation_done,
+                                                progress_cls));
+      break;
 
-      switch (majority_vote)
-        {
-        case VOTE_ADD:
-          progress_cls->num_pending++;
-          GNUNET_assert(GNUNET_OK ==
-                        GNUNET_SET_add_element(output_set->h,
-                                               ri->element,
-                                               set_mutation_done,
-                                               progress_cls));
-          break;
-
-        case VOTE_REMOVE:
-          progress_cls->num_pending++;
-          GNUNET_assert(GNUNET_OK ==
-                        GNUNET_SET_remove_element(output_set->h,
-                                                  ri->element,
-                                                  set_mutation_done,
-                                                  progress_cls));
-          break;
-
-        case VOTE_STAY:
-          /* Nothing to do. */
-          break;
-
-        default:
-          /* not reached */
-          GNUNET_assert(0);
-        }
+    case VOTE_STAY:
+      /* Nothing to do. */
+      break;
+
+    default:
+      /* not reached */
+      GNUNET_assert (0);
     }
+  }
 
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
   if (0 == progress_cls->num_pending)
-    {
-      // call closure right now, no pending ops
-      GNUNET_free(progress_cls);
-      finish_task(task);
-    }
+  {
+    // call closure right now, no pending ops
+    GNUNET_free (progress_cls);
+    finish_task (task);
+  }
 }
 
 
 static void
-task_start_finish(struct TaskEntry *task)
+task_start_finish (struct TaskEntry *task)
 {
   struct SetEntry *final_set;
   struct ConsensusSession *session = task->step->session;
 
-  final_set = lookup_set(session, &task->cls.finish.input_set);
+  final_set = lookup_set (session, &task->cls.finish.input_set);
 
-  GNUNET_assert(NULL != final_set);
+  GNUNET_assert (NULL != final_set);
 
 
-  GNUNET_SET_iterate(final_set->h,
-                     send_to_client_iter,
-                     task);
+  GNUNET_SET_iterate (final_set->h,
+                      send_to_client_iter,
+                      task);
 }
 
 static void
-start_task(struct ConsensusSession *session, struct TaskEntry *task)
+start_task (struct ConsensusSession *session, struct TaskEntry *task)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: starting task {%s}\n", session->local_peer_idx, debug_str_task_key(&task->key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: starting task {%s}\n",
+              session->local_peer_idx, debug_str_task_key (&task->key));
 
-  GNUNET_assert(GNUNET_NO == task->is_started);
-  GNUNET_assert(GNUNET_NO == task->is_finished);
-  GNUNET_assert(NULL != task->start);
+  GNUNET_assert (GNUNET_NO == task->is_started);
+  GNUNET_assert (GNUNET_NO == task->is_finished);
+  GNUNET_assert (NULL != task->start);
 
-  task->start(task);
+  task->start (task);
 
   task->is_started = GNUNET_YES;
 }
@@ -2344,40 +2410,43 @@ start_task(struct ConsensusSession *session, struct TaskEntry *task)
  * more dependencies.
  */
 static void
-run_ready_steps(struct ConsensusSession *session)
+run_ready_steps (struct ConsensusSession *session)
 {
   struct Step *step;
 
   step = session->steps_head;
 
   while (NULL != step)
+  {
+    if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) &&
+        (GNUNET_NO == step->is_finished))
     {
-      if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) && (GNUNET_NO == step->is_finished))
-        {
-          size_t i;
+      size_t i;
 
-          GNUNET_assert(0 == step->finished_tasks);
+      GNUNET_assert (0 == step->finished_tasks);
 
 #ifdef GNUNET_EXTRA_LOGGING
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: Running step `%s' of round %d with %d tasks and %d subordinates\n",
-                     session->local_peer_idx,
-                     step->debug_name,
-                     step->round, step->tasks_len, step->subordinates_len);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: Running step `%s' of round %d with %d tasks and %d subordinates\n",
+                  session->local_peer_idx,
+                  step->debug_name,
+                  step->round, step->tasks_len, step->subordinates_len);
 #endif
 
-          step->is_running = GNUNET_YES;
-          for (i = 0; i < step->tasks_len; i++)
-            start_task(session, step->tasks[i]);
+      step->is_running = GNUNET_YES;
+      for (i = 0; i < step->tasks_len; i++)
+        start_task (session, step->tasks[i]);
 
-          /* Sometimes there is no task to trigger finishing the step, so we have to do it here. */
-          if ((step->finished_tasks == step->tasks_len) && (GNUNET_NO == step->is_finished))
-            finish_step(step);
+      /* Sometimes there is no task to trigger finishing the step, so we have to do it here. */
+      if ((step->finished_tasks == step->tasks_len) && (GNUNET_NO ==
+                                                        step->is_finished))
+        finish_step (step);
 
-          /* Running the next ready steps will be triggered by task completion */
-          return;
-        }
-      step = step->next;
+      /* Running the next ready steps will be triggered by task completion */
+      return;
     }
+    step = step->next;
+  }
 
   return;
 }
@@ -2385,22 +2454,22 @@ run_ready_steps(struct ConsensusSession *session)
 
 
 static void
-finish_task(struct TaskEntry *task)
+finish_task (struct TaskEntry *task)
 {
-  GNUNET_assert(GNUNET_NO == task->is_finished);
+  GNUNET_assert (GNUNET_NO == task->is_finished);
   task->is_finished = GNUNET_YES;
 
   task->step->finished_tasks++;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "P%u: Finishing Task {%s} (now %u/%u tasks finished in step)\n",
-             task->step->session->local_peer_idx,
-             debug_str_task_key(&task->key),
-             (unsigned int)task->step->finished_tasks,
-             (unsigned int)task->step->tasks_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "P%u: Finishing Task {%s} (now %u/%u tasks finished in step)\n",
+              task->step->session->local_peer_idx,
+              debug_str_task_key (&task->key),
+              (unsigned int) task->step->finished_tasks,
+              (unsigned int) task->step->tasks_len);
 
   if (task->step->finished_tasks == task->step->tasks_len)
-    finish_step(task->step);
+    finish_step (task->step);
 }
 
 
@@ -2412,12 +2481,13 @@ finish_task(struct TaskEntry *task)
  * @return index of peer, -1 if peer is not in session
  */
 static int
-get_peer_idx(const struct GNUNET_PeerIdentity *peer, const struct ConsensusSession *session)
+get_peer_idx (const struct GNUNET_PeerIdentity *peer, const struct
+              ConsensusSession *session)
 {
   int i;
 
   for (i = 0; i < session->num_peers; i++)
-    if (0 == GNUNET_memcmp(peer, &session->peers[i]))
+    if (0 == GNUNET_memcmp (peer, &session->peers[i]))
       return i;
   return -1;
 }
@@ -2433,21 +2503,22 @@ get_peer_idx(const struct GNUNET_PeerIdentity *peer, const struct ConsensusSessi
  * @param local_session_id local id of the consensus session
  */
 static void
-compute_global_id(struct ConsensusSession *session,
-                  const struct GNUNET_HashCode *local_session_id)
+compute_global_id (struct ConsensusSession *session,
+                   const struct GNUNET_HashCode *local_session_id)
 {
   const char *salt = "gnunet-service-consensus/session_id";
 
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CRYPTO_kdf(&session->global_id,
-                                  sizeof(struct GNUNET_HashCode),
-                                  salt,
-                                  strlen(salt),
-                                  session->peers,
-                                  session->num_peers * sizeof(struct GNUNET_PeerIdentity),
-                                  local_session_id,
-                                  sizeof(struct GNUNET_HashCode),
-                                  NULL));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (&session->global_id,
+                                    sizeof(struct GNUNET_HashCode),
+                                    salt,
+                                    strlen (salt),
+                                    session->peers,
+                                    session->num_peers * sizeof(struct
+                                                                GNUNET_PeerIdentity),
+                                    local_session_id,
+                                    sizeof(struct GNUNET_HashCode),
+                                    NULL));
 }
 
 
@@ -2459,9 +2530,9 @@ compute_global_id(struct ConsensusSession *session,
  * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
  */
 static int
-peer_id_cmp(const void *h1, const void *h2)
+peer_id_cmp (const void *h1, const void *h2)
 {
-  return memcmp(h1, h2, sizeof(struct GNUNET_PeerIdentity));
+  return memcmp (h1, h2, sizeof(struct GNUNET_PeerIdentity));
 }
 
 
@@ -2473,56 +2544,58 @@ peer_id_cmp(const void *h1, const void *h2)
  * @param join_msg join message with the list of peers participating at the end
  */
 static void
-initialize_session_peer_list(struct ConsensusSession *session,
-                             const struct GNUNET_CONSENSUS_JoinMessage *join_msg)
+initialize_session_peer_list (struct ConsensusSession *session,
+                              const struct
+                              GNUNET_CONSENSUS_JoinMessage *join_msg)
 {
   const struct GNUNET_PeerIdentity *msg_peers
-    = (const struct GNUNET_PeerIdentity *)&join_msg[1];
+    = (const struct GNUNET_PeerIdentity *) &join_msg[1];
   int local_peer_in_list;
 
-  session->num_peers = ntohl(join_msg->num_peers);
+  session->num_peers = ntohl (join_msg->num_peers);
 
   /* Peers in the join message, may or may not include the local peer,
      Add it if it is missing. */
   local_peer_in_list = GNUNET_NO;
   for (unsigned int i = 0; i < session->num_peers; i++)
+  {
+    if (0 == GNUNET_memcmp (&msg_peers[i],
+                            &my_peer))
     {
-      if (0 == GNUNET_memcmp(&msg_peers[i],
-                             &my_peer))
-        {
-          local_peer_in_list = GNUNET_YES;
-          break;
-        }
+      local_peer_in_list = GNUNET_YES;
+      break;
     }
+  }
   if (GNUNET_NO == local_peer_in_list)
     session->num_peers++;
 
-  session->peers = GNUNET_new_array(session->num_peers,
-                                    struct GNUNET_PeerIdentity);
+  session->peers = GNUNET_new_array (session->num_peers,
+                                     struct GNUNET_PeerIdentity);
   if (GNUNET_NO == local_peer_in_list)
     session->peers[session->num_peers - 1] = my_peer;
 
-  GNUNET_memcpy(session->peers,
-                msg_peers,
-                ntohl(join_msg->num_peers) * sizeof(struct GNUNET_PeerIdentity));
-  qsort(session->peers,
-        session->num_peers,
-        sizeof(struct GNUNET_PeerIdentity),
-        &peer_id_cmp);
+  GNUNET_memcpy (session->peers,
+                 msg_peers,
+                 ntohl (join_msg->num_peers) * sizeof(struct
+                                                      GNUNET_PeerIdentity));
+  qsort (session->peers,
+         session->num_peers,
+         sizeof(struct GNUNET_PeerIdentity),
+         &peer_id_cmp);
 }
 
 
 static struct TaskEntry *
-lookup_task(struct ConsensusSession *session,
-            struct TaskKey *key)
+lookup_task (struct ConsensusSession *session,
+             struct TaskKey *key)
 {
   struct GNUNET_HashCode hash;
 
 
-  GNUNET_CRYPTO_hash(key, sizeof(struct TaskKey), &hash);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Looking up task hash %s\n",
-             GNUNET_h2s(&hash));
-  return GNUNET_CONTAINER_multihashmap_get(session->taskmap, &hash);
+  GNUNET_CRYPTO_hash (key, sizeof(struct TaskKey), &hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up task hash %s\n",
+              GNUNET_h2s (&hash));
+  return GNUNET_CONTAINER_multihashmap_get (session->taskmap, &hash);
 }
 
 
@@ -2542,10 +2615,10 @@ lookup_task(struct ConsensusSession *session,
  *        Also necessary to specify the timeout.
  */
 static void
-set_listen_cb(void *cls,
-              const struct GNUNET_PeerIdentity *other_peer,
-              const struct GNUNET_MessageHeader *context_msg,
-              struct GNUNET_SET_Request *request)
+set_listen_cb (void *cls,
+               const struct GNUNET_PeerIdentity *other_peer,
+               const struct GNUNET_MessageHeader *context_msg,
+               struct GNUNET_SET_Request *request)
 {
   struct ConsensusSession *session = cls;
   struct TaskKey tk;
@@ -2553,122 +2626,124 @@ set_listen_cb(void *cls,
   struct GNUNET_CONSENSUS_RoundContextMessage *cm;
 
   if (NULL == context_msg)
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
-  if (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT != ntohs(context_msg->type))
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  if (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT != ntohs (
+        context_msg->type))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
-  if (sizeof(struct GNUNET_CONSENSUS_RoundContextMessage) != ntohs(context_msg->size))
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  if (sizeof(struct GNUNET_CONSENSUS_RoundContextMessage) != ntohs (
+        context_msg->size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
-  cm = (struct GNUNET_CONSENSUS_RoundContextMessage *)context_msg;
+  cm = (struct GNUNET_CONSENSUS_RoundContextMessage *) context_msg;
 
   tk = ((struct TaskKey) {
-    .kind = ntohs(cm->kind),
-    .peer1 = ntohs(cm->peer1),
-    .peer2 = ntohs(cm->peer2),
-    .repetition = ntohs(cm->repetition),
-    .leader = ntohs(cm->leader),
+    .kind = ntohs (cm->kind),
+    .peer1 = ntohs (cm->peer1),
+    .peer2 = ntohs (cm->peer2),
+    .repetition = ntohs (cm->repetition),
+    .leader = ntohs (cm->leader),
   });
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: got req for task %s\n",
-             session->local_peer_idx, debug_str_task_key(&tk));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: got req for task %s\n",
+              session->local_peer_idx, debug_str_task_key (&tk));
 
-  task = lookup_task(session, &tk);
+  task = lookup_task (session, &tk);
 
   if (NULL == task)
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
   if (GNUNET_YES == task->is_finished)
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
   if (task->key.peer2 != session->local_peer_idx)
-    {
-      /* We're being asked, so we must be thne 2nd peer. */
-      GNUNET_break_op(0);
-      return;
-    }
+  {
+    /* We're being asked, so we must be thne 2nd peer. */
+    GNUNET_break_op (0);
+    return;
+  }
 
-  GNUNET_assert(!((task->key.peer1 == session->local_peer_idx) &&
-                  (task->key.peer2 == session->local_peer_idx)));
+  GNUNET_assert (! ((task->key.peer1 == session->local_peer_idx) &&
+                    (task->key.peer2 == session->local_peer_idx)));
 
   struct GNUNET_SET_Option opts[] = {
     { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } },
     { GNUNET_SET_OPTION_END },
   };
 
-  task->cls.setop.op = GNUNET_SET_accept(request,
-                                         GNUNET_SET_RESULT_SYMMETRIC,
-                                         opts,
-                                         set_result_cb,
-                                         task);
+  task->cls.setop.op = GNUNET_SET_accept (request,
+                                          GNUNET_SET_RESULT_SYMMETRIC,
+                                          opts,
+                                          set_result_cb,
+                                          task);
 
   /* If the task hasn't been started yet,
      we wait for that until we commit. */
 
   if (GNUNET_YES == task->is_started)
-    {
-      commit_set(session, task);
-    }
+  {
+    commit_set (session, task);
+  }
 }
 
 
 
 static void
-put_task(struct GNUNET_CONTAINER_MultiHashMap *taskmap,
-         struct TaskEntry *t)
+put_task (struct GNUNET_CONTAINER_MultiHashMap *taskmap,
+          struct TaskEntry *t)
 {
   struct GNUNET_HashCode round_hash;
   struct Step *s;
 
-  GNUNET_assert(NULL != t->step);
+  GNUNET_assert (NULL != t->step);
 
-  t = GNUNET_memdup(t, sizeof(struct TaskEntry));
+  t = GNUNET_memdup (t, sizeof(struct TaskEntry));
 
   s = t->step;
 
   if (s->tasks_len == s->tasks_cap)
-    {
-      unsigned int target_size = 3 * (s->tasks_cap + 1) / 2;
-      GNUNET_array_grow(s->tasks,
-                        s->tasks_cap,
-                        target_size);
-    }
+  {
+    unsigned int target_size = 3 * (s->tasks_cap + 1) / 2;
+    GNUNET_array_grow (s->tasks,
+                       s->tasks_cap,
+                       target_size);
+  }
 
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_assert(NULL != s->debug_name);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Putting task <%s> into step `%s'\n",
-             debug_str_task_key(&t->key),
-             s->debug_name);
+  GNUNET_assert (NULL != s->debug_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting task <%s> into step `%s'\n",
+              debug_str_task_key (&t->key),
+              s->debug_name);
 #endif
 
   s->tasks[s->tasks_len] = t;
   s->tasks_len++;
 
-  GNUNET_CRYPTO_hash(&t->key, sizeof(struct TaskKey), &round_hash);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put(taskmap, &round_hash, t,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_CRYPTO_hash (&t->key, sizeof(struct TaskKey), &round_hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (taskmap, &round_hash, t,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
 
 
 static void
-install_step_timeouts(struct ConsensusSession *session)
+install_step_timeouts (struct ConsensusSession *session)
 {
   /* Given the fully constructed task graph
      with rounds for tasks, we can give the tasks timeouts. */
@@ -2684,37 +2759,37 @@ install_step_timeouts(struct ConsensusSession *session)
  * Arrange two peers in some canonical order.
  */
 static void
-arrange_peers(uint16_t *p1, uint16_t *p2, uint16_t n)
+arrange_peers (uint16_t *p1, uint16_t *p2, uint16_t n)
 {
   uint16_t a;
   uint16_t b;
 
-  GNUNET_assert(*p1 < n);
-  GNUNET_assert(*p2 < n);
+  GNUNET_assert (*p1 < n);
+  GNUNET_assert (*p2 < n);
 
   if (*p1 < *p2)
-    {
-      a = *p1;
-      b = *p2;
-    }
+  {
+    a = *p1;
+    b = *p2;
+  }
   else
-    {
-      a = *p2;
-      b = *p1;
-    }
+  {
+    a = *p2;
+    b = *p1;
+  }
 
   /* For uniformly random *p1, *p2,
      this condition is true with 50% chance */
   if (((b - a) + n) % n <= n / 2)
-    {
-      *p1 = a;
-      *p2 = b;
-    }
+  {
+    *p1 = a;
+    *p2 = b;
+  }
   else
-    {
-      *p1 = b;
-      *p2 = a;
-    }
+  {
+    *p1 = b;
+    *p2 = a;
+  }
 }
 
 
@@ -2722,36 +2797,36 @@ arrange_peers(uint16_t *p1, uint16_t *p2, uint16_t n)
  * Record @a dep as a dependency of @a step.
  */
 static void
-step_depend_on(struct Step *step, struct Step *dep)
+step_depend_on (struct Step *step, struct Step *dep)
 {
   /* We're not checking for cyclic dependencies,
      but this is a cheap sanity check. */
-  GNUNET_assert(step != dep);
-  GNUNET_assert(NULL != step);
-  GNUNET_assert(NULL != dep);
-  GNUNET_assert(dep->round <= step->round);
+  GNUNET_assert (step != dep);
+  GNUNET_assert (NULL != step);
+  GNUNET_assert (NULL != dep);
+  GNUNET_assert (dep->round <= step->round);
 
 #ifdef GNUNET_EXTRA_LOGGING
   /* Make sure we have complete debugging information.
      Also checks that we don't screw up too badly
      constructing the task graph. */
-  GNUNET_assert(NULL != step->debug_name);
-  GNUNET_assert(NULL != dep->debug_name);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Making step `%s' depend on `%s'\n",
-             step->debug_name,
-             dep->debug_name);
+  GNUNET_assert (NULL != step->debug_name);
+  GNUNET_assert (NULL != dep->debug_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Making step `%s' depend on `%s'\n",
+              step->debug_name,
+              dep->debug_name);
 #endif
 
   if (dep->subordinates_cap == dep->subordinates_len)
-    {
-      unsigned int target_size = 3 * (dep->subordinates_cap + 1) / 2;
-      GNUNET_array_grow(dep->subordinates,
-                        dep->subordinates_cap,
-                        target_size);
-    }
+  {
+    unsigned int target_size = 3 * (dep->subordinates_cap + 1) / 2;
+    GNUNET_array_grow (dep->subordinates,
+                       dep->subordinates_cap,
+                       target_size);
+  }
 
-  GNUNET_assert(dep->subordinates_len <= dep->subordinates_cap);
+  GNUNET_assert (dep->subordinates_len <= dep->subordinates_cap);
 
   dep->subordinates[dep->subordinates_len] = step;
   dep->subordinates_len++;
@@ -2761,17 +2836,17 @@ step_depend_on(struct Step *step, struct Step *dep)
 
 
 static struct Step *
-create_step(struct ConsensusSession *session, int round, int early_finishable)
+create_step (struct ConsensusSession *session, int round, int early_finishable)
 {
   struct Step *step;
 
-  step = GNUNET_new(struct Step);
+  step = GNUNET_new (struct Step);
   step->session = session;
   step->round = round;
   step->early_finishable = early_finishable;
-  GNUNET_CONTAINER_DLL_insert_tail(session->steps_head,
-                                   session->steps_tail,
-                                   step);
+  GNUNET_CONTAINER_DLL_insert_tail (session->steps_head,
+                                    session->steps_tail,
+                                    step);
   return step;
 }
 
@@ -2781,11 +2856,11 @@ create_step(struct ConsensusSession *session, int round, int early_finishable)
  * gradecast.
  */
 static void
-construct_task_graph_gradecast(struct ConsensusSession *session,
-                               uint16_t rep,
-                               uint16_t lead,
-                               struct Step *step_before,
-                               struct Step *step_after)
+construct_task_graph_gradecast (struct ConsensusSession *session,
+                                uint16_t rep,
+                                uint16_t lead,
+                                struct Step *step_before,
+                                struct Step *step_after)
 {
   uint16_t n = session->num_peers;
   uint16_t me = session->local_peer_idx;
@@ -2807,155 +2882,168 @@ construct_task_graph_gradecast(struct ConsensusSession *session,
 
   /* gcast step 1: leader disseminates */
 
-  step = create_step(session, round, GNUNET_YES);
+  step = create_step (session, round, GNUNET_YES);
 
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "disseminate leader %u rep %u", lead, rep);
+  GNUNET_asprintf (&step->debug_name, "disseminate leader %u rep %u", lead,
+                   rep);
 #endif
-  step_depend_on(step, step_before);
+  step_depend_on (step, step_before);
 
   if (lead == me)
+  {
+    for (k = 0; k < n; k++)
     {
-      for (k = 0; k < n; k++)
-        {
-          if (k == me)
-            continue;
-          p1 = me;
-          p2 = k;
-          arrange_peers(&p1, &p2, n);
-          task = ((struct TaskEntry) {
+      if (k == me)
+        continue;
+      p1 = me;
+      p2 = k;
+      arrange_peers (&p1, &p2, n);
+      task = ((struct TaskEntry) {
         .step = step,
         .start = task_start_reconcile,
         .cancel = task_cancel_reconcile,
-        .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, me },
+        .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep,
+                                  me },
       });
-          task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
-          put_task(session->taskmap, &task);
-        }
-      /* We run this task to make sure that the leader
-         has the stored the SET_KIND_LEADER set of himself,
-         so it can participate in the rest of the gradecast
-         without the code having to handle any special cases. */
-      task = ((struct TaskEntry) {
+      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+      put_task (session->taskmap, &task);
+    }
+    /* We run this task to make sure that the leader
+       has the stored the SET_KIND_LEADER set of himself,
+       so it can participate in the rest of the gradecast
+       without the code having to handle any special cases. */
+    task = ((struct TaskEntry) {
       .step = step,
       .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, me, me, rep, me },
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
-      task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, me };
-      task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, rep, me };
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+    task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                  me };
+    task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL,
+                                                    rep, me };
+    put_task (session->taskmap, &task);
+  }
   else
-    {
-      p1 = me;
-      p2 = lead;
-      arrange_peers(&p1, &p2, n);
-      task = ((struct TaskEntry) {
+  {
+    p1 = me;
+    p2 = lead;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
       .step = step,
-      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, lead },
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep,
+                                lead },
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
-      task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, lead };
-      task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, rep, lead };
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+    task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                  lead };
+    task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL,
+                                                    rep, lead };
+    put_task (session->taskmap, &task);
+  }
 
   /* gcast phase 2: echo */
   prev_step = step;
   round += 1;
-  step = create_step(session, round, GNUNET_YES);
+  step = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "echo leader %u rep %u", lead, rep);
+  GNUNET_asprintf (&step->debug_name, "echo leader %u rep %u", lead, rep);
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
   for (k = 0; k < n; k++)
-    {
-      p1 = k;
-      p2 = me;
-      arrange_peers(&p1, &p2, n);
-      task = ((struct TaskEntry) {
+  {
+    p1 = k;
+    p2 = me;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
       .step = step,
       .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO, p1, p2, rep, lead },
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, lead };
-      task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_ECHO, rep, lead };
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                 lead };
+    task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_ECHO, rep, lead };
+    put_task (session->taskmap, &task);
+  }
 
   prev_step = step;
   /* Same round, since step only has local tasks */
-  step = create_step(session, round, GNUNET_YES);
+  step = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "echo grade leader %u rep %u", lead, rep);
+  GNUNET_asprintf (&step->debug_name, "echo grade leader %u rep %u", lead, rep);
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
-  arrange_peers(&p1, &p2, n);
+  arrange_peers (&p1, &p2, n);
   task = ((struct TaskEntry) {
-    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO_GRADE, -1, -1, rep, lead },
+    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO_GRADE, -1, -1, rep,
+                              lead },
     .step = step,
     .start = task_start_eval_echo
   });
-  put_task(session->taskmap, &task);
+  put_task (session->taskmap, &task);
 
   prev_step = step;
   round += 1;
-  step = create_step(session, round, GNUNET_YES);
+  step = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "confirm leader %u rep %u", lead, rep);
+  GNUNET_asprintf (&step->debug_name, "confirm leader %u rep %u", lead, rep);
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
   /* gcast phase 3: confirmation and grading */
   for (k = 0; k < n; k++)
-    {
-      p1 = k;
-      p2 = me;
-      arrange_peers(&p1, &p2, n);
-      task = ((struct TaskEntry) {
+  {
+    p1 = k;
+    p2 = me;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
       .step = step,
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
-      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM, p1, p2, rep, lead },
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM, p1, p2, rep,
+                                lead },
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_ECHO_RESULT, rep, lead };
-      task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_CONFIRM, rep, lead };
-      /* If there was at least one element in the echo round that was
-         contested (i.e. it had no n-t majority), then we let the other peers
-         know, and other peers let us know.  The contested flag for each peer is
-         stored in the rfn. */
-      task.cls.setop.transceive_contested = GNUNET_YES;
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_ECHO_RESULT, rep,
+                                                 lead };
+    task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_CONFIRM, rep, lead };
+    /* If there was at least one element in the echo round that was
+       contested (i.e. it had no n-t majority), then we let the other peers
+       know, and other peers let us know.  The contested flag for each peer is
+       stored in the rfn. */
+    task.cls.setop.transceive_contested = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
 
   prev_step = step;
   /* Same round, since step only has local tasks */
-  step = create_step(session, round, GNUNET_YES);
+  step = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "confirm grade leader %u rep %u", lead, rep);
+  GNUNET_asprintf (&step->debug_name, "confirm grade leader %u rep %u", lead,
+                   rep);
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
   task = ((struct TaskEntry) {
     .step = step,
-    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM_GRADE, -1, -1, rep, lead },
+    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM_GRADE, -1, -1, rep,
+                              lead },
     .start = task_start_grade,
   });
-  put_task(session->taskmap, &task);
+  put_task (session->taskmap, &task);
 
-  step_depend_on(step_after, step);
+  step_depend_on (step_after, step);
 }
 
 
 static void
-construct_task_graph(struct ConsensusSession *session)
+construct_task_graph (struct ConsensusSession *session)
 {
   uint16_t n = session->num_peers;
   uint16_t t = n / 3;
@@ -2985,60 +3073,60 @@ construct_task_graph(struct ConsensusSession *session)
 
   /* all-to-all step */
 
-  step = create_step(session, round, GNUNET_NO);
+  step = create_step (session, round, GNUNET_NO);
 
 #ifdef GNUNET_EXTRA_LOGGING
-  step->debug_name = GNUNET_strdup("all to all");
+  step->debug_name = GNUNET_strdup ("all to all");
 #endif
 
   for (i = 0; i < n; i++)
-    {
-      uint16_t p1;
-      uint16_t p2;
+  {
+    uint16_t p1;
+    uint16_t p2;
 
-      p1 = me;
-      p2 = i;
-      arrange_peers(&p1, &p2, n);
-      task = ((struct TaskEntry) {
+    p1 = me;
+    p2 = i;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
       .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL, p1, p2, -1, -1 },
       .step = step,
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
-      task.cls.setop.output_set = task.cls.setop.input_set;
-      task.cls.setop.do_not_remove = GNUNET_YES;
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
+    task.cls.setop.output_set = task.cls.setop.input_set;
+    task.cls.setop.do_not_remove = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
 
   round += 1;
   prev_step = step;
-  step = create_step(session, round, GNUNET_NO);;
+  step = create_step (session, round, GNUNET_NO);;
 #ifdef GNUNET_EXTRA_LOGGING
-  step->debug_name = GNUNET_strdup("all to all 2");
+  step->debug_name = GNUNET_strdup ("all to all 2");
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
 
   for (i = 0; i < n; i++)
-    {
-      uint16_t p1;
-      uint16_t p2;
+  {
+    uint16_t p1;
+    uint16_t p2;
 
-      p1 = me;
-      p2 = i;
-      arrange_peers(&p1, &p2, n);
-      task = ((struct TaskEntry) {
+    p1 = me;
+    p2 = i;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
       .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL_2, p1, p2, -1, -1 },
       .step = step,
       .start = task_start_reconcile,
       .cancel = task_cancel_reconcile,
     });
-      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
-      task.cls.setop.output_set = task.cls.setop.input_set;
-      task.cls.setop.do_not_remove = GNUNET_YES;
-      put_task(session->taskmap, &task);
-    }
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
+    task.cls.setop.output_set = task.cls.setop.input_set;
+    task.cls.setop.do_not_remove = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
 
   round += 1;
 
@@ -3051,47 +3139,48 @@ construct_task_graph(struct ConsensusSession *session)
 
   /* sequential repetitions of the gradecasts */
   for (i = 0; i < t + 1; i++)
-    {
-      struct Step *step_rep_start;
-      struct Step *step_rep_end;
+  {
+    struct Step *step_rep_start;
+    struct Step *step_rep_end;
 
-      /* Every repetition is in a separate round. */
-      step_rep_start = create_step(session, round, GNUNET_YES);
+    /* Every repetition is in a separate round. */
+    step_rep_start = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-      GNUNET_asprintf(&step_rep_start->debug_name, "gradecast start rep %u", i);
+    GNUNET_asprintf (&step_rep_start->debug_name, "gradecast start rep %u", i);
 #endif
 
-      step_depend_on(step_rep_start, prev_step);
+    step_depend_on (step_rep_start, prev_step);
 
-      /* gradecast has three rounds */
-      round += 3;
-      step_rep_end = create_step(session, round, GNUNET_YES);
+    /* gradecast has three rounds */
+    round += 3;
+    step_rep_end = create_step (session, round, GNUNET_YES);
 #ifdef GNUNET_EXTRA_LOGGING
-      GNUNET_asprintf(&step_rep_end->debug_name, "gradecast end rep %u", i);
+    GNUNET_asprintf (&step_rep_end->debug_name, "gradecast end rep %u", i);
 #endif
 
-      /* parallel gradecasts */
-      for (lead = 0; lead < n; lead++)
-        construct_task_graph_gradecast(session, i, lead, step_rep_start, step_rep_end);
+    /* parallel gradecasts */
+    for (lead = 0; lead < n; lead++)
+      construct_task_graph_gradecast (session, i, lead, step_rep_start,
+                                      step_rep_end);
 
-      task = ((struct TaskEntry) {
+    task = ((struct TaskEntry) {
       .step = step_rep_end,
       .key = (struct TaskKey) { PHASE_KIND_APPLY_REP, -1, -1, i, -1 },
       .start = task_start_apply_round,
     });
-      put_task(session->taskmap, &task);
+    put_task (session->taskmap, &task);
 
-      prev_step = step_rep_end;
-    }
+    prev_step = step_rep_end;
+  }
 
   /* There is no next gradecast round, thus the final
      start step is the overall end step of the gradecasts */
   round += 1;
-  step = create_step(session, round, GNUNET_NO);
+  step = create_step (session, round, GNUNET_NO);
 #ifdef GNUNET_EXTRA_LOGGING
-  GNUNET_asprintf(&step->debug_name, "finish");
+  GNUNET_asprintf (&step->debug_name, "finish");
 #endif
-  step_depend_on(step, prev_step);
+  step_depend_on (step, prev_step);
 
   task = ((struct TaskEntry) {
     .step = step,
@@ -3100,7 +3189,7 @@ construct_task_graph(struct ConsensusSession *session)
   });
   task.cls.finish.input_set = (struct SetKey) { SET_KIND_LAST_GRADECAST };
 
-  put_task(session->taskmap, &task);
+  put_task (session->taskmap, &task);
 }
 
 
@@ -3113,17 +3202,17 @@ construct_task_graph(struct ConsensusSession *session)
  * @return #GNUNET_OK if @a m is well-formed
  */
 static int
-check_client_join(void *cls,
-                  const struct GNUNET_CONSENSUS_JoinMessage *m)
+check_client_join (void *cls,
+                   const struct GNUNET_CONSENSUS_JoinMessage *m)
 {
-  uint32_t listed_peers = ntohl(m->num_peers);
+  uint32_t listed_peers = ntohl (m->num_peers);
 
-  if ((ntohs(m->header.size) - sizeof(*m)) !=
+  if ((ntohs (m->header.size) - sizeof(*m)) !=
       listed_peers * sizeof(struct GNUNET_PeerIdentity))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -3135,16 +3224,16 @@ check_client_join(void *cls,
  * @param m message sent by the client
  */
 static void
-handle_client_join(void *cls,
-                   const struct GNUNET_CONSENSUS_JoinMessage *m)
+handle_client_join (void *cls,
+                    const struct GNUNET_CONSENSUS_JoinMessage *m)
 {
   struct ConsensusSession *session = cls;
   struct ConsensusSession *other_session;
 
-  initialize_session_peer_list(session,
-                               m);
-  compute_global_id(session,
-                    &m->session_id);
+  initialize_session_peer_list (session,
+                                m);
+  compute_global_id (session,
+                     &m->session_id);
 
   /* Check if some local client already owns the session.
      It is only legal to have a session with an existing global id
@@ -3152,75 +3241,75 @@ handle_client_join(void *cls,
   for (other_session = sessions_head;
        NULL != other_session;
        other_session = other_session->next)
-    {
-      if ((other_session != session) &&
-          (0 == GNUNET_CRYPTO_hash_cmp(&session->global_id,
-                                       &other_session->global_id)))
-        break;
-    }
+  {
+    if ((other_session != session) &&
+        (0 == GNUNET_CRYPTO_hash_cmp (&session->global_id,
+                                      &other_session->global_id)))
+      break;
+  }
 
   session->conclude_deadline
-    = GNUNET_TIME_absolute_ntoh(m->deadline);
+    = GNUNET_TIME_absolute_ntoh (m->deadline);
   session->conclude_start
-    = GNUNET_TIME_absolute_ntoh(m->start);
-  session->local_peer_idx = get_peer_idx(&my_peer,
-                                         session);
-  GNUNET_assert(-1 != session->local_peer_idx);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Joining consensus session %s containing %u peers as %u with timeout %s\n",
-             GNUNET_h2s(&m->session_id),
-             session->num_peers,
-             session->local_peer_idx,
-             GNUNET_STRINGS_relative_time_to_string
-               (GNUNET_TIME_absolute_get_difference(session->conclude_start,
-                                                    session->conclude_deadline),
-               GNUNET_YES));
+    = GNUNET_TIME_absolute_ntoh (m->start);
+  session->local_peer_idx = get_peer_idx (&my_peer,
+                                          session);
+  GNUNET_assert (-1 != session->local_peer_idx);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Joining consensus session %s containing %u peers as %u with timeout %s\n",
+              GNUNET_h2s (&m->session_id),
+              session->num_peers,
+              session->local_peer_idx,
+              GNUNET_STRINGS_relative_time_to_string
+                (GNUNET_TIME_absolute_get_difference (session->conclude_start,
+                                                      session->conclude_deadline),
+                GNUNET_YES));
 
   session->set_listener
-    = GNUNET_SET_listen(cfg,
-                        GNUNET_SET_OPERATION_UNION,
-                        &session->global_id,
-                        &set_listen_cb,
-                        session);
-
-  session->setmap = GNUNET_CONTAINER_multihashmap_create(1,
-                                                         GNUNET_NO);
-  session->taskmap = GNUNET_CONTAINER_multihashmap_create(1,
+    = GNUNET_SET_listen (cfg,
+                         GNUNET_SET_OPERATION_UNION,
+                         &session->global_id,
+                         &set_listen_cb,
+                         session);
+
+  session->setmap = GNUNET_CONTAINER_multihashmap_create (1,
                                                           GNUNET_NO);
-  session->diffmap = GNUNET_CONTAINER_multihashmap_create(1,
+  session->taskmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                           GNUNET_NO);
+  session->diffmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                           GNUNET_NO);
+  session->rfnmap = GNUNET_CONTAINER_multihashmap_create (1,
                                                           GNUNET_NO);
-  session->rfnmap = GNUNET_CONTAINER_multihashmap_create(1,
-                                                         GNUNET_NO);
 
   {
     struct SetEntry *client_set;
 
-    client_set = GNUNET_new(struct SetEntry);
-    client_set->h = GNUNET_SET_create(cfg,
-                                      GNUNET_SET_OPERATION_UNION);
-    struct SetHandle *sh = GNUNET_new(struct SetHandle);
+    client_set = GNUNET_new (struct SetEntry);
+    client_set->h = GNUNET_SET_create (cfg,
+                                       GNUNET_SET_OPERATION_UNION);
+    struct SetHandle *sh = GNUNET_new (struct SetHandle);
     sh->h = client_set->h;
-    GNUNET_CONTAINER_DLL_insert(session->set_handles_head,
-                                session->set_handles_tail,
-                                sh);
+    GNUNET_CONTAINER_DLL_insert (session->set_handles_head,
+                                 session->set_handles_tail,
+                                 sh);
     client_set->key = ((struct SetKey) { SET_KIND_CURRENT, 0, 0 });
-    put_set(session,
-            client_set);
+    put_set (session,
+             client_set);
   }
 
-  session->peers_blacklisted = GNUNET_new_array(session->num_peers,
-                                                int);
+  session->peers_blacklisted = GNUNET_new_array (session->num_peers,
+                                                 int);
 
   /* Just construct the task graph,
      but don't run anything until the client calls conclude. */
-  construct_task_graph(session);
-  GNUNET_SERVICE_client_continue(session->client);
+  construct_task_graph (session);
+  GNUNET_SERVICE_client_continue (session->client);
 }
 
 
 static void
-client_insert_done(void *cls)
+client_insert_done (void *cls)
 {
   // FIXME: implement
 }
@@ -3234,8 +3323,8 @@ client_insert_done(void *cls)
  * @return #GNUNET_OK (always well-formed)
  */
 static int
-check_client_insert(void *cls,
-                    const struct GNUNET_CONSENSUS_ElementMessage *msg)
+check_client_insert (void *cls,
+                     const struct GNUNET_CONSENSUS_ElementMessage *msg)
 {
   return GNUNET_OK;
 }
@@ -3248,8 +3337,8 @@ check_client_insert(void *cls,
  * @param msg message sent by the client
  */
 static void
-handle_client_insert(void *cls,
-                     const struct GNUNET_CONSENSUS_ElementMessage *msg)
+handle_client_insert (void *cls,
+                      const struct GNUNET_CONSENSUS_ElementMessage *msg)
 {
   struct ConsensusSession *session = cls;
   ssize_t element_size;
@@ -3257,15 +3346,16 @@ handle_client_insert(void *cls,
   struct ConsensusElement *ce;
 
   if (GNUNET_YES == session->conclude_started)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(session->client);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (session->client);
+    return;
+  }
 
-  element_size = ntohs(msg->header.size) - sizeof(struct GNUNET_CONSENSUS_ElementMessage);
-  ce = GNUNET_malloc(sizeof(struct ConsensusElement) + element_size);
-  GNUNET_memcpy(&ce[1], &msg[1], element_size);
+  element_size = ntohs (msg->header.size) - sizeof(struct
+                                                   GNUNET_CONSENSUS_ElementMessage);
+  ce = GNUNET_malloc (sizeof(struct ConsensusElement) + element_size);
+  GNUNET_memcpy (&ce[1], &msg[1], element_size);
   ce->payload_type = msg->element_type;
 
   struct GNUNET_SET_Element element = {
@@ -3278,28 +3368,28 @@ handle_client_insert(void *cls,
     struct SetKey key = { SET_KIND_CURRENT, 0, 0 };
     struct SetEntry *entry;
 
-    entry = lookup_set(session,
-                       &key);
-    GNUNET_assert(NULL != entry);
+    entry = lookup_set (session,
+                        &key);
+    GNUNET_assert (NULL != entry);
     initial_set = entry->h;
   }
 
   session->num_client_insert_pending++;
-  GNUNET_SET_add_element(initial_set,
-                         &element,
-                         &client_insert_done,
-                         session);
+  GNUNET_SET_add_element (initial_set,
+                          &element,
+                          &client_insert_done,
+                          session);
 
 #ifdef GNUNET_EXTRA_LOGGING
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "P%u: element %s added\n",
-               session->local_peer_idx,
-               debug_str_element(&element));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: element %s added\n",
+                session->local_peer_idx,
+                debug_str_element (&element));
   }
 #endif
-  GNUNET_free(ce);
-  GNUNET_SERVICE_client_continue(session->client);
+  GNUNET_free (ce);
+  GNUNET_SERVICE_client_continue (session->client);
 }
 
 
@@ -3310,24 +3400,24 @@ handle_client_insert(void *cls,
  * @param message message sent by the client
  */
 static void
-handle_client_conclude(void *cls,
-                       const struct GNUNET_MessageHeader *message)
+handle_client_conclude (void *cls,
+                        const struct GNUNET_MessageHeader *message)
 {
   struct ConsensusSession *session = cls;
 
   if (GNUNET_YES == session->conclude_started)
-    {
-      /* conclude started twice */
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(session->client);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "conclude requested\n");
+  {
+    /* conclude started twice */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (session->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "conclude requested\n");
   session->conclude_started = GNUNET_YES;
-  install_step_timeouts(session);
-  run_ready_steps(session);
-  GNUNET_SERVICE_client_continue(session->client);
+  install_step_timeouts (session);
+  run_ready_steps (session);
+  GNUNET_SERVICE_client_continue (session->client);
 }
 
 
@@ -3337,12 +3427,12 @@ handle_client_conclude(void *cls,
  * @param cls closure
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "shutting down\n");
-  GNUNET_STATISTICS_destroy(statistics,
-                            GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "shutting down\n");
+  GNUNET_STATISTICS_destroy (statistics,
+                             GNUNET_NO);
   statistics = NULL;
 }
 
@@ -3355,24 +3445,24 @@ shutdown_task(void *cls)
  * @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)
 {
   cfg = c;
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_get_peer_identity(cfg,
-                                      &my_peer))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Could not retrieve host identity\n");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  statistics = GNUNET_STATISTICS_create("consensus",
-                                        cfg);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                NULL);
+      GNUNET_CRYPTO_get_peer_identity (cfg,
+                                       &my_peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not retrieve host identity\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  statistics = GNUNET_STATISTICS_create ("consensus",
+                                         cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
 }
 
 
@@ -3385,17 +3475,17 @@ 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)
 {
-  struct ConsensusSession *session = GNUNET_new(struct ConsensusSession);
+  struct ConsensusSession *session = GNUNET_new (struct ConsensusSession);
 
   session->client = c;
   session->client_mq = mq;
-  GNUNET_CONTAINER_DLL_insert(sessions_head,
-                              sessions_tail,
-                              session);
+  GNUNET_CONTAINER_DLL_insert (sessions_head,
+                               sessions_tail,
+                               session);
   return session;
 }
 
@@ -3408,29 +3498,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)
 {
   struct ConsensusSession *session = internal_cls;
 
   if (NULL != session->set_listener)
-    {
-      GNUNET_SET_listen_cancel(session->set_listener);
-      session->set_listener = NULL;
-    }
-  GNUNET_CONTAINER_DLL_remove(sessions_head,
-                              sessions_tail,
-                              session);
+  {
+    GNUNET_SET_listen_cancel (session->set_listener);
+    session->set_listener = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (sessions_head,
+                               sessions_tail,
+                               session);
 
   while (session->set_handles_head)
-    {
-      struct SetHandle *sh = session->set_handles_head;
-      session->set_handles_head = sh->next;
-      GNUNET_SET_destroy(sh->h);
-      GNUNET_free(sh);
-    }
-  GNUNET_free(session);
+  {
+    struct SetHandle *sh = session->set_handles_head;
+    session->set_handles_head = sh->next;
+    GNUNET_SET_destroy (sh->h);
+    GNUNET_free (sh);
+  }
+  GNUNET_free (session);
 }
 
 
@@ -3444,18 +3534,18 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_fixed_size(client_conclude,
-                          GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-  GNUNET_MQ_hd_var_size(client_insert,
-                        GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT,
-                        struct GNUNET_CONSENSUS_ElementMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(client_join,
-                        GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN,
-                        struct GNUNET_CONSENSUS_JoinMessage,
-                        NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_fixed_size (client_conclude,
+                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_insert,
+                         GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT,
+                         struct GNUNET_CONSENSUS_ElementMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (client_join,
+                         GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN,
+                         struct GNUNET_CONSENSUS_JoinMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
 
 /* end of gnunet-service-consensus.c */
diff --git a/src/consensus/plugin_block_consensus.c b/src/consensus/plugin_block_consensus.c
index a90b451d2..1caf4fc39 100644
--- a/src/consensus/plugin_block_consensus.c
+++ b/src/consensus/plugin_block_consensus.c
@@ -47,16 +47,16 @@
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_consensus_evaluate(void *cls,
-                                struct GNUNET_BLOCK_Context *ctx,
-                                enum GNUNET_BLOCK_Type type,
-                                struct GNUNET_BLOCK_Group *group,
-                                enum GNUNET_BLOCK_EvaluationOptions eo,
-                                const struct GNUNET_HashCode *query,
-                                const void *xquery,
-                                size_t xquery_size,
-                                const void *reply_block,
-                                size_t reply_block_size)
+block_plugin_consensus_evaluate (void *cls,
+                                 struct GNUNET_BLOCK_Context *ctx,
+                                 enum GNUNET_BLOCK_Type type,
+                                 struct GNUNET_BLOCK_Group *group,
+                                 enum GNUNET_BLOCK_EvaluationOptions eo,
+                                 const struct GNUNET_HashCode *query,
+                                 const void *xquery,
+                                 size_t xquery_size,
+                                 const void *reply_block,
+                                 size_t reply_block_size)
 {
   if (reply_block_size < sizeof(struct ConsensusElement))
     return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
@@ -67,15 +67,16 @@ block_plugin_consensus_evaluate(void *cls,
       (0 == ce->payload_type))
     return GNUNET_BLOCK_EVALUATION_OK_MORE;
 
-  return GNUNET_BLOCK_evaluate(ctx,
-                               type,
-                               group,
-                               eo,
-                               query,
-                               xquery,
-                               xquery_size,
-                               &ce[1],
-                               reply_block_size - sizeof(struct ConsensusElement));
+  return GNUNET_BLOCK_evaluate (ctx,
+                                type,
+                                group,
+                                eo,
+                                query,
+                                xquery,
+                                xquery_size,
+                                &ce[1],
+                                reply_block_size - sizeof(struct
+                                                          ConsensusElement));
 }
 
 
@@ -91,11 +92,11 @@ block_plugin_consensus_evaluate(void *cls,
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
-block_plugin_consensus_get_key(void *cls,
-                               enum GNUNET_BLOCK_Type type,
-                               const void *block,
-                               size_t block_size,
-                               struct GNUNET_HashCode *key)
+block_plugin_consensus_get_key (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const void *block,
+                                size_t block_size,
+                                struct GNUNET_HashCode *key)
 {
   return GNUNET_SYSERR;
 }
@@ -105,16 +106,15 @@ block_plugin_consensus_get_key(void *cls,
  * Entry point for the plugin.
  */
 void *
-libgnunet_plugin_block_consensus_init(void *cls)
+libgnunet_plugin_block_consensus_init (void *cls)
 {
-  static enum GNUNET_BLOCK_Type types[] =
-  {
+  static enum GNUNET_BLOCK_Type types[] = {
     GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT,
     GNUNET_BLOCK_TYPE_ANY       /* end of list */
   };
   struct GNUNET_BLOCK_PluginFunctions *api;
 
-  api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions);
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
   api->evaluate = &block_plugin_consensus_evaluate;
   api->get_key = &block_plugin_consensus_get_key;
   api->types = types;
@@ -126,11 +126,11 @@ libgnunet_plugin_block_consensus_init(void *cls)
  * Exit point from the plugin.
  */
 void *
-libgnunet_plugin_block_consensus_done(void *cls)
+libgnunet_plugin_block_consensus_done (void *cls)
 {
   struct GNUNET_BLOCK_PluginFunctions *api = cls;
 
-  GNUNET_free(api);
+  GNUNET_free (api);
   return NULL;
 }
 
diff --git a/src/consensus/test_consensus_api.c b/src/consensus/test_consensus_api.c
index a2ae36222..d32bc06ed 100644
--- a/src/consensus/test_consensus_api.c
+++ b/src/consensus/test_consensus_api.c
@@ -36,31 +36,31 @@ static unsigned int elements_received;
 
 
 static void
-conclude_done(void *cls)
+conclude_done (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "conclude over\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "conclude over\n");
   if (2 != elements_received)
-    GNUNET_assert(0);
-  GNUNET_SCHEDULER_shutdown();
+    GNUNET_assert (0);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 static void
-on_new_element(void *cls,
-               const struct GNUNET_SET_Element *element)
+on_new_element (void *cls,
+                const struct GNUNET_SET_Element *element)
 {
   elements_received++;
 }
 
 static void
-insert_done(void *cls, int success)
+insert_done (void *cls, int success)
 {
   /* make sure cb is only called once */
   static int called = GNUNET_NO;
 
-  GNUNET_assert(GNUNET_NO == called);
+  GNUNET_assert (GNUNET_NO == called);
   called = GNUNET_YES;
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "insert done\n");
-  GNUNET_CONSENSUS_conclude(consensus, &conclude_done, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "insert done\n");
+  GNUNET_CONSENSUS_conclude (consensus, &conclude_done, NULL);
 }
 
 
@@ -70,47 +70,49 @@ insert_done(void *cls, int success)
  * @param cls closure
  */
 static void
-on_shutdown(void *cls)
+on_shutdown (void *cls)
 {
   if (NULL != consensus)
-    {
-      GNUNET_CONSENSUS_destroy(consensus);
-      consensus = NULL;
-    }
+  {
+    GNUNET_CONSENSUS_destroy (consensus);
+    consensus = 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)
 {
   char *str = "foo";
 
   struct GNUNET_SET_Element el1 = { 4, 0, "foo" };
   struct GNUNET_SET_Element el2 = { 5, 0, "quux" };
 
-  GNUNET_log_setup("test_consensus_api",
-                   "INFO",
-                   NULL);
-  GNUNET_SCHEDULER_add_shutdown(&on_shutdown, NULL);
-
-  GNUNET_CRYPTO_hash(str, strlen(str), &session_id);
-  consensus = GNUNET_CONSENSUS_create(cfg, 0, NULL, &session_id,
-                                      GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_SECONDS),
-                                      GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES),
-                                      on_new_element, &consensus);
-  GNUNET_assert(consensus != NULL);
-
-  GNUNET_CONSENSUS_insert(consensus, &el1, NULL, &consensus);
-  GNUNET_CONSENSUS_insert(consensus, &el2, &insert_done, &consensus);
+  GNUNET_log_setup ("test_consensus_api",
+                    "INFO",
+                    NULL);
+  GNUNET_SCHEDULER_add_shutdown (&on_shutdown, NULL);
+
+  GNUNET_CRYPTO_hash (str, strlen (str), &session_id);
+  consensus = GNUNET_CONSENSUS_create (cfg, 0, NULL, &session_id,
+                                       GNUNET_TIME_relative_to_absolute (
+                                         GNUNET_TIME_UNIT_SECONDS),
+                                       GNUNET_TIME_relative_to_absolute (
+                                         GNUNET_TIME_UNIT_MINUTES),
+                                       on_new_element, &consensus);
+  GNUNET_assert (consensus != NULL);
+
+  GNUNET_CONSENSUS_insert (consensus, &el1, NULL, &consensus);
+  GNUNET_CONSENSUS_insert (consensus, &el2, &insert_done, &consensus);
 }
 
 
 int
-main(int argc, char **argv)
+main (int argc, char **argv)
 {
-  return GNUNET_TESTING_peer_run("test_consensus_api",
-                                 "test_consensus.conf",
-                                 &run, NULL);
+  return GNUNET_TESTING_peer_run ("test_consensus_api",
+                                  "test_consensus.conf",
+                                  &run, NULL);
 }