24 files changed, 891 insertions, 552 deletions

diff --git a/src/consensus/consensus_protocol.h b/src/consensus/consensus_protocol.h
index a40162fb8..0afd56b27 100644
--- a/src/consensus/consensus_protocol.h
+++ b/src/consensus/consensus_protocol.h
@@ -124,6 +124,7 @@ struct ConsensusSizeElement
   uint8_t sender_index;
 };
 
+
 struct ConsensusStuffedElement
 {
   struct ConsensusElement ce;
diff --git a/src/consensus/gnunet-service-consensus.c b/src/consensus/gnunet-service-consensus.c
index 13fa0d0e7..371b7f67f 100644
--- a/src/consensus/gnunet-service-consensus.c
+++ b/src/consensus/gnunet-service-consensus.c
@@ -1,6 +1,6 @@
 /*
       This file is part of GNUnet
-      Copyright (C) 2012, 2013, 2017 GNUnet e.V.
+      Copyright (C) 2012, 2013, 2017, 2020 GNUnet e.V.
 
       GNUnet is free software: you can redistribute it and/or modify it
       under the terms of the GNU Affero General Public License as published
@@ -17,13 +17,11 @@
 
      SPDX-License-Identifier: AGPL3.0-or-later
  */
-
 /**
  * @file consensus/gnunet-service-consensus.c
  * @brief multi-peer set reconciliation
  * @author Florian Dold <flo@dold.me>
  */
-
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_block_lib.h"
@@ -62,11 +60,57 @@ enum EarlyStoppingPhase
 };
 
 
+enum PhaseKind
+{
+  PHASE_KIND_ALL_TO_ALL,
+  PHASE_KIND_ALL_TO_ALL_2,
+  PHASE_KIND_GRADECAST_LEADER,
+  PHASE_KIND_GRADECAST_ECHO,
+  PHASE_KIND_GRADECAST_ECHO_GRADE,
+  PHASE_KIND_GRADECAST_CONFIRM,
+  PHASE_KIND_GRADECAST_CONFIRM_GRADE,
+  /**
+   * Apply a repetition of the all-to-all
+   * gradecast to the current set.
+   */
+  PHASE_KIND_APPLY_REP,
+  PHASE_KIND_FINISH,
+};
+
+
+enum SetKind
+{
+  SET_KIND_NONE = 0,
+  SET_KIND_CURRENT,
+  /**
+   * Last result set from a gradecast
+   */
+  SET_KIND_LAST_GRADECAST,
+  SET_KIND_LEADER_PROPOSAL,
+  SET_KIND_ECHO_RESULT,
+};
+
+enum DiffKind
+{
+  DIFF_KIND_NONE = 0,
+  DIFF_KIND_LEADER_PROPOSAL,
+  DIFF_KIND_LEADER_CONSENSUS,
+  DIFF_KIND_GRADECAST_RESULT,
+};
+
+enum RfnKind
+{
+  RFN_KIND_NONE = 0,
+  RFN_KIND_ECHO,
+  RFN_KIND_CONFIRM,
+  RFN_KIND_GRADECAST_RESULT
+};
+
+
 GNUNET_NETWORK_STRUCT_BEGIN
 
 /**
- * Tuple of integers that together
- * identify a task uniquely.
+ * Tuple of integers that together identify a task uniquely.
  */
 struct TaskKey
 {
@@ -102,8 +146,14 @@ struct TaskKey
 
 struct SetKey
 {
-  int set_kind GNUNET_PACKED;
+  enum SetKind set_kind GNUNET_PACKED;
+  /**
+   * Repetition counter.
+   */
   int k1 GNUNET_PACKED;
+  /**
+   * Leader (or 0).
+   */
   int k2 GNUNET_PACKED;
 };
 
@@ -112,9 +162,9 @@ struct SetEntry
 {
   struct SetKey key;
   struct GNUNET_SET_Handle *h;
+
   /**
-   * GNUNET_YES if the set resulted
-   * from applying a referendum with contested
+   * #GNUNET_YES if the set resulted from applying a referendum with contested
    * elements.
    */
   int is_contested;
@@ -123,14 +173,16 @@ struct SetEntry
 
 struct DiffKey
 {
-  int diff_kind GNUNET_PACKED;
+  enum DiffKind diff_kind GNUNET_PACKED;
+
   int k1 GNUNET_PACKED;
+
   int k2 GNUNET_PACKED;
 };
 
 struct RfnKey
 {
-  int rfn_kind GNUNET_PACKED;
+  enum RfnKind rfn_kind GNUNET_PACKED;
   int k1 GNUNET_PACKED;
   int k2 GNUNET_PACKED;
 };
@@ -138,52 +190,6 @@ struct RfnKey
 
 GNUNET_NETWORK_STRUCT_END
 
-enum PhaseKind
-{
-  PHASE_KIND_ALL_TO_ALL,
-  PHASE_KIND_ALL_TO_ALL_2,
-  PHASE_KIND_GRADECAST_LEADER,
-  PHASE_KIND_GRADECAST_ECHO,
-  PHASE_KIND_GRADECAST_ECHO_GRADE,
-  PHASE_KIND_GRADECAST_CONFIRM,
-  PHASE_KIND_GRADECAST_CONFIRM_GRADE,
-  /**
-   * Apply a repetition of the all-to-all
-   * gradecast to the current set.
-   */
-  PHASE_KIND_APPLY_REP,
-  PHASE_KIND_FINISH,
-};
-
-
-enum SetKind
-{
-  SET_KIND_NONE = 0,
-  SET_KIND_CURRENT,
-  /**
-   * Last result set from a gradecast
-   */
-  SET_KIND_LAST_GRADECAST,
-  SET_KIND_LEADER_PROPOSAL,
-  SET_KIND_ECHO_RESULT,
-};
-
-enum DiffKind
-{
-  DIFF_KIND_NONE = 0,
-  DIFF_KIND_LEADER_PROPOSAL,
-  DIFF_KIND_LEADER_CONSENSUS,
-  DIFF_KIND_GRADECAST_RESULT,
-};
-
-enum RfnKind
-{
-  RFN_KIND_NONE = 0,
-  RFN_KIND_ECHO,
-  RFN_KIND_CONFIRM,
-  RFN_KIND_GRADECAST_RESULT
-};
-
 
 struct SetOpCls
 {
@@ -216,9 +222,13 @@ union TaskFuncCls
   struct FinishCls finish;
 };
 
+
 struct TaskEntry;
 
-typedef void (*TaskFunc) (struct TaskEntry *task);
+
+typedef void
+(*TaskFunc) (struct TaskEntry *task);
+
 
 /*
  * Node in the consensus task graph.
@@ -277,14 +287,12 @@ struct Step
   unsigned int subordinates_cap;
 
   /**
-   * Counter for the prerequisites of
-   * this step.
+   * Counter for the prerequisites of this step.
    */
   size_t pending_prereq;
 
-  /*
-   * Task that will run this step despite
-   * any pending prerequisites.
+  /**
+   * Task that will run this step despite any pending prerequisites.
    */
   struct GNUNET_SCHEDULER_Task *timeout_task;
 
@@ -292,28 +300,23 @@ struct Step
 
   unsigned int is_finished;
 
-  /*
-   * Synchrony round of the task.
-   * Determines the deadline for the task.
+  /**
+   * Synchrony round of the task.  Determines the deadline for the task.
    */
   unsigned int round;
 
   /**
-   * Human-readable name for
-   * the task, used for debugging.
+   * Human-readable name for the task, used for debugging.
    */
   char *debug_name;
 
   /**
-   * When we're doing an early finish, how should this step be
-   * treated?
-   * If GNUNET_YES, the step will be marked as finished
-   * without actually running its tasks.
-   * Otherwise, the step will still be run even after
-   * an early finish.
+   * When we're doing an early finish, how should this step be treated?  If
+   * #GNUNET_YES, the step will be marked as finished without actually running
+   * its tasks.  Otherwise, the step will still be run even after an early
+   * finish.
    *
-   * Note that a task may never be finished early if
-   * it is already running.
+   * Note that a task may never be finished early if it is already running.
    */
   int early_finishable;
 };
@@ -323,14 +326,13 @@ struct RfnElementInfo
 {
   const struct GNUNET_SET_Element *element;
 
-  /*
-   * GNUNET_YES if the peer votes for the proposal.
+  /**
+   * #GNUNET_YES if the peer votes for the proposal.
    */
   int *votes;
 
   /**
-   * Proposal for this element,
-   * can only be VOTE_ADD or VOTE_REMOVE.
+   * Proposal for this element, can only be #VOTE_ADD or #VOTE_REMOVE.
    */
   enum ReferendumVote proposal;
 };
@@ -638,7 +640,7 @@ debug_str_element (const struct GNUNET_SET_Element *el)
 
 
 static const char *
-debug_str_task_key (struct TaskKey *tk)
+debug_str_task_key (const struct TaskKey *tk)
 {
   static char buf[256];
 
@@ -652,7 +654,7 @@ debug_str_task_key (struct TaskKey *tk)
 
 
 static const char *
-debug_str_diff_key (struct DiffKey *dk)
+debug_str_diff_key (const struct DiffKey *dk)
 {
   static char buf[256];
 
@@ -671,8 +673,9 @@ debug_str_set_key (const struct SetKey *sk)
 
   snprintf (buf, sizeof(buf),
             "SetKey kind=%s, k1=%d, k2=%d",
-            setname (sk->set_kind), sk->k1, sk->k2);
-
+            setname (sk->set_kind),
+            sk->k1,
+            sk->k2);
   return buf;
 }
 
@@ -684,8 +687,9 @@ debug_str_rfn_key (const struct RfnKey *rk)
 
   snprintf (buf, sizeof(buf),
             "RfnKey kind=%s, k1=%d, k2=%d",
-            rfnname (rk->rfn_kind), rk->k1, rk->k2);
-
+            rfnname (rk->rfn_kind),
+            rk->k1,
+            rk->k2);
   return buf;
 }
 
@@ -730,13 +734,15 @@ send_to_client_iter (void *cls,
                 session->local_peer_idx,
                 debug_str_element (element));
 
-    ev = GNUNET_MQ_msg_extra (m, element->size - sizeof(struct
-                                                        ConsensusElement),
+    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);
+    GNUNET_memcpy (&m[1],
+                   &ce[1],
+                   element->size - sizeof(struct ConsensusElement));
+    GNUNET_MQ_send (session->client_mq,
+                    ev);
   }
   else
   {
@@ -745,14 +751,16 @@ send_to_client_iter (void *cls,
                 session->local_peer_idx);
     ev = GNUNET_MQ_msg_header (
       GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE);
-    GNUNET_MQ_send (session->client_mq, ev);
+    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,
+            const struct SetKey *key)
 {
   struct GNUNET_HashCode hash;
 
@@ -762,13 +770,17 @@ lookup_set (struct ConsensusSession *session, struct SetKey *key)
               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_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,
+             const struct DiffKey *key)
 {
   struct GNUNET_HashCode hash;
 
@@ -776,15 +788,18 @@ lookup_diff (struct ConsensusSession *session, struct DiffKey *key)
               "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_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,
+            const struct RfnKey *key)
 {
   struct GNUNET_HashCode hash;
 
@@ -792,10 +807,12 @@ lookup_rfn (struct ConsensusSession *session, struct RfnKey *key)
               "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_CRYPTO_hash (key,
+                      sizeof(struct RfnKey),
+                      &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->rfnmap,
+                                            &hash);
 }
 
 
@@ -829,7 +846,8 @@ diff_insert (struct DiffEntry *diff,
     di->element = GNUNET_SET_element_dup (element);
     GNUNET_assert (GNUNET_OK ==
                    GNUNET_CONTAINER_multihashmap_put (diff->changes,
-                                                      &hash, di,
+                                                      &hash,
+                                                      di,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
   }
 
@@ -860,11 +878,10 @@ rfn_contest (struct ReferendumEntry *rfn,
 static uint16_t
 rfn_noncontested (struct ReferendumEntry *rfn)
 {
-  uint16_t i;
   uint16_t ret;
 
   ret = 0;
-  for (i = 0; i < rfn->num_peers; i++)
+  for (uint16_t i = 0; i < rfn->num_peers; i++)
     if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO ==
                                                   rfn->peer_contested[i]))
       ret++;
@@ -993,7 +1010,8 @@ set_result_cb (void *cls,
 
   if (SET_KIND_NONE != setop->output_set.set_kind)
   {
-    output_set = lookup_set (session, &setop->output_set);
+    output_set = lookup_set (session,
+                             &setop->output_set);
     GNUNET_assert (NULL != output_set);
   }
 
@@ -1226,8 +1244,8 @@ 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))
   {
@@ -1360,8 +1378,7 @@ cleanup:
 
 
 /**
- * Commit the appropriate set for a
- * task.
+ * Commit the appropriate set for a task.
  */
 static void
 commit_set (struct ConsensusSession *session,
@@ -1379,6 +1396,7 @@ commit_set (struct ConsensusSession *session,
   {
     struct GNUNET_SET_Element element;
     struct ConsensusElement ce = { 0 };
+
     ce.marker = CONSENSUS_MARKER_CONTESTED;
     element.data = &ce;
     element.size = sizeof(struct ConsensusElement);
@@ -1405,7 +1423,6 @@ commit_set (struct ConsensusSession *session,
 
 #ifdef EVIL
   {
-    unsigned int i;
     struct Evilness evil;
 
     get_evilness (session, &evil);
@@ -1444,7 +1461,7 @@ commit_set (struct ConsensusSession *session,
         GNUNET_SET_commit (setop->op, set->h);
         break;
       }
-      for (i = 0; i < evil.num; i++)
+      for (unsigned int i = 0; i < evil.num; i++)
       {
         struct GNUNET_SET_Element element;
         struct ConsensusStuffedElement se = {
@@ -1504,12 +1521,14 @@ commit_set (struct ConsensusSession *session,
       }
       else
       {
-        GNUNET_SET_commit (setop->op, set->h);
+        GNUNET_SET_commit (setop->op,
+                           set->h);
       }
       break;
 
     case EVILNESS_NONE:
-      GNUNET_SET_commit (setop->op, set->h);
+      GNUNET_SET_commit (setop->op,
+                         set->h);
       break;
     }
   }
@@ -1536,11 +1555,12 @@ put_diff (struct ConsensusSession *session,
 {
   struct GNUNET_HashCode hash;
 
-  GNUNET_assert (NULL != diff);
-
-  GNUNET_CRYPTO_hash (&diff->key, sizeof(struct DiffKey), &hash);
+  GNUNET_CRYPTO_hash (&diff->key,
+                      sizeof(struct DiffKey),
+                      &hash);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (session->diffmap, &hash,
+                 GNUNET_CONTAINER_multihashmap_put (session->diffmap,
+                                                    &hash,
                                                     diff,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
@@ -1553,14 +1573,16 @@ put_set (struct ConsensusSession *session,
   struct GNUNET_HashCode hash;
 
   GNUNET_assert (NULL != set->h);
-
   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_CRYPTO_hash (&set->key,
+                      sizeof(struct SetKey),
+                      &hash);
   GNUNET_assert (GNUNET_SYSERR !=
-                 GNUNET_CONTAINER_multihashmap_put (session->setmap, &hash, set,
+                 GNUNET_CONTAINER_multihashmap_put (session->setmap,
+                                                    &hash,
+                                                    set,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
 }
 
@@ -1573,7 +1595,9 @@ put_rfn (struct ConsensusSession *session,
 
   GNUNET_CRYPTO_hash (&rfn->key, sizeof(struct RfnKey), &hash);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (session->rfnmap, &hash, rfn,
+                 GNUNET_CONTAINER_multihashmap_put (session->rfnmap,
+                                                    &hash,
+                                                    rfn,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
 
@@ -1616,18 +1640,20 @@ apply_diff_to_rfn (struct DiffEntry *diff,
 }
 
 
-struct DiffEntry *
-diff_create ()
+static struct DiffEntry *
+diff_create (void)
 {
   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 *
+#if 0
+static struct DiffEntry *
 diff_compose (struct DiffEntry *diff_1,
               struct DiffEntry *diff_2)
 {
@@ -1638,22 +1664,26 @@ diff_compose (struct DiffEntry *diff_1,
   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))
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
   {
-    diff_insert (diff_new, di->weight, di->element);
+    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))
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
   {
-    diff_insert (diff_new, di->weight, di->element);
+    diff_insert (diff_new,
+                 di->weight,
+                 di->element);
   }
   GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
@@ -1661,6 +1691,9 @@ diff_compose (struct DiffEntry *diff_1,
 }
 
 
+#endif
+
+
 struct ReferendumEntry *
 rfn_create (uint16_t size)
 {
@@ -1701,14 +1734,13 @@ rfn_majority (const struct ReferendumEntry *rfn,
 {
   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));
 
-  for (i = 0; i < rfn->num_peers; i++)
+  for (uint16_t i = 0; i < rfn->num_peers; i++)
   {
     if (GNUNET_NO == rfn->peer_commited[i])
       continue;
@@ -1739,7 +1771,8 @@ struct SetCopyCls
 
 
 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;
@@ -1821,8 +1854,6 @@ set_mutation_done (void *cls)
 static void
 try_finish_step_early (struct Step *step)
 {
-  unsigned int i;
-
   if (GNUNET_YES == step->is_running)
     return;
   if (GNUNET_YES == step->is_finished)
@@ -1838,7 +1869,7 @@ try_finish_step_early (struct Step *step)
               step->debug_name);
 #endif
 
-  for (i = 0; i < step->subordinates_len; i++)
+  for (unsigned int i = 0; i < step->subordinates_len; i++)
   {
     GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
     step->subordinates[i]->pending_prereq--;
@@ -1859,8 +1890,6 @@ try_finish_step_early (struct Step *step)
 static void
 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);
@@ -1872,7 +1901,7 @@ finish_step (struct Step *step)
               step->subordinates_len);
 #endif
 
-  for (i = 0; i < step->subordinates_len; i++)
+  for (unsigned int i = 0; i < step->subordinates_len; i++)
   {
     GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
     step->subordinates[i]->pending_prereq--;
@@ -1918,7 +1947,9 @@ task_start_apply_round (struct TaskEntry *task)
   set_out = lookup_set (session, &sk_out);
   if (NULL == set_out)
   {
-    create_set_copy_for_task (task, &sk_in, &sk_out);
+    create_set_copy_for_task (task,
+                              &sk_in,
+                              &sk_out);
     return;
   }
 
@@ -2162,7 +2193,9 @@ task_start_reconcile (struct TaskEntry *task)
        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);
+      create_set_copy_for_task (task,
+                                &setop->input_set,
+                                &setop->output_set);
       return;
     }
   }
@@ -2212,11 +2245,8 @@ task_start_reconcile (struct TaskEntry *task)
                 "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.header.size = htons (sizeof(rcm));
     rcm.kind = htons (task->key.kind);
     rcm.peer1 = htons (task->key.peer1);
     rcm.peer2 = htons (task->key.peer2);
@@ -2227,8 +2257,9 @@ task_start_reconcile (struct TaskEntry *task)
     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));
+                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 } },
@@ -2286,15 +2317,17 @@ task_start_eval_echo (struct TaskEntry *task)
   output_set = lookup_set (session, &sk_out);
   if (NULL == output_set)
   {
-    create_set_copy_for_task (task, &sk_in, &sk_out);
+    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);
+
     last_set->h = output_set->h;
     last_set->key = (struct SetKey) { SET_KIND_LAST_GRADECAST };
     put_set (session, last_set);
@@ -2306,13 +2339,10 @@ task_start_eval_echo (struct TaskEntry *task)
 
   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);
-
   GNUNET_assert (NULL != input_rfn);
-
   iter = GNUNET_CONTAINER_multihashmap_iterator_create (
     input_rfn->rfn_elements);
   GNUNET_assert (NULL != iter);
@@ -2334,7 +2364,8 @@ task_start_eval_echo (struct TaskEntry *task)
          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;
+         round. *///
+      output_set->is_contested = GNUNET_YES;
     }
 
     switch (majority_vote)
@@ -2384,29 +2415,27 @@ 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_SET_iterate (final_set->h,
-                      send_to_client_iter,
+                      &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);
-
   task->start (task);
-
   task->is_started = GNUNET_YES;
 }
 
@@ -2427,8 +2456,6 @@ run_ready_steps (struct ConsensusSession *session)
     if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) &&
         (GNUNET_NO == step->is_finished))
     {
-      size_t i;
-
       GNUNET_assert (0 == step->finished_tasks);
 
 #ifdef GNUNET_EXTRA_LOGGING
@@ -2440,7 +2467,7 @@ run_ready_steps (struct ConsensusSession *session)
 #endif
 
       step->is_running = GNUNET_YES;
-      for (i = 0; i < step->tasks_len; i++)
+      for (size_t 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. */
@@ -2463,9 +2490,7 @@ finish_task (struct TaskEntry *task)
 {
   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,
@@ -2486,12 +2511,10 @@ 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++)
+  for (int i = 0; i < session->num_peers; i++)
     if (0 == GNUNET_memcmp (peer, &session->peers[i]))
       return i;
   return -1;
@@ -2528,14 +2551,15 @@ compute_global_id (struct ConsensusSession *session,
 
 
 /**
- * Compare two peer identities.
+ * Compare two peer identities (for qsort()).
  *
  * @param h1 some peer identity
  * @param h2 some peer identity
  * @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));
 }
@@ -2549,9 +2573,9 @@ 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];
@@ -2578,29 +2602,31 @@ initialize_session_peer_list (struct ConsensusSession *session,
                                      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));
+                 ntohl (join_msg->num_peers)
+                 * sizeof(struct GNUNET_PeerIdentity));
   qsort (session->peers,
          session->num_peers,
-         sizeof(struct GNUNET_PeerIdentity),
+         sizeof (struct GNUNET_PeerIdentity),
          &peer_id_cmp);
 }
 
 
 static struct TaskEntry *
-lookup_task (struct ConsensusSession *session,
-             struct TaskKey *key)
+lookup_task (const struct ConsensusSession *session,
+             const 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_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);
+  return GNUNET_CONTAINER_multihashmap_get (session->taskmap,
+                                            &hash);
 }
 
 
@@ -2695,7 +2721,7 @@ set_listen_cb (void *cls,
   task->cls.setop.op = GNUNET_SET_accept (request,
                                           GNUNET_SET_RESULT_SYMMETRIC,
                                           opts,
-                                          set_result_cb,
+                                          &set_result_cb,
                                           task);
 
   /* If the task hasn't been started yet,
@@ -2716,11 +2742,8 @@ put_task (struct GNUNET_CONTAINER_MultiHashMap *taskmap,
   struct Step *s;
 
   GNUNET_assert (NULL != t->step);
-
   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;
@@ -2739,9 +2762,13 @@ put_task (struct GNUNET_CONTAINER_MultiHashMap *taskmap,
   s->tasks[s->tasks_len] = t;
   s->tasks_len++;
 
-  GNUNET_CRYPTO_hash (&t->key, sizeof(struct TaskKey), &round_hash);
+  GNUNET_CRYPTO_hash (&t->key,
+                      sizeof(struct TaskKey),
+                      &round_hash);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (taskmap, &round_hash, t,
+                 GNUNET_CONTAINER_multihashmap_put (taskmap,
+                                                    &round_hash,
+                                                    t,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 }
 
@@ -2762,7 +2789,9 @@ 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;
@@ -2800,7 +2829,8 @@ 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. */
@@ -2839,7 +2869,9 @@ 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;
 
@@ -2855,8 +2887,7 @@ create_step (struct ConsensusSession *session, int round, int early_finishable)
 
 
 /**
- * Construct the task graph for a single
- * gradecast.
+ * Construct the task graph for a single gradecast.
  */
 static void
 construct_task_graph_gradecast (struct ConsensusSession *session,
@@ -2867,35 +2898,32 @@ construct_task_graph_gradecast (struct ConsensusSession *session,
 {
   uint16_t n = session->num_peers;
   uint16_t me = session->local_peer_idx;
-
   uint16_t p1;
   uint16_t p2;
-
   /* The task we're currently setting up. */
   struct TaskEntry task;
-
   struct Step *step;
   struct Step *prev_step;
-
   uint16_t round;
 
-  unsigned int k;
-
   round = step_before->round + 1;
 
   /* 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,
+  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 (unsigned int k = 0; k < n; k++)
     {
       if (k == me)
         continue;
@@ -2952,13 +2980,19 @@ construct_task_graph_gradecast (struct ConsensusSession *session,
   /* 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++)
+  for (unsigned int k = 0; k < n; k++)
   {
     p1 = k;
     p2 = me;
@@ -3001,7 +3035,7 @@ construct_task_graph_gradecast (struct ConsensusSession *session,
   step_depend_on (step, prev_step);
 
   /* gcast phase 3: confirmation and grading */
-  for (k = 0; k < n; k++)
+  for (unsigned int k = 0; k < n; k++)
   {
     p1 = k;
     p2 = me;
@@ -3050,22 +3084,15 @@ construct_task_graph (struct ConsensusSession *session)
 {
   uint16_t n = session->num_peers;
   uint16_t t = n / 3;
-
   uint16_t me = session->local_peer_idx;
-
   /* The task we're currently setting up. */
   struct TaskEntry task;
-
   /* Current leader */
   unsigned int lead;
-
   struct Step *step;
   struct Step *prev_step;
-
   unsigned int round = 0;
 
-  unsigned int i;
-
   // XXX: introduce first step,
   // where we wait for all insert acks
   // from the set service
@@ -3082,7 +3109,7 @@ construct_task_graph (struct ConsensusSession *session)
   step->debug_name = GNUNET_strdup ("all to all");
 #endif
 
-  for (i = 0; i < n; i++)
+  for (unsigned int i = 0; i < n; i++)
   {
     uint16_t p1;
     uint16_t p2;
@@ -3111,7 +3138,7 @@ construct_task_graph (struct ConsensusSession *session)
   step_depend_on (step, prev_step);
 
 
-  for (i = 0; i < n; i++)
+  for (unsigned int i = 0; i < n; i++)
   {
     uint16_t p1;
     uint16_t p2;
@@ -3140,7 +3167,7 @@ construct_task_graph (struct ConsensusSession *session)
   /* Byzantine union */
 
   /* sequential repetitions of the gradecasts */
-  for (i = 0; i < t + 1; i++)
+  for (unsigned int i = 0; i < t + 1; i++)
   {
     struct Step *step_rep_start;
     struct Step *step_rep_end;
@@ -3243,9 +3270,9 @@ handle_client_join (void *cls,
        NULL != other_session;
        other_session = other_session->next)
   {
-    if ((other_session != session) &&
-        (0 == GNUNET_CRYPTO_hash_cmp (&session->global_id,
-                                      &other_session->global_id)))
+    if ( (other_session != session) &&
+         (0 == GNUNET_CRYPTO_hash_cmp (&session->global_id,
+                                       &other_session->global_id)) )
       break;
   }
 
@@ -3262,9 +3289,9 @@ handle_client_join (void *cls,
               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_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_difference (session->conclude_start,
+                                                     session->conclude_deadline),
                 GNUNET_YES));
 
   session->set_listener
@@ -3309,13 +3336,6 @@ handle_client_join (void *cls,
 }
 
 
-static void
-client_insert_done (void *cls)
-{
-  // FIXME: implement
-}
-
-
 /**
  * Called when a client performs an insert operation.
  *
@@ -3352,19 +3372,13 @@ handle_client_insert (void *cls,
     GNUNET_SERVICE_client_drop (session->client);
     return;
   }
-
-  element_size = ntohs (msg->header.size) - sizeof(struct
-                                                   GNUNET_CONSENSUS_ElementMessage);
+  element_size = ntohs (msg->header.size) - sizeof(*msg);
   ce = GNUNET_malloc (sizeof(struct ConsensusElement) + element_size);
-  GNUNET_memcpy (&ce[1], &msg[1], element_size);
+  GNUNET_memcpy (&ce[1],
+                 &msg[1],
+                 element_size);
   ce->payload_type = msg->element_type;
 
-  struct GNUNET_SET_Element element = {
-    .element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT,
-    .size = sizeof(struct ConsensusElement) + element_size,
-    .data = ce,
-  };
-
   {
     struct SetKey key = { SET_KIND_CURRENT, 0, 0 };
     struct SetEntry *entry;
@@ -3376,19 +3390,25 @@ handle_client_insert (void *cls,
   }
 
   session->num_client_insert_pending++;
-  GNUNET_SET_add_element (initial_set,
-                          &element,
-                          &client_insert_done,
-                          session);
 
-#ifdef GNUNET_EXTRA_LOGGING
   {
+    struct GNUNET_SET_Element element = {
+      .element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT,
+      .size = sizeof(struct ConsensusElement) + element_size,
+      .data = ce,
+    };
+
+    GNUNET_SET_add_element (initial_set,
+                            &element,
+                            NULL,
+                            NULL);
+#ifdef GNUNET_EXTRA_LOGGING
     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);
 }
@@ -3513,10 +3533,10 @@ client_disconnect_cb (void *cls,
   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);
@@ -3528,8 +3548,8 @@ client_disconnect_cb (void *cls,
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN
-  ("consensus",
+GNUNET_SERVICE_MAIN (
+  "consensus",
   GNUNET_SERVICE_OPTION_NONE,
   &run,
   &client_connect_cb,
diff --git a/src/consensus/plugin_block_consensus.c b/src/consensus/plugin_block_consensus.c
index fb6da5bcd..cdac12ed5 100644
--- a/src/consensus/plugin_block_consensus.c
+++ b/src/consensus/plugin_block_consensus.c
@@ -58,13 +58,12 @@ block_plugin_consensus_evaluate (void *cls,
                                  const void *reply_block,
                                  size_t reply_block_size)
 {
-  if (reply_block_size < sizeof(struct ConsensusElement))
-    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-
   const struct ConsensusElement *ce = reply_block;
 
-  if ((0 != ce->marker) ||
-      (0 == ce->payload_type))
+  if (reply_block_size < sizeof(struct ConsensusElement))
+    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+  if ( (0 != ce->marker) ||
+       (0 == ce->payload_type) )
     return GNUNET_BLOCK_EVALUATION_OK_MORE;
 
   return GNUNET_BLOCK_evaluate (ctx,
@@ -75,8 +74,8 @@ block_plugin_consensus_evaluate (void *cls,
                                 xquery,
                                 xquery_size,
                                 &ce[1],
-                                reply_block_size - sizeof(struct
-                                                          ConsensusElement));
+                                reply_block_size
+                                - sizeof(struct ConsensusElement));
 }
 
 
diff --git a/src/gns/test_gns_proxy.c b/src/gns/test_gns_proxy.c
index 13764d520..579de774f 100644
--- a/src/gns/test_gns_proxy.c
+++ b/src/gns/test_gns_proxy.c
@@ -189,7 +189,7 @@ copy_buffer (void *ptr, size_t size, size_t nmemb, void *ctx)
 }
 
 
-static int
+static enum MHD_Result
 mhd_ahc (void *cls,
          struct MHD_Connection *connection,
          const char *url,
@@ -528,8 +528,6 @@ run (void *cls,
 int
 main (int argc, char *const *argv)
 {
-  char *tmp_argv;
-
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_uint16 ('p',
                                  "port",
@@ -559,7 +557,7 @@ main (int argc, char *const *argv)
   }
   if (GNUNET_OK !=
       GNUNET_STRINGS_get_utf8_args (argc, argv,
-                                    &argc, &tmp_argv))
+                                    &argc, &argv))
     return 2;
   GNUNET_log_setup ("gnunet-gns-proxy-test",
                     "WARNING",
@@ -570,7 +568,7 @@ main (int argc, char *const *argv)
                                        options,
                                        &run, NULL))
     return 1;
-  GNUNET_free (tmp_argv);
+  GNUNET_free_nz ((void*) argv);
   return global_ret;
 }
 
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index e542038d3..202abb7ac 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -99,6 +99,8 @@ gnunetinclude_HEADERS = \
   gnunet_secretsharing_service.h \
   gnunet_service_lib.h \
   gnunet_set_service.h \
+  gnunet_seti_service.h \
+  gnunet_setu_service.h \
   gnunet_signal_lib.h \
   gnunet_signatures.h \
   gnunet_socks.h \
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index efd696b36..085d7187f 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -619,7 +619,7 @@ GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
  * @param result where to store the hash code
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_hash_from_string2 (const char *enc,
                                  size_t enclen,
                                  struct GNUNET_HashCode *result);
diff --git a/src/include/gnunet_transport_communication_service.h b/src/include/gnunet_transport_communication_service.h
index ea6b95e2d..431b9a671 100644
--- a/src/include/gnunet_transport_communication_service.h
+++ b/src/include/gnunet_transport_communication_service.h
@@ -336,6 +336,14 @@ void
 GNUNET_TRANSPORT_communicator_address_remove (
   struct GNUNET_TRANSPORT_AddressIdentifier *ai);
 
+/**
+ * Notify transport service that this communicator no longer provides all its addresses for this peer.
+ *
+ * @param ch The communicator handle.
+ */
+void
+GNUNET_TRANSPORT_communicator_address_remove_all (
+                                                  struct GNUNET_TRANSPORT_CommunicatorHandle *ch);
 
 /**
  * The communicator asks the transport service to route a message via
diff --git a/src/reclaim/gnunet-reclaim.c b/src/reclaim/gnunet-reclaim.c
index ab281a645..b9306b802 100644
--- a/src/reclaim/gnunet-reclaim.c
+++ b/src/reclaim/gnunet-reclaim.c
@@ -862,7 +862,7 @@ main (int argc, char *const argv[])
                                gettext_noop ("List credentials for EGO"),
                                &list_credentials),
     GNUNET_GETOPT_option_string ('I',
-                                 "Credential ID",
+                                 "credential-id",
                                  "CREDENTIAL_ID",
                                  gettext_noop (
                                    "Credential to use for attribute"),
diff --git a/src/reclaim/plugin_reclaim_credential_jwt.c b/src/reclaim/plugin_reclaim_credential_jwt.c
index 148865223..6f52f3a4e 100644
--- a/src/reclaim/plugin_reclaim_credential_jwt.c
+++ b/src/reclaim/plugin_reclaim_credential_jwt.c
@@ -177,6 +177,8 @@ jwt_parse_attributes (void *cls,
   json_object_foreach (json_val, key, value) {
     if (0 == strcmp ("iss", key))
       continue;
+    if (0 == strcmp ("jti", key))
+      continue;
     if (0 == strcmp ("exp", key))
       continue;
     if (0 == strcmp ("iat", key))
diff --git a/src/seti/Makefile.am b/src/seti/Makefile.am
index b4980b670..522f33ece 100644
--- a/src/seti/Makefile.am
+++ b/src/seti/Makefile.am
@@ -37,7 +37,7 @@ gnunet_seti_profiler_LDADD = \
 
 gnunet_service_seti_SOURCES = \
  gnunet-service-seti.c \
- gnunet-service-set_protocol.h
+ gnunet-service-seti_protocol.h
 gnunet_service_seti_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/statistics/libgnunetstatistics.la \
diff --git a/src/setu/Makefile.am b/src/setu/Makefile.am
index b37ceba51..cc7711462 100644
--- a/src/setu/Makefile.am
+++ b/src/setu/Makefile.am
@@ -46,7 +46,7 @@ gnunet_setu_ibf_profiler_LDADD = \
   $(GN_LIBINTL)
 
 gnunet_service_setu_SOURCES = \
- gnunet-service-setu.c gnunet-service-setu.h \
+ gnunet-service-setu.c gnunet-service-setu_protocol.h \
  ibf.c ibf.h \
  gnunet-service-setu_strata_estimator.c gnunet-service-setu_strata_estimator.h \
  gnunet-service-setu_protocol.h
diff --git a/src/setu/test_setu.conf b/src/setu/test_setu.conf
new file mode 100644
index 000000000..4eaf3f0c0
--- /dev/null
+++ b/src/setu/test_setu.conf
@@ -0,0 +1,32 @@
+@INLINE@ ../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-set/
+
+[setu]
+START_ON_DEMAND = YES
+#PREFIX = valgrind --leak-check=full
+#PREFIX = gdbserver :1234
+OPTIONS = -L INFO
+
+[transport]
+PLUGINS = unix
+OPTIONS = -LERROR
+
+[nat]
+RETURN_LOCAL_ADDRESSES = YES
+DISABLEV6 = YES
+USE_LOCALADDR = YES
+
+[peerinfo]
+NO_IO = YES
+
+[nat]
+# Use addresses from the local network interfaces (inluding loopback, but also others)
+USE_LOCALADDR = YES
+
+# Disable IPv6 support
+DISABLEV6 = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index 880145424..59f42496a 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -308,6 +308,38 @@ struct TCPRekey
   struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 };
 
+/**
+ * Signature we use to verify that the ephemeral key was really chosen by
+ * the specified sender.
+ */
+struct TcpRekeySignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the TCP connection (TCP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the TCP connection (TCP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Ephemeral key used by the @e sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+};
 
 /**
  * TCP finish. Sender asks for the connection to be closed.
@@ -362,11 +394,6 @@ struct Queue
   struct GNUNET_PeerIdentity target;
 
   /**
-   * ID of listen task
-   */
-  struct GNUNET_SCHEDULER_Task *listen_task;
-
-  /**
    * Listen socket.
    */
   struct GNUNET_NETWORK_Handle *listen_sock;
@@ -606,11 +633,6 @@ struct ProtoQueue
   struct ProtoQueue *prev;
 
   /**
-   * ID of listen task
-   */
-  struct GNUNET_SCHEDULER_Task *listen_task;
-
-  /**
    * Listen socket.
    */
   struct GNUNET_NETWORK_Handle *listen_sock;
@@ -729,6 +751,11 @@ static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
 static struct GNUNET_CONTAINER_MultiPeerMap *queue_map;
 
 /**
+ * ListenTasks (map from socket to `struct ListenTask`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *lt_map;
+
+/**
  * Our public key.
  */
 static struct GNUNET_PeerIdentity my_identity;
@@ -784,6 +811,16 @@ struct Addresses *addrs_head;
 struct Addresses *addrs_tail;
 
 /**
+ * Head of DLL with ListenTasks.
+ */
+struct ListenTask *lts_head;
+
+/**
+ * Head of DLL with ListenTask.
+ */
+struct ListenTask *lts_tail;
+
+/**
  * Number of addresses in the DLL for register at NAT service.
  */
 int addrs_lens;
@@ -799,6 +836,16 @@ size_t unverified_size;
 static struct GNUNET_PEERSTORE_Handle *peerstore;
 
 /**
+ * A flag indicating we are already doing a shutdown.
+ */
+int shutdown_running = GNUNET_NO;
+
+/**
+ * The port the communicator should be assigned to.
+ */
+unsigned int bind_port;
+
+/**
  * We have been notified that our listen socket has something to
  * read. Do the read and reschedule this function to be called again
  * once more is available.
@@ -808,7 +855,6 @@ static struct GNUNET_PEERSTORE_Handle *peerstore;
 static void
 listen_cb (void *cls);
 
-
 /**
  * Functions with this signature are called whenever we need
  * to close a queue due to a disconnect or failure to
@@ -819,11 +865,14 @@ listen_cb (void *cls);
 static void
 queue_destroy (struct Queue *queue)
 {
-  struct GNUNET_MQ_Handle *mq;
-  struct ListenTask *lt;
-  lt = GNUNET_new (struct ListenTask);
-  lt->listen_sock = queue->listen_sock;
-  lt->listen_task = queue->listen_task;
+  struct ListenTask *lt = NULL;
+  struct GNUNET_HashCode h_sock;
+
+  GNUNET_CRYPTO_hash (queue->listen_sock,
+                      sizeof(queue->listen_sock),
+                      &h_sock);
+
+  lt =   GNUNET_CONTAINER_multihashmap_get (lt_map, &h_sock);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Disconnecting queue for peer `%s'\n",
@@ -858,11 +907,6 @@ queue_destroy (struct Queue *queue)
     GNUNET_PEERSTORE_iterate_cancel (queue->handshake_ack_monotime_get);
     queue->handshake_ack_monotime_get = NULL;
   }
-  if (NULL != (mq = queue->mq))
-  {
-    queue->mq = NULL;
-    GNUNET_MQ_destroy (mq);
-  }
   if (NULL != queue->qh)
   {
     GNUNET_TRANSPORT_communicator_mq_del (queue->qh);
@@ -885,7 +929,11 @@ queue_destroy (struct Queue *queue)
     GNUNET_SCHEDULER_cancel (queue->write_task);
     queue->write_task = NULL;
   }
-  GNUNET_NETWORK_socket_close (queue->sock);
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_close (queue->sock))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "closing socket failed\n");
+  }
   gcry_cipher_close (queue->in_cipher);
   gcry_cipher_close (queue->out_cipher);
   GNUNET_free (queue->address);
@@ -894,12 +942,18 @@ queue_destroy (struct Queue *queue)
   else
     GNUNET_free (queue);
 
-  if (NULL == lt->listen_task)
+  if ((! shutdown_running) && (NULL == lt->listen_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "add read net listen\n");
     lt->listen_task = GNUNET_SCHEDULER_add_read_net (
       GNUNET_TIME_UNIT_FOREVER_REL,
       lt->listen_sock,
       &listen_cb,
       lt);
+  }
+  else
+    GNUNET_free (lt);
 }
 
 
@@ -1001,6 +1055,13 @@ core_read_finished_cb (void *cls, int success)
                               "# messages lost in communicator API towards CORE",
                               1,
                               GNUNET_NO);
+  if (NULL == queue)
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "backpressure %u\n",
+              queue->backpressure);
+
   queue->backpressure--;
   /* handle deferred queue destruction */
   if ((queue->destroyed) && (0 == queue->backpressure))
@@ -1008,15 +1069,18 @@ core_read_finished_cb (void *cls, int success)
     GNUNET_free (queue);
     return;
   }
-  reschedule_queue_timeout (queue);
-  /* possibly unchoke reading, now that CORE made progress */
-  if (NULL == queue->read_task)
-    queue->read_task =
-      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
-                                       queue->timeout),
-                                     queue->sock,
-                                     &queue_read,
-                                     queue);
+  else if (GNUNET_YES != queue->destroyed)
+  {
+    reschedule_queue_timeout (queue);
+    /* possibly unchoke reading, now that CORE made progress */
+    if (NULL == queue->read_task)
+      queue->read_task =
+        GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
+                                         queue->timeout),
+                                       queue->sock,
+                                       &queue_read,
+                                       queue);
+  }
 }
 
 
@@ -1219,13 +1283,34 @@ rekey_monotime_cb (void *cls,
 static void
 do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
 {
-  struct TcpHandshakeSignature thp;
+  struct TcpRekeySignature thp;
+
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
   thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_rekey size %u\n",
+              thp.purpose.size);
   thp.sender = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&queue->target.public_key));
   thp.receiver = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
   thp.ephemeral = rekey->ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
   thp.monotonic_time = rekey->monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
+  GNUNET_assert (ntohl ((&thp)->purpose.size) == sizeof (*(&thp)));
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY,
                                   &thp,
@@ -1359,7 +1444,7 @@ try_handle_plaintext (struct Queue *queue)
   if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Already received data of size %u bigger than KX size %u!\n",
+                "Already received data of size %lu bigger than KX size %lu!\n",
                 unverified_size,
                 INITIAL_CORE_KX_SIZE);
     GNUNET_break_op (0);
@@ -1636,6 +1721,8 @@ tcp_address_to_sockaddr_numeric_v6 (socklen_t *sock_len, struct sockaddr_in6 v6,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
 #endif
+  v6.sin6_flowinfo = 0;
+  v6.sin6_scope_id = 0;
   in = GNUNET_memdup (&v6, sizeof(v6));
   *sock_len = sizeof(struct sockaddr_in6);
 
@@ -1739,11 +1826,19 @@ extract_address (const char *bindto)
   char *cp;
   char *rest = NULL;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address with bindto %s\n",
+              bindto);
+
   if (NULL == bindto)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "bindto is NULL\n");
 
   cp = GNUNET_strdup (bindto);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address 2\n");
+
   start = cp;
   if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
   {
@@ -1763,7 +1858,11 @@ extract_address (const char *bindto)
     }
   }
 
-  GNUNET_free (cp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address 3\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address with start %s\n",
+              start);
 
   return start;
 }
@@ -1865,10 +1964,25 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
   // cp = GNUNET_strdup (bindto);
   start = extract_address (bindto);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "start %s\n",
+              start);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "!bindto %s\n",
+              bindto);
+
+
+
   if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
   {
     // colon = strrchr (cp, ':');
     port = extract_port (bindto);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "port %u\n",
+                port);
+
     in = tcp_address_to_sockaddr_numeric_v4 (sock_len, v4, port);
   }
   else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
@@ -1877,6 +1991,11 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
     port = extract_port (bindto);
     in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
   }
+  else{
+    GNUNET_assert (0);
+  }
+
+  // GNUNET_free (start);
 
   return in;
 }
@@ -1913,7 +2032,7 @@ static void
 inject_rekey (struct Queue *queue)
 {
   struct TCPRekey rekey;
-  struct TcpHandshakeSignature thp;
+  struct TcpRekeySignature thp;
 
   GNUNET_assert (0 == queue->pwrite_off);
   memset (&rekey, 0, sizeof(rekey));
@@ -1925,10 +2044,26 @@ inject_rekey (struct Queue *queue)
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
   thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "inject_rekey size %u\n",
+              thp.purpose.size);
   thp.sender = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
   thp.receiver = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
   thp.ephemeral = rekey.ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
   thp.monotonic_time = rekey.monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
   GNUNET_CRYPTO_eddsa_sign (my_private_key,
                             &thp,
                             &rekey.sender_sig);
@@ -2004,10 +2139,11 @@ queue_write (void *cls)
     queue->cwrite_off += queue->pwrite_off;
     queue->pwrite_off = 0;
   }
-  if ((0 == queue->pwrite_off) &&
-      ((0 == queue->rekey_left_bytes) ||
-       (0 ==
-        GNUNET_TIME_absolute_get_remaining (queue->rekey_time).rel_value_us)))
+  if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) &&
+                                 ((0 == queue->rekey_left_bytes) ||
+                                  (0 ==
+                                   GNUNET_TIME_absolute_get_remaining (
+                                     queue->rekey_time).rel_value_us))))
   {
     inject_rekey (queue);
   }
@@ -2403,11 +2539,6 @@ decrypt_and_check_tc (struct Queue *queue,
 static void
 free_proto_queue (struct ProtoQueue *pq)
 {
-  if (NULL != pq->listen_task)
-  {
-    GNUNET_SCHEDULER_cancel (pq->listen_task);
-    pq->listen_task = NULL;
-  }
   if (NULL != pq->listen_sock)
   {
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pq->listen_sock));
@@ -2526,7 +2657,6 @@ proto_read_kx (void *cls)
   queue->address = pq->address; /* steals reference */
   queue->address_len = pq->address_len;
   queue->target = tc.sender;
-  queue->listen_task = pq->listen_task;
   queue->listen_sock = pq->listen_sock;
   queue->sock = pq->sock;
 
@@ -2569,6 +2699,9 @@ listen_cb (void *cls)
   struct ProtoQueue *pq;
   struct ListenTask *lt;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "listen_cb\n");
+
   lt = cls;
 
   lt->listen_task = NULL;
@@ -2707,7 +2840,7 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
   struct Queue *queue;
   const char *path;
   struct sockaddr *in;
-  socklen_t in_len;
+  socklen_t in_len = 0;
   struct GNUNET_NETWORK_Handle *sock;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2729,6 +2862,10 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
     return GNUNET_SYSERR;
   }
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "in %s\n",
+              GNUNET_a2s (in, in_len));
+
   sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP);
   if (NULL == sock)
   {
@@ -2778,6 +2915,36 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
 }
 
 /**
+ * Iterator over all ListenTasks to clean up.
+ *
+ * @param cls NULL
+ * @param key unused
+ * @param value the ListenTask to cancel.
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_lt_delete_it (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  struct ListenTask *lt = value;
+
+  (void) cls;
+  (void) key;
+  if (NULL != lt->listen_task)
+  {
+    GNUNET_SCHEDULER_cancel (lt->listen_task);
+    lt->listen_task = NULL;
+  }
+  if (NULL != lt->listen_sock)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (lt->listen_sock));
+    lt->listen_sock = NULL;
+  }
+  return GNUNET_OK;
+}
+
+/**
  * Iterator over all message queues to clean up.
  *
  * @param cls NULL
@@ -2798,7 +2965,6 @@ get_queue_delete_it (void *cls,
   return GNUNET_OK;
 }
 
-
 /**
  * Shutdown the UNIX communicator.
  *
@@ -2807,6 +2973,15 @@ get_queue_delete_it (void *cls,
 static void
 do_shutdown (void *cls)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown %s!\n",
+              shutdown_running ? "running" : "not running");
+
+  if (GNUNET_YES == shutdown_running)
+    return;
+  else
+    shutdown_running = GNUNET_YES;
+
   while (NULL != proto_head)
     free_proto_queue (proto_head);
   if (NULL != nat)
@@ -2814,8 +2989,10 @@ do_shutdown (void *cls)
     GNUNET_NAT_unregister (nat);
     nat = NULL;
   }
+  GNUNET_CONTAINER_multihashmap_iterate (lt_map, &get_lt_delete_it, NULL);
   GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL);
   GNUNET_CONTAINER_multipeermap_destroy (queue_map);
+  GNUNET_TRANSPORT_communicator_address_remove_all (ch);
   if (NULL != ch)
   {
     GNUNET_TRANSPORT_communicator_disconnect (ch);
@@ -2836,6 +3013,18 @@ do_shutdown (void *cls)
     GNUNET_NT_scanner_done (is);
     is = NULL;
   }
+  if (NULL != peerstore)
+  {
+    GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
+    peerstore = NULL;
+  }
+  if (NULL != resolve_request_handle)
+  {
+    GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    resolve_request_handle = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown done!\n");
 }
 
 
@@ -2886,6 +3075,11 @@ nat_address_cb (void *cls,
   char *my_addr;
   struct GNUNET_TRANSPORT_AddressIdentifier *ai;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "nat address cb %s %s\n",
+              add_remove ? "add" : "remove",
+              GNUNET_a2s (addr, addrlen));
+
   if (GNUNET_YES == add_remove)
   {
     enum GNUNET_NetworkType nt;
@@ -2912,6 +3106,35 @@ nat_address_cb (void *cls,
 }
 
 /**
+ * This method adds addresses to the DLL, that are later register at the NAT service.
+ */
+static void
+add_addr (struct sockaddr *in, socklen_t in_len)
+{
+
+  struct Addresses *saddrs;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  saddrs = GNUNET_new (struct Addresses);
+  saddrs->addr = in;
+  saddrs->addr_len = in_len;
+  GNUNET_CONTAINER_DLL_insert (addrs_head, addrs_tail, saddrs);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "after add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (saddrs->addr, saddrs->addr_len));
+
+  addrs_lens++;
+}
+
+/**
  * This method launch network interactions for each address we like to bind to.
  *
  * @param addr The address we will listen to.
@@ -2919,13 +3142,14 @@ nat_address_cb (void *cls,
  * @return GNUNET_SYSERR in case of error. GNUNET_OK in case we are successfully listen to the address.
  */
 static int
-init_socket (const struct sockaddr *addr,
+init_socket (struct sockaddr *addr,
              socklen_t in_len)
 {
   struct sockaddr_storage in_sto;
   socklen_t sto_len;
   struct GNUNET_NETWORK_Handle *listen_sock;
   struct ListenTask *lt;
+  struct GNUNET_HashCode h_sock;
 
   if (NULL == addr)
   {
@@ -2977,13 +3201,12 @@ init_socket (const struct sockaddr *addr,
     sto_len = in_len;
   }
 
-  addr = (struct sockaddr *) &in_sto;
+  // addr = (struct sockaddr *) &in_sto;
   in_len = sto_len;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Bound to `%s'\n",
               GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
   stats = GNUNET_STATISTICS_create ("C-TCP", cfg);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
   if (NULL == is)
     is = GNUNET_NT_scanner_init ();
@@ -3012,6 +3235,27 @@ init_socket (const struct sockaddr *addr,
                                                    &listen_cb,
                                                    lt);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating hash\n");
+  GNUNET_CRYPTO_hash (lt->listen_sock,
+                      sizeof(lt->listen_sock),
+                      &h_sock);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map\n");
+  if (NULL == lt_map)
+    lt_map = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map entry\n");
+  GNUNET_CONTAINER_multihashmap_put (lt_map,
+                                     &h_sock,
+                                     lt,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "map entry created\n");
+
   if (NULL == queue_map)
     queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
 
@@ -3034,6 +3278,7 @@ init_socket (const struct sockaddr *addr,
     return GNUNET_SYSERR;
   }
 
+  add_addr (addr, in_len);
   return GNUNET_OK;
 
 }
@@ -3050,6 +3295,10 @@ nat_register ()
   int i;
   struct Addresses *pos;
 
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "starting nat register!\n");
+
   i = 0;
   saddrs = GNUNET_malloc ((addrs_lens + 1) * sizeof(struct sockaddr *));
 
@@ -3058,9 +3307,12 @@ nat_register ()
   for (pos = addrs_head; NULL != pos; pos = pos->next)
   {
 
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "registering address %s\n",
+                GNUNET_a2s (addrs_head->addr, addrs_head->addr_len));
+
     saddr_lens[i] = addrs_head->addr_len;
-    saddrs[i] = GNUNET_malloc (saddr_lens[i]);
-    saddrs[i] = addrs_head->addr;
+    saddrs[i] = GNUNET_memdup (addrs_head->addr, saddr_lens[i]);
 
     i++;
 
@@ -3078,8 +3330,8 @@ nat_register ()
 
   i = 0;
 
-  /*for (i = addrs_lens - 1; i >= 0; i--)
-    GNUNET_free (saddrs[i]);*/
+  for (i = addrs_lens - 1; i >= 0; i--)
+    GNUNET_free (saddrs[i]);
   GNUNET_free (saddrs);
   GNUNET_free (saddr_lens);
 
@@ -3093,22 +3345,6 @@ nat_register ()
 }
 
 /**
- * This method adds addresses to the DLL, that are later register at the NAT service.
- */
-static void
-add_addr (struct sockaddr *in, socklen_t in_len)
-{
-
-  struct Addresses *saddrs;
-
-  saddrs = GNUNET_new (struct Addresses);
-  saddrs->addr = in;
-  saddrs->addr_len = in_len;
-  GNUNET_CONTAINER_DLL_insert (addrs_head, addrs_tail, saddrs);
-  addrs_lens++;
-}
-
-/**
  * This method is the callback called by the resolver API, and wraps method init_socket.
  *
  * @param cls The port we will bind to.
@@ -3123,22 +3359,19 @@ init_socket_resolv (void *cls,
   struct sockaddr_in *v4;
   struct sockaddr_in6 *v6;
   struct sockaddr *in;
-  unsigned int *port;
 
-  port = cls;
+  (void) cls;
   if (NULL  != addr)
   {
     if (AF_INET == addr->sa_family)
     {
       v4 = (struct sockaddr_in *) addr;
-      in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, *port);// _global);
-      add_addr (in, in_len);
+      in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, bind_port);// _global);
     }
     else if (AF_INET6 == addr->sa_family)
     {
       v6 = (struct sockaddr_in6 *) addr;
-      in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, *port);// _global);
-      add_addr (in, in_len);
+      in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, bind_port);// _global);
     }
     else
     {
@@ -3149,14 +3382,20 @@ init_socket_resolv (void *cls,
                   AF_INET6);
       return;
     }
-    init_socket (in,
-                 in_len);
+    init_socket (in, in_len);
   }
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Address is NULL. This might be an error or the resolver finished resolving.\n");
+    if (NULL == addrs_head)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Resolver finished resolving, but we do not listen to an address!.\n");
+      return;
+    }
     nat_register ();
+
   }
 }
 
@@ -3221,12 +3460,11 @@ run (void *cls,
     return;
   }
 
-  // cp = GNUNET_strdup (bindto);
-  start = extract_address (bindto);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
-  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
+  if (1 == sscanf (bindto, "%u%1s", &bind_port, dummy))
   {
-    po = tcp_address_to_sockaddr_port_only (bindto, &port);
+    po = tcp_address_to_sockaddr_port_only (bindto, &bind_port);
 
     addr_len_ipv4 = po->addr_len_ipv4;
 
@@ -3238,46 +3476,55 @@ run (void *cls,
     if (NULL != po->addr_ipv4)
     {
       init_socket (po->addr_ipv4, addr_len_ipv4);
-      add_addr (po->addr_ipv4, addr_len_ipv4);
     }
 
     if (NULL != po->addr_ipv6)
     {
       addr_len_ipv6 = po->addr_len_ipv6;
       init_socket (po->addr_ipv6, addr_len_ipv6);
-      add_addr (po->addr_ipv6, addr_len_ipv6);
     }
 
+    GNUNET_free (po);
     nat_register ();
+    GNUNET_free (bindto);
+
+    return;
   }
-  else if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
+
+  start = extract_address (bindto);
+
+  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
   {
-    port = extract_port (bindto);
+    bind_port = extract_port (bindto);
 
-    in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, port);
+    in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
     init_socket (in, in_len);
-    add_addr (in, in_len);
     nat_register ();
+    GNUNET_free (bindto);
+
+    return;
   }
-  else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+
+  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
   {
-    port = extract_port (bindto);
-    in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, port);
+    bind_port = extract_port (bindto);
+    in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
     init_socket (in, in_len);
-    add_addr (in, in_len);
     nat_register ();
-  }
-  else
-  {
-    port = extract_port (bindto);
+    GNUNET_free (bindto);
 
-    resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto, ":",
-                                                               &rest),
-                                                     AF_UNSPEC,
-                                                     GNUNET_TIME_UNIT_MINUTES,
-                                                     &init_socket_resolv,
-                                                     &port);
+    return;
   }
+
+
+  bind_port = extract_port (bindto);
+
+  resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto, ":",
+                                                             &rest),
+                                                   AF_UNSPEC,
+                                                   GNUNET_TIME_UNIT_MINUTES,
+                                                   &init_socket_resolv,
+                                                   &port);
   GNUNET_free (bindto);
 }
 
diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c
index e2d2eb73c..aa02bda93 100644
--- a/src/transport/test_communicator_basic.c
+++ b/src/transport/test_communicator_basic.c
@@ -124,6 +124,25 @@ communicator_available_cb (void *cls,
        address_prefix);
 }
 
+static void
+open_queue (void *cls)
+{
+  char *address = cls;
+
+  if (NULL != tc_hs[PEER_A]->c_mq)
+  {
+    queue_est = GNUNET_YES;
+    GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (tc_hs[PEER_A],
+                                                                &peer_id[PEER_B],
+                                                                address);
+  }
+  else
+  {
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                  &open_queue,
+                                  address);
+  }
+}
 
 static void
 add_address_cb (void *cls,
@@ -144,10 +163,7 @@ add_address_cb (void *cls,
   if ((0 == strcmp ((char*) cls, cfg_peers_name[PEER_B])) &&
       (GNUNET_NO == queue_est))
   {
-    queue_est = GNUNET_YES;
-    GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (tc_hs[PEER_A],
-                                                                &peer_id[PEER_B],
-                                                                address);
+    open_queue (address);
   }
 }
 
diff --git a/src/transport/test_communicator_tcp_rekey_peer2.conf b/src/transport/test_communicator_tcp_rekey_peer2.conf
index 138650a3b..643b037b2 100644
--- a/src/transport/test_communicator_tcp_rekey_peer2.conf
+++ b/src/transport/test_communicator_tcp_rekey_peer2.conf
@@ -31,10 +31,10 @@ UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
 UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
 
 [communicator-tcp]
-#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
 #PREFIX = valgrind --leak-check=full --track-origins=yes
 BINDTO = 60003
-DISABLE_V6 = YES
+DISABLE_V6 = NO
 REKEY_INTERVAL = 100ms
 
 [communicator-udp]
diff --git a/src/transport/test_communicator_unix_basic_peer1.conf b/src/transport/test_communicator_unix_basic_peer1.conf
index 71283e381..8e9700108 100644
--- a/src/transport/test_communicator_unix_basic_peer1.conf
+++ b/src/transport/test_communicator_unix_basic_peer1.conf
@@ -28,6 +28,8 @@ PORT = 62089
 UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
 
 [communicator-unix]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
 UNIXPATH = $GNUNET_RUNTIME_DIR/communicator-unix-1.sock
 
 [communicator-tcp]
diff --git a/src/transport/test_communicator_unix_basic_peer2.conf b/src/transport/test_communicator_unix_basic_peer2.conf
index ac95845b2..c12cc9111 100644
--- a/src/transport/test_communicator_unix_basic_peer2.conf
+++ b/src/transport/test_communicator_unix_basic_peer2.conf
@@ -28,6 +28,8 @@ PORT = 62090
 UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
 
 [communicator-unix]
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
 UNIXPATH = $GNUNET_RUNTIME_DIR/communicator-unix-2.sock
 
 [communicator-tcp]
diff --git a/src/transport/transport-testing2.c b/src/transport/transport-testing2.c
index 13944e9f0..98cfd5e29 100644
--- a/src/transport/transport-testing2.c
+++ b/src/transport/transport-testing2.c
@@ -59,145 +59,6 @@ struct MyClient
 };
 
 /**
- * @brief Handle to a transport communicator
- */
-struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
-{
-  /**
-   * Clients
-   */
-  struct MyClient *client_head;
-  struct MyClient *client_tail;
-
-  /**
-  * @brief Handle to the client
-  */
-  struct GNUNET_MQ_Handle *c_mq;
-
-  /**
-    * @brief Handle to the configuration
-    */
-  struct GNUNET_CONFIGURATION_Handle *cfg;
-
-  /**
-   * @brief File name of configuration file
-   */
-  char *cfg_filename;
-
-  struct GNUNET_PeerIdentity peer_id;
-
-  /**
-   * @brief Handle to the transport service
-   */
-  struct GNUNET_SERVICE_Handle *tsh;
-
-  /**
-   * @brief Task that will be run on shutdown to stop and clean transport
-   * service
-   */
-  struct GNUNET_SCHEDULER_Task *ts_shutdown_task;
-
-
-  /**
-   * @brief Process of the communicator
-   */
-  struct GNUNET_OS_Process *c_proc;
-
-  /**
-   * NAT process
-   */
-  struct GNUNET_OS_Process *nat_proc;
-
-  /**
-   * resolver service process
-   */
-  struct GNUNET_OS_Process *resolver_proc;
-
-  /**
-   * peerstore service process
-   */
-  struct GNUNET_OS_Process *ps_proc;
-
-  /**
-   * @brief Task that will be run on shutdown to stop and clean communicator
-   */
-  struct GNUNET_SCHEDULER_Task *c_shutdown_task;
-
-  /**
-   * @brief Characteristics of the communicator
-   */
-  enum GNUNET_TRANSPORT_CommunicatorCharacteristics c_characteristics;
-
-  /**
-   * @brief Specifies supported addresses
-   */
-  char *c_addr_prefix;
-
-  /**
-   * @brief Specifies supported addresses
-   */
-  char *c_address;
-
-  /**
-   * @brief Head of the DLL of queues associated with this communicator
-   */
-  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_head;
-
-  /**
-   * @brief Tail of the DLL of queues associated with this communicator
-   */
-  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_tail;
-
-  /* Callbacks + Closures */
-  /**
-   * @brief Callback called when a new communicator connects
-   */
-  GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback
-    communicator_available_cb;
-
-  /**
-   * @brief Callback called when a new communicator connects
-   */
-  GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb;
-
-  /**
-   * @brief Callback called when a new communicator connects
-   */
-  GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb;
-
-  /**
-   * @brief Callback called when a new communicator connects
-   */
-  GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb;
-
-  /**
-   * @brief Callback called when a new communicator connects
-   */
-  GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_msg_cb;
-
-  /**
-   * @brief Backchannel callback
-   */
-  GNUNET_TRANSPORT_TESTING_BackchannelCallback bc_cb;
-
-  /**
-   * Our service handle
-   */
-  struct GNUNET_SERVICE_Handle *sh;
-
-  /**
-   * @brief Closure to the callback
-   */
-  void *cb_cls;
-
-  /**
-   * Backchannel supported
-   */
-  int bc_enabled;
-};
-
-
-/**
  * @brief Queue of a communicator and some context
  */
 struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue
@@ -707,6 +568,9 @@ shutdown_service (void *cls)
 {
   struct GNUNET_SERVICE_Handle *h = cls;
 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down service!\n");
+
   GNUNET_SERVICE_stop (h);
 }
 
@@ -897,7 +761,6 @@ shutdown_process (struct GNUNET_OS_Process *proc)
   GNUNET_OS_process_destroy (proc);
 }
 
-
 static void
 shutdown_peerstore (void *cls)
 {
@@ -905,7 +768,6 @@ shutdown_peerstore (void *cls)
   shutdown_process (proc);
 }
 
-
 static void
 shutdown_communicator (void *cls)
 {
@@ -941,8 +803,7 @@ communicator_start (
 
 
   binary = GNUNET_OS_get_libexec_binary_path (binary_name);
-  tc_h->c_proc = GNUNET_OS_start_process_s (GNUNET_OS_USE_PIPE_CONTROL
-                                            | GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+  tc_h->c_proc = GNUNET_OS_start_process_s (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                             NULL,
                                             loprefix,
                                             binary,
@@ -1026,10 +887,8 @@ peerstore_start (
 {
   char *binary;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "peerstore_start\n");
   binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-peerstore");
-  tc_h->ps_proc = GNUNET_OS_start_process (GNUNET_OS_USE_PIPE_CONTROL
-                                           | GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+  tc_h->ps_proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                            NULL,
                                            NULL,
                                            NULL,
@@ -1047,7 +906,6 @@ peerstore_start (
   GNUNET_free (binary);
 }
 
-
 /**
  * @brief Start NAT
  *
@@ -1208,6 +1066,8 @@ GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (
   memcpy (&msg[1], address, alen);
   if (NULL != tc_h->c_mq)
   {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Sending queue create immediately\n");
     GNUNET_MQ_send (tc_h->c_mq, env);
   }
   else
diff --git a/src/transport/transport-testing2.h b/src/transport/transport-testing2.h
index b77125e82..04f75fc88 100644
--- a/src/transport/transport-testing2.h
+++ b/src/transport/transport-testing2.h
@@ -29,13 +29,6 @@
 #include "gnunet_ats_transport_service.h"
 #include "transport.h"
 
-
-/**
- * @brief Handle to a transport communicator
- */
-struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle;
-
-
 /**
  * @brief Queue of a communicator and some context
  */
@@ -151,6 +144,143 @@ typedef void
                                                     const char*payload,
                                                     size_t payload_len);
 
+/**
+ * @brief Handle to a transport communicator
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+{
+  /**
+   * Clients
+   */
+  struct MyClient *client_head;
+  struct MyClient *client_tail;
+
+  /**
+  * @brief Handle to the client
+  */
+  struct GNUNET_MQ_Handle *c_mq;
+
+  /**
+    * @brief Handle to the configuration
+    */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * @brief File name of configuration file
+   */
+  char *cfg_filename;
+
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * @brief Handle to the transport service
+   */
+  struct GNUNET_SERVICE_Handle *tsh;
+
+  /**
+   * @brief Task that will be run on shutdown to stop and clean transport
+   * service
+   */
+  struct GNUNET_SCHEDULER_Task *ts_shutdown_task;
+
+
+  /**
+   * @brief Process of the communicator
+   */
+  struct GNUNET_OS_Process *c_proc;
+
+  /**
+   * NAT process
+   */
+  struct GNUNET_OS_Process *nat_proc;
+
+  /**
+   * resolver service process
+   */
+  struct GNUNET_OS_Process *resolver_proc;
+
+  /**
+   * peerstore service process
+   */
+  struct GNUNET_OS_Process *ps_proc;
+
+  /**
+   * @brief Task that will be run on shutdown to stop and clean communicator
+   */
+  struct GNUNET_SCHEDULER_Task *c_shutdown_task;
+
+  /**
+   * @brief Characteristics of the communicator
+   */
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics c_characteristics;
+
+  /**
+   * @brief Specifies supported addresses
+   */
+  char *c_addr_prefix;
+
+  /**
+   * @brief Specifies supported addresses
+   */
+  char *c_address;
+
+  /**
+   * @brief Head of the DLL of queues associated with this communicator
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_head;
+
+  /**
+   * @brief Tail of the DLL of queues associated with this communicator
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_tail;
+
+  /* Callbacks + Closures */
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback
+    communicator_available_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_msg_cb;
+
+  /**
+   * @brief Backchannel callback
+   */
+  GNUNET_TRANSPORT_TESTING_BackchannelCallback bc_cb;
+
+  /**
+   * Our service handle
+   */
+  struct GNUNET_SERVICE_Handle *sh;
+
+  /**
+   * @brief Closure to the callback
+   */
+  void *cb_cls;
+
+  /**
+   * Backchannel supported
+   */
+  int bc_enabled;
+};
 
 /**
  * @brief Start communicator part of transport service and communicator
diff --git a/src/transport/transport_api2_communication.c b/src/transport/transport_api2_communication.c
index d1e28cc36..b048ad851 100644
--- a/src/transport/transport_api2_communication.c
+++ b/src/transport/transport_api2_communication.c
@@ -1081,7 +1081,6 @@ GNUNET_TRANSPORT_communicator_address_add (
   return ai;
 }
 
-
 /**
  * Notify transport service about an address that this communicator no
  * longer provides for this peer.
@@ -1100,6 +1099,20 @@ GNUNET_TRANSPORT_communicator_address_remove (
   GNUNET_free (ai);
 }
 
+/**
+ * Notify transport service that this communicator no longer provides all its addresses for this peer.
+ *
+ * @param ch The communicator handle.
+ */
+void
+GNUNET_TRANSPORT_communicator_address_remove_all (
+                                              struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
+       ai = ai->next)
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+}
+
 
 /* ************************* Backchannel *************************** */
 
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 0dbe9dbe8..94b6f5099 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -94,7 +94,7 @@ GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
  * @param result where to store the hash code
  * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_hash_from_string2 (const char *enc,
                                  size_t enclen,
                                  struct GNUNET_HashCode *result)
diff --git a/src/util/gnunet-qr.c b/src/util/gnunet-qr.c
index 83b2af2fc..451d61d40 100644
--- a/src/util/gnunet-qr.c
+++ b/src/util/gnunet-qr.c
@@ -36,7 +36,7 @@
 /**
  * Video device to capture from. Sane default for GNU/Linux systems.
  */
-static char *device = "/dev/video0";
+static char *device;
 
 /**
  * --verbose option
@@ -51,7 +51,7 @@ static int silent = false;
 /**
  * Handler exit code
  */
-static long unsigned int exit_code = 1;
+static long unsigned int exit_code = 0;
 
 /**
  * Helper process we started.
@@ -228,6 +228,8 @@ get_symbol (zbar_processor_t *proc)
   }
 
   /* initialize the Processor */
+  if (NULL == device)
+    device = GNUNET_strdup ("/dev/video0");
   if (0 != (rc = zbar_processor_init (proc, device, 1)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -306,6 +308,7 @@ run_zbar ()
   ret = GNUNET_strdup (data);
   /* clean up */
   zbar_processor_destroy (proc);
+  GNUNET_free (device);
   return ret;
 }
 
diff --git a/src/util/gnunet-uri.c b/src/util/gnunet-uri.c
index 9443c9120..de0ff1f92 100644
--- a/src/util/gnunet-uri.c
+++ b/src/util/gnunet-uri.c
@@ -29,7 +29,7 @@
 /**
  * Handler exit code
  */
-static long unsigned int exit_code = 1;
+static long unsigned int exit_code = 0;
 
 /**
  * Helper process we started.
diff --git a/src/util/mq.c b/src/util/mq.c
index 302b310de..29ead02a4 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -273,7 +273,7 @@ GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers,
       break;
     }
   }
-done:
+  done:
   if (GNUNET_NO == handled)
   {
     LOG (GNUNET_ERROR_TYPE_INFO,
@@ -355,6 +355,10 @@ void
 GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
                 struct GNUNET_MQ_Envelope *ev)
 {
+  if (NULL == mq)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "mq is NUll when sending message of type %u\n",
+                (unsigned int) ntohs (ev->mh->type));
   GNUNET_assert (NULL != mq);
   GNUNET_assert (NULL == ev->parent_queue);