-merge

78 files changed, 4836 insertions, 4239 deletions

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index 2db2ba0d1..bf5982d10 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -1915,7 +1915,6 @@ setup_service (void *cls,
   struct sockaddr **addrs;
   socklen_t *addr_lens;
   int ret;
-  unsigned int i;
 
   if (0 == strcasecmp (section,
                        "arm"))
@@ -2027,7 +2026,7 @@ setup_service (void *cls,
                                         &addr_lens)))
     return;
   /* this will free (or capture) addrs[i] */
-  for (i = 0; i < ret; i++)
+  for (unsigned int i = 0; i < ret; i++)
     create_listen_socket (addrs[i],
                           addr_lens[i],
                           sl);
diff --git a/src/auction/Makefile.am b/src/auction/Makefile.am
index bdede0ce0..f86e846e2 100644
--- a/src/auction/Makefile.am
+++ b/src/auction/Makefile.am
@@ -68,6 +68,11 @@ test_auction_api_LDADD = \
 check_SCRIPTS = \
         test_auction_create.sh
 
+EXTRA_DIST = \
+  auction.h \
+  auction.conf \
+  $(check_SCRIPTS)
+
 if ENABLE_TEST_RUN
         AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
         TESTS = $(check_PROGRAMS) $(check_SCRIPTS)
diff --git a/src/cadet/cadet_api.c b/src/cadet/cadet_api.c
index 00a482452..497c9a4f0 100644
--- a/src/cadet/cadet_api.c
+++ b/src/cadet/cadet_api.c
@@ -391,6 +391,8 @@ destroy_channel_on_reconnect_cb (void *cls,
   /* struct GNUNET_CADET_Handle *handle = cls; */
   struct GNUNET_CADET_Channel *ch = value;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying channel due to reconnect\n");
   destroy_channel (ch);
   return GNUNET_OK;
 }
@@ -824,6 +826,29 @@ handle_mq_error (void *cls,
 
 
 /**
+ * Check that message received from CADET service is well-formed.
+ *
+ * @param cls the `struct GNUNET_CADET_Handle`
+ * @param message the message we got
+ * @return #GNUNET_OK if the message is well-formed,
+ *         #GNUNET_SYSERR otherwise
+ */
+static int
+check_get_peers (void *cls,
+                 const struct GNUNET_MessageHeader *message)
+{
+  size_t esize;
+
+  esize = ntohs (message->size);
+  if (sizeof (struct GNUNET_CADET_LocalInfoPeer) == esize)
+    return GNUNET_OK;
+  if (sizeof (struct GNUNET_MessageHeader) == esize)
+    return GNUNET_OK;
+  return GNUNET_SYSERR;
+}
+
+
+/**
  * Process a local reply about info on all tunnels, pass info to the user.
  *
  * @param cls Closure (Cadet handle).
@@ -831,17 +856,26 @@ handle_mq_error (void *cls,
  */
 static void
 handle_get_peers (void *cls,
-                  const struct GNUNET_CADET_LocalInfoPeer *msg)
+                  const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CADET_Handle *h = cls;
+  const struct GNUNET_CADET_LocalInfoPeer *info =
+    (const struct GNUNET_CADET_LocalInfoPeer *) msg;
 
   if (NULL == h->info_cb.peers_cb)
     return;
-  h->info_cb.peers_cb (h->info_cls,
-                       &msg->destination,
-                       (int) ntohs (msg->tunnel),
-                       (unsigned int) ntohs (msg->paths),
-                       0);
+  if (sizeof (struct GNUNET_CADET_LocalInfoPeer) == ntohs (msg->size))
+    h->info_cb.peers_cb (h->info_cls,
+                         &info->destination,
+                         (int) ntohs (info->tunnel),
+                         (unsigned int) ntohs (info->paths),
+                         0);
+  else
+    h->info_cb.peers_cb (h->info_cls,
+                         NULL,
+                         0,
+                         0,
+                         0);
 }
 
 
@@ -946,6 +980,29 @@ handle_get_peer (void *cls,
 
 
 /**
+ * Check that message received from CADET service is well-formed.
+ *
+ * @param cls the `struct GNUNET_CADET_Handle`
+ * @param message the message we got
+ * @return #GNUNET_OK if the message is well-formed,
+ *         #GNUNET_SYSERR otherwise
+ */
+static int
+check_get_tunnels (void *cls,
+                   const struct GNUNET_MessageHeader *message)
+{
+  size_t esize;
+
+  esize = ntohs (message->size);
+  if (sizeof (struct GNUNET_CADET_LocalInfoTunnel) == esize)
+    return GNUNET_OK;
+  if (sizeof (struct GNUNET_MessageHeader) == esize)
+    return GNUNET_OK;
+  return GNUNET_SYSERR;
+}
+
+
+/**
  * Process a local reply about info on all tunnels, pass info to the user.
  *
  * @param cls Closure (Cadet handle).
@@ -953,19 +1010,28 @@ handle_get_peer (void *cls,
  */
 static void
 handle_get_tunnels (void *cls,
-                    const struct GNUNET_CADET_LocalInfoTunnel *msg)
+                    const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CADET_Handle *h = cls;
+  const struct GNUNET_CADET_LocalInfoTunnel *info =
+    (const struct GNUNET_CADET_LocalInfoTunnel *) msg;
 
   if (NULL == h->info_cb.tunnels_cb)
     return;
-  h->info_cb.tunnels_cb (h->info_cls,
-                         &msg->destination,
-                         ntohl (msg->channels),
-                         ntohl (msg->connections),
-                         ntohs (msg->estate),
-                         ntohs (msg->cstate));
-
+  if (sizeof (struct GNUNET_CADET_LocalInfoTunnel) == ntohs (msg->size))
+    h->info_cb.tunnels_cb (h->info_cls,
+                           &info->destination,
+                           ntohl (info->channels),
+                           ntohl (info->connections),
+                           ntohs (info->estate),
+                           ntohs (info->cstate));
+  else
+    h->info_cb.tunnels_cb (h->info_cls,
+                           NULL,
+                           0,
+                           0,
+                           0,
+                           0);
 }
 
 
@@ -1075,18 +1141,18 @@ reconnect (struct GNUNET_CADET_Handle *h)
                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
                              struct GNUNET_CADET_LocalAck,
                              h),
-    GNUNET_MQ_hd_fixed_size (get_peers,
-                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
-                             struct GNUNET_CADET_LocalInfoPeer,
-                             h),
+    GNUNET_MQ_hd_var_size (get_peers,
+                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
+                           struct GNUNET_MessageHeader,
+                           h),
     GNUNET_MQ_hd_var_size (get_peer,
                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER,
                            struct GNUNET_CADET_LocalInfoPeer,
                            h),
-    GNUNET_MQ_hd_fixed_size (get_tunnels,
-                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
-                             struct GNUNET_CADET_LocalInfoTunnel,
-                             h),
+    GNUNET_MQ_hd_var_size (get_tunnels,
+                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
+                           struct GNUNET_MessageHeader,
+                           h),
     GNUNET_MQ_hd_var_size (get_tunnel,
                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL,
                            struct GNUNET_CADET_LocalInfoTunnel,
@@ -1094,6 +1160,7 @@ reconnect (struct GNUNET_CADET_Handle *h)
     GNUNET_MQ_handler_end ()
   };
 
+  GNUNET_assert (NULL == h->mq);
   h->mq = GNUNET_CLIENT_connect (h->cfg,
                                  "cadet",
                                  handlers,
@@ -1132,6 +1199,8 @@ destroy_channel_cb (void *cls,
          "channel %X not destroyed\n",
          ntohl (ch->ccn.channel_of_client));
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying channel due to GNUNET_CADET_disconnect()\n");
   destroy_channel (ch);
   return GNUNET_OK;
 }
@@ -1246,6 +1315,8 @@ GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
     GNUNET_MQ_send (h->mq,
                     env);
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
   destroy_channel (channel);
 }
 
@@ -1600,7 +1671,10 @@ GNUNET_CADET_open_port (struct GNUNET_CADET_Handle *h,
 
   GNUNET_assert (NULL != connects);
   GNUNET_assert (NULL != disconnects);
-
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Listening to CADET port %s\n",
+              GNUNET_h2s (port));
+  
   p = GNUNET_new (struct GNUNET_CADET_Port);
   p->cadet = h;
   p->id = *port;
@@ -1663,6 +1737,10 @@ GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h,
   struct GNUNET_MQ_Envelope *env;
 
   GNUNET_assert (NULL != disconnects);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating channel to peer %s at port %s\n",
+              GNUNET_i2s (destination),
+              GNUNET_h2s (port));
   ch = create_channel (h,
                        NULL);
   ch->ctx = channel_cls;
diff --git a/src/cadet/cadet_test_lib.c b/src/cadet/cadet_test_lib.c
index 1df6bff0d..20ef028b2 100644
--- a/src/cadet/cadet_test_lib.c
+++ b/src/cadet/cadet_test_lib.c
@@ -241,6 +241,7 @@ GNUNET_CADET_TEST_cleanup (struct GNUNET_CADET_TEST_Context *ctx)
   }
   GNUNET_free (ctx->ops);
   GNUNET_free (ctx->cadets);
+  GNUNET_free (ctx->handlers);
   GNUNET_free (ctx);
   GNUNET_SCHEDULER_shutdown ();
 }
diff --git a/src/cadet/gnunet-cadet.c b/src/cadet/gnunet-cadet.c
index 675e7faf0..a9b02714b 100644
--- a/src/cadet/gnunet-cadet.c
+++ b/src/cadet/gnunet-cadet.c
@@ -693,6 +693,7 @@ show_tunnel (void *cls)
 {
   struct GNUNET_PeerIdentity pid;
 
+  job = NULL;
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_public_key_from_string (tunnel_id,
                                                   strlen (tunnel_id),
diff --git a/src/cadet/gnunet-service-cadet_core.c b/src/cadet/gnunet-service-cadet_core.c
index ae03b4f35..84aff1857 100644
--- a/src/cadet/gnunet-service-cadet_core.c
+++ b/src/cadet/gnunet-service-cadet_core.c
@@ -623,7 +623,7 @@ timeout_cb (void *cls)
   {
     exp = GNUNET_TIME_absolute_add (r->last_use,
                                     linger);
-    if (0 != GNUNET_TIME_absolute_get_duration (exp).rel_value_us)
+    if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
     {
       /* Route not yet timed out, wait until it does. */
       timeout_task = GNUNET_SCHEDULER_add_at (exp,
@@ -631,6 +631,11 @@ timeout_cb (void *cls)
                                               NULL);
       return;
     }
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
+                GNUNET_STRINGS_absolute_time_to_string (r->last_use),
+                GNUNET_STRINGS_relative_time_to_string (linger,
+                                                        GNUNET_YES));
     send_broken (&r->prev,
                  &r->cid,
                  NULL,
@@ -688,6 +693,8 @@ dir_ready_cb (void *cls,
     return;
   }
   odir = (dir == &route->next) ? &route->prev : &route->next;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Sending BROKEN due to MQ going down\n");
   send_broken (&route->next,
                &route->cid,
                GCP_get_id (odir->hop),
@@ -771,6 +778,33 @@ handle_connection_create (void *cls,
 
   options = (enum GNUNET_CADET_ChannelOption) ntohl (msg->options);
   path_length = size / sizeof (struct GNUNET_PeerIdentity);
+  if (0 == path_length)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Dropping CADET_CONNECTION_CREATE with empty path\n");
+    GNUNET_break_op (0);
+    return;
+  }
+  /* Check for loops */
+  struct GNUNET_CONTAINER_MultiPeerMap *map;
+  map = GNUNET_CONTAINER_multipeermap_create (path_length * 2,
+                                              GNUNET_YES);
+  GNUNET_assert (NULL != map);
+  for (off = 0; off < path_length; off++) {
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multipeermap_put (map,
+                                           &pids[off],
+                                           NULL,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) {
+      /* bogus request */
+      GNUNET_CONTAINER_multipeermap_destroy (map);
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Dropping CADET_CONNECTION_CREATE with cyclic path\n");
+      GNUNET_break_op (0);
+      return;
+    }
+  }
+  GNUNET_CONTAINER_multipeermap_destroy (map);
   /* Initiator is at offset 0. */
   for (off=1;off<path_length;off++)
     if (0 == memcmp (&my_full_id,
@@ -779,7 +813,8 @@ handle_connection_create (void *cls,
       break;
   if (off == path_length)
   {
-    /* We are not on the path, bogus request */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Dropping CADET_CONNECTION_CREATE without us in the path\n");
     GNUNET_break_op (0);
     return;
   }
@@ -787,7 +822,8 @@ handle_connection_create (void *cls,
   if (sender != GCP_get (&pids[off - 1],
                          GNUNET_NO))
   {
-    /* sender is not on the path, not allowed */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Dropping CADET_CONNECTION_CREATE without sender in the path\n");
     GNUNET_break_op (0);
     return;
   }
diff --git a/src/cadet/gnunet-service-cadet_paths.c b/src/cadet/gnunet-service-cadet_paths.c
index 7b90fe152..9dd6f1ddd 100644
--- a/src/cadet/gnunet-service-cadet_paths.c
+++ b/src/cadet/gnunet-service-cadet_paths.c
@@ -179,7 +179,7 @@ GCPP_del_connection (struct CadetPeerPath *path,
        GCC_2s (cc),
        GCPP_2s (path),
        off);
-  GNUNET_assert (off < path->entries_length); /* FIXME: #4909: This assertion fails sometimes! */
+  GNUNET_assert (off < path->entries_length);
   entry = path->entries[off];
   GNUNET_assert (cc == entry->cc);
   entry->cc = NULL;
@@ -187,33 +187,51 @@ GCPP_del_connection (struct CadetPeerPath *path,
 
 
 /**
- * This path is no longer needed, free resources.
+ * Tries to attach @a path to a peer, working backwards from the end
+ * and stopping at @a stop_at. If path->hn is NULL on return then the
+ * path was not attached and you can assume that path->entries_length
+ * is equal to @a stop_at.
  *
- * @param path path resources to free
+ * @param path the path to attach
+ * @param stop_at the path length at which to stop trying
  */
 static void
-path_destroy (struct CadetPeerPath *path)
+attach_path (struct CadetPeerPath *path, unsigned int stop_at)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Destroying path %s\n",
-       GCPP_2s (path));
-  for (unsigned int i=0;i<path->entries_length;i++)
+  GNUNET_assert (NULL == path->hn);
+
+  /* Try to attach this path to a peer, working backwards from the end. */
+  while (path->entries_length > stop_at)
   {
-    struct CadetPeerPathEntry *entry = path->entries[i];
+    unsigned int end = path->entries_length - 1;
+    struct CadetPeerPathEntry *entry = path->entries[end];
+    int force = GNUNET_NO;
 
+    recalculate_path_desirability (path);
+    /* If the entry already has a connection using it, force attach. */
     if (NULL != entry->cc)
-    {
-      struct CadetTConnection *ct;
+      force = GNUNET_YES;
+    path->hn = GCP_attach_path (entry->peer,
+                                path,
+                                end,
+                                force);
+    if (NULL != path->hn)
+      break;
 
-      ct = GCC_get_ct (entry->cc);
-      if (NULL != ct)
-        GCT_connection_lost (ct);
-      GCC_destroy_without_tunnel (entry->cc);
-    }
+    /* Attach failed, trim this entry from the path. */
+    GNUNET_assert (NULL == entry->cc);
+    GCP_path_entry_remove (entry->peer,
+                           entry,
+                           end);
     GNUNET_free (entry);
+    path->entries[end] = NULL;
+    path->entries_length--;
   }
-  GNUNET_free (path->entries);
-  GNUNET_free (path);
+
+  /* Shrink array to actual path length. */
+  GNUNET_array_grow (path->entries,
+                     path->entries_length,
+                     path->entries_length);
 }
 
 
@@ -228,7 +246,6 @@ void
 GCPP_release (struct CadetPeerPath *path)
 {
   struct CadetPeerPathEntry *entry;
-  int force;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Owner releases path %s\n",
@@ -236,34 +253,23 @@ GCPP_release (struct CadetPeerPath *path)
   path->hn = NULL;
   entry = path->entries[path->entries_length - 1];
   GNUNET_assert (path == entry->path);
-  while (1)
+  GNUNET_assert (NULL == entry->cc);
+  /* cut 'off' end of path */
+  GCP_path_entry_remove (entry->peer,
+                         entry,
+                         path->entries_length - 1);
+  GNUNET_free (entry);
+  path->entries[path->entries_length - 1] = NULL;
+  path->entries_length--;
+  /* see if new peer at the end likes this path any better */
+  attach_path (path, 0);
+  if (NULL == path->hn)
   {
-    /* cut 'off' end of path */
-    GNUNET_assert (NULL == entry->cc);
-    GCP_path_entry_remove (entry->peer,
-                           entry,
-                           path->entries_length - 1);
-    path->entries_length--; /* We don't bother shrinking the 'entries' array,
-                               as it's probably not worth it. */
-    GNUNET_free (entry);
-    if (0 == path->entries_length)
-      break; /* the end */
-
-    /* see if new peer at the end likes this path any better */
-    entry = path->entries[path->entries_length - 1];
-    GNUNET_assert (path == entry->path);
-    force = (NULL == entry->cc) ? GNUNET_NO : GNUNET_YES;
-    path->hn = GCP_attach_path (entry->peer,
-                                path,
-                                path->entries_length - 1,
-                                force);
-    if (NULL != path->hn)
-      return; /* yep, got attached, we are done. */
-    GNUNET_assert (GNUNET_NO == force);
+    /* nobody wants us, discard the path */
+    GNUNET_assert (0 == path->entries_length);
+    GNUNET_assert (NULL == path->entries);
+    GNUNET_free (path);
   }
-
-  /* nobody wants us, discard the path */
-  path_destroy (path);
 }
 
 
@@ -422,33 +428,13 @@ extend_path (struct CadetPeerPath *path,
                    path,
                    path->hn);
   path->hn = NULL;
-  for (i=num_peers-1;i>=0;i--)
-  {
-    struct CadetPeerPathEntry *entry = path->entries[old_len + i];
-
-    path->entries_length = old_len + i + 1;
-    recalculate_path_desirability (path);
-    if (NULL != entry->cc)
-      force = GNUNET_YES;
-    path->hn = GCP_attach_path (peers[i],
-                                path,
-                                old_len + (unsigned int) i,
-                                force);
-    if (NULL != path->hn)
-      break;
-    GCP_path_entry_remove (entry->peer,
-                           entry,
-                           old_len + i);
-    GNUNET_free (entry);
-    path->entries[old_len + i] = NULL;
-  }
+  path->entries_length = old_len + num_peers;
+  attach_path (path, old_len);
   if (NULL == path->hn)
   {
     /* none of the peers is interested in this path;
-       shrink path back and re-attach. */
-    GNUNET_array_grow (path->entries,
-                       path->entries_length,
-                       old_len);
+       re-attach. */
+    GNUNET_assert (old_len == path->entries_length);
     path->hn = GCP_attach_path (path->entries[old_len - 1]->peer,
                                 path,
                                 old_len - 1,
@@ -483,7 +469,6 @@ GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path,
   struct CadetPeer *cpath[get_path_length + put_path_length];
   struct CheckMatchContext cm_ctx;
   struct CadetPeerPath *path;
-  struct GNUNET_CONTAINER_HeapNode *hn;
   int i;
   unsigned int skip;
   unsigned int total_len;
@@ -501,6 +486,14 @@ GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path,
     pid = (off < get_path_length)
       ? &get_path[get_path_length - off - 1]
       : &put_path[get_path_length + put_path_length - off - 1];
+    /* Check that I am not in the path */
+    if (0 == memcmp (&my_full_id,
+                     pid,
+                     sizeof (struct GNUNET_PeerIdentity)))
+    {
+      skip = off + 1;
+      continue;
+    }
     cpath[off - skip] = GCP_get (pid,
                                  GNUNET_YES);
     /* Check that no peer is twice on the path */
@@ -513,6 +506,12 @@ GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path,
       }
     }
   }
+  if (skip >= total_len)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Path discovered from DHT is one big cycle?\n");
+    return;
+  }
   total_len -= skip;
 
   /* First figure out if this path is a subset of an existing path, an
@@ -573,39 +572,17 @@ GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path,
   }
 
   /* Finally, try to attach it */
-  hn = NULL;
-  for (i=total_len-1;i>=0;i--)
-  {
-    struct CadetPeerPathEntry *entry = path->entries[i];
-
-    path->entries_length = i + 1;
-    recalculate_path_desirability (path);
-    hn = GCP_attach_path (cpath[i],
-                          path,
-                          (unsigned int) i,
-                          GNUNET_NO);
-    if (NULL != hn)
-      break;
-    GCP_path_entry_remove (entry->peer,
-                           entry,
-                           i);
-    GNUNET_free (entry);
-    path->entries[i] = NULL;
-  }
-  if (NULL == hn)
+  attach_path (path, 0);
+  if (NULL == path->hn)
   {
     /* None of the peers on the path care about it. */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Path discovered from DHT is not interesting to us\n");
-    GNUNET_free (path->entries);
+    GNUNET_assert (0 == path->entries_length);
+    GNUNET_assert (NULL == path->entries);
     GNUNET_free (path);
     return;
   }
-  path->hn = hn;
-  /* Shrink path to actual useful length */
-  GNUNET_array_grow (path->entries,
-                     path->entries_length,
-                     i + 1);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Created new path %s based on information from DHT\n",
        GCPP_2s (path));
diff --git a/src/cadet/gnunet-service-cadet_peer.c b/src/cadet/gnunet-service-cadet_peer.c
index c4e2c0ccf..da78a03c4 100644
--- a/src/cadet/gnunet-service-cadet_peer.c
+++ b/src/cadet/gnunet-service-cadet_peer.c
@@ -532,49 +532,32 @@ GCP_set_mq (struct CadetPeer *cp,
        GCP_2s (cp),
        mq);
   cp->core_mq = mq;
-  /* Since these callbacks can remove any items from this list, we must take a
-   * snapshot and then test each one to see if it's still in the list. */
-  int count = 0;
-  for (struct GCP_MessageQueueManager *mqm = cp->mqm_head;
+  for (struct GCP_MessageQueueManager *mqm = cp->mqm_head, *next;
        NULL != mqm;
-       mqm = mqm->next)
-    ++count;
-  struct GCP_MessageQueueManager *mqms[count];
-  int i = 0;
-  for (struct GCP_MessageQueueManager *mqm = cp->mqm_head;
-       NULL != mqm;
-       mqm = mqm->next)
-    mqms[i++] = mqm;
-  for (i = 0; i < count; ++i)
+       mqm = next)
   {
-    for (struct GCP_MessageQueueManager *mqm = cp->mqm_head;
-         NULL != mqm;
-         mqm = mqm->next)
+    /* Save next pointer in case mqm gets freed by the callback */
+    next = mqm->next;
+    if (NULL == mq)
     {
-      if (mqms[i] != mqm)
-        continue;
-      if (NULL == mq)
+      if (NULL != mqm->env)
       {
-        if (NULL != mqm->env)
-        {
-          GNUNET_MQ_discard (mqm->env);
-          mqm->env = NULL;
-          mqm->cb (mqm->cb_cls,
-                   GNUNET_SYSERR);
-        }
-        else
-        {
-          mqm->cb (mqm->cb_cls,
-                   GNUNET_NO);
-        }
+        GNUNET_MQ_discard (mqm->env);
+        mqm->env = NULL;
+        mqm->cb (mqm->cb_cls,
+                 GNUNET_SYSERR);
       }
       else
       {
-        GNUNET_assert (NULL == mqm->env);
         mqm->cb (mqm->cb_cls,
-                 GNUNET_YES);
+                 GNUNET_NO);
       }
-      break;
+    }
+    else
+    {
+      GNUNET_assert (NULL == mqm->env);
+      mqm->cb (mqm->cb_cls,
+               GNUNET_YES);
     }
   }
   if ( (NULL != mq) ||
@@ -996,7 +979,7 @@ GCP_attach_path (struct CadetPeer *cp,
          (desirability < root_desirability) )
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Decided to not attach path %p to peer %s due to undesirability\n",
+           "Decided to not attach path %s to peer %s due to undesirability\n",
            GCPP_2s (path),
            GCP_2s (cp));
       return NULL;
diff --git a/src/cadet/gnunet-service-cadet_tunnels.c b/src/cadet/gnunet-service-cadet_tunnels.c
index 22e19ef70..fb91a4a6a 100644
--- a/src/cadet/gnunet-service-cadet_tunnels.c
+++ b/src/cadet/gnunet-service-cadet_tunnels.c
@@ -2856,7 +2856,9 @@ handle_plaintext_channel_destroy (void *cls,
  *
  * @param cls the `struct CadetTunnel` that got the message
  * @param msg the message
- * @return #GNUNET_OK (continue to process)
+ * @return #GNUNET_OK on success (always)
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 handle_decrypted (void *cls,
diff --git a/src/cadet/test_cadet.c b/src/cadet/test_cadet.c
index 72df2203c..b9f177652 100644
--- a/src/cadet/test_cadet.c
+++ b/src/cadet/test_cadet.c
@@ -58,6 +58,11 @@ struct CadetTestChannelWrapper
 #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
 
 /**
+ * How fast do we send messages?
+ */
+#define SEND_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 10)
+
+/**
  * DIFFERENT TESTS TO RUN
  */
 #define SETUP 0
@@ -269,12 +274,20 @@ show_end_data (void)
 
   end_time = GNUNET_TIME_absolute_get ();
   total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
-  FPRINTF (stderr, "\nResults of test \"%s\"\n", test_name);
-  FPRINTF (stderr, "Test time %s\n",
+  FPRINTF (stderr,
+           "\nResults of test \"%s\"\n",
+           test_name);
+  FPRINTF (stderr,
+           "Test time %s\n",
            GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
-  FPRINTF (stderr, "Test bandwidth: %f kb/s\n", 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000));    // 4bytes * ms
-  FPRINTF (stderr, "Test throughput: %f packets/s\n\n", total_packets * 1000.0 / (total_time.rel_value_us / 1000));     // packets * ms
-  GAUGER ("CADET", test_name,
+  FPRINTF (stderr,
+           "Test bandwidth: %f kb/s\n",
+           4 * total_packets * 1.0 / (total_time.rel_value_us / 1000));    // 4bytes * ms
+  FPRINTF (stderr,
+           "Test throughput: %f packets/s\n\n",
+           total_packets * 1000.0 / (total_time.rel_value_us / 1000));     // packets * ms
+  GAUGER ("CADET",
+          test_name,
           total_packets * 1000.0 / (total_time.rel_value_us / 1000),
           "packets/s");
 }
@@ -290,13 +303,12 @@ static void
 disconnect_cadet_peers (void *cls)
 {
   long line = (long) cls;
-  unsigned int i;
 
   disconnect_task = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "disconnecting cadet service of peers, called from line %ld\n",
               line);
-  for (i = 0; i < 2; i++)
+  for (unsigned int i = 0; i < 2; i++)
   {
     GNUNET_TESTBED_operation_done (t_op[i]);
   }
@@ -324,7 +336,8 @@ disconnect_cadet_peers (void *cls)
 static void
 shutdown_task (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Ending test.\n");
   if (NULL != send_next_msg_task)
   {
     GNUNET_SCHEDULER_cancel (send_next_msg_task);
@@ -339,7 +352,8 @@ shutdown_task (void *cls)
   {
     GNUNET_SCHEDULER_cancel (disconnect_task);
     disconnect_task =
-        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, (void *) __LINE__);
+        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
+                                  (void *) __LINE__);
   }
 }
 
@@ -354,10 +368,14 @@ shutdown_task (void *cls)
  *          operation has executed successfully.
  */
 static void
-stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
+stats_cont (void *cls,
+            struct GNUNET_TESTBED_Operation *op,
+            const char *emsg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, " KA sent: %u, KA received: %u\n",
-              ka_sent, ka_received);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "KA sent: %u, KA received: %u\n",
+              ka_sent,
+              ka_received);
   if ((KEEPALIVE == test) && ((ka_sent < 2) || (ka_sent > ka_received + 1)))
   {
     GNUNET_break (0);
@@ -367,7 +385,8 @@ stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 
   if (NULL != disconnect_task)
     GNUNET_SCHEDULER_cancel (disconnect_task);
-  disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, cls);
+  disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
+                                              cls);
 }
 
 
@@ -438,7 +457,6 @@ gather_stats_and_exit (void *cls)
 }
 
 
-
 /**
  * Abort test: schedule disconnect and shutdown immediately
  *
@@ -450,9 +468,12 @@ abort_test (long line)
   if (NULL != disconnect_task)
   {
     GNUNET_SCHEDULER_cancel (disconnect_task);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting test from %ld\n", line);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Aborting test from %ld\n",
+                line);
     disconnect_task =
-        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, (void *) line);
+        GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
+                                  (void *) line);
   }
 }
 
@@ -525,6 +546,7 @@ send_test_message (struct GNUNET_CADET_Channel *channel)
   GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
 }
 
+
 /**
  * Task to request a new data transmission in a SPEED test, without waiting
  * for previous messages to be sent/arrrive.
@@ -537,7 +559,9 @@ send_next_msg (void *cls)
   struct GNUNET_CADET_Channel *channel;
 
   send_next_msg_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending next message: %d\n", data_sent);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending next message: %d\n",
+              data_sent);
 
   channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
   GNUNET_assert (NULL != channel);
@@ -550,9 +574,9 @@ send_next_msg (void *cls)
                 "Scheduling message %d\n",
                 data_sent + 1);
     send_next_msg_task =
-        GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
-                                     &send_next_msg,
-                                     NULL);
+      GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL,
+                                      &send_next_msg,
+                                      NULL);
   }
 }
 
@@ -571,7 +595,7 @@ reschedule_timeout_task (long line)
     if (NULL != disconnect_task)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  " reschedule timeout every 10 messages\n");
+                  "reschedule timeout every 10 messages\n");
       GNUNET_SCHEDULER_cancel (disconnect_task);
       disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
                                                       &gather_stats_and_exit,
@@ -605,7 +629,8 @@ check_data (void *cls, const struct GNUNET_MessageHeader *message)
  * @param message the actual message
  */
 static void
-handle_data (void *cls, const struct GNUNET_MessageHeader *message)
+handle_data (void *cls,
+             const struct GNUNET_MessageHeader *message)
 {
   struct CadetTestChannelWrapper *ch = cls;
   struct GNUNET_CADET_Channel *channel = ch->ch;
@@ -770,19 +795,21 @@ connect_handler (void *cls, struct GNUNET_CADET_Channel *channel,
  * @param channel Connection to the other end (henceforth invalid).
  */
 static void
-disconnect_handler (void *cls, const struct GNUNET_CADET_Channel *channel)
+disconnect_handler (void *cls,
+                    const struct GNUNET_CADET_Channel *channel)
 {
   struct CadetTestChannelWrapper *ch_w = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Channel disconnected\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Channel disconnected at %d\n",
+              ok);
   GNUNET_assert (ch_w->ch == channel);
   if (channel == incoming_ch)
   {
     ok++;
     incoming_ch = NULL;
   }
-  else if (outgoing_ch == channel
-  )
+  else if (outgoing_ch == channel)
   {
     if (P2P_SIGNAL == test)
     {
@@ -791,15 +818,17 @@ disconnect_handler (void *cls, const struct GNUNET_CADET_Channel *channel)
     outgoing_ch = NULL;
   }
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unknown channel! %p\n", channel);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d\n", ok);
-
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unknown channel! %p\n",
+                channel);
   if (NULL != disconnect_task)
   {
     GNUNET_SCHEDULER_cancel (disconnect_task);
     disconnect_task =
-        GNUNET_SCHEDULER_add_now (&gather_stats_and_exit, (void *) __LINE__);
+        GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
+                                  (void *) __LINE__);
   }
+  GNUNET_free (ch_w);
 }
 
 
@@ -879,25 +908,34 @@ start_test (void *cls)
  *             NULL if the operation is successfull
  */
 static void
-pi_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
-       const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
+pi_cb (void *cls,
+       struct GNUNET_TESTBED_Operation *op,
+       const struct GNUNET_TESTBED_PeerInformation *pinfo,
+       const char *emsg)
 {
   long i = (long) cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ID callback for %ld\n", i);
-
-  if ((NULL == pinfo) || (NULL != emsg))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ID callback for %ld\n",
+              i);
+  if ( (NULL == pinfo) ||
+       (NULL != emsg) )
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "pi_cb: %s\n",
+                emsg);
     abort_test (__LINE__);
     return;
   }
   p_id[i] = pinfo->result.id;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  id: %s\n", GNUNET_i2s (p_id[i]));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "id: %s\n",
+              GNUNET_i2s (p_id[i]));
   p_ids++;
   if (p_ids < 2)
     return;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got all IDs, starting test\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got all IDs, starting test\n");
   test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL);
 }
 
@@ -929,7 +967,8 @@ tmain (void *cls,
   disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
                                                   &disconnect_cadet_peers,
                                                   (void *) __LINE__);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
   t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
                                                  GNUNET_TESTBED_PIT_IDENTITY,
                                                  &pi_cb,
@@ -960,16 +999,16 @@ main (int argc, char *argv[])
   char port_id[] = "test port";
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_relative_time ('t',
-                                            "time",
-                                            "short_time",
-                                            gettext_noop ("set short timeout"),
-                                            &short_time),
+                                        "time",
+                                        "short_time",
+                                        gettext_noop ("set short timeout"),
+                                        &short_time),
 
     GNUNET_GETOPT_option_uint ('m',
-                                   "messages",
-                                   "NUM_MESSAGES",
-                                   gettext_noop ("set number of messages to send"),
-                                   &total_packets),
+                               "messages",
+                               "NUM_MESSAGES",
+                               gettext_noop ("set number of messages to send"),
+                               &total_packets),
 
     GNUNET_GETOPT_OPTION_END
   };
diff --git a/src/conversation/gnunet-helper-audio-playback-gst.c b/src/conversation/gnunet-helper-audio-playback-gst.c
index 264b14e76..002fed6c7 100644
--- a/src/conversation/gnunet-helper-audio-playback-gst.c
+++ b/src/conversation/gnunet-helper-audio-playback-gst.c
@@ -221,6 +221,11 @@ feed_buffer_to_gst (const char *audio, size_t b_len)
 
 /**
  * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
  */
 static int
 stdin_receiver (void *cls,
diff --git a/src/conversation/gnunet-helper-audio-playback.c b/src/conversation/gnunet-helper-audio-playback.c
index 4344e1d41..18f63ad18 100644
--- a/src/conversation/gnunet-helper-audio-playback.c
+++ b/src/conversation/gnunet-helper-audio-playback.c
@@ -546,6 +546,11 @@ ogg_demux_and_decode ()
 
 /**
  * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
  */
 static int
 stdin_receiver (void *cls,
diff --git a/src/conversation/gnunet_gst.c b/src/conversation/gnunet_gst.c
index 52cb2ccbc..828b35077 100644
--- a/src/conversation/gnunet_gst.c
+++ b/src/conversation/gnunet_gst.c
@@ -649,6 +649,11 @@ gnunet_read (GNUNET_gstData * d)
 
 /**
  * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
  */
 static int
 stdin_receiver (void *cls,
diff --git a/src/conversation/microphone.c b/src/conversation/microphone.c
index 7871433a3..11468fc59 100644
--- a/src/conversation/microphone.c
+++ b/src/conversation/microphone.c
@@ -65,7 +65,9 @@ struct Microphone
  *
  * @param cls clsoure with our `struct Microphone`
  * @param msg the message from the helper
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 process_record_messages (void *cls,
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index 625bf9655..214f72904 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -426,6 +426,9 @@ struct TokenizerContext
  *
  * @param cls reservation request (`struct TokenizerContext`)
  * @param message the actual message
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 tokenized_cb (void *cls,
diff --git a/src/core/gnunet-service-core_kx.c b/src/core/gnunet-service-core_kx.c
index 8a7cada5c..944d1e692 100644
--- a/src/core/gnunet-service-core_kx.c
+++ b/src/core/gnunet-service-core_kx.c
@@ -708,6 +708,9 @@ setup_fresh_ping (struct GSC_KeyExchangeInfo *kx)
  *
  * @param cls the `struct GSC_KeyExchangeInfo`
  * @param m the message
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 deliver_message (void *cls,
@@ -950,7 +953,7 @@ handle_ephemeral_key (void *cls,
               kx->peer,
               sizeof (struct GNUNET_PeerIdentity)))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Received EPHEMERAL_KEY from %s, but expected %s\n",
                 GNUNET_i2s (&m->origin_identity),
                 GNUNET_i2s_full (kx->peer));
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c
index 5d34b7c26..babf169c0 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -147,12 +147,6 @@ struct Session
   struct GNUNET_TIME_Relative typemap_delay;
 
   /**
-   * Is the neighbour queue empty and thus ready for us
-   * to transmit an encrypted message?
-   */
-  int ready_to_transmit;
-
-  /**
    * Is this the first time we're sending the typemap? If so,
    * we want to send it a bit faster the second time.  0 if
    * we are sending for the first time, 1 if not.
@@ -641,13 +635,7 @@ try_transmission (struct Session *session)
   enum GNUNET_CORE_Priority maxpc;
   struct GSC_ClientActiveRequest *car;
   int excess;
-
-  if (GNUNET_YES != session->ready_to_transmit)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Not yet ready to transmit, not evaluating queue\n");
-    return;
-  }
+  
   msize = 0;
   min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
   /* if the peer has excess bandwidth, background traffic is allowed,
@@ -801,7 +789,6 @@ try_transmission (struct Session *session)
                            total_bytes / total_msgs,
                            GNUNET_NO);
     /* now actually transmit... */
-    session->ready_to_transmit = GNUNET_NO;
     GSC_KX_encrypt_and_transmit (session->kx,
                                  pbuf,
                                  used);
@@ -888,10 +875,12 @@ GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid)
 {
   struct Session *session;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transport solicits for %s\n",
+              GNUNET_i2s (pid));
   session = find_session (pid);
   if (NULL == session)
     return;
-  session->ready_to_transmit = GNUNET_YES;
   try_transmission (session);
 }
 
diff --git a/src/dht/Makefile.am b/src/dht/Makefile.am
index 4a78ea4c7..d60ff62d6 100644
--- a/src/dht/Makefile.am
+++ b/src/dht/Makefile.am
@@ -197,6 +197,7 @@ test_dht_monitor_LDADD = \
 
 EXTRA_DIST = \
   $(check_SCRIPTS) \
+  gnunet-service-dht_clients.c \
   test_dht_api_data.conf \
   test_dht_api_peer1.conf \
   test_dht_monitor.conf \
diff --git a/src/dht/gnunet-service-dht.c b/src/dht/gnunet-service-dht.c
index f2b922dc4..829c53aea 100644
--- a/src/dht/gnunet-service-dht.c
+++ b/src/dht/gnunet-service-dht.c
@@ -55,7 +55,6 @@ static struct GNUNET_TRANSPORT_HelloGetHandle *ghh;
 struct GNUNET_TIME_Relative hello_expiration;
 
 
-/* Code shared between different DHT implementations */
 #include "gnunet-service-dht_clients.c"
 
 
diff --git a/src/fs/fs_dirmetascan.c b/src/fs/fs_dirmetascan.c
index 7b9f178fd..8a3e37b49 100644
--- a/src/fs/fs_dirmetascan.c
+++ b/src/fs/fs_dirmetascan.c
@@ -246,6 +246,9 @@ finish_scan (void *cls)
  *
  * @param cls the closure (directory scanner object)
  * @param msg message from the helper process
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 process_helper_msgs (void *cls,
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index 76a1ea911..8f27e82af 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -179,7 +179,6 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
                               GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL);
     break;
   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-    consider_restart (event->status);
     printf ("Download complete,  %llu kbps.\n",
             (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index be9006d42..103ca01b8 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -134,7 +134,6 @@ progress_cb (void *cls,
   switch (event->status)
   {
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-    consider_restart (event->status);
     ret = event->value.publish.cctx;
     printf ("Publish complete,  %llu kbps.\n",
             (unsigned long long) (FILESIZE * 1000000LL /
diff --git a/src/hello/hello.c b/src/hello/hello.c
index 27580275f..690a0961a 100644
--- a/src/hello/hello.c
+++ b/src/hello/hello.c
@@ -271,7 +271,10 @@ GNUNET_HELLO_iterate_addresses (const struct GNUNET_HELLO_Message *msg,
   msize = GNUNET_HELLO_size (msg);
   if ((msize < sizeof (struct GNUNET_HELLO_Message)) ||
       (ntohs (msg->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
+  {
+    GNUNET_break_op (0);
     return NULL;
+  }
   ret = NULL;
   if (return_modified)
   {
@@ -285,6 +288,10 @@ GNUNET_HELLO_iterate_addresses (const struct GNUNET_HELLO_Message *msg,
   wpos = 0;
   woff = (NULL != ret) ? (char *) &ret[1] : NULL;
   address.peer.public_key = msg->publicKey;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "HELLO has %u bytes of address data\n",
+              (unsigned int) insize);
+  
   while (insize > 0)
   {
     esize = get_hello_address_size (inptr,
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index e5abec416..08e9dd156 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -33,6 +33,7 @@ gnunetinclude_HEADERS = \
   gnunet_bandwidth_lib.h \
   gnunet_bio_lib.h \
   gnunet_block_lib.h \
+  gnunet_block_group_lib.h \
   gnunet_block_plugin.h \
   gnunet_client_lib.h \
   gnunet_common.h \
@@ -65,7 +66,10 @@ gnunetinclude_HEADERS = \
   gnunet_hello_lib.h \
   gnunet_helper_lib.h \
   gnunet_identity_service.h \
+  gnunet_identity_provider_service.h \
   gnunet_json_lib.h \
+  gnunet_jsonapi_lib.h \
+  gnunet_jsonapi_util.h \
   gnunet_load_lib.h \
   gnunet_cadet_service.h \
   gnunet_microphone_lib.h \
@@ -102,6 +106,8 @@ gnunetinclude_HEADERS = \
   gnunet_protocols.h \
   gnunet_resolver_service.h \
   gnunet_regex_service.h \
+  gnunet_rest_lib.h \
+  gnunet_rest_plugin.h \
   gnunet_revocation_service.h \
   gnunet_scalarproduct_service.h \
   gnunet_scheduler_lib.h \
@@ -111,6 +117,7 @@ gnunetinclude_HEADERS = \
   gnunet_signal_lib.h \
   gnunet_signatures.h \
   gnunet_social_service.h \
+  gnunet_socks.h \
   gnunet_speaker_lib.h \
   gnunet_sq_lib.h \
   gnunet_statistics_service.h \
diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index d7f7b76ff..7d23e6f9b 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -988,7 +988,8 @@ GNUNET_ntoh_double (double d);
  *        arr is important since size is the number of elements and
  *        not the size in bytes
  * @param size the number of elements in the existing vector (number
- *        of elements to copy over)
+ *        of elements to copy over), will be updated with the new 
+ *        array size
  * @param tsize the target size for the resulting vector, use 0 to
  *        free the vector (then, arr will be NULL afterwards).
  */
@@ -996,8 +997,16 @@ GNUNET_ntoh_double (double d);
 
 /**
  * @ingroup memory
- * Append an element to a list (growing the
- * list by one).
+ * Append an element to a list (growing the list by one).
+ * 
+ * @param arr base-pointer of the vector, may be NULL if size is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param size the number of elements in the existing vector (number
+ *        of elements to copy over), will be updated with the new 
+ *        array size
+ * @param element the element that will be appended to the array
  */
 #define GNUNET_array_append(arr,size,element) do { GNUNET_array_grow(arr,size,size+1); arr[size-1] = element; } while(0)
 
diff --git a/src/include/gnunet_mst_lib.h b/src/include/gnunet_mst_lib.h
index 7a1ca7a55..fe6524eb3 100644
--- a/src/include/gnunet_mst_lib.h
+++ b/src/include/gnunet_mst_lib.h
@@ -61,7 +61,9 @@ struct GNUNET_MessageStreamTokenizer;
  *
  * @param cls closure
  * @param message the actual message
- * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
  */
 typedef int
 (*GNUNET_MessageTokenizerCallback) (void *cls,
diff --git a/src/include/gnunet_network_lib.h b/src/include/gnunet_network_lib.h
index d9d3d90e7..9e692bbbf 100644
--- a/src/include/gnunet_network_lib.h
+++ b/src/include/gnunet_network_lib.h
@@ -464,7 +464,7 @@ GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
  * @return POSIX file descriptor
  */
 int
-GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc);
+GNUNET_NETWORK_get_fd (const struct GNUNET_NETWORK_Handle *desc);
 
 
 /**
@@ -474,7 +474,7 @@ GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc);
  * @return POSIX file descriptor
  */
 struct sockaddr*
-GNUNET_NETWORK_get_addr (struct GNUNET_NETWORK_Handle *desc);
+GNUNET_NETWORK_get_addr (const struct GNUNET_NETWORK_Handle *desc);
 
 
 /**
@@ -484,7 +484,7 @@ GNUNET_NETWORK_get_addr (struct GNUNET_NETWORK_Handle *desc);
  * @return socklen_t for sockaddr
  */
 socklen_t
-GNUNET_NETWORK_get_addrlen (struct GNUNET_NETWORK_Handle *desc);
+GNUNET_NETWORK_get_addrlen (const struct GNUNET_NETWORK_Handle *desc);
 
 
 /**
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index 6710d749f..436adc5a4 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -2067,7 +2067,11 @@ extern "C"
 /** S->C: slave join acknowledgement */
 #define GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN_ACK 684
 
-/* 685-686 */
+/** C->S: request to part from a channel */
+#define GNUNET_MESSAGE_TYPE_PSYC_PART_REQUEST 685
+
+/** S->C: acknowledgement that a slave of master parted from a channel */
+#define GNUNET_MESSAGE_TYPE_PSYC_PART_ACK 686
 
 /** M->S->C: incoming join request from multicast */
 #define GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST 687
@@ -2258,6 +2262,7 @@ extern "C"
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_PART_ACK 755
 
+// FIXME: this is never used!
 /**
  * Group terminated.
  */
@@ -2398,35 +2403,38 @@ extern "C"
 /** C->S: request to leave a place */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE 848
 
+/** S->C: place leave acknowledgement */
+#define GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK 849
+
 /** C->S: add place to GNS zone */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_PLACE 849
+#define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_PLACE 850
 
 /** C->S: add nym to GNS zone */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_NYM 850
+#define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_NYM 851
 
 /** C->S: connect application */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT 851
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT 852
 
 /** C->S: detach a place from application */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_DETACH 852
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_DETACH 853
 
 /** S->C: notify about an existing ego */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO 853
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO 854
 
 /** S->C: end of ego list */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END 854
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END 855
 
 /** S->C: notify about an existing place */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE 855
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE 856
 
 /** S->C: end of place list */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END 856
+#define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END 857
 
 /** C->S: set message processing flags */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET 860
+#define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET 858
 
 /** C->S: clear message processing flags */
-#define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_CLEAR 861
+#define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_CLEAR 859
 
 /*******************************************************************************
  * X-VINE DHT messages
diff --git a/src/include/gnunet_rest_lib.h b/src/include/gnunet_rest_lib.h
index 243c38403..a4dbb0696 100644
--- a/src/include/gnunet_rest_lib.h
+++ b/src/include/gnunet_rest_lib.h
@@ -32,7 +32,7 @@
 #define GNUNET_REST_LIB_H
 
 #include "gnunet_util_lib.h"
-#include "microhttpd.h"
+#include <microhttpd.h>
 
 #define GNUNET_REST_HANDLER_END {NULL, NULL, NULL}
 
diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h
index a855ab8ab..d2805a685 100644
--- a/src/include/gnunet_scheduler_lib.h
+++ b/src/include/gnunet_scheduler_lib.h
@@ -152,14 +152,14 @@ struct GNUNET_SCHEDULER_FdInfo
    * NULL if this is about a file handle or if no network
    * handle was given to the scheduler originally.
    */
-  struct GNUNET_NETWORK_Handle *fd;
+  const struct GNUNET_NETWORK_Handle *fd;
 
   /**
    * GNUnet file handle the event is about, matches @a sock,
    * NULL if this is about a network socket or if no network
    * handle was given to the scheduler originally.
    */
-  struct GNUNET_DISK_FileHandle *fh;
+  const struct GNUNET_DISK_FileHandle *fh;
 
   /**
    * Type of the event that was generated related to @e sock.
@@ -216,17 +216,18 @@ struct GNUNET_SCHEDULER_TaskContext
 
 /**
  * Function used by event-loop implementations to signal the scheduler
- * that a particular @a task is ready due to an event of type @a et.
+ * that a particular @a task is ready due to an event specified in the
+ * et field of @a fdi.
  *
  * This function will then queue the task to notify the application
  * that the task is ready (with the respective priority).
  *
  * @param task the task that is ready
- * @param et information about why the task is ready
+ * @param fdi information about the related FD
  */
 void
 GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
-                             enum GNUNET_SCHEDULER_EventType et);
+                             struct GNUNET_SCHEDULER_FdInfo *fdi);
 
 
 /**
@@ -241,15 +242,16 @@ struct GNUNET_SCHEDULER_Handle;
  * there are tasks left to run just to give other tasks a chance as
  * well.  If we return #GNUNET_YES, the driver should call this
  * function again as soon as possible, while if we return #GNUNET_NO
- * it must block until the operating system has more work as the
- * scheduler has no more work to do right now.
+ * it must block until either the operating system has more work (the
+ * scheduler has no more work to do right now) or the timeout set by
+ * the scheduler (using the set_wakeup callback) is reached.
  *
  * @param sh scheduler handle that was given to the `loop`
  * @return #GNUNET_OK if there are more tasks that are ready,
  *          and thus we would like to run more (yield to avoid
  *          blocking other activities for too long)
  *         #GNUNET_NO if we are done running tasks (yield to block)
- *         #GNUNET_SYSERR on error
+ *         #GNUNET_SYSERR on error, e.g. no tasks were ready
  */
 int
 GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh);
@@ -268,8 +270,11 @@ struct GNUNET_SCHEDULER_Driver
   void *cls;
 
   /**
-   * Add a @a task to be run if the conditions given
-   * in @a fdi are satisfied.
+   * Add a @a task to be run if the conditions specified in the 
+   * et field of the given @a fdi are satisfied. The et field will
+   * be cleared after this call and the driver is expected to set
+   * the type of the actual event before passing @a fdi to
+   * #GNUNET_SCHEDULER_task_ready.
    *
    * @param cls closure
    * @param task task to add
@@ -280,21 +285,21 @@ struct GNUNET_SCHEDULER_Driver
   int
   (*add)(void *cls,
          struct GNUNET_SCHEDULER_Task *task,
-         struct GNUNET_SCHEDULER_FdInfo *fdi);
+         struct GNUNET_SCHEDULER_FdInfo *fdi);
 
   /**
-   * Delete a @a task from the set of tasks to be run.
+   * Delete a @a task from the set of tasks to be run. A task may
+   * comprise multiple FdInfo entries previously added with the add
+   * function. The driver is expected to delete them all.
    *
    * @param cls closure
    * @param task task to delete
-   * @param fdi conditions to watch for (must match @e add call)
    * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
-   *   (i.e. @a task or @a fdi do not match prior @e add call)
+   *   (i.e. @a task does not match prior @e add call)
    */
   int
   (*del)(void *cls,
-         struct GNUNET_SCHEDULER_Task *task,
-         const struct GNUNET_SCHEDULER_FdInfo *fdi);
+         struct GNUNET_SCHEDULER_Task *task);
 
   /**
    * Set time at which we definitively want to get a wakeup call.
@@ -309,7 +314,10 @@ struct GNUNET_SCHEDULER_Driver
   /**
    * Event loop's "main" function, to be called from
    * #GNUNET_SCHEDULER_run_with_driver() to actually
-   * launch the loop.
+   * launch the loop. The loop should run as long as
+   * tasks (added by the add callback) are available 
+   * OR the wakeup time (added by the set_wakeup
+   * callback) is not FOREVER.
    *
    * @param cls closure
    * @param sh scheduler handle to pass to
@@ -359,7 +367,7 @@ GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
  *
  * @return NULL on error
  */
-const struct GNUNET_SCHEDULER_Driver *
+struct GNUNET_SCHEDULER_Driver *
 GNUNET_SCHEDULER_driver_select (void);
 
 
diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h
index aacafe956..dda827c95 100644
--- a/src/include/gnunet_service_lib.h
+++ b/src/include/gnunet_service_lib.h
@@ -366,11 +366,16 @@ GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
 /**
  * Ask the server to disconnect from the given client.  This is the
  * same as returning #GNUNET_SYSERR within the check procedure when
- * handling a message, wexcept that it allows dropping of a client even
+ * handling a message, except that it allows dropping of a client even
  * when not handling a message from that client.  The `disconnect_cb`
  * will be called on @a c even if the application closes the connection
  * using this function.
  *
+ * This function should be called (outside of util's internal logic)
+ * if (and usually only if) the client has violated the
+ * protocol. Otherwise, we should leave it to the client to disconnect
+ * from the service.
+ *
  * @param c client to disconnect now
  */
 void
diff --git a/src/jsonapi/Makefile.am b/src/jsonapi/Makefile.am
index 3cf3a4cd2..054d3c550 100644
--- a/src/jsonapi/Makefile.am
+++ b/src/jsonapi/Makefile.am
@@ -24,7 +24,7 @@ libgnunetjsonapi_la_LDFLAGS = \
   -version-info 0:0:0 \
   -no-undefined
 libgnunetjsonapi_la_SOURCES = \
-        jsonapi_document.c \
+        jsonapi_document.c jsonapi_objects.h \
         jsonapi_resource.c \
         jsonapi_error.c \
         jsonapi_relationship.c
diff --git a/src/multicast/Makefile.am b/src/multicast/Makefile.am
index 13212bca3..48185e1a4 100644
--- a/src/multicast/Makefile.am
+++ b/src/multicast/Makefile.am
@@ -19,7 +19,7 @@ endif
 lib_LTLIBRARIES = libgnunetmulticast.la
 
 libgnunetmulticast_la_SOURCES = \
-  multicast_api.c
+  multicast_api.c multicast.h
 libgnunetmulticast_la_LIBADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(GN_LIBINTL) $(XLIB)
diff --git a/src/multicast/gnunet-service-multicast.c b/src/multicast/gnunet-service-multicast.c
index 2f4dc8a14..ba1086cc5 100644
--- a/src/multicast/gnunet-service-multicast.c
+++ b/src/multicast/gnunet-service-multicast.c
@@ -137,6 +137,7 @@ struct Channel
    */
   struct GNUNET_CADET_Channel *channel;
 
+  // FIXME: not used
   /**
    * CADET transmission handle.
    */
@@ -228,7 +229,7 @@ struct Group
   /**
    * Is the client disconnected? #GNUNET_YES or #GNUNET_NO
    */
-  uint8_t disconnected;
+  uint8_t is_disconnected;
 
   /**
    * Is this an origin (#GNUNET_YES), or member (#GNUNET_NO)?
@@ -365,6 +366,8 @@ client_send_join_decision (struct Member *mem,
 static void
 shutdown_task (void *cls)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "shutting down\n");
   if (NULL != cadet)
   {
     GNUNET_CADET_disconnect (cadet);
@@ -420,6 +423,11 @@ cleanup_member (struct Member *mem)
     GNUNET_free (mem->join_dcsn);
     mem->join_dcsn = NULL;
   }
+  if (NULL != mem->origin_channel)
+  {
+    GNUNET_CADET_channel_destroy (mem->origin_channel->channel);
+    mem->origin_channel = NULL;
+  }
   GNUNET_CONTAINER_multihashmap_remove (members, &grp->pub_key_hash, mem);
   GNUNET_free (mem);
 }
@@ -553,36 +561,47 @@ client_send (struct GNUNET_SERVICE_Client *client,
  * Send message to all clients connected to the group.
  */
 static void
-client_send_group (const struct Group *grp,
-                   const struct GNUNET_MessageHeader *msg)
+client_send_group_keep_envelope (const struct Group *grp,
+                                 struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "%p Sending message to all clients of the group.\n", grp);
+  struct ClientList *cli = grp->clients_head;
 
-  struct ClientList *cl = grp->clients_head;
-  while (NULL != cl)
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "%p Sending message to all clients of the group.\n",
+              grp);
+  while (NULL != cli)
   {
-    struct GNUNET_MQ_Envelope *
-      env = GNUNET_MQ_msg_copy (msg);
-
-    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cl->client),
-                    env);
-    cl = cl->next;
+    GNUNET_MQ_send_copy (GNUNET_SERVICE_client_get_mq (cli->client),
+                         env);
+    cli = cli->next;
   }
 }
 
 
 /**
+ * Send message to all clients connected to the group and
+ * takes care of freeing @env.
+ */
+static void
+client_send_group (const struct Group *grp,
+                   struct GNUNET_MQ_Envelope *env)
+{
+  client_send_group_keep_envelope (grp, env);
+  GNUNET_MQ_discard (env);
+}
+
+
+/**
  * Iterator callback for sending a message to origin clients.
  */
 static int
 client_send_origin_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
                        void *origin)
 {
-  const struct GNUNET_MessageHeader *msg = cls;
+  struct GNUNET_MQ_Envelope *env = cls;
   struct Member *orig = origin;
 
-  client_send_group (&orig->group, msg);
+  client_send_group_keep_envelope (&orig->group, env);
   return GNUNET_YES;
 }
 
@@ -594,12 +613,12 @@ static int
 client_send_member_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
                        void *member)
 {
-  const struct GNUNET_MessageHeader *msg = cls;
+  struct GNUNET_MQ_Envelope *env = cls;
   struct Member *mem = member;
 
   if (NULL != mem->join_dcsn)
   { /* Only send message to admitted members */
-    client_send_group (&mem->group, msg);
+    client_send_group_keep_envelope (&mem->group, env);
   }
   return GNUNET_YES;
 }
@@ -615,15 +634,16 @@ client_send_member_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
  */
 static int
 client_send_all (struct GNUNET_HashCode *pub_key_hash,
-                 const struct GNUNET_MessageHeader *msg)
+                 struct GNUNET_MQ_Envelope *env)
 {
   int n = 0;
   n += GNUNET_CONTAINER_multihashmap_get_multiple (origins, pub_key_hash,
                                                    client_send_origin_cb,
-                                                   (void *) msg);
+                                                   (void *) env);
   n += GNUNET_CONTAINER_multihashmap_get_multiple (members, pub_key_hash,
                                                    client_send_member_cb,
-                                                   (void *) msg);
+                                                   (void *) env);
+  GNUNET_MQ_discard (env);
   return n;
 }
 
@@ -636,14 +656,14 @@ client_send_all (struct GNUNET_HashCode *pub_key_hash,
  */
 static int
 client_send_random (struct GNUNET_HashCode *pub_key_hash,
-                    const struct GNUNET_MessageHeader *msg)
+                    struct GNUNET_MQ_Envelope *env)
 {
   int n = 0;
   n = GNUNET_CONTAINER_multihashmap_get_random (origins, client_send_origin_cb,
-                                                 (void *) msg);
+                                                 (void *) env);
   if (n <= 0)
     n = GNUNET_CONTAINER_multihashmap_get_random (members, client_send_member_cb,
-                                                   (void *) msg);
+                                                   (void *) env);
   return n;
 }
 
@@ -658,12 +678,12 @@ client_send_random (struct GNUNET_HashCode *pub_key_hash,
  */
 static int
 client_send_origin (struct GNUNET_HashCode *pub_key_hash,
-                    const struct GNUNET_MessageHeader *msg)
+                    struct GNUNET_MQ_Envelope *env)
 {
   int n = 0;
   n += GNUNET_CONTAINER_multihashmap_get_multiple (origins, pub_key_hash,
                                                    client_send_origin_cb,
-                                                   (void *) msg);
+                                                   (void *) env);
   return n;
 }
 
@@ -677,17 +697,12 @@ client_send_origin (struct GNUNET_HashCode *pub_key_hash,
 static void
 client_send_ack (struct GNUNET_HashCode *pub_key_hash)
 {
+  struct GNUNET_MQ_Envelope *env;
+
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Sending message ACK to client.\n");
-
-  static struct GNUNET_MessageHeader *msg = NULL;
-  if (NULL == msg)
-  {
-    msg = GNUNET_malloc (sizeof (*msg));
-    msg->type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK);
-    msg->size = htons (sizeof (*msg));
-  }
-  client_send_all (pub_key_hash, msg);
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK);
+  client_send_all (pub_key_hash, env);
 }
 
 
@@ -983,7 +998,8 @@ handle_cadet_join_request (void *cls,
   chn->peer = req->peer;
   chn->join_status = JOIN_WAITING;
 
-  client_send_all (&group_pub_hash, &req->header);
+  client_send_all (&group_pub_hash,
+                   GNUNET_MQ_msg_copy (&req->header));
 }
 
 
@@ -1102,7 +1118,8 @@ handle_cadet_message (void *cls,
 {
   struct Channel *chn = cls;
   GNUNET_CADET_receive_done (chn->channel);
-  client_send_all (&chn->group_pub_hash, &msg->header);
+  client_send_all (&chn->group_pub_hash,
+                   GNUNET_MQ_msg_copy (&msg->header));
 }
 
 
@@ -1153,30 +1170,32 @@ handle_cadet_request (void *cls,
 {
   struct Channel *chn = cls;
   GNUNET_CADET_receive_done (chn->channel);
-  client_send_origin (&chn->group_pub_hash, &req->header);
+  client_send_origin (&chn->group_pub_hash,
+                      GNUNET_MQ_msg_copy (&req->header));
 }
 
 
-static int
-check_cadet_replay_request (void *cls,
-                            const struct MulticastReplayRequestMessage *req)
-{
-  uint16_t size = ntohs (req->header.size);
-  if (size < sizeof (*req))
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-
-  struct Channel *chn = cls;
-  if (NULL == chn)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-
-  return GNUNET_OK;
-}
+// FIXME: do checks in handle_cadet_replay_request
+//static int
+//check_cadet_replay_request (void *cls,
+//                            const struct MulticastReplayRequestMessage *req)
+//{
+//  uint16_t size = ntohs (req->header.size);
+//  if (size < sizeof (*req))
+//  {
+//    GNUNET_break_op (0);
+//    return GNUNET_SYSERR;
+//  }
+//
+//  struct Channel *chn = cls;
+//  if (NULL == chn)
+//  {
+//    GNUNET_break_op (0);
+//    return GNUNET_SYSERR;
+//  }
+//
+//  return GNUNET_OK;
+//}
 
 
 /**
@@ -1187,6 +1206,7 @@ handle_cadet_replay_request (void *cls,
                              const struct MulticastReplayRequestMessage *req)
 {
   struct Channel *chn = cls;
+
   GNUNET_CADET_receive_done (chn->channel);
 
   struct MulticastReplayRequestMessage rep = *req;
@@ -1203,12 +1223,16 @@ handle_cadet_replay_request (void *cls,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
   }
   struct GNUNET_HashCode key_hash;
-  replay_key_hash (rep.fragment_id, rep.message_id, rep.fragment_offset,
-                   rep.flags, &key_hash);
+  replay_key_hash (rep.fragment_id,
+                   rep.message_id,
+                   rep.fragment_offset,
+                   rep.flags,
+                   &key_hash);
   GNUNET_CONTAINER_multihashmap_put (grp_replay_req, &key_hash, chn,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
-  client_send_random (&chn->group_pub_hash, &rep.header);
+  client_send_random (&chn->group_pub_hash,
+                      GNUNET_MQ_msg_copy (&rep.header));
 }
 
 
@@ -1290,10 +1314,10 @@ cadet_channel_create (struct Group *grp, struct GNUNET_PeerIdentity *peer)
                            struct MulticastJoinDecisionMessageHeader,
                            chn),
 
-    GNUNET_MQ_hd_var_size (cadet_replay_request,
-                           GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
-                           struct MulticastReplayRequestMessage,
-                           chn),
+    GNUNET_MQ_hd_fixed_size (cadet_replay_request,
+                             GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
+                             struct MulticastReplayRequestMessage,
+                             chn),
 
     GNUNET_MQ_hd_var_size (cadet_replay_response,
                            GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE,
@@ -1357,6 +1381,7 @@ handle_client_origin_start (void *cls,
     grp->is_origin = GNUNET_YES;
     grp->pub_key = pub_key;
     grp->pub_key_hash = pub_key_hash;
+    grp->is_disconnected = GNUNET_NO;
 
     GNUNET_CONTAINER_multihashmap_put (origins, &grp->pub_key_hash, orig,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
@@ -1379,10 +1404,10 @@ handle_client_origin_start (void *cls,
                              struct MulticastJoinRequestMessage,
                              grp),
 
-      GNUNET_MQ_hd_var_size (cadet_replay_request,
-                             GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
-                             struct MulticastReplayRequestMessage,
-                             grp),
+      GNUNET_MQ_hd_fixed_size (cadet_replay_request,
+                               GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
+                               struct MulticastReplayRequestMessage,
+                               grp),
 
       GNUNET_MQ_hd_var_size (cadet_replay_response,
                              GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE,
@@ -1484,6 +1509,7 @@ handle_client_member_join (void *cls,
     grp->is_origin = GNUNET_NO;
     grp->pub_key = msg->group_pub_key;
     grp->pub_key_hash = pub_key_hash;
+    grp->is_disconnected = GNUNET_NO;
     group_set_cadet_port_hash (grp);
   
     if (NULL == grp_mem)
@@ -1494,7 +1520,8 @@ handle_client_member_join (void *cls,
     }
     GNUNET_CONTAINER_multihashmap_put (grp_mem, &mem->pub_key_hash, mem,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-
+   
+    // FIXME: should the members hash map have option UNIQUE_FAST?
     GNUNET_CONTAINER_multihashmap_put (members, &grp->pub_key_hash, mem,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   }
@@ -1509,10 +1536,11 @@ handle_client_member_join (void *cls,
 
   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&mem->pub_key);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client connected to group %s as member %s (%s).\n",
+              "Client connected to group %s as member %s (%s). size = %d\n",
               GNUNET_h2s (&grp->pub_key_hash),
               GNUNET_h2s2 (&mem->pub_key_hash),
-              str);
+              str,
+              GNUNET_CONTAINER_multihashmap_size (members));
   GNUNET_free (str);
 
   if (NULL != mem->join_dcsn)
@@ -1567,7 +1595,9 @@ handle_client_member_join (void *cls,
       GNUNET_free (mem->join_req);
     mem->join_req = req;
 
-    if (0 == client_send_origin (&grp->pub_key_hash, &mem->join_req->header))
+    if (0 ==
+        client_send_origin (&grp->pub_key_hash,
+                            GNUNET_MQ_msg_copy (&mem->join_req->header)))
     { /* No local origins, send to remote origin */
       cadet_send_join_request (mem);
     }
@@ -1580,7 +1610,7 @@ static void
 client_send_join_decision (struct Member *mem,
                            const struct MulticastJoinDecisionMessageHeader *hdcsn)
 {
-  client_send_group (&mem->group, &hdcsn->header);
+  client_send_group (&mem->group, GNUNET_MQ_msg_copy (&hdcsn->header));
 
   const struct MulticastJoinDecisionMessage *
     dcsn = (const struct MulticastJoinDecisionMessage *) &hdcsn[1];
@@ -1621,8 +1651,9 @@ handle_client_join_decision (void *cls,
     GNUNET_SERVICE_client_drop (client);
     return;
   }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Got join decision from client for group %s..\n",
+              "%p got join decision from client for group %s..\n",
               grp, GNUNET_h2s (&grp->pub_key_hash));
 
   struct GNUNET_CONTAINER_MultiHashMap *
@@ -1652,6 +1683,32 @@ handle_client_join_decision (void *cls,
 }
 
 
+static void
+handle_client_part_request (void *cls,
+                            const struct GNUNET_MessageHeader *msg)
+{
+  struct Client *c = cls;
+  struct GNUNET_SERVICE_Client *client = c->client;
+  struct Group *grp = c->group;
+  struct GNUNET_MQ_Envelope *env;
+
+  if (NULL == grp)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p got part request from client for group %s.\n",
+              grp, GNUNET_h2s (&grp->pub_key_hash));
+  grp->is_disconnected = GNUNET_YES;
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_MULTICAST_PART_ACK);
+  client_send_group (grp, env);
+  GNUNET_SERVICE_client_continue (client);
+}
+
+
 static int
 check_client_multicast_message (void *cls,
                                 const struct GNUNET_MULTICAST_MessageHeader *msg)
@@ -1667,6 +1724,7 @@ static void
 handle_client_multicast_message (void *cls,
                                  const struct GNUNET_MULTICAST_MessageHeader *msg)
 {
+  // FIXME: what if GNUNET_YES == grp->is_disconnected? Do we allow sending messages?
   struct Client *c = cls;
   struct GNUNET_SERVICE_Client *client = c->client;
   struct Group *grp = c->group;
@@ -1680,6 +1738,7 @@ handle_client_multicast_message (void *cls,
   GNUNET_assert (GNUNET_YES == grp->is_origin);
   struct Origin *orig = grp->origin;
 
+  // FIXME: use GNUNET_MQ_msg_copy
   /* FIXME: yucky, should use separate message structs for P2P and CS! */
   struct GNUNET_MULTICAST_MessageHeader *
     out = (struct GNUNET_MULTICAST_MessageHeader *) GNUNET_copy_message (&msg->header);
@@ -1696,7 +1755,7 @@ handle_client_multicast_message (void *cls,
     GNUNET_assert (0);
   }
 
-  client_send_all (&grp->pub_key_hash, &out->header);
+  client_send_all (&grp->pub_key_hash, GNUNET_MQ_msg_copy (&out->header));
   cadet_send_children (&grp->pub_key_hash, &out->header);
   client_send_ack (&grp->pub_key_hash);
   GNUNET_free (out);
@@ -1730,6 +1789,7 @@ handle_client_multicast_request (void *cls,
     GNUNET_SERVICE_client_drop (client);
     return;
   }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
   GNUNET_assert (GNUNET_NO == grp->is_origin);
   struct Member *mem = grp->member;
 
@@ -1751,7 +1811,9 @@ handle_client_multicast_request (void *cls,
   }
 
   uint8_t send_ack = GNUNET_YES;
-  if (0 == client_send_origin (&grp->pub_key_hash, &out->header))
+  if (0 ==
+      client_send_origin (&grp->pub_key_hash,
+                          GNUNET_MQ_msg_copy (&out->header)))
   { /* No local origins, send to remote origin */
     if (NULL != mem->origin_channel)
     {
@@ -1792,6 +1854,7 @@ handle_client_replay_request (void *cls,
     GNUNET_SERVICE_client_drop (client);
     return;
   }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
   GNUNET_assert (GNUNET_NO == grp->is_origin);
   struct Member *mem = grp->member;
 
@@ -1812,7 +1875,9 @@ handle_client_replay_request (void *cls,
   GNUNET_CONTAINER_multihashmap_put (grp_replay_req, &key_hash, client,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
-  if (0 == client_send_origin (&grp->pub_key_hash, &rep->header))
+  if (0 ==
+      client_send_origin (&grp->pub_key_hash,
+                          GNUNET_MQ_msg_copy (&rep->header)))
   { /* No local origin, replay from remote members / origin. */
     if (NULL != mem->origin_channel)
     {
@@ -1821,6 +1886,7 @@ handle_client_replay_request (void *cls,
     else
     {
       /* FIXME: not yet connected to origin */
+      GNUNET_assert (0);
       GNUNET_SERVICE_client_drop (client);
       return;
     }
@@ -1880,6 +1946,7 @@ handle_client_replay_response_end (void *cls,
     GNUNET_SERVICE_client_drop (client);
     return;
   }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
 
   struct GNUNET_HashCode key_hash;
   replay_key_hash (res->fragment_id, res->message_id, res->fragment_offset,
@@ -1939,6 +2006,7 @@ handle_client_replay_response (void *cls,
     GNUNET_SERVICE_client_drop (client);
     return;
   }
+  GNUNET_assert (GNUNET_NO == grp->is_disconnected);
 
   const struct GNUNET_MessageHeader *msg = &res->header;
   if (GNUNET_MULTICAST_REC_OK == res->error_code)
@@ -2033,9 +2101,14 @@ client_notify_disconnect (void *cls,
               grp, (GNUNET_YES == grp->is_origin) ? "origin" : "member",
               GNUNET_h2s (&grp->pub_key_hash));
 
+  // FIXME (due to protocol change): here we must not remove all clients,
+  // only the one we were notified about!
   struct ClientList *cl = grp->clients_head;
   while (NULL != cl)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "iterating clients for group %p\n",
+                grp);
     if (cl->client == client)
     {
       GNUNET_CONTAINER_DLL_remove (grp->clients_head, grp->clients_tail, cl);
@@ -2049,16 +2122,7 @@ client_notify_disconnect (void *cls,
 
   if (NULL == grp->clients_head)
   { /* Last client disconnected. */
-#if FIXME
-    if (NULL != grp->tmit_head)
-    { /* Send pending messages via CADET before cleanup. */
-      transmit_message (grp);
-    }
-    else
-#endif
-    {
-      cleanup_group (grp);
-    }
+    cleanup_group (grp);
   }
 }
 
@@ -2103,9 +2167,9 @@ run (void *cls,
 GNUNET_SERVICE_MAIN
 ("multicast",
  GNUNET_SERVICE_OPTION_NONE,
- run,
- client_notify_connect,
- client_notify_disconnect,
+ &run,
+ &client_notify_connect,
+ &client_notify_disconnect,
  NULL,
  GNUNET_MQ_hd_fixed_size (client_origin_start,
                           GNUNET_MESSAGE_TYPE_MULTICAST_ORIGIN_START,
@@ -2119,6 +2183,10 @@ GNUNET_SERVICE_MAIN
                         GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION,
                         struct MulticastJoinDecisionMessageHeader,
                         NULL),
+ GNUNET_MQ_hd_fixed_size (client_part_request,
+                          GNUNET_MESSAGE_TYPE_MULTICAST_PART_REQUEST,
+                          struct GNUNET_MessageHeader,
+                          NULL),
  GNUNET_MQ_hd_var_size (client_multicast_message,
                         GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE,
                         struct GNUNET_MULTICAST_MessageHeader,
diff --git a/src/multicast/multicast_api.c b/src/multicast/multicast_api.c
index a8b1dee40..3c911f48a 100644
--- a/src/multicast/multicast_api.c
+++ b/src/multicast/multicast_api.c
@@ -542,31 +542,12 @@ group_cleanup (struct GNUNET_MULTICAST_Group *grp)
 
 
 static void
-group_disconnect (struct GNUNET_MULTICAST_Group *grp,
-                  GNUNET_ContinuationCallback cb,
-                  void *cls)
+handle_group_part_ack (void *cls,
+                       const struct GNUNET_MessageHeader *msg)
 {
-  grp->is_disconnecting = GNUNET_YES;
-  grp->disconnect_cb = cb;
-  grp->disconnect_cls = cls;
+  struct GNUNET_MULTICAST_Group *grp = cls;
 
-  if (NULL != grp->mq)
-  {
-    struct GNUNET_MQ_Envelope *last = GNUNET_MQ_get_last_envelope (grp->mq);
-    if (NULL != last)
-    {
-      GNUNET_MQ_notify_sent (last,
-                             (GNUNET_SCHEDULER_TaskCallback) group_cleanup, grp);
-    }
-    else
-    {
-      group_cleanup (grp);
-    }
-  }
-  else
-  {
-    group_cleanup (grp);
-  }
+  group_cleanup (grp);
 }
 
 
@@ -779,6 +760,10 @@ origin_connect (struct GNUNET_MULTICAST_Origin *orig)
                            GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST,
                            struct MulticastJoinRequestMessage,
                            grp),
+    GNUNET_MQ_hd_fixed_size (group_part_ack,
+                             GNUNET_MESSAGE_TYPE_MULTICAST_PART_ACK,
+                             struct GNUNET_MessageHeader,
+                             grp),
     GNUNET_MQ_hd_fixed_size (group_replay_request,
                              GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
                              struct MulticastReplayRequestMessage,
@@ -879,8 +864,13 @@ GNUNET_MULTICAST_origin_stop (struct GNUNET_MULTICAST_Origin *orig,
                               void *stop_cls)
 {
   struct GNUNET_MULTICAST_Group *grp = &orig->grp;
+  struct GNUNET_MQ_Envelope *env;
 
-  group_disconnect (grp, stop_cb, stop_cls);
+  grp->is_disconnecting = GNUNET_YES;
+  grp->disconnect_cb = stop_cb;
+  grp->disconnect_cls = stop_cls;
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_MULTICAST_PART_REQUEST);
+  GNUNET_MQ_send (grp->mq, env);
 }
 
 
@@ -1065,6 +1055,10 @@ member_connect (struct GNUNET_MULTICAST_Member *mem)
                            GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION,
                            struct MulticastJoinDecisionMessageHeader,
                            mem),
+    GNUNET_MQ_hd_fixed_size (group_part_ack,
+                             GNUNET_MESSAGE_TYPE_MULTICAST_PART_ACK,
+                             struct GNUNET_MessageHeader,
+                             grp),
     GNUNET_MQ_hd_fixed_size (group_replay_request,
                              GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST,
                              struct MulticastReplayRequestMessage,
@@ -1198,16 +1192,19 @@ GNUNET_MULTICAST_member_part (struct GNUNET_MULTICAST_Member *mem,
                               GNUNET_ContinuationCallback part_cb,
                               void *part_cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%p Member parting.\n", mem);
   struct GNUNET_MULTICAST_Group *grp = &mem->grp;
+  struct GNUNET_MQ_Envelope *env;
 
   mem->join_dcsn_cb = NULL;
   grp->join_req_cb = NULL;
   grp->message_cb = NULL;
   grp->replay_msg_cb = NULL;
   grp->replay_frag_cb = NULL;
-
-  group_disconnect (grp, part_cb, part_cls);
+  grp->is_disconnecting = GNUNET_YES;
+  grp->disconnect_cb = part_cb;
+  grp->disconnect_cls = part_cls;
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_MULTICAST_PART_REQUEST);
+  GNUNET_MQ_send (grp->mq, env);
 }
 
 
diff --git a/src/multicast/test_multicast_multipeer.c b/src/multicast/test_multicast_multipeer.c
index 5f4493993..7df1a8213 100644
--- a/src/multicast/test_multicast_multipeer.c
+++ b/src/multicast/test_multicast_multipeer.c
@@ -35,9 +35,10 @@
 
 #define PEERS_REQUESTED 12
 
-struct multicast_peer
+struct MulticastPeerContext
 {
   int peer; /* peer number */
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
   const struct GNUNET_PeerIdentity *id;
   struct GNUNET_TESTBED_Operation *op; /* not yet in use */
   struct GNUNET_TESTBED_Operation *pi_op; /* not yet in use */
@@ -61,7 +62,7 @@ static void service_connect (void *cls,
                              void *ca_result,
                              const char *emsg);
 
-static struct multicast_peer **mc_peers;
+static struct MulticastPeerContext **multicast_peers;
 static struct GNUNET_TESTBED_Peer **peers;
 
 // FIXME: refactor
@@ -69,18 +70,14 @@ static struct GNUNET_TESTBED_Operation *op[PEERS_REQUESTED];
 static struct GNUNET_TESTBED_Operation *pi_op[PEERS_REQUESTED];
 
 static struct GNUNET_MULTICAST_Origin *origin;
-static struct GNUNET_MULTICAST_Member *member[PEERS_REQUESTED]; /* first element always empty */
+static struct GNUNET_MULTICAST_Member *members[PEERS_REQUESTED]; /* first element always empty */
 
 static struct GNUNET_SCHEDULER_Task *timeout_tid;
 
-static struct GNUNET_CRYPTO_EddsaPrivateKey group_key;
+//static struct GNUNET_CRYPTO_EddsaPrivateKey *group_key;
 static struct GNUNET_CRYPTO_EddsaPublicKey group_pub_key;
 static struct GNUNET_HashCode group_pub_key_hash;
 
-static struct GNUNET_CRYPTO_EcdsaPrivateKey *member_key[PEERS_REQUESTED];
-static struct GNUNET_CRYPTO_EcdsaPublicKey *member_pub_key[PEERS_REQUESTED];
-
-
 /**
  * Global result for testcase.
  */
@@ -93,6 +90,8 @@ static int result;
 static void
 shutdown_task (void *cls)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "shutdown_task!\n");
   for (int i=0;i<PEERS_REQUESTED;i++)
   {
     if (NULL != op[i])
@@ -107,14 +106,16 @@ shutdown_task (void *cls)
     }
   }
 
-  if (NULL != mc_peers)
+  if (NULL != multicast_peers)
   {
     for (int i=0; i < PEERS_REQUESTED; i++)
     {
-      GNUNET_free (mc_peers[i]);
-      mc_peers[i] = NULL;
+      GNUNET_free (multicast_peers[i]->key);
+      GNUNET_free (multicast_peers[i]);
+      multicast_peers[i] = NULL;
     }
-    GNUNET_free (mc_peers);
+    GNUNET_free (multicast_peers);
+    multicast_peers = NULL;
   }
 
   if (NULL != timeout_tid)
@@ -141,11 +142,11 @@ member_join_request (void *cls,
                      const struct GNUNET_MessageHeader *join_msg,
                      struct GNUNET_MULTICAST_JoinHandle *jh)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Peer #%u (%s) sent a join request.\n", 
               mc_peer->peer, 
-              GNUNET_i2s (mc_peers[mc_peer->peer]->id));
+              GNUNET_i2s (multicast_peers[mc_peer->peer]->id));
 }
 
 
@@ -154,7 +155,7 @@ notify (void *cls,
         size_t *data_size,
         void *data)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
 
   struct pingpong_msg *pp_msg = GNUNET_new (struct pingpong_msg);
   pp_msg->peer = mc_peer->peer;
@@ -178,18 +179,18 @@ member_join_decision (void *cls,
                       const struct GNUNET_PeerIdentity *relays,
                       const struct GNUNET_MessageHeader *join_msg)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
   struct GNUNET_MULTICAST_MemberTransmitHandle *req;
   
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
               "Peer #%u (%s) received a decision from origin: %s\n", 
               mc_peer->peer, 
-              GNUNET_i2s (mc_peers[mc_peer->peer]->id),
+              GNUNET_i2s (multicast_peers[mc_peer->peer]->id),
               (GNUNET_YES == is_admitted)?"accepted":"rejected");
   
   if (GNUNET_YES == is_admitted)
   {
-    req = GNUNET_MULTICAST_member_to_origin (member[mc_peer->peer],
+    req = GNUNET_MULTICAST_member_to_origin (members[mc_peer->peer],
                                              0,
                                              notify,
                                              cls);
@@ -215,10 +216,32 @@ member_replay_msg ()
 
 
 static void
+origin_disconnected_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Origin disconnected. Shutting down.\n");
+  result = GNUNET_YES;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+member_disconnected_cb (void *cls)
+{
+  for (int i = 1; i < PEERS_REQUESTED; ++i)
+    if (GNUNET_NO == multicast_peers[i]->test_ok)
+      return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All member disconnected. Stopping origin.\n");
+  GNUNET_MULTICAST_origin_stop (origin, origin_disconnected_cb, cls);
+}
+
+
+static void
 member_message (void *cls, 
                 const struct GNUNET_MULTICAST_MessageHeader *msg)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
   struct pingpong_msg *pp_msg = (struct pingpong_msg*) &(msg[1]);
 
   if (PONG == pp_msg->msg && mc_peer->peer == pp_msg->peer)
@@ -226,18 +249,15 @@ member_message (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "peer #%i (%s) receives a pong\n", 
                 mc_peer->peer,
-                GNUNET_i2s (mc_peers[mc_peer->peer]->id));
-
+                GNUNET_i2s (multicast_peers[mc_peer->peer]->id));
     mc_peer->test_ok = GNUNET_OK;
-  }
-
-  // Test for completeness of received PONGs
-  for (int i=1; i<PEERS_REQUESTED; i++)
-    if (GNUNET_NO == mc_peers[i]->test_ok)
-      return;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "peer #%u (%s) parting from multicast group\n",
+                mc_peer->peer,
+                GNUNET_i2s (multicast_peers[mc_peer->peer]->id));
 
-  result = GNUNET_YES;
-  GNUNET_SCHEDULER_shutdown();
+    GNUNET_MULTICAST_member_part (members[mc_peer->peer], member_disconnected_cb, cls);
+  }
 }
 
 
@@ -349,81 +369,53 @@ origin_message (void *cls,
 
 
 static void
-multicast_da (void *cls,
-              void *op_result)
+multicast_disconnect (void *cls,
+                      void *op_result)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
 
-  if (0 == mc_peer->peer)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Origin closes multicast group\n");
-
-    GNUNET_MULTICAST_origin_stop (origin, NULL, cls);
-  }
-  else 
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "peer #%u (%s) parting from multicast group\n",
-                mc_peer->peer,
-                GNUNET_i2s (mc_peers[mc_peer->peer]->id));
-
-    GNUNET_MULTICAST_member_part (member[mc_peer->peer], NULL, cls);
-  }
 }
 
 
 static void *
-multicast_ca (void *cls,
-              const struct GNUNET_CONFIGURATION_Handle *cfg)
+multicast_connect (void *cls,
+                   const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *multicast_peer = cls;
   struct GNUNET_MessageHeader *join_msg;
   char data[64];
 
-  if (0 == mc_peer->peer)
+  multicast_peer->key = GNUNET_CRYPTO_ecdsa_key_create ();
+  if (0 == multicast_peer->peer)
   {
-    struct GNUNET_CRYPTO_EddsaPrivateKey *key = GNUNET_CRYPTO_eddsa_key_create ();
-    GNUNET_CRYPTO_eddsa_key_get_public (key, &group_pub_key);
+    GNUNET_CRYPTO_eddsa_key_get_public (multicast_peer->key, &group_pub_key);
     GNUNET_CRYPTO_hash (&group_pub_key, sizeof (group_pub_key), &group_pub_key_hash);
-
-    group_key = *key;
-    
     origin = GNUNET_MULTICAST_origin_start (cfg,
-                                          &group_key,
-                                          0,
-                                          origin_join_request,
-                                          origin_replay_frag,
-                                          origin_replay_msg,
-                                          origin_request,
-                                          origin_message,
-                                          cls);
-
-    if (NULL == origin) {
+                                            multicast_peer->key,
+                                            0,
+                                            origin_join_request,
+                                            origin_replay_frag,
+                                            origin_replay_msg,
+                                            origin_request,
+                                            origin_message,
+                                            cls);
+    if (NULL == origin)
+    {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Peer #%u could not create a multicast group",
-                  mc_peer->peer);
+                  multicast_peer->peer);
       return NULL;
     }
-
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Peer #%u connected as origin to group %s\n",
-                mc_peer->peer,
+                multicast_peer->peer,
                 GNUNET_h2s (&group_pub_key_hash));
-
     return origin;
   }
   else
   {
-    // Get members keys
-    member_pub_key[mc_peer->peer] = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPublicKey);
-    member_key[mc_peer->peer] = GNUNET_CRYPTO_ecdsa_key_create ();
-    GNUNET_CRYPTO_ecdsa_key_get_public (member_key[mc_peer->peer], 
-                                        member_pub_key[mc_peer->peer]);
-    
     sprintf(data, "Hi, I am peer #%u (%s). Can I enter?", 
-            mc_peer->peer,
-            GNUNET_i2s (mc_peers[mc_peer->peer]->id));
+            multicast_peer->peer,
+            GNUNET_i2s (multicast_peers[multicast_peer->peer]->id));
     uint8_t data_size = strlen (data) + 1;
     join_msg = GNUNET_malloc (sizeof (join_msg) + data_size);
     join_msg->size = htons (sizeof (join_msg) + data_size);
@@ -432,24 +424,25 @@ multicast_ca (void *cls,
 
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Peer #%u (%s) tries to join multicast group %s\n", 
-                mc_peer->peer,
-                GNUNET_i2s (mc_peers[mc_peer->peer]->id),
+                multicast_peer->peer,
+                GNUNET_i2s (multicast_peers[multicast_peer->peer]->id),
                 GNUNET_h2s (&group_pub_key_hash));
 
-    member[mc_peer->peer] = GNUNET_MULTICAST_member_join (cfg,
-                                                         &group_pub_key,
-                                                         member_key[mc_peer->peer],
-                                                         mc_peers[0]->id,
-                                                         0,
-                                                         NULL,
-                                                         join_msg, /* join message */
-                                                         member_join_request,
-                                                         member_join_decision,
-                                                         member_replay_frag,
-                                                         member_replay_msg,
-                                                         member_message,
-                                                         cls);
-    return member[mc_peer->peer];
+    members[multicast_peer->peer] =
+      GNUNET_MULTICAST_member_join (cfg,
+                                    &group_pub_key,
+                                    multicast_peer->key,
+                                    multicast_peers[0]->id,
+                                    0,
+                                    NULL,
+                                    join_msg, /* join message */
+                                    member_join_request,
+                                    member_join_decision,
+                                    member_replay_frag,
+                                    member_replay_msg,
+                                    member_message,
+                                    cls);
+    return members[multicast_peer->peer];
   }
 }
 
@@ -460,7 +453,7 @@ peer_information_cb (void *cls,
                      const struct GNUNET_TESTBED_PeerInformation *pinfo,
                      const char *emsg)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
 
   if (NULL == pinfo) {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got no peer information\n");
@@ -468,7 +461,7 @@ peer_information_cb (void *cls,
     GNUNET_SCHEDULER_shutdown ();
   }
 
-  mc_peers[mc_peer->peer]->id = pinfo->result.id;
+  multicast_peers[mc_peer->peer]->id = pinfo->result.id;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Got peer information of %s (%s)\n", 
@@ -478,22 +471,28 @@ peer_information_cb (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Create peer #%u (%s)\n", 
               mc_peer->peer,
-              GNUNET_i2s (mc_peers[mc_peer->peer]->id));
+              GNUNET_i2s (multicast_peers[mc_peer->peer]->id));
 
   if (0 != mc_peer->peer)
   {
     /* connect to multicast service of members */
-    op[mc_peer->peer] = GNUNET_TESTBED_service_connect (NULL,                    /* Closure for operation */
-                                                        peers[mc_peer->peer],                /* The peer whose service to connect to */
-                                                        "multicast",             /* The name of the service */
-                                                        service_connect,         /* callback to call after a handle to service
-                                                                                    is opened */
-                                                        cls,               /* closure for the above callback */
-                                                        multicast_ca,            /* callback to call with peer's configuration;
-                                                                                    this should open the needed service connection */
-                                                        multicast_da,            /* callback to be called when closing the
-                                                                                    opened service connection */
-                                                        cls);              /* closure for the above two callbacks */
+    op[mc_peer->peer] =
+      GNUNET_TESTBED_service_connect (/* Closure for operation */
+                                      NULL, 
+                                      /* The peer whose service to connect to */
+                                      peers[mc_peer->peer],
+                                      /* The name of the service */
+                                      "multicast",
+                                      /* called after a handle to service is opened */
+                                      service_connect,
+                                      /* closure for the above callback */
+                                      cls,
+                                      /* called when opening the service connection */
+                                      multicast_connect,
+                                      /* called when closing the service connection */
+                                      multicast_disconnect,
+                                      /* closure for the above two callbacks */
+                                      cls);
   }
 }
 
@@ -504,14 +503,14 @@ service_connect (void *cls,
                  void *ca_result,
                  const char *emsg)
 {
-  struct multicast_peer *mc_peer = (struct multicast_peer*)cls;
+  struct MulticastPeerContext *mc_peer = (struct MulticastPeerContext*)cls;
 
   if (NULL == ca_result)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
                 "Connection adapter not created for peer #%u (%s)\n", 
                 mc_peer->peer,
-                GNUNET_i2s (mc_peers[mc_peer->peer]->id));
+                GNUNET_i2s (multicast_peers[mc_peer->peer]->id));
 
     result = GNUNET_SYSERR;
     GNUNET_SCHEDULER_shutdown();
@@ -525,7 +524,7 @@ service_connect (void *cls,
       pi_op[i] = GNUNET_TESTBED_peer_get_information (peers[i],
                                                       GNUNET_TESTBED_PIT_IDENTITY,
                                                       peer_information_cb,
-                                                      mc_peers[i]);
+                                                      multicast_peers[i]);
     }
   }
 }
@@ -549,50 +548,51 @@ service_connect (void *cls,
  * @param links_failed number of links testbed was unable to establish
  */ static void
 testbed_master (void *cls,
-     struct GNUNET_TESTBED_RunHandle *h,
-     unsigned int num_peers,
-     struct GNUNET_TESTBED_Peer **p,
-     unsigned int links_succeeded,
-     unsigned int links_failed)
+                struct GNUNET_TESTBED_RunHandle *h,
+                unsigned int num_peers,
+                struct GNUNET_TESTBED_Peer **p,
+                unsigned int links_succeeded,
+                unsigned int links_failed)
 {
   /* Testbed is ready with peers running and connected in a pre-defined overlay
      topology (FIXME)  */
-  
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Connected to testbed_master()\n");
-
   peers = p;
-
-  mc_peers = GNUNET_new_array (PEERS_REQUESTED, struct multicast_peer*);
+  multicast_peers = GNUNET_new_array (PEERS_REQUESTED, struct MulticastPeerContext*);
 
   // Create test contexts for members
   for (int i = 0; i<PEERS_REQUESTED; i++) 
   {
-    mc_peers[i] = GNUNET_new (struct multicast_peer);
-    mc_peers[i]->peer = i;
-    mc_peers[i]->test_ok = GNUNET_NO;
+    multicast_peers[i] = GNUNET_new (struct MulticastPeerContext);
+    multicast_peers[i]->peer = i;
+    multicast_peers[i]->test_ok = GNUNET_NO;
   }
-
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Create origin peer\n");
-
-  op[0] = GNUNET_TESTBED_service_connect (NULL,                    /* Closure for operation */
-                                          peers[0],                /* The peer whose service to connect to */
-                                          "multicast",             /* The name of the service */
-                                          service_connect,   /* callback to call after a handle to service
-                                                                 is opened */
-                                          mc_peers[0],                    /* closure for the above callback */
-                                          multicast_ca,      /* callback to call with peer's configuration;
-                                                                 this should open the needed service connection */
-                                          multicast_da,     /* callback to be called when closing the
-                                                                opened service connection */
-                                          mc_peers[0]);                   /* closure for the above two callbacks */
-
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); /* Schedule a new task on shutdown */
-
+  op[0] =
+    GNUNET_TESTBED_service_connect (/* Closure for operation */
+                                    NULL,
+                                    /* The peer whose service to connect to */
+                                    peers[0],
+                                    /* The name of the service */
+                                    "multicast",
+                                    /* called after a handle to service is opened */
+                                    service_connect,
+                                    /* closure for the above callback */
+                                    multicast_peers[0],
+                                    /* called when opening the service connection */
+                                    multicast_connect,
+                                    /* called when closing the service connection */
+                                    multicast_disconnect,
+                                    /* closure for the above two callbacks */
+                                    multicast_peers[0]);
+  /* Schedule a new task on shutdown */
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
   /* Schedule the shutdown task with a delay of a few Seconds */
-  timeout_tid = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 400),
-                                              &timeout_task, NULL);
+  timeout_tid =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                  (GNUNET_TIME_UNIT_SECONDS, 400),
+                                  &timeout_task,
+                                  NULL);
 }
 
 
@@ -616,15 +616,21 @@ main (int argc, char *argv[])
   }
 
   result = GNUNET_SYSERR;
-  ret = GNUNET_TESTBED_test_run
-      ("test-multicast-multipeer",  /* test case name */
-       config_file, /* template configuration */
-       PEERS_REQUESTED,       /* number of peers to start */
-       0LL, /* Event mask - set to 0 for no event notifications */
-       NULL, /* Controller event callback */
-       NULL, /* Closure for controller event callback */
-       testbed_master, /* continuation callback to be called when testbed setup is complete */
-       NULL); /* Closure for the test_master callback */
+  ret =
+    GNUNET_TESTBED_test_run ("test-multicast-multipeer",
+                             config_file, 
+                             /* number of peers to start */
+                             PEERS_REQUESTED, 
+                             /* Event mask - set to 0 for no event notifications */
+                             0LL, 
+                             /* Controller event callback */
+                             NULL, 
+                             /* Closure for controller event callback */
+                             NULL, 
+                             /* called when testbed setup is complete */
+                             testbed_master, 
+                             /* Closure for the test_master callback */
+                             NULL); 
   if ( (GNUNET_OK != ret) || (GNUNET_OK != result) )
     return 1;
   return 0;
diff --git a/src/psyc/gnunet-service-psyc.c b/src/psyc/gnunet-service-psyc.c
index 73a3ae4ee..cf161435a 100644
--- a/src/psyc/gnunet-service-psyc.c
+++ b/src/psyc/gnunet-service-psyc.c
@@ -279,7 +279,7 @@ struct Channel
    * Is the client disconnected?
    * #GNUNET_YES or #GNUNET_NO
    */
-  uint8_t is_disconnected;
+  uint8_t is_disconnecting;
 
   /**
    * Is this a channel master (#GNUNET_YES), or slave (#GNUNET_NO)?
@@ -508,8 +508,6 @@ cleanup_master (struct Master *mst)
 {
   struct Channel *chn = &mst->channel;
 
-  if (NULL != mst->origin)
-    GNUNET_MULTICAST_origin_stop (mst->origin, NULL, NULL); // FIXME
   GNUNET_CONTAINER_multihashmap_destroy (mst->join_reqs);
   GNUNET_CONTAINER_multihashmap_remove (masters, &chn->pub_key_hash, mst);
 }
@@ -546,11 +544,6 @@ cleanup_slave (struct Slave *slv)
     GNUNET_free (slv->relays);
     slv->relays = NULL;
   }
-  if (NULL != slv->member)
-  {
-    GNUNET_MULTICAST_member_part (slv->member, NULL, NULL); // FIXME
-    slv->member = NULL;
-  }
   GNUNET_CONTAINER_multihashmap_remove (slaves, &chn->pub_key_hash, slv);
 }
 
@@ -603,15 +596,16 @@ client_notify_disconnect (void *cls,
   if (NULL == chn)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%p User context is NULL in client_disconnect()\n",
+                "%p User context is NULL in client_notify_disconnect ()\n",
                 chn);
     GNUNET_break (0);
     return;
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Client (%s) disconnected from channel %s\n",
+              "%p Client %p (%s) disconnected from channel %s\n",
               chn,
+              client,
               (GNUNET_YES == chn->is_master) ? "master" : "slave",
               GNUNET_h2s (&chn->pub_key_hash));
 
@@ -645,15 +639,8 @@ client_notify_disconnect (void *cls,
                 chn,
                 (GNUNET_YES == chn->is_master) ? "master" : "slave",
                 GNUNET_h2s (&chn->pub_key_hash));
-    chn->is_disconnected = GNUNET_YES;
-    if (NULL != chn->tmit_head)
-    { /* Send pending messages to multicast before cleanup. */
-      transmit_message (chn);
-    }
-    else
-    {
-      cleanup_channel (chn);
-    }
+    chn->is_disconnecting = GNUNET_YES;
+    cleanup_channel (chn);
   }
 }
 
@@ -688,7 +675,7 @@ client_send_msg (const struct Channel *chn,
                  const struct GNUNET_MessageHeader *msg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending message to clients.\n",
+              "Sending message to clients of channel %p.\n",
               chn);
 
   struct ClientList *cli = chn->clients_head;
@@ -699,7 +686,6 @@ client_send_msg (const struct Channel *chn,
 
     GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cli->client),
                     env);
-
     cli = cli->next;
   }
 }
@@ -734,7 +720,7 @@ client_send_result (struct GNUNET_SERVICE_Client *client, uint64_t op_id,
     GNUNET_memcpy (&res[1], data, data_size);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending result to client for operation #%" PRIu64 ": %" PRId64 " (size: %u)\n",
+              "%p Sending result to client for OP ID %" PRIu64 ": %" PRId64 " (size: %u)\n",
               client,
               GNUNET_ntohll (op_id),
               result_code,
@@ -1202,12 +1188,12 @@ fragment_queue_insert (struct Channel *chn,
     else if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == first_ptype
              || frag_offset == fragq->header_size)
     { /* header is now complete */
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p Header of message %" PRIu64 " is complete.\n",
                   chn,
                   GNUNET_ntohll (mmsg->message_id));
 
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p Adding message %" PRIu64 " to queue.\n",
                   chn,
                   GNUNET_ntohll (mmsg->message_id));
@@ -1215,7 +1201,7 @@ fragment_queue_insert (struct Channel *chn,
     }
     else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p Header of message %" PRIu64 " is NOT complete yet: %" PRIu64 " != %" PRIu64 "\n",
                   chn,
                   GNUNET_ntohll (mmsg->message_id),
@@ -1230,7 +1216,7 @@ fragment_queue_insert (struct Channel *chn,
     if (frag_offset == fragq->size)
       fragq->state = MSG_FRAG_STATE_END;
     else
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p Message %" PRIu64 " is NOT complete yet: %" PRIu64 " != %" PRIu64 "\n",
                   chn,
                   GNUNET_ntohll (mmsg->message_id),
@@ -1285,7 +1271,7 @@ static void
 fragment_queue_run (struct Channel *chn, uint64_t msg_id,
                     struct FragmentQueue *fragq, uint8_t drop)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Running message fragment queue for message %" PRIu64 " (state: %u).\n",
               chn,
               msg_id,
@@ -1413,7 +1399,7 @@ store_recv_state_modify_result (void *cls, int64_t result,
 static uint64_t
 message_queue_run (struct Channel *chn)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Running message queue.\n", chn);
   uint64_t n = 0;
   uint64_t msg_id;
@@ -1421,7 +1407,7 @@ message_queue_run (struct Channel *chn)
   while (GNUNET_YES == GNUNET_CONTAINER_heap_peek2 (chn->recv_msgs, NULL,
                                                     &msg_id))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "%p Processing message %" PRIu64 " in queue.\n", chn, msg_id);
     struct GNUNET_HashCode msg_id_hash;
     hash_key_from_hll (&msg_id_hash, msg_id);
@@ -1431,7 +1417,7 @@ message_queue_run (struct Channel *chn)
 
     if (NULL == fragq || fragq->state <= MSG_FRAG_STATE_HEADER)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p No fragq (%p) or header not complete.\n",
                   chn, fragq);
       break;
@@ -1453,7 +1439,7 @@ message_queue_run (struct Channel *chn)
             && (chn->max_message_id != msg_id - 1
                 && chn->max_message_id != msg_id))
         {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "%p Out of order message. "
                       "(%" PRIu64 " != %" PRIu64 " - 1)\n",
                       chn, chn->max_message_id, msg_id);
@@ -1469,7 +1455,7 @@ message_queue_run (struct Channel *chn)
         {
           if (msg_id - fragq->state_delta != chn->max_state_message_id)
           {
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                         "%p Out of order stateful message. "
                         "(%" PRIu64 " - %" PRIu64 " != %" PRIu64 ")\n",
                         chn, msg_id, fragq->state_delta, chn->max_state_message_id);
@@ -1515,8 +1501,6 @@ message_queue_run (struct Channel *chn)
 static uint64_t
 message_queue_drop (struct Channel *chn)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "%p Dropping message queue.\n", chn);
   uint64_t n = 0;
   uint64_t msg_id;
   while (GNUNET_YES == GNUNET_CONTAINER_heap_peek2 (chn->recv_msgs, NULL,
@@ -1703,7 +1687,7 @@ store_recv_slave_counters (void *cls, int result, uint64_t max_fragment_id,
   res.result_code = htonl (result);
   res.max_message_id = GNUNET_htonll (max_message_id);
 
-  if (GNUNET_OK == result || GNUNET_NO == result)
+  if (GNUNET_YES == result || GNUNET_NO == result)
   {
     chn->max_message_id = max_message_id;
     chn->max_state_message_id = max_state_message_id;
@@ -1831,6 +1815,9 @@ handle_client_slave_join (void *cls,
   struct GNUNET_CRYPTO_EcdsaPublicKey slv_pub_key;
   struct GNUNET_HashCode pub_key_hash, slv_pub_hash;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "got join request from client %p\n",
+              client);
   GNUNET_CRYPTO_ecdsa_key_get_public (&req->slave_key, &slv_pub_key);
   GNUNET_CRYPTO_hash (&slv_pub_key, sizeof (slv_pub_key), &slv_pub_hash);
   GNUNET_CRYPTO_hash (&req->channel_pub_key, sizeof (req->channel_pub_key), &pub_key_hash);
@@ -1905,7 +1892,7 @@ handle_client_slave_join (void *cls,
     GNUNET_CONTAINER_multihashmap_put (slaves, &chn->pub_key_hash, chn,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
     chn->store_op = GNUNET_PSYCSTORE_counters_get (store, &chn->pub_key,
-                                                  &store_recv_slave_counters, slv);
+                                                   &store_recv_slave_counters, slv);
   }
   else
   {
@@ -1952,8 +1939,9 @@ handle_client_slave_join (void *cls,
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Client connected as slave to channel %s.\n",
-              slv, GNUNET_h2s (&chn->pub_key_hash));
+              "Client %p connected as slave to channel %s.\n",
+              client,
+              GNUNET_h2s (&chn->pub_key_hash));
 
   struct ClientList *cli = GNUNET_malloc (sizeof (*cli));
   cli->client = client;
@@ -2037,6 +2025,49 @@ handle_client_join_decision (void *cls,
 }
 
 
+static void
+channel_part_cb (void *cls)
+{
+  struct GNUNET_SERVICE_Client *client = cls;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_PSYC_PART_ACK);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+}
+
+
+static void
+handle_client_part_request (void *cls,
+                            const struct GNUNET_MessageHeader *msg)
+{
+  struct Client *c = cls;
+
+  c->channel->is_disconnecting = GNUNET_YES;
+  if (GNUNET_YES == c->channel->is_master)
+  {
+    struct Master *mst = (struct Master *) c->channel;
+   
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got part request from master %p\n",
+                mst);
+    GNUNET_assert (NULL != mst->origin);
+    GNUNET_MULTICAST_origin_stop (mst->origin, channel_part_cb, c->client);
+  }
+  else
+  {
+    struct Slave *slv = (struct Slave *) c->channel;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got part request from slave %p\n",
+                slv);
+    GNUNET_assert (NULL != slv->member);
+    GNUNET_MULTICAST_member_part (slv->member, channel_part_cb, c->client);
+  }
+  GNUNET_SERVICE_client_continue (c->client);
+}
+
+
 /**
  * Send acknowledgement to a client.
  *
@@ -2096,7 +2127,7 @@ transmit_notify (void *cls, size_t *data_size, void *data)
   {
     GNUNET_SCHEDULER_add_now (&schedule_transmit_message, chn);
   }
-  else if (GNUNET_YES == chn->is_disconnected
+  else if (GNUNET_YES == chn->is_disconnecting
            && tmit_msg->last_ptype < GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END)
   {
     /* FIXME: handle partial message (when still in_transmit) */
@@ -2208,12 +2239,10 @@ transmit_message (struct Channel *chn)
 static void
 master_queue_message (struct Master *mst, struct TransmitMessage *tmit_msg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%p master_queue_message()\n", mst);
-
   if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == tmit_msg->first_ptype)
   {
     tmit_msg->id = ++mst->max_message_id;
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "%p master_queue_message: message_id=%" PRIu64 "\n",
                 mst, tmit_msg->id);
     struct GNUNET_PSYC_MessageMethod *pmeth
@@ -2225,7 +2254,7 @@ master_queue_message (struct Master *mst, struct TransmitMessage *tmit_msg)
     }
     else if (pmeth->flags & GNUNET_PSYC_MASTER_TRANSMIT_STATE_MODIFY)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "%p master_queue_message: state_delta=%" PRIu64 "\n",
                   mst, tmit_msg->id - mst->max_state_message_id);
       pmeth->state_delta = GNUNET_htonll (tmit_msg->id
@@ -2234,7 +2263,7 @@ master_queue_message (struct Master *mst, struct TransmitMessage *tmit_msg)
     }
     else
     {
-        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                     "%p master_queue_message: state not modified\n", mst);
       pmeth->state_delta = GNUNET_htonll (GNUNET_PSYC_STATE_NOT_MODIFIED);
     }
@@ -2359,7 +2388,9 @@ handle_client_psyc_message (void *cls,
   if (GNUNET_YES != chn->is_ready)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "%p Channel is not ready yet, disconnecting client.\n", chn);
+                "%p Channel is not ready yet, disconnecting client %p.\n",
+                chn,
+                client);
     GNUNET_break (0);
     GNUNET_SERVICE_client_drop (client);
     return;
@@ -2789,9 +2820,9 @@ run (void *cls,
 GNUNET_SERVICE_MAIN
 ("psyc",
  GNUNET_SERVICE_OPTION_NONE,
- run,
- client_notify_connect,
- client_notify_disconnect,
+ &run,
+ &client_notify_connect,
+ &client_notify_disconnect,
  NULL,
  GNUNET_MQ_hd_fixed_size (client_master_start,
                           GNUNET_MESSAGE_TYPE_PSYC_MASTER_START,
@@ -2805,6 +2836,10 @@ GNUNET_SERVICE_MAIN
                         GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION,
                         struct GNUNET_PSYC_JoinDecisionMessage,
                         NULL),
+ GNUNET_MQ_hd_fixed_size (client_part_request,
+                          GNUNET_MESSAGE_TYPE_PSYC_PART_REQUEST,
+                          struct GNUNET_MessageHeader,
+                          NULL),
  GNUNET_MQ_hd_var_size (client_psyc_message,
                         GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
                         struct GNUNET_MessageHeader,
diff --git a/src/psyc/psyc_api.c b/src/psyc/psyc_api.c
index c93d8b383..d8f4c98bc 100644
--- a/src/psyc/psyc_api.c
+++ b/src/psyc/psyc_api.c
@@ -260,6 +260,10 @@ handle_channel_result (void *cls,
   GNUNET_OP_result (chn->op, GNUNET_ntohll (res->op_id),
                     GNUNET_ntohll (res->result_code),
                     data, data_size, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "handle_channel_result: Received result message with OP ID %" PRIu64 "\n",
+              GNUNET_ntohll (res->op_id));
 }
 
 
@@ -555,6 +559,9 @@ handle_slave_join_decision (void *cls,
 static void
 channel_cleanup (struct GNUNET_PSYC_Channel *chn)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "cleaning up channel %p\n",
+              chn);
   if (NULL != chn->tmit)
   {
     GNUNET_PSYC_transmit_destroy (chn->tmit);
@@ -562,6 +569,7 @@ channel_cleanup (struct GNUNET_PSYC_Channel *chn)
   }
   if (NULL != chn->recv)
   {
+
     GNUNET_PSYC_receive_destroy (chn->recv);
     chn->recv = NULL;
   }
@@ -585,30 +593,12 @@ channel_cleanup (struct GNUNET_PSYC_Channel *chn)
 
 
 static void
-channel_disconnect (struct GNUNET_PSYC_Channel *chn,
-                    GNUNET_ContinuationCallback cb,
-                    void *cls)
+handle_channel_part_ack (void *cls,
+                         const struct GNUNET_MessageHeader *msg)
 {
-  chn->is_disconnecting = GNUNET_YES;
-  chn->disconnect_cb = cb;
-  chn->disconnect_cls = cls;
+  struct GNUNET_PSYC_Channel *chn = cls;
 
-  if (NULL != chn->mq)
-  {
-    struct GNUNET_MQ_Envelope *env = GNUNET_MQ_get_last_envelope (chn->mq);
-    if (NULL != env)
-    {
-      GNUNET_MQ_notify_sent (env, (GNUNET_SCHEDULER_TaskCallback) channel_cleanup, chn);
-    }
-    else
-    {
-      channel_cleanup (chn);
-    }
-  }
-  else
-  {
-    channel_cleanup (chn);
-  }
+  channel_cleanup (chn); 
 }
 
 
@@ -671,6 +661,10 @@ master_connect (struct GNUNET_PSYC_Master *mst)
                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
                            struct GNUNET_PSYC_JoinRequestMessage,
                            mst),
+    GNUNET_MQ_hd_fixed_size (channel_part_ack,
+                             GNUNET_MESSAGE_TYPE_PSYC_PART_ACK,
+                             struct GNUNET_MessageHeader,
+                             chn),
     GNUNET_MQ_hd_var_size (channel_message,
                            GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
                            struct GNUNET_PSYC_MessageHeader,
@@ -694,8 +688,11 @@ master_connect (struct GNUNET_PSYC_Master *mst)
     GNUNET_MQ_handler_end ()
   };
 
-  chn->mq = GNUNET_CLIENT_connect (chn->cfg, "psyc",
-                                   handlers, master_disconnected, mst);
+  chn->mq = GNUNET_CLIENT_connect (chn->cfg,
+                                   "psyc",
+                                   handlers,
+                                   &master_disconnected,
+                                   mst);
   GNUNET_assert (NULL != chn->mq);
   chn->tmit = GNUNET_PSYC_transmit_create (chn->mq);
 
@@ -780,10 +777,13 @@ GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *mst,
                          void *stop_cls)
 {
   struct GNUNET_PSYC_Channel *chn = &mst->chn;
+  struct GNUNET_MQ_Envelope *env;
 
-  /* FIXME: send msg to service */
-
-  channel_disconnect (chn, stop_cb, stop_cls);
+  chn->is_disconnecting = GNUNET_YES;
+  chn->disconnect_cb = stop_cb;
+  chn->disconnect_cls = stop_cls;
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_PSYC_PART_REQUEST);
+  GNUNET_MQ_send (chn->mq, env);
 }
 
 
@@ -931,7 +931,8 @@ slave_reconnect (void *cls)
  * Reconnect after backoff period.
  */
 static void
-slave_disconnected (void *cls, enum GNUNET_MQ_Error error)
+slave_disconnected (void *cls,
+                    enum GNUNET_MQ_Error error)
 {
   struct GNUNET_PSYC_Slave *slv = cls;
   struct GNUNET_PSYC_Channel *chn = &slv->chn;
@@ -950,7 +951,7 @@ slave_disconnected (void *cls, enum GNUNET_MQ_Error error)
     chn->mq = NULL;
   }
   chn->reconnect_task = GNUNET_SCHEDULER_add_delayed (chn->reconnect_delay,
-                                                      slave_reconnect,
+                                                      &slave_reconnect,
                                                       slv);
   chn->reconnect_delay = GNUNET_TIME_STD_BACKOFF (chn->reconnect_delay);
 }
@@ -970,6 +971,10 @@ slave_connect (struct GNUNET_PSYC_Slave *slv)
                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION,
                            struct GNUNET_PSYC_JoinDecisionMessage,
                            slv),
+    GNUNET_MQ_hd_fixed_size (channel_part_ack,
+                             GNUNET_MESSAGE_TYPE_PSYC_PART_ACK,
+                             struct GNUNET_MessageHeader,
+                             chn),
     GNUNET_MQ_hd_var_size (channel_message,
                            GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
                            struct GNUNET_PSYC_MessageHeader,
@@ -993,9 +998,19 @@ slave_connect (struct GNUNET_PSYC_Slave *slv)
     GNUNET_MQ_handler_end ()
   };
 
-  chn->mq = GNUNET_CLIENT_connect (chn->cfg, "psyc",
-                                   handlers, slave_disconnected, slv);
-  GNUNET_assert (NULL != chn->mq);
+  chn->mq = GNUNET_CLIENT_connect (chn->cfg,
+                                   "psyc",
+                                   handlers,
+                                   &slave_disconnected,
+                                   slv);
+  if (NULL == chn->mq)
+  {
+    chn->reconnect_task = GNUNET_SCHEDULER_add_delayed (chn->reconnect_delay,
+                                                        &slave_reconnect,
+                                                        slv);
+    chn->reconnect_delay = GNUNET_TIME_STD_BACKOFF (chn->reconnect_delay);
+    return;
+  }
   chn->tmit = GNUNET_PSYC_transmit_create (chn->mq);
 
   GNUNET_MQ_send_copy (chn->mq, chn->connect_env);
@@ -1107,10 +1122,13 @@ GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slv,
                         void *part_cls)
 {
   struct GNUNET_PSYC_Channel *chn = &slv->chn;
+  struct GNUNET_MQ_Envelope *env;
 
-  /* FIXME: send msg to service */
-
-  channel_disconnect (chn, part_cb, part_cls);
+  chn->is_disconnecting = GNUNET_YES;
+  chn->disconnect_cb = part_cb;
+  chn->disconnect_cls = part_cls;
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_PSYC_PART_REQUEST);
+  GNUNET_MQ_send (chn->mq, env);
 }
 
 
@@ -1233,6 +1251,9 @@ GNUNET_PSYC_channel_slave_add (struct GNUNET_PSYC_Channel *chn,
   req->did_join = GNUNET_YES;
   req->op_id = GNUNET_htonll (GNUNET_OP_add (chn->op, result_cb, cls, NULL));
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "GNUNET_PSYC_channel_slave_add, OP ID: %" PRIu64 "\n",
+              GNUNET_ntohll (req->op_id));
   GNUNET_MQ_send (chn->mq, env);
 }
 
@@ -1283,6 +1304,9 @@ GNUNET_PSYC_channel_slave_remove (struct GNUNET_PSYC_Channel *chn,
   req->did_join = GNUNET_NO;
   req->op_id = GNUNET_htonll (GNUNET_OP_add (chn->op, result_cb, cls, NULL));
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "GNUNET_PSYC_channel_slave_remove, OP ID: %" PRIu64 "\n",
+              GNUNET_ntohll (req->op_id));
   GNUNET_MQ_send (chn->mq, env);
 }
 
@@ -1321,6 +1345,10 @@ channel_history_replay (struct GNUNET_PSYC_Channel *chn,
   req->message_limit = GNUNET_htonll (message_limit);
   req->flags = htonl (flags);
   req->op_id = GNUNET_htonll (hist->op_id);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "channel_history_replay, OP ID: %" PRIu64 "\n",
+              GNUNET_ntohll (req->op_id));
   GNUNET_memcpy (&req[1], method_prefix, method_size);
 
   GNUNET_MQ_send (chn->mq, env);
@@ -1459,6 +1487,11 @@ channel_state_get (struct GNUNET_PSYC_Channel *chn,
   struct GNUNET_MQ_Envelope *
     env = GNUNET_MQ_msg_extra (req, name_size, type);
   req->op_id = GNUNET_htonll (sr->op_id);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "channel_state_get, OP ID: %" PRIu64 "\n",
+              GNUNET_ntohll (req->op_id));
+
   GNUNET_memcpy (&req[1], name, name_size);
 
   GNUNET_MQ_send (chn->mq, env);
diff --git a/src/psyc/test_psyc.c b/src/psyc/test_psyc.c
index 03a1890b1..370befb9d 100644
--- a/src/psyc/test_psyc.c
+++ b/src/psyc/test_psyc.c
@@ -755,15 +755,22 @@ slave_add ()
 
 
 static void
+schedule_second_slave_join (void *cls)
+{
+  slave_join (TEST_SLAVE_JOIN_ACCEPT);
+}
+
+
+static void
 first_slave_parted (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First slave parted.\n");
-  slave_join (TEST_SLAVE_JOIN_ACCEPT);
+  GNUNET_SCHEDULER_add_now (&schedule_second_slave_join, NULL);
 }
 
 
 static void
-schedule_slave_part (void *cls)
+schedule_first_slave_part (void *cls)
 {
   GNUNET_PSYC_slave_part (slv, GNUNET_NO, &first_slave_parted, NULL);
 }
@@ -783,7 +790,7 @@ join_decision_cb (void *cls,
   case TEST_SLAVE_JOIN_REJECT:
     GNUNET_assert (0 == is_admitted);
     GNUNET_assert (1 == join_req_count);
-    GNUNET_SCHEDULER_add_now (&schedule_slave_part, NULL);
+    GNUNET_SCHEDULER_add_now (&schedule_first_slave_part, NULL);
     break;
 
   case TEST_SLAVE_JOIN_ACCEPT:
@@ -844,11 +851,18 @@ slave_join (int t)
   struct GNUNET_PSYC_Message *
     join_msg = GNUNET_PSYC_message_create ("_request_join", env, "some data", 9);
 
-  slv = GNUNET_PSYC_slave_join (cfg, &channel_pub_key, slave_key,
+  slv = GNUNET_PSYC_slave_join (cfg,
+                                &channel_pub_key,
+                                slave_key,
                                 GNUNET_PSYC_SLAVE_JOIN_NONE,
-                                &origin, 0, NULL,
-                                &slave_message_cb, &slave_message_part_cb,
-                                &slave_connect_cb, &join_decision_cb, NULL,
+                                &origin,
+                                0,
+                                NULL,
+                                &slave_message_cb,
+                                &slave_message_part_cb,
+                                &slave_connect_cb,
+                                &join_decision_cb,
+                                NULL,
                                 join_msg);
   GNUNET_free (join_msg);
   slv_chn = GNUNET_PSYC_slave_get_channel (slv);
diff --git a/src/psyc/test_psyc.conf b/src/psyc/test_psyc.conf
index e69de29bb..e00a614d2 100644
--- a/src/psyc/test_psyc.conf
+++ b/src/psyc/test_psyc.conf
@@ -0,0 +1,16 @@
+@INLINE@ ../../contrib/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = /tmp/gnunet-test-psyc/
+
+[transport]
+PLUGINS = tcp
+
+[nat]
+DISABLEV6 = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
diff --git a/src/psycstore/psycstore_api.c b/src/psycstore/psycstore_api.c
index d79daa357..16f4a1ae9 100644
--- a/src/psycstore/psycstore_api.c
+++ b/src/psycstore/psycstore_api.c
@@ -148,14 +148,14 @@ handle_result_code (void *cls, const struct OperationResult *opres)
                                       str, size - sizeof (*opres), (void **) &op))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "handle_result_code: Received result message with operation ID: %" PRIu64 "\n",
+         "handle_result_code: Received result message with OP ID: %" PRIu64 "\n",
          GNUNET_ntohll (opres->op_id));
     GNUNET_free (op);
   }
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "handle_result_code: No callback registered for operation with ID %" PRIu64 ".\n",
+         "handle_result_code: No callback registered for OP ID %" PRIu64 ".\n",
          GNUNET_ntohll (opres->op_id));
   }
   h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
@@ -187,7 +187,7 @@ handle_result_counters (void *cls, const struct CountersResult *cres)
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "handle_result_counters: No callback registered for operation with ID %" PRIu64 ".\n",
+         "handle_result_counters: No callback registered for OP ID %" PRIu64 ".\n",
          GNUNET_ntohll (cres->op_id));
   }
   h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
@@ -233,7 +233,7 @@ handle_result_fragment (void *cls, const struct FragmentResult *fres)
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "handle_result_fragment: No callback registered for operation with ID %" PRIu64 ".\n",
+         "handle_result_fragment: No callback registered for OP ID %" PRIu64 ".\n",
          GNUNET_ntohll (fres->op_id));
   }
   h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
@@ -282,7 +282,7 @@ handle_result_state (void *cls, const struct StateResult *sres)
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "handle_result_state: No callback registered for operation with ID %" PRIu64 ".\n",
+         "handle_result_state: No callback registered for OP ID %" PRIu64 ".\n",
          GNUNET_ntohll (sres->op_id));
   }
   h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
diff --git a/src/rest/Makefile.am b/src/rest/Makefile.am
index c0feb9122..ebfb98024 100644
--- a/src/rest/Makefile.am
+++ b/src/rest/Makefile.am
@@ -26,6 +26,8 @@ lib_LTLIBRARIES = \
 libexec_PROGRAMS = \
  gnunet-rest-server
 
+EXTRA_DIST = \
+ rest.conf
 
 gnunet_rest_server_SOURCES = \
  gnunet-rest-server.c
diff --git a/src/rps/.gitignore b/src/rps/.gitignore
index 0d460e62c..cb14f5b09 100644
--- a/src/rps/.gitignore
+++ b/src/rps/.gitignore
@@ -1,3 +1,15 @@
 gnunet-service-rps
 gnunet-rps
 gnunet-rps-profiler
+test_rps_malicious_1
+test_rps_malicious_2
+test_rps_malicious_3
+test_rps_req_cancel
+test_rps_seed_big
+test_rps_seed_request
+test_rps_single_req
+test_service_rps_custommap
+test_service_rps_sampler_elem
+test_service_rps_view
+test_rps_churn
+test_service_rps_peers
diff --git a/src/rps/Makefile.am b/src/rps/Makefile.am
index e6c8cd929..de3469254 100644
--- a/src/rps/Makefile.am
+++ b/src/rps/Makefile.am
@@ -49,7 +49,6 @@ endif
 gnunet_service_rps_SOURCES = \
  gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
  gnunet-service-rps_sampler.h gnunet-service-rps_sampler.c \
- gnunet-service-rps_peers.h gnunet-service-rps_peers.c \
  gnunet-service-rps_custommap.h gnunet-service-rps_custommap.c \
  gnunet-service-rps_view.h gnunet-service-rps_view.c \
  rps-test_util.h rps-test_util.c \
@@ -73,7 +72,6 @@ if HAVE_TESTING
 check_PROGRAMS = \
  test_service_rps_view \
  test_service_rps_custommap \
- test_service_rps_peers \
  test_service_rps_sampler_elem \
  test_rps_malicious_1 \
  test_rps_malicious_2 \
@@ -81,7 +79,8 @@ check_PROGRAMS = \
  test_rps_seed_request \
  test_rps_single_req \
  test_rps_req_cancel \
- test_rps_seed_big
+ test_rps_seed_big \
+ test_rps_churn
 endif
 
 ld_rps_test_lib = \
@@ -105,13 +104,6 @@ test_service_rps_view_SOURCES = \
   test_service_rps_view.c
 test_service_rps_view_LDADD = $(top_builddir)/src/util/libgnunetutil.la
 
-test_service_rps_peers_SOURCES = \
-  gnunet-service-rps_peers.h gnunet-service-rps_peers.c \
-  test_service_rps_peers.c
-test_service_rps_peers_LDADD = \
-  $(top_builddir)/src/util/libgnunetutil.la \
-  $(top_builddir)/src/cadet/libgnunetcadet.la
-
 test_service_rps_custommap_SOURCES = \
   gnunet-service-rps_custommap.h gnunet-service-rps_custommap.c \
   test_service_rps_custommap.c
@@ -145,6 +137,9 @@ test_rps_req_cancel_LDADD = $(ld_rps_test_lib)
 test_rps_seed_big_SOURCES = $(rps_test_src)
 test_rps_seed_big_LDADD = $(ld_rps_test_lib)
 
+test_rps_churn_SOURCES = $(rps_test_src)
+test_rps_churn_LDADD = $(ld_rps_test_lib)
+
 gnunet_rps_profiler_SOURCES = $(rps_test_src)
 gnunet_rps_profiler_LDADD = $(ld_rps_test_lib)
 
diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index 0a4543b30..ec70075cf 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -33,7 +33,6 @@
 #include "rps-test_util.h"
 #include "gnunet-service-rps_sampler.h"
 #include "gnunet-service-rps_custommap.h"
-#include "gnunet-service-rps_peers.h"
 #include "gnunet-service-rps_view.h"
 
 #include <math.h>
@@ -66,6 +65,1728 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 static struct GNUNET_PeerIdentity own_identity;
 
 
+
+/***********************************************************************
+ * Old gnunet-service-rps_peers.c
+***********************************************************************/
+
+/**
+ * Set a peer flag of given peer context.
+ */
+#define set_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
+
+/**
+ * Get peer flag of given peer context.
+ */
+#define check_peer_flag_set(peer_ctx, mask)\
+  ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
+
+/**
+ * Unset flag of given peer context.
+ */
+#define unset_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
+
+/**
+ * Set a channel flag of given channel context.
+ */
+#define set_channel_flag(channel_flags, mask) ((*channel_flags) |= (mask))
+
+/**
+ * Get channel flag of given channel context.
+ */
+#define check_channel_flag_set(channel_flags, mask)\
+  ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
+
+/**
+ * Unset flag of given channel context.
+ */
+#define unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask))
+
+
+
+/**
+ * Pending operation on peer consisting of callback and closure
+ *
+ * When an operation cannot be executed right now this struct is used to store
+ * the callback and closure for later execution.
+ */
+struct PeerPendingOp
+{
+  /**
+   * Callback
+   */
+  PeerOp op;
+
+  /**
+   * Closure
+   */
+  void *op_cls;
+};
+
+/**
+ * List containing all messages that are yet to be send
+ *
+ * This is used to keep track of all messages that have not been sent yet. When
+ * a peer is to be removed the pending messages can be removed properly.
+ */
+struct PendingMessage
+{
+  /**
+   * DLL next, prev
+   */
+  struct PendingMessage *next;
+  struct PendingMessage *prev;
+
+  /**
+   * The envelope to the corresponding message
+   */
+  struct GNUNET_MQ_Envelope *ev;
+
+  /**
+   * The corresponding context
+   */
+  struct PeerContext *peer_ctx;
+
+  /**
+   * The message type
+   */
+  const char *type;
+};
+
+/**
+ * Struct used to keep track of other peer's status
+ *
+ * This is stored in a multipeermap.
+ * It contains information such as cadet channels, a message queue for sending,
+ * status about the channels, the pending operations on this peer and some flags
+ * about the status of the peer itself. (live, valid, ...)
+ */
+struct PeerContext
+{
+  /**
+   * Message queue open to client
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Channel open to client.
+   */
+  struct GNUNET_CADET_Channel *send_channel;
+
+  /**
+   * Flags to the sending channel
+   */
+  uint32_t *send_channel_flags;
+
+  /**
+   * Channel open from client.
+   */
+  struct GNUNET_CADET_Channel *recv_channel; // unneeded?
+
+  /**
+   * Flags to the receiving channel
+   */
+  uint32_t *recv_channel_flags;
+
+  /**
+   * Array of pending operations on this peer.
+   */
+  struct PeerPendingOp *pending_ops;
+
+  /**
+   * Handle to the callback given to cadet_ntfy_tmt_rdy()
+   *
+   * To be canceled on shutdown.
+   */
+  struct PendingMessage *liveliness_check_pending;
+
+  /**
+   * Number of pending operations.
+   */
+  unsigned int num_pending_ops;
+
+  /**
+   * Identity of the peer
+   */
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * Flags indicating status of peer
+   */
+  uint32_t peer_flags;
+
+  /**
+   * Last time we received something from that peer.
+   */
+  struct GNUNET_TIME_Absolute last_message_recv;
+
+  /**
+   * Last time we received a keepalive message.
+   */
+  struct GNUNET_TIME_Absolute last_keepalive;
+
+  /**
+   * DLL with all messages that are yet to be sent
+   */
+  struct PendingMessage *pending_messages_head;
+  struct PendingMessage *pending_messages_tail;
+
+  /**
+   * This is pobably followed by 'statistical' data (when we first saw
+   * him, how did we get his ID, how many pushes (in a timeinterval),
+   * ...)
+   */
+};
+
+/**
+ * @brief Closure to #valid_peer_iterator
+ */
+struct PeersIteratorCls
+{
+  /**
+   * Iterator function
+   */
+  PeersIterator iterator;
+
+  /**
+   * Closure to iterator
+   */
+  void *cls;
+};
+
+/**
+ * @brief Hashmap of valid peers.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
+
+/**
+ * @brief Maximum number of valid peers to keep.
+ * TODO read from config
+ */
+static uint32_t num_valid_peers_max = UINT32_MAX;
+
+/**
+ * @brief Filename of the file that stores the valid peers persistently.
+ */
+static char *filename_valid_peers;
+
+/**
+ * Set of all peers to keep track of them.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+
+/**
+ * Cadet handle.
+ */
+static struct GNUNET_CADET_Handle *cadet_handle;
+
+
+
+/**
+ * @brief Get the #PeerContext associated with a peer
+ *
+ * @param peer the peer id
+ *
+ * @return the #PeerContext
+ */
+static struct PeerContext *
+get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *ctx;
+  int ret;
+
+  ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+  GNUNET_assert (GNUNET_YES == ret);
+  ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
+  GNUNET_assert (NULL != ctx);
+  return ctx;
+}
+
+int
+Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * @brief Create a new #PeerContext and insert it into the peer map
+ *
+ * @param peer the peer to create the #PeerContext for
+ *
+ * @return the #PeerContext
+ */
+static struct PeerContext *
+create_peer_ctx (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *ctx;
+  int ret;
+
+  GNUNET_assert (GNUNET_NO == Peers_check_peer_known (peer));
+
+  ctx = GNUNET_new (struct PeerContext);
+  ctx->peer_id = *peer;
+  ctx->send_channel_flags = GNUNET_new (uint32_t);
+  ctx->recv_channel_flags = GNUNET_new (uint32_t);
+  ret = GNUNET_CONTAINER_multipeermap_put (peer_map, peer, ctx,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  GNUNET_assert (GNUNET_OK == ret);
+  return ctx;
+}
+
+
+/**
+ * @brief Create or get a #PeerContext
+ *
+ * @param peer the peer to get the associated context to
+ *
+ * @return the context
+ */
+static struct PeerContext *
+create_or_get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {
+    return create_peer_ctx (peer);
+  }
+  return get_peer_ctx (peer);
+}
+
+void
+Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+
+void
+Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+
+/**
+ * @brief Check whether we have a connection to this @a peer
+ *
+ * Also sets the #Peers_ONLINE flag accordingly
+ *
+ * @param peer the peer in question
+ *
+ * @return #GNUNET_YES if we are connected
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_check_connected (const struct GNUNET_PeerIdentity *peer)
+{
+  const struct PeerContext *peer_ctx;
+
+  /* If we don't know about this peer we don't know whether it's online */
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {
+    return GNUNET_NO;
+  }
+  /* Get the context */
+  peer_ctx = get_peer_ctx (peer);
+  /* If we have no channel to this peer we don't know whether it's online */
+  if ( (NULL == peer_ctx->send_channel) &&
+       (NULL == peer_ctx->recv_channel) )
+  {
+    Peers_unset_peer_flag (peer, Peers_ONLINE);
+    return GNUNET_NO;
+  }
+  /* Otherwise (if we have a channel, we know that it's online */
+  Peers_set_peer_flag (peer, Peers_ONLINE);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief The closure to #get_rand_peer_iterator.
+ */
+struct GetRandPeerIteratorCls
+{
+  /**
+   * @brief The index of the peer to return.
+   * Will be decreased until 0.
+   * Then current peer is returned.
+   */
+  uint32_t index;
+
+  /**
+   * @brief Pointer to peer to return.
+   */
+  const struct GNUNET_PeerIdentity *peer;
+};
+
+
+/**
+ * @brief Iterator function for #get_random_peer_from_peermap.
+ *
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Decreases the index until the index is null.
+ * Then returns the current peer.
+ *
+ * @param cls the #GetRandPeerIteratorCls containing index and peer
+ * @param peer current peer
+ * @param value unused
+ *
+ * @return  #GNUNET_YES if we should continue to
+ *          iterate,
+ *          #GNUNET_NO if not.
+ */
+static int
+get_rand_peer_iterator (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        void *value)
+{
+  struct GetRandPeerIteratorCls *iterator_cls = cls;
+  if (0 >= iterator_cls->index)
+  {
+    iterator_cls->peer = peer;
+    return GNUNET_NO;
+  }
+  iterator_cls->index--;
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Get a random peer from @a peer_map
+ *
+ * @param peer_map the peer_map to get the peer from
+ *
+ * @return a random peer
+ */
+static const struct GNUNET_PeerIdentity *
+get_random_peer_from_peermap (const struct
+                              GNUNET_CONTAINER_MultiPeerMap *peer_map)
+{
+  struct GetRandPeerIteratorCls *iterator_cls;
+  const struct GNUNET_PeerIdentity *ret;
+
+  iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
+  iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+      GNUNET_CONTAINER_multipeermap_size (peer_map));
+  (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+                                                get_rand_peer_iterator,
+                                                iterator_cls);
+  ret = iterator_cls->peer;
+  GNUNET_free (iterator_cls);
+  return ret;
+}
+
+
+/**
+ * @brief Add a given @a peer to valid peers.
+ *
+ * If valid peers are already #num_valid_peers_max, delete a peer previously.
+ *
+ * @param peer the peer that is added to the valid peers.
+ *
+ * @return #GNUNET_YES if no other peer had to be removed
+ *         #GNUNET_NO  otherwise
+ */
+static int
+add_valid_peer (const struct GNUNET_PeerIdentity *peer)
+{
+  const struct GNUNET_PeerIdentity *rand_peer;
+  int ret;
+
+  ret = GNUNET_YES;
+  while (GNUNET_CONTAINER_multipeermap_size (valid_peers) >= num_valid_peers_max)
+  {
+    rand_peer = get_random_peer_from_peermap (valid_peers);
+    GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
+    ret = GNUNET_NO;
+  }
+  (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  return ret;
+}
+
+
+/**
+ * @brief Set the peer flag to living and
+ *        call the pending operations on this peer.
+ *
+ * Also adds peer to #valid_peers.
+ *
+ * @param peer_ctx the #PeerContext of the peer to set live
+ */
+static void
+set_peer_live (struct PeerContext *peer_ctx)
+{
+  struct GNUNET_PeerIdentity *peer;
+  unsigned int i;
+
+  peer = &peer_ctx->peer_id;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Peer %s is live and valid, calling %i pending operations on it\n",
+      GNUNET_i2s (peer),
+      peer_ctx->num_pending_ops);
+
+  if (NULL != peer_ctx->liveliness_check_pending)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Removing pending liveliness check for peer %s\n",
+         GNUNET_i2s (&peer_ctx->peer_id));
+    // TODO wait until cadet sets mq->cancel_impl
+    //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
+    GNUNET_free (peer_ctx->liveliness_check_pending);
+    peer_ctx->liveliness_check_pending = NULL;
+  }
+
+  (void) add_valid_peer (peer);
+  set_peer_flag (peer_ctx, Peers_ONLINE);
+
+  /* Call pending operations */
+  for (i = 0; i < peer_ctx->num_pending_ops; i++)
+  {
+    peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
+  }
+  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
+}
+
+static void
+cleanup_destroyed_channel (void *cls,
+                           const struct GNUNET_CADET_Channel *channel);
+
+/* Declaration of handlers */
+static void
+handle_peer_check (void *cls,
+                   const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_push (void *cls,
+                  const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_pull_request (void *cls,
+                          const struct GNUNET_MessageHeader *msg);
+
+static int
+check_peer_pull_reply (void *cls,
+                       const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+static void
+handle_peer_pull_reply (void *cls,
+                        const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+/* End declaration of handlers */
+
+
+/**
+ * @brief Get the channel of a peer. If not existing, create.
+ *
+ * @param peer the peer id
+ * @return the #GNUNET_CADET_Channel used to send data to @a peer
+ */
+struct GNUNET_CADET_Channel *
+get_channel (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+  struct GNUNET_HashCode port;
+  /* There exists a copy-paste-clone in run() */
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (peer_check,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_push,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_pull_request,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_var_size (peer_pull_reply,
+                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+                           struct GNUNET_RPS_P2P_PullReplyMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+
+
+  peer_ctx = get_peer_ctx (peer);
+  if (NULL == peer_ctx->send_channel)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Trying to establish channel to peer %s\n",
+         GNUNET_i2s (peer));
+    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS,
+                        strlen (GNUNET_APPLICATION_PORT_RPS),
+                        &port);
+    peer_ctx->send_channel =
+      GNUNET_CADET_channel_create (cadet_handle,
+                                   (struct GNUNET_PeerIdentity *) peer, /* context */
+                                   peer,
+                                   &port,
+                                   GNUNET_CADET_OPTION_RELIABLE,
+                                   NULL, /* WindowSize handler */
+                                   cleanup_destroyed_channel, /* Disconnect handler */
+                                   cadet_handlers);
+  }
+  GNUNET_assert (NULL != peer_ctx->send_channel);
+  return peer_ctx->send_channel;
+}
+
+
+/**
+ * Get the message queue (#GNUNET_MQ_Handle) of a specific peer.
+ *
+ * If we already have a message queue open to this client,
+ * simply return it, otherways create one.
+ *
+ * @param peer the peer to get the mq to
+ * @return the #GNUNET_MQ_Handle
+ */
+static struct GNUNET_MQ_Handle *
+get_mq (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+
+  if (NULL == peer_ctx->mq)
+  {
+    (void) get_channel (peer);
+    peer_ctx->mq = GNUNET_CADET_get_mq (peer_ctx->send_channel);
+  }
+  return peer_ctx->mq;
+}
+
+
+/**
+ * @brief This is called in response to the first message we sent as a
+ * liveliness check.
+ *
+ * @param cls #PeerContext of peer with pending liveliness check
+ */
+static void
+mq_liveliness_check_successful (void *cls)
+{
+  struct PeerContext *peer_ctx = cls;
+
+  if (NULL != peer_ctx->liveliness_check_pending)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Liveliness check for peer %s was successfull\n",
+        GNUNET_i2s (&peer_ctx->peer_id));
+    GNUNET_free (peer_ctx->liveliness_check_pending);
+    peer_ctx->liveliness_check_pending = NULL;
+    set_peer_live (peer_ctx);
+  }
+}
+
+/**
+ * Issue a check whether peer is live
+ *
+ * @param peer_ctx the context of the peer
+ */
+static void
+check_peer_live (struct PeerContext *peer_ctx)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Get informed about peer %s getting live\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+
+  struct GNUNET_MQ_Handle *mq;
+  struct GNUNET_MQ_Envelope *ev;
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
+  peer_ctx->liveliness_check_pending = GNUNET_new (struct PendingMessage);
+  peer_ctx->liveliness_check_pending->ev = ev;
+  peer_ctx->liveliness_check_pending->peer_ctx = peer_ctx;
+  peer_ctx->liveliness_check_pending->type = "Check liveliness";
+  mq = get_mq (&peer_ctx->peer_id);
+  GNUNET_MQ_notify_sent (ev,
+                         mq_liveliness_check_successful,
+                         peer_ctx);
+  GNUNET_MQ_send (mq, ev);
+}
+
+/**
+ * @brief Add an envelope to a message passed to mq to list of pending messages
+ *
+ * @param peer peer the message was sent to
+ * @param ev envelope to the message
+ * @param type type of the message to be sent
+ * @return pointer to pending message
+ */
+static struct PendingMessage *
+insert_pending_message (const struct GNUNET_PeerIdentity *peer,
+                        struct GNUNET_MQ_Envelope *ev,
+                        const char *type)
+{
+  struct PendingMessage *pending_msg;
+  struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+  pending_msg = GNUNET_new (struct PendingMessage);
+  pending_msg->ev = ev;
+  pending_msg->peer_ctx = peer_ctx;
+  pending_msg->type = type;
+  GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
+                               peer_ctx->pending_messages_tail,
+                               pending_msg);
+  return pending_msg;
+}
+
+
+/**
+ * @brief Remove a pending message from the respective DLL
+ *
+ * @param pending_msg the pending message to remove
+ * @param cancel cancel the pending message, too
+ */
+static void
+remove_pending_message (struct PendingMessage *pending_msg, int cancel)
+{
+  struct PeerContext *peer_ctx;
+
+  peer_ctx = pending_msg->peer_ctx;
+  GNUNET_assert (NULL != peer_ctx);
+  GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
+                               peer_ctx->pending_messages_tail,
+                               pending_msg);
+  // TODO wait for the cadet implementation of message cancellation
+  //if (GNUNET_YES == cancel)
+  //{
+  //  GNUNET_MQ_send_cancel (pending_msg->ev);
+  //}
+  GNUNET_free (pending_msg);
+}
+
+
+/**
+ * @brief Check whether function of type #PeerOp was already scheduled
+ *
+ * The array with pending operations will probably never grow really big, so
+ * iterating over it should be ok.
+ *
+ * @param peer the peer to check
+ * @param peer_op the operation (#PeerOp) on the peer
+ *
+ * @return #GNUNET_YES if this operation is scheduled on that peer
+ *         #GNUNET_NO  otherwise
+ */
+static int
+check_operation_scheduled (const struct GNUNET_PeerIdentity *peer,
+                           const PeerOp peer_op)
+{
+  const struct PeerContext *peer_ctx;
+  unsigned int i;
+
+  peer_ctx = get_peer_ctx (peer);
+  for (i = 0; i < peer_ctx->num_pending_ops; i++)
+    if (peer_op == peer_ctx->pending_ops[i].op)
+      return GNUNET_YES;
+  return GNUNET_NO;
+}
+
+int
+Peers_remove_peer (const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Iterator over hash map entries. Deletes all contexts of peers.
+ *
+ * @param cls closure
+ * @param key current public key
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+peermap_clear_iterator (void *cls,
+                        const struct GNUNET_PeerIdentity *key,
+                        void *value)
+{
+  Peers_remove_peer (key);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief This is called once a message is sent.
+ *
+ * Removes the pending message
+ *
+ * @param cls type of the message that was sent
+ */
+static void
+mq_notify_sent_cb (void *cls)
+{
+  struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "%s was sent.\n",
+      pending_msg->type);
+  /* Do not cancle message */
+  remove_pending_message (pending_msg, GNUNET_NO);
+}
+
+
+/**
+ * @brief Iterator function for #store_valid_peers.
+ *
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Writes single peer to disk.
+ *
+ * @param cls the file handle to write to.
+ * @param peer current peer
+ * @param value unused
+ *
+ * @return  #GNUNET_YES if we should continue to
+ *          iterate,
+ *          #GNUNET_NO if not.
+ */
+static int
+store_peer_presistently_iterator (void *cls,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  void *value)
+{
+  const struct GNUNET_DISK_FileHandle *fh = cls;
+  char peer_string[128];
+  int size;
+  ssize_t ret;
+
+  if (NULL == peer)
+  {
+    return GNUNET_YES;
+  }
+  size = GNUNET_snprintf (peer_string,
+                          sizeof (peer_string),
+                          "%s\n",
+                          GNUNET_i2s_full (peer));
+  GNUNET_assert (53 == size);
+  ret = GNUNET_DISK_file_write (fh,
+                                peer_string,
+                                size);
+  GNUNET_assert (size == ret);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Store the peers currently in #valid_peers to disk.
+ */
+static void
+store_valid_peers ()
+{
+  struct GNUNET_DISK_FileHandle *fh;
+  uint32_t number_written_peers;
+  int ret;
+
+  if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
+  {
+    return;
+  }
+
+  ret = GNUNET_DISK_directory_create_for_file (filename_valid_peers);
+  if (GNUNET_SYSERR == ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Not able to create directory for file `%s'\n",
+        filename_valid_peers);
+    GNUNET_break (0);
+  }
+  else if (GNUNET_NO == ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Directory for file `%s' exists but is not writable for us\n",
+        filename_valid_peers);
+    GNUNET_break (0);
+  }
+  fh = GNUNET_DISK_file_open (filename_valid_peers,
+                              GNUNET_DISK_OPEN_WRITE |
+                                  GNUNET_DISK_OPEN_CREATE,
+                              GNUNET_DISK_PERM_USER_READ |
+                                  GNUNET_DISK_PERM_USER_WRITE);
+  if (NULL == fh)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Not able to write valid peers to file `%s'\n",
+        filename_valid_peers);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Writing %u valid peers to disk\n",
+      GNUNET_CONTAINER_multipeermap_size (valid_peers));
+  number_written_peers =
+    GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+                                           store_peer_presistently_iterator,
+                                           fh);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  GNUNET_assert (number_written_peers ==
+      GNUNET_CONTAINER_multipeermap_size (valid_peers));
+}
+
+
+/**
+ * @brief Convert string representation of peer id to peer id.
+ *
+ * Counterpart to #GNUNET_i2s_full.
+ *
+ * @param string_repr The string representation of the peer id
+ *
+ * @return The peer id
+ */
+static const struct GNUNET_PeerIdentity *
+s2i_full (const char *string_repr)
+{
+  struct GNUNET_PeerIdentity *peer;
+  size_t len;
+  int ret;
+
+  peer = GNUNET_new (struct GNUNET_PeerIdentity);
+  len = strlen (string_repr);
+  if (52 > len)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Not able to convert string representation of PeerID to PeerID\n"
+        "Sting representation: %s (len %lu) - too short\n",
+        string_repr,
+        len);
+    GNUNET_break (0);
+  }
+  else if (52 < len)
+  {
+    len = 52;
+  }
+  ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
+                                                    len,
+                                                    &peer->public_key);
+  if (GNUNET_OK != ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Not able to convert string representation of PeerID to PeerID\n"
+        "Sting representation: %s\n",
+        string_repr);
+    GNUNET_break (0);
+  }
+  return peer;
+}
+
+
+/**
+ * @brief Restore the peers on disk to #valid_peers.
+ */
+static void
+restore_valid_peers ()
+{
+  off_t file_size;
+  uint32_t num_peers;
+  struct GNUNET_DISK_FileHandle *fh;
+  char *buf;
+  ssize_t size_read;
+  char *iter_buf;
+  char *str_repr;
+  const struct GNUNET_PeerIdentity *peer;
+
+  if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
+  {
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_DISK_file_test (filename_valid_peers))
+  {
+    return;
+  }
+  fh = GNUNET_DISK_file_open (filename_valid_peers,
+                              GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_NONE);
+  GNUNET_assert (NULL != fh);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
+  num_peers = file_size / 53;
+  buf = GNUNET_malloc (file_size);
+  size_read = GNUNET_DISK_file_read (fh, buf, file_size);
+  GNUNET_assert (size_read == file_size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Restoring %" PRIu32 " peers from file `%s'\n",
+      num_peers,
+      filename_valid_peers);
+  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
+  {
+    str_repr = GNUNET_strndup (iter_buf, 53);
+    peer = s2i_full (str_repr);
+    GNUNET_free (str_repr);
+    add_valid_peer (peer);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Restored valid peer %s from disk\n",
+        GNUNET_i2s_full (peer));
+  }
+  iter_buf = NULL;
+  GNUNET_free (buf);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "num_peers: %" PRIu32 ", _size (valid_peers): %u\n",
+      num_peers,
+      GNUNET_CONTAINER_multipeermap_size (valid_peers));
+  if (num_peers != GNUNET_CONTAINER_multipeermap_size (valid_peers))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Number of restored peers does not match file size. Have probably duplicates.\n");
+  }
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "Restored %u valid peers from disk\n",
+      GNUNET_CONTAINER_multipeermap_size (valid_peers));
+}
+
+
+/**
+ * @brief Initialise storage of peers
+ *
+ * @param fn_valid_peers filename of the file used to store valid peer ids
+ * @param cadet_h cadet handle
+ * @param disconnect_handler Disconnect handler
+ * @param own_id own peer identity
+ */
+void
+Peers_initialise (char* fn_valid_peers,
+                  struct GNUNET_CADET_Handle *cadet_h,
+                  GNUNET_CADET_DisconnectEventHandler disconnect_handler,
+                  const struct GNUNET_PeerIdentity *own_id)
+{
+  filename_valid_peers = GNUNET_strdup (fn_valid_peers);
+  cadet_handle = cadet_h;
+  own_identity = *own_id;
+  peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+  valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+  restore_valid_peers ();
+}
+
+
+/**
+ * @brief Delete storage of peers that was created with #Peers_initialise ()
+ */
+void
+Peers_terminate ()
+{
+  if (GNUNET_SYSERR ==
+      GNUNET_CONTAINER_multipeermap_iterate (peer_map,
+                                             peermap_clear_iterator,
+                                             NULL))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+        "Iteration destroying peers was aborted.\n");
+  }
+  GNUNET_CONTAINER_multipeermap_destroy (peer_map);
+  store_valid_peers ();
+  GNUNET_free (filename_valid_peers);
+  GNUNET_CONTAINER_multipeermap_destroy (valid_peers);
+}
+
+
+/**
+ * Iterator over #valid_peers hash map entries.
+ *
+ * @param cls closure - unused
+ * @param peer current peer id
+ * @param value value in the hash map - unused
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+valid_peer_iterator (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
+{
+  struct PeersIteratorCls *it_cls = cls;
+
+  return it_cls->iterator (it_cls->cls,
+                           peer);
+}
+
+
+/**
+ * @brief Get all currently known, valid peer ids.
+ *
+ * @param it function to call on each peer id
+ * @param it_cls extra argument to @a it
+ * @return the number of key value pairs processed,
+ *         #GNUNET_SYSERR if it aborted iteration
+ */
+int
+Peers_get_valid_peers (PeersIterator iterator,
+                       void *it_cls)
+{
+  struct PeersIteratorCls *cls;
+  int ret;
+
+  cls = GNUNET_new (struct PeersIteratorCls);
+  cls->iterator = iterator;
+  cls->cls = it_cls;
+  ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+                                               valid_peer_iterator,
+                                               cls);
+  GNUNET_free (cls);
+  return ret;
+}
+
+
+/**
+ * @brief Add peer to known peers.
+ *
+ * This function is called on new peer_ids from 'external' sources
+ * (client seed, cadet get_peers(), ...)
+ *
+ * @param peer the new #GNUNET_PeerIdentity
+ *
+ * @return #GNUNET_YES if peer was inserted
+ *         #GNUNET_NO  otherwise (if peer was already known or
+ *                     peer was #own_identity)
+ */
+int
+Peers_insert_peer (const struct GNUNET_PeerIdentity *peer)
+{
+  if ( (GNUNET_YES == Peers_check_peer_known (peer)) ||
+       (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity)) )
+  {
+    return GNUNET_NO; /* We already know this peer - nothing to do */
+  }
+  (void) create_peer_ctx (peer);
+  return GNUNET_YES;
+}
+
+int
+Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+
+/**
+ * @brief Try connecting to a peer to see whether it is online
+ *
+ * If not known yet, insert into known peers
+ *
+ * @param peer the peer whose liveliness is to be checked
+ * @return #GNUNET_YES if peer had to be inserted
+ *         #GNUNET_NO  otherwise (if peer was already known or
+ *                     peer was #own_identity)
+ */
+int
+Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+  int ret;
+
+  if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity))
+  {
+    return GNUNET_NO;
+  }
+  ret = Peers_insert_peer (peer);
+  peer_ctx = get_peer_ctx (peer);
+  if (GNUNET_NO == Peers_check_peer_flag (peer, Peers_ONLINE))
+  {
+    check_peer_live (peer_ctx);
+  }
+  return ret;
+}
+
+
+/**
+ * @brief Check if peer is removable.
+ *
+ * Check if
+ *  - a recv channel exists
+ *  - there are pending messages
+ *  - there is no pending pull reply
+ *
+ * @param peer the peer in question
+ * @return #GNUNET_YES    if peer is removable
+ *         #GNUNET_NO     if peer is NOT removable
+ *         #GNUNET_SYSERR if peer is not known
+ */
+int
+Peers_check_removable (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
+  {
+    return GNUNET_SYSERR;
+  }
+
+  peer_ctx = get_peer_ctx (peer);
+  if ( (NULL != peer_ctx->recv_channel) ||
+       (NULL != peer_ctx->pending_messages_head) ||
+       (GNUNET_NO == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) )
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+uint32_t *
+Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
+                        enum Peers_ChannelRole role);
+
+int
+Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
+
+/**
+ * @brief Remove peer
+ *
+ * @param peer the peer to clean
+ * @return #GNUNET_YES if peer was removed
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+  uint32_t *channel_flag;
+
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
+  {
+    return GNUNET_NO;
+  }
+
+  peer_ctx = get_peer_ctx (peer);
+  set_peer_flag (peer_ctx, Peers_TO_DESTROY);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to remove peer %s\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+  Peers_unset_peer_flag (peer, Peers_ONLINE);
+
+  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
+  while (NULL != peer_ctx->pending_messages_head)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Removing unsent %s\n",
+        peer_ctx->pending_messages_head->type);
+    /* Cancle pending message, too */
+    remove_pending_message (peer_ctx->pending_messages_head, GNUNET_YES);
+  }
+  /* If we are still waiting for notification whether this peer is live
+   * cancel the according task */
+  if (NULL != peer_ctx->liveliness_check_pending)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+         "Removing pending liveliness check for peer %s\n",
+         GNUNET_i2s (&peer_ctx->peer_id));
+    // TODO wait until cadet sets mq->cancel_impl
+    //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
+    GNUNET_free (peer_ctx->liveliness_check_pending);
+    peer_ctx->liveliness_check_pending = NULL;
+  }
+  channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_SENDING);
+  if (NULL != peer_ctx->send_channel &&
+      GNUNET_YES != Peers_check_channel_flag (channel_flag, Peers_CHANNEL_DESTROING))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Destroying send channel\n");
+    GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
+    peer_ctx->send_channel = NULL;
+  }
+  channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_RECEIVING);
+  if (NULL != peer_ctx->recv_channel &&
+      GNUNET_YES != Peers_check_channel_flag (channel_flag, Peers_CHANNEL_DESTROING))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Destroying recv channel\n");
+    GNUNET_CADET_channel_destroy (peer_ctx->recv_channel);
+    peer_ctx->recv_channel = NULL;
+  }
+
+  GNUNET_free (peer_ctx->send_channel_flags);
+  GNUNET_free (peer_ctx->recv_channel_flags);
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove_all (peer_map, &peer_ctx->peer_id))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer from peer_map failed\n");
+  }
+  GNUNET_free (peer_ctx);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief set flags on a given peer.
+ *
+ * @param peer the peer to set flags on
+ * @param flags the flags
+ */
+void
+Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
+{
+  struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+  set_peer_flag (peer_ctx, flags);
+}
+
+
+/**
+ * @brief unset flags on a given peer.
+ *
+ * @param peer the peer to unset flags on
+ * @param flags the flags
+ */
+void
+Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
+{
+  struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+  unset_peer_flag (peer_ctx, flags);
+}
+
+
+/**
+ * @brief Check whether flags on a peer are set.
+ *
+ * @param peer the peer to check the flag of
+ * @param flags the flags to check
+ *
+ * @return #GNUNET_SYSERR if peer is not known
+ *         #GNUNET_YES    if all given flags are set
+ *         #GNUNET_NO     otherwise
+ */
+int
+Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {
+    return GNUNET_SYSERR;
+  }
+  peer_ctx = get_peer_ctx (peer);
+  return check_peer_flag_set (peer_ctx, flags);
+}
+
+
+/**
+ * @brief set flags on a given channel.
+ *
+ * @param channel the channel to set flags on
+ * @param flags the flags
+ */
+void
+Peers_set_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
+{
+  set_channel_flag (channel_flags, flags);
+}
+
+
+/**
+ * @brief unset flags on a given channel.
+ *
+ * @param channel the channel to unset flags on
+ * @param flags the flags
+ */
+void
+Peers_unset_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
+{
+  unset_channel_flag (channel_flags, flags);
+}
+
+
+/**
+ * @brief Check whether flags on a channel are set.
+ *
+ * @param channel the channel to check the flag of
+ * @param flags the flags to check
+ *
+ * @return #GNUNET_YES if all given flags are set
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
+{
+  return check_channel_flag_set (channel_flags, flags);
+}
+
+/**
+ * @brief Get the flags for the channel in @a role for @a peer.
+ *
+ * @param peer Peer to get the channel flags for.
+ * @param role Role of channel to get flags for
+ *
+ * @return The flags.
+ */
+uint32_t *
+Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
+                        enum Peers_ChannelRole role)
+{
+  const struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+  if (Peers_CHANNEL_ROLE_SENDING == role)
+  {
+    return peer_ctx->send_channel_flags;
+  }
+  else if (Peers_CHANNEL_ROLE_RECEIVING == role)
+  {
+    return peer_ctx->recv_channel_flags;
+  }
+  else
+  {
+    GNUNET_assert (0);
+  }
+}
+
+/**
+ * @brief Check whether we have information about the given peer.
+ *
+ * FIXME probably deprecated. Make this the new _online.
+ *
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is known
+ *         #GNUNET_NO  if peer is not knwon
+ */
+int
+Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+}
+
+
+/**
+ * @brief Check whether @a peer is actually a peer.
+ *
+ * A valid peer is a peer that we know exists eg. we were connected to once.
+ *
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is valid
+ *         #GNUNET_NO  if peer is not valid
+ */
+int
+Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
+}
+
+
+/**
+ * @brief Indicate that we want to send to the other peer
+ *
+ * This establishes a sending channel
+ *
+ * @param peer the peer to establish channel to
+ */
+void
+Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
+{
+  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
+  (void) get_channel (peer);
+}
+
+
+/**
+ * @brief Check whether other peer has the intention to send/opened channel
+ *        towars us
+ *
+ * @param peer the peer in question
+ *
+ * @return #GNUNET_YES if peer has the intention to send
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
+{
+  const struct PeerContext *peer_ctx;
+
+  peer_ctx = get_peer_ctx (peer);
+  if (NULL != peer_ctx->recv_channel)
+  {
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Handle the channel a peer opens to us.
+ *
+ * @param cls The closure
+ * @param channel The channel the peer wants to establish
+ * @param initiator The peer's peer ID
+ *
+ * @return initial channel context for the channel
+ *         (can be NULL -- that's not an error)
+ */
+void *
+Peers_handle_inbound_channel (void *cls,
+                              struct GNUNET_CADET_Channel *channel,
+                              const struct GNUNET_PeerIdentity *initiator)
+{
+  struct PeerContext *peer_ctx;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+      "New channel was established to us (Peer %s).\n",
+      GNUNET_i2s (initiator));
+  GNUNET_assert (NULL != channel); /* according to cadet API */
+  /* Make sure we 'know' about this peer */
+  peer_ctx = create_or_get_peer_ctx (initiator);
+  set_peer_live (peer_ctx);
+  /* We only accept one incoming channel per peer */
+  if (GNUNET_YES == Peers_check_peer_send_intention (initiator))
+  {
+    set_channel_flag (peer_ctx->recv_channel_flags,
+                      Peers_CHANNEL_ESTABLISHED_TWICE);
+    GNUNET_CADET_channel_destroy (channel);
+    /* return the channel context */
+    return &peer_ctx->peer_id;
+  }
+  peer_ctx->recv_channel = channel;
+  return &peer_ctx->peer_id;
+}
+
+
+/**
+ * @brief Check whether a sending channel towards the given peer exists
+ *
+ * @param peer the peer to check for
+ *
+ * @return #GNUNET_YES if a sending channel towards that peer exists
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  { /* If no such peer exists, there is no channel */
+    return GNUNET_NO;
+  }
+  peer_ctx = get_peer_ctx (peer);
+  if (NULL == peer_ctx->send_channel)
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief check whether the given channel is the sending channel of the given
+ *        peer
+ *
+ * @param peer the peer in question
+ * @param channel the channel to check for
+ * @param role either #Peers_CHANNEL_ROLE_SENDING, or
+ *                    #Peers_CHANNEL_ROLE_RECEIVING
+ *
+ * @return #GNUNET_YES if the given chennel is the sending channel of the peer
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
+                          const struct GNUNET_CADET_Channel *channel,
+                          enum Peers_ChannelRole role)
+{
+  const struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {
+    return GNUNET_NO;
+  }
+  peer_ctx = get_peer_ctx (peer);
+  if ( (Peers_CHANNEL_ROLE_SENDING == role) &&
+       (channel == peer_ctx->send_channel) )
+  {
+    return GNUNET_YES;
+  }
+  if ( (Peers_CHANNEL_ROLE_RECEIVING == role) &&
+       (channel == peer_ctx->recv_channel) )
+  {
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * @brief Destroy the send channel of a peer e.g. stop indicating a sending
+ *        intention to another peer
+ *
+ * If there is also no channel to receive messages from that peer, remove it
+ * from the peermap.
+ * TODO really?
+ *
+ * @peer the peer identity of the peer whose sending channel to destroy
+ * @return #GNUNET_YES if channel was destroyed
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {
+    return GNUNET_NO;
+  }
+  peer_ctx = get_peer_ctx (peer);
+  if (NULL != peer_ctx->send_channel)
+  {
+    set_channel_flag (peer_ctx->send_channel_flags, Peers_CHANNEL_CLEAN);
+    GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
+    peer_ctx->send_channel = NULL;
+    (void) Peers_check_connected (peer);
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+/**
+ * This is called when a channel is destroyed.
+ *
+ * @param cls The closure
+ * @param channel The channel being closed
+ * @param channel_ctx The context associated with this channel
+ */
+void
+Peers_cleanup_destroyed_channel (void *cls,
+                                 const struct GNUNET_CADET_Channel *channel)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == Peers_check_peer_known (peer))
+  {/* We don't want to implicitly create a context that we're about to kill */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "channel (%s) without associated context was destroyed\n",
+       GNUNET_i2s (peer));
+    return;
+  }
+  peer_ctx = get_peer_ctx (peer);
+
+  /* If our peer issued the destruction of the channel, the #Peers_TO_DESTROY
+   * flag will be set. In this case simply make sure that the channels are
+   * cleaned. */
+  /* FIXME This distinction seems to be redundant */
+  if (Peers_check_peer_flag (peer, Peers_TO_DESTROY))
+  {/* We initiatad the destruction of this particular peer */
+    if (channel == peer_ctx->send_channel)
+      peer_ctx->send_channel = NULL;
+    else if (channel == peer_ctx->recv_channel)
+      peer_ctx->recv_channel = NULL;
+
+    if (NULL != peer_ctx->send_channel)
+    {
+      GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
+      peer_ctx->send_channel = NULL;
+    }
+    if (NULL != peer_ctx->recv_channel)
+    {
+      GNUNET_CADET_channel_destroy (peer_ctx->recv_channel);
+      peer_ctx->recv_channel = NULL;
+    }
+    /* Set the #Peers_ONLINE flag accordingly */
+    (void) Peers_check_connected (peer);
+    return;
+  }
+
+  else
+  { /* We did not initiate the destruction of this peer */
+    if (channel == peer_ctx->send_channel)
+    { /* Something (but us) killd the channel - clean up peer */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+          "send channel (%s) was destroyed - cleaning up\n",
+          GNUNET_i2s (peer));
+      peer_ctx->send_channel = NULL;
+    }
+    else if (channel == peer_ctx->recv_channel)
+    { /* Other peer doesn't want to send us messages anymore */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Peer %s destroyed recv channel - cleaning up channel\n",
+           GNUNET_i2s (peer));
+      peer_ctx->recv_channel = NULL;
+    }
+    else
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "unknown channel (%s) was destroyed\n",
+           GNUNET_i2s (peer));
+    }
+  }
+  (void) Peers_check_connected (peer);
+}
+
+/**
+ * @brief Send a message to another peer.
+ *
+ * Keeps track about pending messages so they can be properly removed when the
+ * peer is destroyed.
+ *
+ * @param peer receeiver of the message
+ * @param ev envelope of the message
+ * @param type type of the message
+ */
+void
+Peers_send_message (const struct GNUNET_PeerIdentity *peer,
+                    struct GNUNET_MQ_Envelope *ev,
+                    const char *type)
+{
+  struct PendingMessage *pending_msg;
+  struct GNUNET_MQ_Handle *mq;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending message to %s of type %s\n",
+              GNUNET_i2s (peer),
+              type);
+  pending_msg = insert_pending_message (peer, ev, type);
+  mq = get_mq (peer);
+  GNUNET_MQ_notify_sent (ev,
+                         mq_notify_sent_cb,
+                         pending_msg);
+  GNUNET_MQ_send (mq, ev);
+}
+
+/**
+ * @brief Schedule a operation on given peer
+ *
+ * Avoids scheduling an operation twice.
+ *
+ * @param peer the peer we want to schedule the operation for once it gets live
+ *
+ * @return #GNUNET_YES if the operation was scheduled
+ *         #GNUNET_NO  otherwise
+ */
+int
+Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
+                          const PeerOp peer_op)
+{
+  struct PeerPendingOp pending_op;
+  struct PeerContext *peer_ctx;
+
+  if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity))
+  {
+    return GNUNET_NO;
+  }
+  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
+
+  //TODO if LIVE/ONLINE execute immediately
+
+  if (GNUNET_NO == check_operation_scheduled (peer, peer_op))
+  {
+    peer_ctx = get_peer_ctx (peer);
+    pending_op.op = peer_op;
+    pending_op.op_cls = NULL;
+    GNUNET_array_append (peer_ctx->pending_ops,
+                         peer_ctx->num_pending_ops,
+                         pending_op);
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+/**
+ * @brief Get the recv_channel of @a peer.
+ * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming
+ * messages.
+ *
+ * @param peer The peer to get the recv_channel from.
+ *
+ * @return The recv_channel.
+ */
+struct GNUNET_CADET_Channel *
+Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
+  peer_ctx = get_peer_ctx (peer);
+  return peer_ctx->recv_channel;
+}
+/***********************************************************************
+ * /Old gnunet-service-rps_peers.c
+***********************************************************************/
+
+
 /***********************************************************************
  * Housekeeping with clients
 ***********************************************************************/
@@ -847,6 +2568,7 @@ cleanup_destroyed_channel (void *cls,
 {
   struct GNUNET_PeerIdentity *peer = cls;
   uint32_t *channel_flag;
+  struct PeerContext *peer_ctx;
 
   if (GNUNET_NO == Peers_check_peer_known (peer))
   { /* We don't know a context to that peer */
@@ -856,6 +2578,15 @@ cleanup_destroyed_channel (void *cls,
     return;
   }
 
+  peer_ctx = get_peer_ctx (peer);
+  if (GNUNET_YES == Peers_check_channel_role (peer, channel, Peers_CHANNEL_ROLE_RECEIVING))
+  {
+    set_channel_flag (peer_ctx->recv_channel_flags, Peers_CHANNEL_DESTROING);
+  } else if (GNUNET_YES == Peers_check_channel_role (peer, channel, Peers_CHANNEL_ROLE_SENDING))
+  {
+    set_channel_flag (peer_ctx->send_channel_flags, Peers_CHANNEL_DESTROING);
+  }
+
   if (GNUNET_YES == Peers_check_peer_flag (peer, Peers_TO_DESTROY))
   { /* We are in the middle of removing that peer from our knowledge. In this
        case simply make sure that the channels are cleaned. */
@@ -1121,7 +2852,6 @@ handle_client_request_cancel (void *cls,
           (rep_cls->id != ntohl (msg->id)) )
     rep_cls = rep_cls->next;
   GNUNET_assert (rep_cls->id == ntohl (msg->id));
-  RPS_sampler_request_cancel (rep_cls->req_handle);
   destroy_reply_cls (rep_cls);
   GNUNET_SERVICE_client_continue (cli_ctx->client);
 }
@@ -1239,24 +2969,24 @@ handle_peer_push (void *cls,
        (3 == mal_type) )
   { /* Try to maximise representation */
     tmp_att_peer = GNUNET_new (struct AttackedPeer);
-    GNUNET_memcpy (&tmp_att_peer->peer_id, peer, sizeof (struct GNUNET_PeerIdentity));
+    tmp_att_peer->peer_id = *peer;
     if (NULL == att_peer_set)
       att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
-    if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
-                                                             peer))
+    if (GNUNET_NO ==
+        GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
+                                                peer))
     {
       GNUNET_CONTAINER_DLL_insert (att_peers_head,
                                    att_peers_tail,
                                    tmp_att_peer);
       add_peer_array_to_set (peer, 1, att_peer_set);
     }
-    GNUNET_CADET_receive_done (Peers_get_recv_channel (peer));
   }
 
 
   else if (2 == mal_type)
-  { /* We attack one single well-known peer - simply ignore */
-    GNUNET_CADET_receive_done (Peers_get_recv_channel (peer));
+  {
+    /* We attack one single well-known peer - simply ignore */
   }
   #endif /* ENABLE_MALICIOUS */
 
@@ -1289,7 +3019,6 @@ handle_peer_pull_request (void *cls,
       || 3 == mal_type)
   { /* Try to maximise representation */
     send_pull_reply (peer, mal_peers, num_mal_peers);
-    GNUNET_CADET_receive_done (Peers_get_recv_channel (peer));
   }
 
   else if (2 == mal_type)
@@ -1298,7 +3027,6 @@ handle_peer_pull_request (void *cls,
     {
       send_pull_reply (peer, mal_peers, num_mal_peers);
     }
-    GNUNET_CADET_receive_done (Peers_get_recv_channel (peer));
   }
   #endif /* ENABLE_MALICIOUS */
 
@@ -1360,7 +3088,7 @@ static void
 handle_peer_pull_reply (void *cls,
                         const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
 {
-  struct GNUNET_PeerIdentity *peers;
+  const struct GNUNET_PeerIdentity *peers;
   struct GNUNET_PeerIdentity *sender = cls;
   uint32_t i;
 #ifdef ENABLE_MALICIOUS
@@ -1373,12 +3101,11 @@ handle_peer_pull_reply (void *cls,
   // We shouldn't even receive pull replies as we're not sending
   if (2 == mal_type)
   {
-    GNUNET_CADET_receive_done (Peers_get_recv_channel (sender));
   }
   #endif /* ENABLE_MALICIOUS */
 
   /* Do actual logic */
-  peers = (struct GNUNET_PeerIdentity *) &msg[1];
+  peers = (const struct GNUNET_PeerIdentity *) &msg[1];
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "PULL REPLY received, got following %u peers:\n",
@@ -2132,7 +3859,6 @@ shutdown_task (void *cls)
                                    reply_cls);
       GNUNET_free (reply_cls);
     }
-    GNUNET_MQ_destroy (client_ctx->mq);
     GNUNET_CONTAINER_DLL_remove (cli_ctx_head, cli_ctx_tail, client_ctx);
     GNUNET_free (client_ctx);
   }
@@ -2150,6 +3876,7 @@ shutdown_task (void *cls)
   GNUNET_NSE_disconnect (nse);
   RPS_sampler_destroy (prot_sampler);
   RPS_sampler_destroy (client_sampler);
+  GNUNET_CADET_close_port (cadet_port);
   GNUNET_CADET_disconnect (cadet_handle);
   View_destroy ();
   CustomPeerMap_destroy (push_map);
@@ -2240,26 +3967,6 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *c,
      struct GNUNET_SERVICE_Handle *service)
 {
-  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
-    GNUNET_MQ_hd_fixed_size (peer_check,
-                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
-                             struct GNUNET_MessageHeader,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (peer_push,
-                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
-                             struct GNUNET_MessageHeader,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (peer_pull_request,
-                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
-                             struct GNUNET_MessageHeader,
-                             NULL),
-    GNUNET_MQ_hd_var_size (peer_pull_reply,
-                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
-                           struct GNUNET_RPS_P2P_PullReplyMessage,
-                           NULL),
-    GNUNET_MQ_handler_end ()
-  };
-
   int size;
   int out_size;
   char* fn_valid_peers;
@@ -2349,6 +4056,27 @@ run (void *cls,
 
 
   /* Initialise cadet */
+  /* There exists a copy-paste-clone in get_channel() */
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (peer_check,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_push,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_pull_request,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_var_size (peer_pull_reply,
+                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+                           struct GNUNET_RPS_P2P_PullReplyMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+
   cadet_handle = GNUNET_CADET_connect (cfg);
   GNUNET_assert (NULL != cadet_handle);
   GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS,
@@ -2365,7 +4093,7 @@ run (void *cls,
 
   peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
   Peers_initialise (fn_valid_peers, cadet_handle, cleanup_destroyed_channel,
-                    cadet_handlers, &own_identity);
+                    &own_identity);
   GNUNET_free (fn_valid_peers);
 
   /* Initialise sampler */
diff --git a/src/rps/gnunet-service-rps_peers.c b/src/rps/gnunet-service-rps_peers.c
deleted file mode 100644
index 58aa84ccf..000000000
--- a/src/rps/gnunet-service-rps_peers.c
+++ /dev/null
@@ -1,1694 +0,0 @@
-/*
-     This file is part of GNUnet.
-     Copyright (C)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-     Boston, MA 02110-1301, USA.
-*/
-
-/**
- * @file rps/gnunet-service-rps_peers.c
- * @brief utilities for managing (information about) peers
- * @author Julius Bünger
- */
-#include "platform.h"
-#include "gnunet_applications.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_cadet_service.h"
-#include <inttypes.h>
-#include "rps.h"
-#include "gnunet-service-rps_peers.h"
-
-
-
-#define LOG(kind, ...) GNUNET_log_from(kind,"rps-peers",__VA_ARGS__)
-
-
-/**
- * Set a peer flag of given peer context.
- */
-#define set_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
-
-/**
- * Get peer flag of given peer context.
- */
-#define check_peer_flag_set(peer_ctx, mask)\
-  ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
-
-/**
- * Unset flag of given peer context.
- */
-#define unset_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
-
-/**
- * Set a channel flag of given channel context.
- */
-#define set_channel_flag(channel_flags, mask) ((*channel_flags) |= (mask))
-
-/**
- * Get channel flag of given channel context.
- */
-#define check_channel_flag_set(channel_flags, mask)\
-  ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
-
-/**
- * Unset flag of given channel context.
- */
-#define unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask))
-
-
-
-/**
- * Pending operation on peer consisting of callback and closure
- *
- * When an operation cannot be executed right now this struct is used to store
- * the callback and closure for later execution.
- */
-struct PeerPendingOp
-{
-  /**
-   * Callback
-   */
-  PeerOp op;
-
-  /**
-   * Closure
-   */
-  void *op_cls;
-};
-
-/**
- * List containing all messages that are yet to be send
- *
- * This is used to keep track of all messages that have not been sent yet. When
- * a peer is to be removed the pending messages can be removed properly.
- */
-struct PendingMessage
-{
-  /**
-   * DLL next, prev
-   */
-  struct PendingMessage *next;
-  struct PendingMessage *prev;
-
-  /**
-   * The envelope to the corresponding message
-   */
-  struct GNUNET_MQ_Envelope *ev;
-
-  /**
-   * The corresponding context
-   */
-  struct PeerContext *peer_ctx;
-
-  /**
-   * The message type
-   */
-  const char *type;
-};
-
-/**
- * Struct used to keep track of other peer's status
- *
- * This is stored in a multipeermap.
- * It contains information such as cadet channels, a message queue for sending,
- * status about the channels, the pending operations on this peer and some flags
- * about the status of the peer itself. (live, valid, ...)
- */
-struct PeerContext
-{
-  /**
-   * Message queue open to client
-   */
-  struct GNUNET_MQ_Handle *mq;
-
-  /**
-   * Channel open to client.
-   */
-  struct GNUNET_CADET_Channel *send_channel;
-
-  /**
-   * Flags to the sending channel
-   */
-  uint32_t *send_channel_flags;
-
-  /**
-   * Channel open from client.
-   */
-  struct GNUNET_CADET_Channel *recv_channel; // unneeded?
-
-  /**
-   * Flags to the receiving channel
-   */
-  uint32_t *recv_channel_flags;
-
-  /**
-   * Array of pending operations on this peer.
-   */
-  struct PeerPendingOp *pending_ops;
-
-  /**
-   * Handle to the callback given to cadet_ntfy_tmt_rdy()
-   *
-   * To be canceled on shutdown.
-   */
-  struct PendingMessage *liveliness_check_pending;
-
-  /**
-   * Number of pending operations.
-   */
-  unsigned int num_pending_ops;
-
-  /**
-   * Identity of the peer
-   */
-  struct GNUNET_PeerIdentity peer_id;
-
-  /**
-   * Flags indicating status of peer
-   */
-  uint32_t peer_flags;
-
-  /**
-   * Last time we received something from that peer.
-   */
-  struct GNUNET_TIME_Absolute last_message_recv;
-
-  /**
-   * Last time we received a keepalive message.
-   */
-  struct GNUNET_TIME_Absolute last_keepalive;
-
-  /**
-   * DLL with all messages that are yet to be sent
-   */
-  struct PendingMessage *pending_messages_head;
-  struct PendingMessage *pending_messages_tail;
-
-  /**
-   * This is pobably followed by 'statistical' data (when we first saw
-   * him, how did we get his ID, how many pushes (in a timeinterval),
-   * ...)
-   */
-};
-
-/**
- * @brief Closure to #valid_peer_iterator
- */
-struct PeersIteratorCls
-{
-  /**
-   * Iterator function
-   */
-  PeersIterator iterator;
-
-  /**
-   * Closure to iterator
-   */
-  void *cls;
-};
-
-/**
- * @brief Hashmap of valid peers.
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
-
-/**
- * @brief Maximum number of valid peers to keep.
- * TODO read from config
- */
-static uint32_t num_valid_peers_max = UINT32_MAX;
-
-/**
- * @brief Filename of the file that stores the valid peers persistently.
- */
-static char *filename_valid_peers;
-
-/**
- * Set of all peers to keep track of them.
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
-
-/**
- * Own #GNUNET_PeerIdentity.
- */
-static const struct GNUNET_PeerIdentity *own_identity;
-
-/**
- * Cadet handle.
- */
-static struct GNUNET_CADET_Handle *cadet_handle;
-
-/**
- * @brief Disconnect handler
- */
-static GNUNET_CADET_DisconnectEventHandler cleanup_destroyed_channel;
-
-/**
- * @brief cadet handlers
- */
-static const struct GNUNET_MQ_MessageHandler *cadet_handlers;
-
-
-
-/**
- * @brief Get the #PeerContext associated with a peer
- *
- * @param peer the peer id
- *
- * @return the #PeerContext
- */
-static struct PeerContext *
-get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *ctx;
-  int ret;
-
-  ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
-  GNUNET_assert (GNUNET_YES == ret);
-  ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
-  GNUNET_assert (NULL != ctx);
-  return ctx;
-}
-
-
-/**
- * @brief Create a new #PeerContext and insert it into the peer map
- *
- * @param peer the peer to create the #PeerContext for
- *
- * @return the #PeerContext
- */
-static struct PeerContext *
-create_peer_ctx (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *ctx;
-  int ret;
-
-  GNUNET_assert (GNUNET_NO == Peers_check_peer_known (peer));
-
-  ctx = GNUNET_new (struct PeerContext);
-  ctx->peer_id = *peer;
-  ctx->send_channel_flags = GNUNET_new (uint32_t);
-  ctx->recv_channel_flags = GNUNET_new (uint32_t);
-  ret = GNUNET_CONTAINER_multipeermap_put (peer_map, peer, ctx,
-      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-  GNUNET_assert (GNUNET_OK == ret);
-  return ctx;
-}
-
-
-/**
- * @brief Create or get a #PeerContext
- *
- * @param peer the peer to get the associated context to
- *
- * @return the context
- */
-static struct PeerContext *
-create_or_get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
-{
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return create_peer_ctx (peer);
-  }
-  return get_peer_ctx (peer);
-}
-
-
-/**
- * @brief Check whether we have a connection to this @a peer
- *
- * Also sets the #Peers_ONLINE flag accordingly
- *
- * @param peer the peer in question
- *
- * @return #GNUNET_YES if we are connected
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_connected (const struct GNUNET_PeerIdentity *peer)
-{
-  const struct PeerContext *peer_ctx;
-
-  /* If we don't know about this peer we don't know whether it's online */
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_NO;
-  }
-  /* Get the context */
-  peer_ctx = get_peer_ctx (peer);
-  /* If we have no channel to this peer we don't know whether it's online */
-  if ( (NULL == peer_ctx->send_channel) &&
-       (NULL == peer_ctx->recv_channel) )
-  {
-    Peers_unset_peer_flag (peer, Peers_ONLINE);
-    return GNUNET_NO;
-  }
-  /* Otherwise (if we have a channel, we know that it's online */
-  Peers_set_peer_flag (peer, Peers_ONLINE);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief The closure to #get_rand_peer_iterator.
- */
-struct GetRandPeerIteratorCls
-{
-  /**
-   * @brief The index of the peer to return.
-   * Will be decreased until 0.
-   * Then current peer is returned.
-   */
-  uint32_t index;
-
-  /**
-   * @brief Pointer to peer to return.
-   */
-  const struct GNUNET_PeerIdentity *peer;
-};
-
-
-/**
- * @brief Iterator function for #get_random_peer_from_peermap.
- *
- * Implements #GNUNET_CONTAINER_PeerMapIterator.
- * Decreases the index until the index is null.
- * Then returns the current peer.
- *
- * @param cls the #GetRandPeerIteratorCls containing index and peer
- * @param peer current peer
- * @param value unused
- *
- * @return  #GNUNET_YES if we should continue to
- *          iterate,
- *          #GNUNET_NO if not.
- */
-static int
-get_rand_peer_iterator (void *cls,
-                        const struct GNUNET_PeerIdentity *peer,
-                        void *value)
-{
-  struct GetRandPeerIteratorCls *iterator_cls = cls;
-  if (0 >= iterator_cls->index)
-  {
-    iterator_cls->peer = peer;
-    return GNUNET_NO;
-  }
-  iterator_cls->index--;
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief Get a random peer from @a peer_map
- *
- * @param peer_map the peer_map to get the peer from
- *
- * @return a random peer
- */
-static const struct GNUNET_PeerIdentity *
-get_random_peer_from_peermap (const struct
-                              GNUNET_CONTAINER_MultiPeerMap *peer_map)
-{
-  struct GetRandPeerIteratorCls *iterator_cls;
-  const struct GNUNET_PeerIdentity *ret;
-
-  iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
-  iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-      GNUNET_CONTAINER_multipeermap_size (peer_map));
-  (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
-                                                get_rand_peer_iterator,
-                                                iterator_cls);
-  ret = iterator_cls->peer;
-  GNUNET_free (iterator_cls);
-  return ret;
-}
-
-
-/**
- * @brief Add a given @a peer to valid peers.
- *
- * If valid peers are already #num_valid_peers_max, delete a peer previously.
- *
- * @param peer the peer that is added to the valid peers.
- *
- * @return #GNUNET_YES if no other peer had to be removed
- *         #GNUNET_NO  otherwise
- */
-static int
-add_valid_peer (const struct GNUNET_PeerIdentity *peer)
-{
-  const struct GNUNET_PeerIdentity *rand_peer;
-  int ret;
-
-  ret = GNUNET_YES;
-  while (GNUNET_CONTAINER_multipeermap_size (valid_peers) >= num_valid_peers_max)
-  {
-    rand_peer = get_random_peer_from_peermap (valid_peers);
-    GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
-    ret = GNUNET_NO;
-  }
-  (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
-      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-  return ret;
-}
-
-
-/**
- * @brief Set the peer flag to living and
- *        call the pending operations on this peer.
- *
- * Also adds peer to #valid_peers.
- *
- * @param peer_ctx the #PeerContext of the peer to set live
- */
-static void
-set_peer_live (struct PeerContext *peer_ctx)
-{
-  struct GNUNET_PeerIdentity *peer;
-  unsigned int i;
-
-  peer = &peer_ctx->peer_id;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Peer %s is live and valid, calling %i pending operations on it\n",
-      GNUNET_i2s (peer),
-      peer_ctx->num_pending_ops);
-
-  if (NULL != peer_ctx->liveliness_check_pending)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Removing pending liveliness check for peer %s\n",
-         GNUNET_i2s (&peer_ctx->peer_id));
-    // TODO wait until cadet sets mq->cancel_impl
-    //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
-    GNUNET_free (peer_ctx->liveliness_check_pending);
-    peer_ctx->liveliness_check_pending = NULL;
-  }
-
-  (void) add_valid_peer (peer);
-  set_peer_flag (peer_ctx, Peers_ONLINE);
-
-  /* Call pending operations */
-  for (i = 0; i < peer_ctx->num_pending_ops; i++)
-  {
-    peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
-  }
-  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
-}
-
-
-/**
- * @brief Get the channel of a peer. If not existing, create.
- *
- * @param peer the peer id
- * @return the #GNUNET_CADET_Channel used to send data to @a peer
- */
-struct GNUNET_CADET_Channel *
-get_channel (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-  struct GNUNET_HashCode port;
-
-  peer_ctx = get_peer_ctx (peer);
-  if (NULL == peer_ctx->send_channel)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Trying to establish channel to peer %s\n",
-         GNUNET_i2s (peer));
-    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS,
-                        strlen (GNUNET_APPLICATION_PORT_RPS),
-                        &port);
-    peer_ctx->send_channel =
-      GNUNET_CADET_channel_create (cadet_handle,
-                                   (struct GNUNET_PeerIdentity *) peer, /* context */
-                                   peer,
-                                   &port,
-                                   GNUNET_CADET_OPTION_RELIABLE,
-                                   NULL, /* WindowSize handler */
-                                   cleanup_destroyed_channel, /* Disconnect handler */
-                                   cadet_handlers);
-  }
-  GNUNET_assert (NULL != peer_ctx->send_channel);
-  return peer_ctx->send_channel;
-}
-
-
-/**
- * Get the message queue (#GNUNET_MQ_Handle) of a specific peer.
- *
- * If we already have a message queue open to this client,
- * simply return it, otherways create one.
- *
- * @param peer the peer to get the mq to
- * @return the #GNUNET_MQ_Handle
- */
-static struct GNUNET_MQ_Handle *
-get_mq (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-
-  if (NULL == peer_ctx->mq)
-  {
-    (void) get_channel (peer);
-    peer_ctx->mq = GNUNET_CADET_get_mq (peer_ctx->send_channel);
-  }
-  return peer_ctx->mq;
-}
-
-
-/**
- * @brief This is called in response to the first message we sent as a
- * liveliness check.
- *
- * @param cls #PeerContext of peer with pending liveliness check
- */
-static void
-mq_liveliness_check_successful (void *cls)
-{
-  struct PeerContext *peer_ctx = cls;
-
-  if (NULL != peer_ctx->liveliness_check_pending)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Liveliness check for peer %s was successfull\n",
-        GNUNET_i2s (&peer_ctx->peer_id));
-    GNUNET_free (peer_ctx->liveliness_check_pending);
-    peer_ctx->liveliness_check_pending = NULL;
-    set_peer_live (peer_ctx);
-  }
-}
-
-/**
- * Issue a check whether peer is live
- *
- * @param peer_ctx the context of the peer
- */
-static void
-check_peer_live (struct PeerContext *peer_ctx)
-{
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Get informed about peer %s getting live\n",
-       GNUNET_i2s (&peer_ctx->peer_id));
-
-  struct GNUNET_MQ_Handle *mq;
-  struct GNUNET_MQ_Envelope *ev;
-
-  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
-  peer_ctx->liveliness_check_pending = GNUNET_new (struct PendingMessage);
-  peer_ctx->liveliness_check_pending->ev = ev;
-  peer_ctx->liveliness_check_pending->peer_ctx = peer_ctx;
-  peer_ctx->liveliness_check_pending->type = "Check liveliness";
-  mq = get_mq (&peer_ctx->peer_id);
-  GNUNET_MQ_notify_sent (ev,
-                         mq_liveliness_check_successful,
-                         peer_ctx);
-  GNUNET_MQ_send (mq, ev);
-}
-
-/**
- * @brief Add an envelope to a message passed to mq to list of pending messages
- *
- * @param peer peer the message was sent to
- * @param ev envelope to the message
- * @param type type of the message to be sent
- * @return pointer to pending message
- */
-static struct PendingMessage *
-insert_pending_message (const struct GNUNET_PeerIdentity *peer,
-                        struct GNUNET_MQ_Envelope *ev,
-                        const char *type)
-{
-  struct PendingMessage *pending_msg;
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  pending_msg = GNUNET_new (struct PendingMessage);
-  pending_msg->ev = ev;
-  pending_msg->peer_ctx = peer_ctx;
-  pending_msg->type = type;
-  GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
-                               peer_ctx->pending_messages_tail,
-                               pending_msg);
-  return pending_msg;
-}
-
-
-/**
- * @brief Remove a pending message from the respective DLL
- *
- * @param pending_msg the pending message to remove
- */
-static void
-remove_pending_message (struct PendingMessage *pending_msg)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = pending_msg->peer_ctx;
-  GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
-                               peer_ctx->pending_messages_tail,
-                               pending_msg);
-  GNUNET_MQ_send_cancel (peer_ctx->pending_messages_head->ev);
-  GNUNET_free (pending_msg);
-}
-
-
-/**
- * @brief Check whether function of type #PeerOp was already scheduled
- *
- * The array with pending operations will probably never grow really big, so
- * iterating over it should be ok.
- *
- * @param peer the peer to check
- * @param peer_op the operation (#PeerOp) on the peer
- *
- * @return #GNUNET_YES if this operation is scheduled on that peer
- *         #GNUNET_NO  otherwise
- */
-static int
-check_operation_scheduled (const struct GNUNET_PeerIdentity *peer,
-                           const PeerOp peer_op)
-{
-  const struct PeerContext *peer_ctx;
-  unsigned int i;
-
-  peer_ctx = get_peer_ctx (peer);
-  for (i = 0; i < peer_ctx->num_pending_ops; i++)
-    if (peer_op == peer_ctx->pending_ops[i].op)
-      return GNUNET_YES;
-  return GNUNET_NO;
-}
-
-
-/**
- * Iterator over hash map entries. Deletes all contexts of peers.
- *
- * @param cls closure
- * @param key current public key
- * @param value value in the hash map
- * @return #GNUNET_YES if we should continue to iterate,
- *         #GNUNET_NO if not.
- */
-static int
-peermap_clear_iterator (void *cls,
-                        const struct GNUNET_PeerIdentity *key,
-                        void *value)
-{
-  Peers_remove_peer (key);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief This is called once a message is sent.
- *
- * Removes the pending message
- *
- * @param cls type of the message that was sent
- */
-static void
-mq_notify_sent_cb (void *cls)
-{
-  struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "%s was sent.\n",
-      pending_msg->type);
-  remove_pending_message (pending_msg);
-}
-
-
-/**
- * @brief Iterator function for #store_valid_peers.
- *
- * Implements #GNUNET_CONTAINER_PeerMapIterator.
- * Writes single peer to disk.
- *
- * @param cls the file handle to write to.
- * @param peer current peer
- * @param value unused
- *
- * @return  #GNUNET_YES if we should continue to
- *          iterate,
- *          #GNUNET_NO if not.
- */
-static int
-store_peer_presistently_iterator (void *cls,
-                                  const struct GNUNET_PeerIdentity *peer,
-                                  void *value)
-{
-  const struct GNUNET_DISK_FileHandle *fh = cls;
-  char peer_string[128];
-  int size;
-  ssize_t ret;
-
-  if (NULL == peer)
-  {
-    return GNUNET_YES;
-  }
-  size = GNUNET_snprintf (peer_string,
-                          sizeof (peer_string),
-                          "%s\n",
-                          GNUNET_i2s_full (peer));
-  GNUNET_assert (53 == size);
-  ret = GNUNET_DISK_file_write (fh,
-                                peer_string,
-                                size);
-  GNUNET_assert (size == ret);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief Store the peers currently in #valid_peers to disk.
- */
-static void
-store_valid_peers ()
-{
-  struct GNUNET_DISK_FileHandle *fh;
-  uint32_t number_written_peers;
-  int ret;
-
-  if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
-  {
-    return;
-  }
-
-  ret = GNUNET_DISK_directory_create_for_file (filename_valid_peers);
-  if (GNUNET_SYSERR == ret)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Not able to create directory for file `%s'\n",
-        filename_valid_peers);
-    GNUNET_break (0);
-  }
-  else if (GNUNET_NO == ret)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Directory for file `%s' exists but is not writable for us\n",
-        filename_valid_peers);
-    GNUNET_break (0);
-  }
-  fh = GNUNET_DISK_file_open (filename_valid_peers,
-                              GNUNET_DISK_OPEN_WRITE |
-                                  GNUNET_DISK_OPEN_CREATE,
-                              GNUNET_DISK_PERM_USER_READ |
-                                  GNUNET_DISK_PERM_USER_WRITE);
-  if (NULL == fh)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Not able to write valid peers to file `%s'\n",
-        filename_valid_peers);
-    return;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Writing %u valid peers to disk\n",
-      GNUNET_CONTAINER_multipeermap_size (valid_peers));
-  number_written_peers =
-    GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
-                                           store_peer_presistently_iterator,
-                                           fh);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
-  GNUNET_assert (number_written_peers ==
-      GNUNET_CONTAINER_multipeermap_size (valid_peers));
-}
-
-
-/**
- * @brief Convert string representation of peer id to peer id.
- *
- * Counterpart to #GNUNET_i2s_full.
- *
- * @param string_repr The string representation of the peer id
- *
- * @return The peer id
- */
-static const struct GNUNET_PeerIdentity *
-s2i_full (const char *string_repr)
-{
-  struct GNUNET_PeerIdentity *peer;
-  size_t len;
-  int ret;
-
-  peer = GNUNET_new (struct GNUNET_PeerIdentity);
-  len = strlen (string_repr);
-  if (52 > len)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Not able to convert string representation of PeerID to PeerID\n"
-        "Sting representation: %s (len %u) - too short\n",
-        string_repr,
-        len);
-    GNUNET_break (0);
-  }
-  else if (52 < len)
-  {
-    len = 52;
-  }
-  ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
-                                                    len,
-                                                    &peer->public_key);
-  if (GNUNET_OK != ret)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Not able to convert string representation of PeerID to PeerID\n"
-        "Sting representation: %s\n",
-        string_repr);
-    GNUNET_break (0);
-  }
-  return peer;
-}
-
-
-/**
- * @brief Restore the peers on disk to #valid_peers.
- */
-static void
-restore_valid_peers ()
-{
-  off_t file_size;
-  uint32_t num_peers;
-  struct GNUNET_DISK_FileHandle *fh;
-  char *buf;
-  ssize_t size_read;
-  char *iter_buf;
-  char *str_repr;
-  const struct GNUNET_PeerIdentity *peer;
-
-  if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
-  {
-    return;
-  }
-
-  if (GNUNET_OK != GNUNET_DISK_file_test (filename_valid_peers))
-  {
-    return;
-  }
-  fh = GNUNET_DISK_file_open (filename_valid_peers,
-                              GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
-  GNUNET_assert (NULL != fh);
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
-  num_peers = file_size / 53;
-  buf = GNUNET_malloc (file_size);
-  size_read = GNUNET_DISK_file_read (fh, buf, file_size);
-  GNUNET_assert (size_read == file_size);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Restoring %" PRIu32 " peers from file `%s'\n",
-      num_peers,
-      filename_valid_peers);
-  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
-  {
-    str_repr = GNUNET_strndup (iter_buf, 53);
-    peer = s2i_full (str_repr);
-    GNUNET_free (str_repr);
-    add_valid_peer (peer);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Restored valid peer %s from disk\n",
-        GNUNET_i2s_full (peer));
-  }
-  iter_buf = NULL;
-  GNUNET_free (buf);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "num_peers: %" PRIu32 ", _size (valid_peers): %u\n",
-      num_peers,
-      GNUNET_CONTAINER_multipeermap_size (valid_peers));
-  if (num_peers != GNUNET_CONTAINER_multipeermap_size (valid_peers))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Number of restored peers does not match file size. Have probably duplicates.\n");
-  }
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Restored %u valid peers from disk\n",
-      GNUNET_CONTAINER_multipeermap_size (valid_peers));
-}
-
-
-/**
- * @brief Initialise storage of peers
- *
- * @param fn_valid_peers filename of the file used to store valid peer ids
- * @param cadet_h cadet handle
- * @param disconnect_handler Disconnect handler
- * @param c_handlers cadet handlers
- * @param own_id own peer identity
- */
-void
-Peers_initialise (char* fn_valid_peers,
-                  struct GNUNET_CADET_Handle *cadet_h,
-                  GNUNET_CADET_DisconnectEventHandler disconnect_handler,
-                  const struct GNUNET_MQ_MessageHandler *c_handlers,
-                  const struct GNUNET_PeerIdentity *own_id)
-{
-  filename_valid_peers = GNUNET_strdup (fn_valid_peers);
-  cadet_handle = cadet_h;
-  cleanup_destroyed_channel = disconnect_handler;
-  cadet_handlers = c_handlers;
-  own_identity = own_id;
-  peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
-  valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
-  restore_valid_peers ();
-}
-
-
-/**
- * @brief Delete storage of peers that was created with #Peers_initialise ()
- */
-void
-Peers_terminate ()
-{
-  if (GNUNET_SYSERR ==
-      GNUNET_CONTAINER_multipeermap_iterate (peer_map,
-                                             peermap_clear_iterator,
-                                             NULL))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-        "Iteration destroying peers was aborted.\n");
-  }
-  GNUNET_CONTAINER_multipeermap_destroy (peer_map);
-  store_valid_peers ();
-  GNUNET_free (filename_valid_peers);
-  GNUNET_CONTAINER_multipeermap_destroy (valid_peers);
-}
-
-
-/**
- * Iterator over #valid_peers hash map entries.
- *
- * @param cls closure - unused
- * @param peer current peer id
- * @param value value in the hash map - unused
- * @return #GNUNET_YES if we should continue to
- *         iterate,
- *         #GNUNET_NO if not.
- */
-static int
-valid_peer_iterator (void *cls,
-                     const struct GNUNET_PeerIdentity *peer,
-                     void *value)
-{
-  struct PeersIteratorCls *it_cls = cls;
-
-  return it_cls->iterator (it_cls->cls,
-                           peer);
-}
-
-
-/**
- * @brief Get all currently known, valid peer ids.
- *
- * @param it function to call on each peer id
- * @param it_cls extra argument to @a it
- * @return the number of key value pairs processed,
- *         #GNUNET_SYSERR if it aborted iteration
- */
-int
-Peers_get_valid_peers (PeersIterator iterator,
-                       void *it_cls)
-{
-  struct PeersIteratorCls *cls;
-  int ret;
-
-  cls = GNUNET_new (struct PeersIteratorCls);
-  cls->iterator = iterator;
-  cls->cls = it_cls;
-  ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
-                                               valid_peer_iterator,
-                                               cls);
-  GNUNET_free (cls);
-  return ret;
-}
-
-
-/**
- * @brief Add peer to known peers.
- *
- * This function is called on new peer_ids from 'external' sources
- * (client seed, cadet get_peers(), ...)
- *
- * @param peer the new #GNUNET_PeerIdentity
- *
- * @return #GNUNET_YES if peer was inserted
- *         #GNUNET_NO  otherwise (if peer was already known or
- *                     peer was #own_identity)
- */
-int
-Peers_insert_peer (const struct GNUNET_PeerIdentity *peer)
-{
-  if ( (GNUNET_YES == Peers_check_peer_known (peer)) ||
-       (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, own_identity)) )
-  {
-    return GNUNET_NO; /* We already know this peer - nothing to do */
-  }
-  (void) create_peer_ctx (peer);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief Try connecting to a peer to see whether it is online
- *
- * If not known yet, insert into known peers
- *
- * @param peer the peer whose liveliness is to be checked
- * @return #GNUNET_YES if peer had to be inserted
- *         #GNUNET_NO  otherwise (if peer was already known or
- *                     peer was #own_identity)
- */
-int
-Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-  int ret;
-
-  if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, own_identity))
-  {
-    return GNUNET_NO;
-  }
-  ret = Peers_insert_peer (peer);
-  peer_ctx = get_peer_ctx (peer);
-  if (GNUNET_NO == Peers_check_peer_flag (peer, Peers_ONLINE))
-  {
-    check_peer_live (peer_ctx);
-  }
-  return ret;
-}
-
-
-/**
- * @brief Check if peer is removable.
- *
- * Check if
- *  - a recv channel exists
- *  - there are pending messages
- *  - there is no pending pull reply
- *
- * @param peer the peer in question
- * @return #GNUNET_YES    if peer is removable
- *         #GNUNET_NO     if peer is NOT removable
- *         #GNUNET_SYSERR if peer is not known
- */
-int
-Peers_check_removable (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
-  {
-    return GNUNET_SYSERR;
-  }
-
-  peer_ctx = get_peer_ctx (peer);
-  if ( (NULL != peer_ctx->recv_channel) ||
-       (NULL != peer_ctx->pending_messages_head) ||
-       (GNUNET_NO == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) )
-  {
-    return GNUNET_NO;
-  }
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief Remove peer
- *
- * @param peer the peer to clean
- * @return #GNUNET_YES if peer was removed
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
-  {
-    return GNUNET_NO;
-  }
-
-  peer_ctx = get_peer_ctx (peer);
-  set_peer_flag (peer_ctx, Peers_TO_DESTROY);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Going to remove peer %s\n",
-       GNUNET_i2s (&peer_ctx->peer_id));
-  Peers_unset_peer_flag (peer, Peers_ONLINE);
-
-  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
-  while (NULL != peer_ctx->pending_messages_head)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Removing unsent %s\n",
-        peer_ctx->pending_messages_head->type);
-    remove_pending_message (peer_ctx->pending_messages_head);
-  }
-  /* If we are still waiting for notification whether this peer is live
-   * cancel the according task */
-  if (NULL != peer_ctx->liveliness_check_pending)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-         "Removing pending liveliness check for peer %s\n",
-         GNUNET_i2s (&peer_ctx->peer_id));
-    // TODO wait until cadet sets mq->cancel_impl
-    //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
-    GNUNET_free (peer_ctx->liveliness_check_pending);
-    peer_ctx->liveliness_check_pending = NULL;
-  }
-  if (NULL != peer_ctx->send_channel)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Destroying send channel\n");
-    GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
-    peer_ctx->send_channel = NULL;
-  }
-  if (NULL != peer_ctx->recv_channel)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Destroying recv channel\n");
-    GNUNET_CADET_channel_destroy (peer_ctx->recv_channel);
-    peer_ctx->recv_channel = NULL;
-  }
-  if (NULL != peer_ctx->mq)
-  {
-    GNUNET_MQ_destroy (peer_ctx->mq);
-    peer_ctx->mq = NULL;
-  }
-
-  GNUNET_free (peer_ctx->send_channel_flags);
-  GNUNET_free (peer_ctx->recv_channel_flags);
-
-  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove_all (peer_map, &peer_ctx->peer_id))
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer from peer_map failed\n");
-  }
-  GNUNET_free (peer_ctx);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief set flags on a given peer.
- *
- * @param peer the peer to set flags on
- * @param flags the flags
- */
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  set_peer_flag (peer_ctx, flags);
-}
-
-
-/**
- * @brief unset flags on a given peer.
- *
- * @param peer the peer to unset flags on
- * @param flags the flags
- */
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  unset_peer_flag (peer_ctx, flags);
-}
-
-
-/**
- * @brief Check whether flags on a peer are set.
- *
- * @param peer the peer to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_SYSERR if peer is not known
- *         #GNUNET_YES    if all given flags are set
- *         #GNUNET_NO     otherwise
- */
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_SYSERR;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  return check_peer_flag_set (peer_ctx, flags);
-}
-
-
-/**
- * @brief set flags on a given channel.
- *
- * @param channel the channel to set flags on
- * @param flags the flags
- */
-void
-Peers_set_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
-{
-  set_channel_flag (channel_flags, flags);
-}
-
-
-/**
- * @brief unset flags on a given channel.
- *
- * @param channel the channel to unset flags on
- * @param flags the flags
- */
-void
-Peers_unset_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
-{
-  unset_channel_flag (channel_flags, flags);
-}
-
-
-/**
- * @brief Check whether flags on a channel are set.
- *
- * @param channel the channel to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_YES if all given flags are set
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags)
-{
-  return check_channel_flag_set (channel_flags, flags);
-}
-
-/**
- * @brief Get the flags for the channel in @a role for @a peer.
- *
- * @param peer Peer to get the channel flags for.
- * @param role Role of channel to get flags for
- *
- * @return The flags.
- */
-uint32_t *
-Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
-                        enum Peers_ChannelRole role)
-{
-  const struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  if (Peers_CHANNEL_ROLE_SENDING == role)
-  {
-    return peer_ctx->send_channel_flags;
-  }
-  else if (Peers_CHANNEL_ROLE_RECEIVING == role)
-  {
-    return peer_ctx->recv_channel_flags;
-  }
-  else
-  {
-    GNUNET_assert (0);
-  }
-}
-
-/**
- * @brief Check whether we have information about the given peer.
- *
- * FIXME probably deprecated. Make this the new _online.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is known
- *         #GNUNET_NO  if peer is not knwon
- */
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer)
-{
-  return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
-}
-
-
-/**
- * @brief Check whether @a peer is actually a peer.
- *
- * A valid peer is a peer that we know exists eg. we were connected to once.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is valid
- *         #GNUNET_NO  if peer is not valid
- */
-int
-Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer)
-{
-  return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
-}
-
-
-/**
- * @brief Indicate that we want to send to the other peer
- *
- * This establishes a sending channel
- *
- * @param peer the peer to establish channel to
- */
-void
-Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
-{
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
-  (void) get_channel (peer);
-}
-
-
-/**
- * @brief Check whether other peer has the intention to send/opened channel
- *        towars us
- *
- * @param peer the peer in question
- *
- * @return #GNUNET_YES if peer has the intention to send
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
-{
-  const struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  if (NULL != peer_ctx->recv_channel)
-  {
-    return GNUNET_YES;
-  }
-  return GNUNET_NO;
-}
-
-
-/**
- * Handle the channel a peer opens to us.
- *
- * @param cls The closure
- * @param channel The channel the peer wants to establish
- * @param initiator The peer's peer ID
- *
- * @return initial channel context for the channel
- *         (can be NULL -- that's not an error)
- */
-void *
-Peers_handle_inbound_channel (void *cls,
-                              struct GNUNET_CADET_Channel *channel,
-                              const struct GNUNET_PeerIdentity *initiator)
-{
-  struct PeerContext *peer_ctx;
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "New channel was established to us (Peer %s).\n",
-      GNUNET_i2s (initiator));
-  GNUNET_assert (NULL != channel); /* according to cadet API */
-  /* Make sure we 'know' about this peer */
-  peer_ctx = create_or_get_peer_ctx (initiator);
-  set_peer_live (peer_ctx);
-  /* We only accept one incoming channel per peer */
-  if (GNUNET_YES == Peers_check_peer_send_intention (initiator))
-  {
-    set_channel_flag (peer_ctx->recv_channel_flags,
-                      Peers_CHANNEL_ESTABLISHED_TWICE);
-    GNUNET_CADET_channel_destroy (channel);
-    /* return the channel context */
-    return &peer_ctx->peer_id;
-  }
-  peer_ctx->recv_channel = channel;
-  return &peer_ctx->peer_id;
-}
-
-
-/**
- * @brief Check whether a sending channel towards the given peer exists
- *
- * @param peer the peer to check for
- *
- * @return #GNUNET_YES if a sending channel towards that peer exists
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  { /* If no such peer exists, there is no channel */
-    return GNUNET_NO;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  if (NULL == peer_ctx->send_channel)
-  {
-    return GNUNET_NO;
-  }
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief check whether the given channel is the sending channel of the given
- *        peer
- *
- * @param peer the peer in question
- * @param channel the channel to check for
- * @param role either #Peers_CHANNEL_ROLE_SENDING, or
- *                    #Peers_CHANNEL_ROLE_RECEIVING
- *
- * @return #GNUNET_YES if the given chennel is the sending channel of the peer
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
-                          const struct GNUNET_CADET_Channel *channel,
-                          enum Peers_ChannelRole role)
-{
-  const struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_NO;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  if ( (Peers_CHANNEL_ROLE_SENDING == role) &&
-       (channel == peer_ctx->send_channel) )
-  {
-    return GNUNET_YES;
-  }
-  if ( (Peers_CHANNEL_ROLE_RECEIVING == role) &&
-       (channel == peer_ctx->recv_channel) )
-  {
-    return GNUNET_YES;
-  }
-  return GNUNET_NO;
-}
-
-
-/**
- * @brief Destroy the send channel of a peer e.g. stop indicating a sending
- *        intention to another peer
- *
- * If there is also no channel to receive messages from that peer, remove it
- * from the peermap.
- * TODO really?
- *
- * @peer the peer identity of the peer whose sending channel to destroy
- * @return #GNUNET_YES if channel was destroyed
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_NO;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  if (NULL != peer_ctx->send_channel)
-  {
-    set_channel_flag (peer_ctx->send_channel_flags, Peers_CHANNEL_CLEAN);
-    GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
-    peer_ctx->send_channel = NULL;
-    (void) Peers_check_connected (peer);
-    return GNUNET_YES;
-  }
-  return GNUNET_NO;
-}
-
-/**
- * This is called when a channel is destroyed.
- *
- * @param cls The closure
- * @param channel The channel being closed
- * @param channel_ctx The context associated with this channel
- */
-void
-Peers_cleanup_destroyed_channel (void *cls,
-                                 const struct GNUNET_CADET_Channel *channel)
-{
-  struct GNUNET_PeerIdentity *peer = cls;
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {/* We don't want to implicitly create a context that we're about to kill */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "channel (%s) without associated context was destroyed\n",
-       GNUNET_i2s (peer));
-    return;
-  }
-  peer_ctx = get_peer_ctx (peer);
-
-  /* If our peer issued the destruction of the channel, the #Peers_TO_DESTROY
-   * flag will be set. In this case simply make sure that the channels are
-   * cleaned. */
-  /* FIXME This distinction seems to be redundant */
-  if (Peers_check_peer_flag (peer, Peers_TO_DESTROY))
-  {/* We initiatad the destruction of this particular peer */
-    if (channel == peer_ctx->send_channel)
-      peer_ctx->send_channel = NULL;
-    else if (channel == peer_ctx->recv_channel)
-      peer_ctx->recv_channel = NULL;
-
-    if (NULL != peer_ctx->send_channel)
-    {
-      GNUNET_CADET_channel_destroy (peer_ctx->send_channel);
-      peer_ctx->send_channel = NULL;
-    }
-    if (NULL != peer_ctx->recv_channel)
-    {
-      GNUNET_CADET_channel_destroy (peer_ctx->recv_channel);
-      peer_ctx->recv_channel = NULL;
-    }
-    /* Set the #Peers_ONLINE flag accordingly */
-    (void) Peers_check_connected (peer);
-    return;
-  }
-
-  else
-  { /* We did not initiate the destruction of this peer */
-    if (channel == peer_ctx->send_channel)
-    { /* Something (but us) killd the channel - clean up peer */
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-          "send channel (%s) was destroyed - cleaning up\n",
-          GNUNET_i2s (peer));
-      peer_ctx->send_channel = NULL;
-    }
-    else if (channel == peer_ctx->recv_channel)
-    { /* Other peer doesn't want to send us messages anymore */
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Peer %s destroyed recv channel - cleaning up channel\n",
-           GNUNET_i2s (peer));
-      peer_ctx->recv_channel = NULL;
-    }
-    else
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "unknown channel (%s) was destroyed\n",
-           GNUNET_i2s (peer));
-    }
-  }
-  (void) Peers_check_connected (peer);
-}
-
-/**
- * @brief Send a message to another peer.
- *
- * Keeps track about pending messages so they can be properly removed when the
- * peer is destroyed.
- *
- * @param peer receeiver of the message
- * @param ev envelope of the message
- * @param type type of the message
- */
-void
-Peers_send_message (const struct GNUNET_PeerIdentity *peer,
-                    struct GNUNET_MQ_Envelope *ev,
-                    const char *type)
-{
-  struct PendingMessage *pending_msg;
-  struct GNUNET_MQ_Handle *mq;
-
-  pending_msg = insert_pending_message (peer, ev, type);
-  mq = get_mq (peer);
-  GNUNET_MQ_notify_sent (ev,
-                         mq_notify_sent_cb,
-                         pending_msg);
-  GNUNET_MQ_send (mq, ev);
-}
-
-/**
- * @brief Schedule a operation on given peer
- *
- * Avoids scheduling an operation twice.
- *
- * @param peer the peer we want to schedule the operation for once it gets live
- *
- * @return #GNUNET_YES if the operation was scheduled
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
-                          const PeerOp peer_op)
-{
-  struct PeerPendingOp pending_op;
-  struct PeerContext *peer_ctx;
-
-  if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, own_identity))
-  {
-    return GNUNET_NO;
-  }
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
-
-  //TODO if LIVE/ONLINE execute immediately
-
-  if (GNUNET_NO == check_operation_scheduled (peer, peer_op))
-  {
-    peer_ctx = get_peer_ctx (peer);
-    pending_op.op = peer_op;
-    pending_op.op_cls = NULL;
-    GNUNET_array_append (peer_ctx->pending_ops,
-                         peer_ctx->num_pending_ops,
-                         pending_op);
-    return GNUNET_YES;
-  }
-  return GNUNET_NO;
-}
-
-/**
- * @brief Get the recv_channel of @a peer.
- * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming
- * messages.
- *
- * @param peer The peer to get the recv_channel from.
- *
- * @return The recv_channel.
- */
-struct GNUNET_CADET_Channel *
-Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
-  peer_ctx = get_peer_ctx (peer);
-  return peer_ctx->recv_channel;
-}
-
-/* end of gnunet-service-rps_peers.c */
diff --git a/src/rps/gnunet-service-rps_peers.h b/src/rps/gnunet-service-rps_peers.h
deleted file mode 100644
index 15970a7ce..000000000
--- a/src/rps/gnunet-service-rps_peers.h
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
-     This file is part of GNUnet.
-     Copyright (C)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-     Boston, MA 02110-1301, USA.
-*/
-
-/**
- * @file rps/gnunet-service-rps_peers.h
- * @brief utilities for managing (information about) peers
- * @author Julius Bünger
- */
-#include "gnunet_util_lib.h"
-#include <inttypes.h>
-#include "gnunet_cadet_service.h"
-
-
-/**
- * Different flags indicating the status of another peer.
- */
-enum Peers_PeerFlags
-{
-  /**
-   * If we are waiting for a reply from that peer (sent a pull request).
-   */
-  Peers_PULL_REPLY_PENDING   = 0x01,
-
-  /* IN_OTHER_GOSSIP_LIST = 0x02, unneeded? */
-  /* IN_OWN_SAMPLER_LIST  = 0x04, unneeded? */
-  /* IN_OWN_GOSSIP_LIST   = 0x08, unneeded? */
-
-  /**
-   * We set this bit when we know the peer is online.
-   */
-  Peers_ONLINE               = 0x20,
-
-  /**
-   * We set this bit when we are going to destroy the channel to this peer.
-   * When cleanup_channel is called, we know that we wanted to destroy it.
-   * Otherwise the channel to the other peer was destroyed.
-   */
-  Peers_TO_DESTROY           = 0x40,
-};
-
-/**
- * Keep track of the status of a channel.
- *
- * This is needed in order to know what to do with a channel when it's
- * destroyed.
- */
-enum Peers_ChannelFlags
-{
-  /**
-   * We destroyed the channel because the other peer established a second one.
-   */
-  Peers_CHANNEL_ESTABLISHED_TWICE = 0x1,
-
-  /**
-   * The channel was removed because it was not needed any more. This should be
-   * the sending channel.
-   */
-  Peers_CHANNEL_CLEAN = 0x2,
-};
-
-/**
- * @brief The role of a channel. Sending or receiving.
- */
-enum Peers_ChannelRole
-{
-  /**
-   * Channel is used for sending
-   */
-  Peers_CHANNEL_ROLE_SENDING   = 0x01,
-
-  /**
-   * Channel is used for receiving
-   */
-  Peers_CHANNEL_ROLE_RECEIVING = 0x02,
-};
-
-/**
- * @brief Functions of this type can be used to be stored at a peer for later execution.
- *
- * @param cls closure
- * @param peer peer to execute function on
- */
-typedef void (* PeerOp) (void *cls, const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Iterator over valid peers.
- *
- * @param cls closure
- * @param peer current public peer id
- * @return #GNUNET_YES if we should continue to
- *         iterate,
- *         #GNUNET_NO if not.
- */
-typedef int
-(*PeersIterator) (void *cls,
-                  const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Initialise storage of peers
- *
- * @param fn_valid_peers filename of the file used to store valid peer ids
- * @param cadet_h cadet handle
- * @param disconnect_handler Disconnect handler
- * @param c_handlers cadet handlers
- * @param own_id own peer identity
- */
-void
-Peers_initialise (char* fn_valid_peers,
-                  struct GNUNET_CADET_Handle *cadet_h,
-                  GNUNET_CADET_DisconnectEventHandler disconnect_handler,
-                  const struct GNUNET_MQ_MessageHandler *c_handlers,
-                  const struct GNUNET_PeerIdentity *own_id);
-
-/**
- * @brief Delete storage of peers that was created with #Peers_initialise ()
- */
-void
-Peers_terminate ();
-
-
-/**
- * @brief Get all currently known, valid peer ids.
- *
- * @param it function to call on each peer id
- * @param it_cls extra argument to @a it
- * @return the number of key value pairs processed,
- *         #GNUNET_SYSERR if it aborted iteration
- */
-int
-Peers_get_valid_peers (PeersIterator iterator,
-                       void *it_cls);
-
-/**
- * @brief Add peer to known peers.
- *
- * This function is called on new peer_ids from 'external' sources
- * (client seed, cadet get_peers(), ...)
- *
- * @param peer the new #GNUNET_PeerIdentity
- *
- * @return #GNUNET_YES if peer was inserted
- *         #GNUNET_NO  otherwise (if peer was already known or
- *                     peer was #own_identity)
- */
-int
-Peers_insert_peer (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Try connecting to a peer to see whether it is online
- *
- * If not known yet, insert into known peers
- *
- * @param peer the peer whose liveliness is to be checked
- * @return #GNUNET_YES if peer had to be inserted
- *         #GNUNET_NO  otherwise (if peer was already known or
- *                     peer was #own_identity)
- */
-int
-Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Check if peer is removable.
- *
- * Check if
- *  - a recv channel exists
- *  - there are pending messages
- *  - there is no pending pull reply
- *
- * @param peer the peer in question
- * @return #GNUNET_YES    if peer is removable
- *         #GNUNET_NO     if peer is NOT removable
- *         #GNUNET_SYSERR if peer is not known
- */
-int
-Peers_check_removable (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Remove peer
- *
- * @param peer the peer to clean
- * @return #GNUNET_YES if peer was removed
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_remove_peer (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief set flags on a given peer.
- *
- * @param peer the peer to set flags on
- * @param flags the flags
- */
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
-
-/**
- * @brief unset flags on a given peer.
- *
- * @param peer the peer to unset flags on
- * @param flags the flags
- */
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
-
-/**
- * @brief Check whether flags on a peer are set.
- *
- * @param peer the peer to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_YES if all given flags are set
- *         ##GNUNET_NO  otherwise
- */
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
-
-
-/**
- * @brief set flags on a given channel.
- *
- * @param channel the channel to set flags on
- * @param flags the flags
- */
-void
-Peers_set_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
-
-/**
- * @brief unset flags on a given channel.
- *
- * @param channel the channel to unset flags on
- * @param flags the flags
- */
-void
-Peers_unset_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
-
-/**
- * @brief Check whether flags on a channel are set.
- *
- * @param channel the channel to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_YES if all given flags are set
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
-
-/**
- * @brief Get the flags for the channel in @a role for @a peer.
- *
- * @param peer Peer to get the channel flags for.
- * @param role Role of channel to get flags for
- *
- * @return The flags.
- */
-uint32_t *
-Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
-                        enum Peers_ChannelRole role);
-
-/**
- * @brief Check whether we have information about the given peer.
- *
- * FIXME probably deprecated. Make this the new _online.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is known
- *         #GNUNET_NO  if peer is not knwon
- */
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Check whether @a peer is actually a peer.
- *
- * A valid peer is a peer that we know exists eg. we were connected to once.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is valid
- *         #GNUNET_NO  if peer is not valid
- */
-int
-Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Indicate that we want to send to the other peer
- *
- * This establishes a sending channel
- *
- * @param peer the peer to establish channel to
- */
-void
-Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief Check whether other peer has the intention to send/opened channel
- *        towars us
- *
- * @param peer the peer in question
- *
- * @return #GNUNET_YES if peer has the intention to send
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * Handle the channel a peer opens to us.
- *
- * @param cls The closure
- * @param channel The channel the peer wants to establish
- * @param initiator The peer's peer ID
- *
- * @return initial channel context for the channel
- *         (can be NULL -- that's not an error)
- */
-void *
-Peers_handle_inbound_channel (void *cls,
-                              struct GNUNET_CADET_Channel *channel,
-                              const struct GNUNET_PeerIdentity *initiator);
-
-/**
- * @brief Check whether a sending channel towards the given peer exists
- *
- * @param peer the peer to check for
- *
- * @return #GNUNET_YES if a sending channel towards that peer exists
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * @brief check whether the given channel is the sending channel of the given
- *        peer
- *
- * @param peer the peer in question
- * @param channel the channel to check for
- * @param role either #Peers_CHANNEL_ROLE_SENDING, or
- *                    #Peers_CHANNEL_ROLE_RECEIVING
- *
- * @return #GNUNET_YES if the given chennel is the sending channel of the peer
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
-                          const struct GNUNET_CADET_Channel *channel,
-                          enum Peers_ChannelRole role);
-
-/**
- * @brief Destroy the send channel of a peer e.g. stop indicating a sending
- *        intention to another peer
- *
- * If there is also no channel to receive messages from that peer, remove it
- * from the peermap.
- *
- * @peer the peer identity of the peer whose sending channel to destroy
- * @return #GNUNET_YES if channel was destroyed
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * This is called when a channel is destroyed.
- *
- * Removes peer completely from our knowledge if the send_channel was destroyed
- * Otherwise simply delete the recv_channel
- *
- * @param cls The closure
- * @param channel The channel being closed
- * @param channel_ctx The context associated with this channel
- */
-void
-Peers_cleanup_destroyed_channel (void *cls,
-                                 const struct GNUNET_CADET_Channel *channel);
-
-/**
- * @brief Send a message to another peer.
- *
- * Keeps track about pending messages so they can be properly removed when the
- * peer is destroyed.
- *
- * @param peer receeiver of the message
- * @param ev envelope of the message
- * @param type type of the message
- */
-void
-Peers_send_message (const struct GNUNET_PeerIdentity *peer,
-                    struct GNUNET_MQ_Envelope *ev,
-                    const char *type);
-
-/**
- * @brief Schedule a operation on given peer
- *
- * Avoids scheduling an operation twice.
- *
- * @param peer the peer we want to schedule the operation for once it gets live
- *
- * @return #GNUNET_YES if the operation was scheduled
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
-                          const PeerOp peer_op);
-
-/**
- * @brief Get the recv_channel of @a peer.
- * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming
- * messages.
- *
- * @param peer The peer to get the recv_channel from.
- *
- * @return The recv_channel.
- */
-struct GNUNET_CADET_Channel *
-Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer);
-
-/* end of gnunet-service-rps_peers.h */
diff --git a/src/rps/rps.h b/src/rps/rps.h
index 3037e2190..f5cc2e8d1 100644
--- a/src/rps/rps.h
+++ b/src/rps/rps.h
@@ -175,4 +175,100 @@ struct GNUNET_RPS_CS_ActMaliciousMessage
 };
 #endif /* ENABLE_MALICIOUS */
 
+
+/***********************************************************************
+ * Defines from old gnunet-service-rps_peers.h
+***********************************************************************/
+
+/**
+ * Different flags indicating the status of another peer.
+ */
+enum Peers_PeerFlags
+{
+  /**
+   * If we are waiting for a reply from that peer (sent a pull request).
+   */
+  Peers_PULL_REPLY_PENDING   = 0x01,
+
+  /* IN_OTHER_GOSSIP_LIST = 0x02, unneeded? */
+  /* IN_OWN_SAMPLER_LIST  = 0x04, unneeded? */
+  /* IN_OWN_GOSSIP_LIST   = 0x08, unneeded? */
+
+  /**
+   * We set this bit when we know the peer is online.
+   */
+  Peers_ONLINE               = 0x20,
+
+  /**
+   * We set this bit when we are going to destroy the channel to this peer.
+   * When cleanup_channel is called, we know that we wanted to destroy it.
+   * Otherwise the channel to the other peer was destroyed.
+   */
+  Peers_TO_DESTROY           = 0x40,
+};
+
+/**
+ * Keep track of the status of a channel.
+ *
+ * This is needed in order to know what to do with a channel when it's
+ * destroyed.
+ */
+enum Peers_ChannelFlags
+{
+  /**
+   * We destroyed the channel because the other peer established a second one.
+   */
+  Peers_CHANNEL_ESTABLISHED_TWICE = 0x1,
+
+  /**
+   * The channel was removed because it was not needed any more. This should be
+   * the sending channel.
+   */
+  Peers_CHANNEL_CLEAN = 0x2,
+
+  /**
+   * We destroyed the channel because the other peer established a second one.
+   */
+  Peers_CHANNEL_DESTROING = 0x4,
+};
+
+
+/**
+ * @brief The role of a channel. Sending or receiving.
+ */
+enum Peers_ChannelRole
+{
+  /**
+   * Channel is used for sending
+   */
+  Peers_CHANNEL_ROLE_SENDING   = 0x01,
+
+  /**
+   * Channel is used for receiving
+   */
+  Peers_CHANNEL_ROLE_RECEIVING = 0x02,
+};
+
+/**
+ * @brief Functions of this type can be used to be stored at a peer for later execution.
+ *
+ * @param cls closure
+ * @param peer peer to execute function on
+ */
+typedef void (* PeerOp) (void *cls, const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * @brief Iterator over valid peers.
+ *
+ * @param cls closure
+ * @param peer current public peer id
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+typedef int
+(*PeersIterator) (void *cls,
+                  const struct GNUNET_PeerIdentity *peer);
+
+
 GNUNET_NETWORK_STRUCT_END
diff --git a/src/rps/test_rps.c b/src/rps/test_rps.c
index acd3a165d..0114a19fe 100644
--- a/src/rps/test_rps.c
+++ b/src/rps/test_rps.c
@@ -18,7 +18,7 @@
      Boston, MA 02110-1301, USA.
 */
 /**
- * @file rps/test_rps_multipeer.c
+ * @file rps/test_rps.c
  * @brief Testcase for the random peer sampling service.  Starts
  *        a peergroup with a given number of peers, then waits to
  *        receive size pushes/pulls from each peer.  Expects to wait
@@ -344,6 +344,11 @@ struct SingleTestRun
    * Number of Requests to make.
    */
   uint32_t num_requests;
+
+  /**
+   * Run with churn
+   */
+  int have_churn;
 } cur_test_run;
 
 /**
@@ -1023,6 +1028,33 @@ req_cancel_cb (struct RPSPeer *rps_peer)
 }
 
 /***********************************
+ * CHURN
+***********************************/
+
+static void
+churn (void *cls);
+
+static void
+churn_test_cb (struct RPSPeer *rps_peer)
+{
+  /* Start churn */
+  if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting churn task\n");
+    churn_task = GNUNET_SCHEDULER_add_delayed (
+          GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+          churn,
+          NULL);
+  } else {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not starting churn task\n");
+  }
+
+  schedule_missing_requests (rps_peer);
+}
+
+/***********************************
  * PROFILER
 ***********************************/
 
@@ -1148,6 +1180,9 @@ churn (void *cls)
   double portion_go_online;
   double portion_go_offline;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Churn function executing\n");
+
   /* Compute the probability for an online peer to go offline
    * this round */
   portion_online = num_peers_online * 1.0 / num_peers;
@@ -1256,12 +1291,17 @@ static void
 profiler_cb (struct RPSPeer *rps_peer)
 {
   /* Start churn */
-  if (NULL == churn_task)
+  if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting churn task\n");
     churn_task = GNUNET_SCHEDULER_add_delayed (
           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
           churn,
           NULL);
+  } else {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not starting churn task\n");
   }
 
   /* Only request peer ids at one peer.
@@ -1353,6 +1393,24 @@ run (void *cls,
   struct OpListEntry *entry;
   uint32_t num_mal_peers;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
+
+  /* Check whether we timed out */
+  if (n_peers != num_peers ||
+      NULL == peers ||
+      0 == links_succeeded)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Going down due to args (eg. timeout)\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n", num_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n", links_succeeded);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+
+  /* Initialize peers */
   testbed_peers = peers;
   num_peers_online = 0;
   for (i = 0; i < num_peers; i++)
@@ -1412,6 +1470,7 @@ main (int argc, char *argv[])
   cur_test_run.pre_test = NULL;
   cur_test_run.reply_handle = default_reply_handle;
   cur_test_run.eval_cb = default_eval_cb;
+  cur_test_run.have_churn = GNUNET_YES;
   churn_task = NULL;
   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
 
@@ -1446,6 +1505,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
     cur_test_run.name = "test-rps-single-req";
     cur_test_run.main_test = single_req_cb;
+    cur_test_run.have_churn = GNUNET_NO;
   }
 
   else if (strstr (argv[0], "_delayed_reqs") != NULL)
@@ -1453,6 +1513,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
     cur_test_run.name = "test-rps-delayed-reqs";
     cur_test_run.main_test = delay_req_cb;
+    cur_test_run.have_churn = GNUNET_NO;
   }
 
   else if (strstr (argv[0], "_seed_big") != NULL)
@@ -1462,6 +1523,7 @@ main (int argc, char *argv[])
     cur_test_run.name = "test-rps-seed-big";
     cur_test_run.main_test = seed_big_cb;
     cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = GNUNET_NO;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
   }
 
@@ -1470,6 +1532,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on a single peer\n");
     cur_test_run.name = "test-rps-single-peer-seed";
     cur_test_run.main_test = single_peer_seed_cb;
+    cur_test_run.have_churn = GNUNET_NO;
   }
 
   else if (strstr (argv[0], "_seed_request") != NULL)
@@ -1477,6 +1540,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on multiple peers\n");
     cur_test_run.name = "test-rps-seed-request";
     cur_test_run.main_test = seed_req_cb;
+    cur_test_run.have_churn = GNUNET_NO;
   }
 
   else if (strstr (argv[0], "_seed") != NULL)
@@ -1485,6 +1549,7 @@ main (int argc, char *argv[])
     cur_test_run.name = "test-rps-seed";
     cur_test_run.main_test = seed_cb;
     cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = GNUNET_NO;
   }
 
   else if (strstr (argv[0], "_req_cancel") != NULL)
@@ -1494,6 +1559,20 @@ main (int argc, char *argv[])
     num_peers = 1;
     cur_test_run.main_test = req_cancel_cb;
     cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = GNUNET_NO;
+    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
+  }
+
+  else if (strstr (argv[0], "_churn") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test churn\n");
+    cur_test_run.name = "test-rps-churn";
+    num_peers = 5;
+    cur_test_run.init_peer = default_init_peer;
+    cur_test_run.main_test = churn_test_cb;
+    cur_test_run.reply_handle = default_reply_handle;
+    cur_test_run.eval_cb = default_eval_cb;
+    cur_test_run.have_churn = GNUNET_YES;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
   }
 
@@ -1510,6 +1589,7 @@ main (int argc, char *argv[])
     cur_test_run.eval_cb = profiler_eval;
     cur_test_run.request_interval = 2;
     cur_test_run.num_requests = 5;
+    cur_test_run.have_churn = GNUNET_YES;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90);
 
     /* 'Clean' directory */
@@ -1542,4 +1622,4 @@ main (int argc, char *argv[])
   return ret_value;
 }
 
-/* end of test_rps_multipeer.c */
+/* end of test_rps.c */
diff --git a/src/rps/test_rps.conf b/src/rps/test_rps.conf
index 7da91ccf0..fce07c945 100644
--- a/src/rps/test_rps.conf
+++ b/src/rps/test_rps.conf
@@ -24,16 +24,16 @@ INITSIZE = 4
 [testbed]
 HOSTNAME = localhost
 
-OPERATION_TIMEOUT = 60 s
+# OPERATION_TIMEOUT = 60 s
 
-MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS = 1
-#OVERLAY_TOPOLOGY = CLIQUE
-OVERLAY_TOPOLOGY = SMALL_WORLD
+# MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS = 100
+OVERLAY_TOPOLOGY = CLIQUE
+#OVERLAY_TOPOLOGY = SMALL_WORLD
 #SCALE_FREE_TOPOLOGY_CAP = 
 
-OVERLAY_RANDOM_LINKS = 25
+# OVERLAY_RANDOM_LINKS = 25
 
-SETUP_TIMEOUT = 2 m
+# SETUP_TIMEOUT = 2 m
 
 [nse]
 WORKBITS = 0
@@ -46,7 +46,27 @@ USE_LOCALADDR = YES
 RETURN_LOCAL_ADDRESSES = YES
 
 [transport]
-PLUGINS = unix
+PLUGINS = udp
+
+[ats]
+# Network specific inbound/outbound quotas
+UNSPECIFIED_QUOTA_IN = unlimited
+UNSPECIFIED_QUOTA_OUT = unlimited
+# LOOPBACK
+LOOPBACK_QUOTA_IN = unlimited
+LOOPBACK_QUOTA_OUT = unlimited
+# LAN
+LAN_QUOTA_IN = unlimited
+LAN_QUOTA_OUT = unlimited
+#WAN
+WAN_QUOTA_OUT = unlimited
+WAN_QUOTA_IN = unlimited
+# WLAN
+WLAN_QUOTA_IN = unlimited
+WLAN_QUOTA_OUT = unlimited
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = unlimited
+BLUETOOTH_QUOTA_OUT = unlimited
 
 [dht]
 DISABLE_TRY_CONNECT = YES
@@ -69,6 +89,10 @@ NO_IO = YES
 FORCESTART = NO
 AUTOSTART = NO
 
+[zonemaster]
+FORCESTART = NO
+AUTOSTART = NO
+
 [namecache]
 FORCESTART = NO
 AUTOSTART = NO
diff --git a/src/rps/test_service_rps_peers.c b/src/rps/test_service_rps_peers.c
deleted file mode 100644
index 9cd677fef..000000000
--- a/src/rps/test_service_rps_peers.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-     This file is part of GNUnet.
-     Copyright (C)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-     Boston, MA 02110-1301, USA.
-*/
-/**
- * @file rps/test_service_rps_peers.c
- * @brief testcase for gnunet-service-rps_peers.c
- */
-#include <platform.h>
-#include "gnunet-service-rps_peers.h"
-
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); Peers_terminate (); return 1; }
-#define CHECK(c) { if (! (c)) ABORT(); }
-
-#define FN_VALID_PEERS "DISABLE"
-
-/**
- * @brief Dummy implementation of #PeerOp (Operation on peer)
- *
- * @param cls closure
- * @param peer peer
- */
-void peer_op (void *cls, const struct GNUNET_PeerIdentity *peer)
-{
-  GNUNET_assert (NULL != peer);
-}
-
-/**
- * @brief Function that is called on a peer for later execution
- *
- * @param cls closure
- * @param peer peer to execute function upon
- */
-void
-peer_op (void *cls, const struct GNUNET_PeerIdentity *peer);
-
-static int
-check ()
-{
-  struct GNUNET_PeerIdentity k1;
-  struct GNUNET_PeerIdentity own_id;
-  
-  memset (&k1, 0, sizeof (k1));
-  memset (&own_id, 1, sizeof (own_id));
-
-  /* Do nothing */
-  Peers_initialise (FN_VALID_PEERS, NULL, NULL, NULL, &own_id);
-  Peers_terminate ();
-
-
-  /* Create peer */
-  Peers_initialise (FN_VALID_PEERS, NULL, NULL, NULL, &own_id);
-  CHECK (GNUNET_YES == Peers_insert_peer (&k1));
-  Peers_terminate ();
-
-
-  /* Create peer */
-  Peers_initialise (FN_VALID_PEERS, NULL, NULL, NULL, &own_id);
-  CHECK (GNUNET_YES == Peers_insert_peer (&k1));
-  CHECK (GNUNET_YES == Peers_remove_peer (&k1));
-  Peers_terminate ();
-
-
-  /* Insertion and Removal */
-  Peers_initialise (FN_VALID_PEERS, NULL, NULL, NULL, &own_id);
-  CHECK (GNUNET_NO  == Peers_check_peer_known (&k1));
-
-  CHECK (GNUNET_YES == Peers_insert_peer (&k1));
-  CHECK (GNUNET_NO  == Peers_insert_peer (&k1));
-  CHECK (GNUNET_YES == Peers_check_peer_known (&k1));
-
-  CHECK (GNUNET_YES == Peers_remove_peer (&k1));
-  CHECK (GNUNET_NO  == Peers_remove_peer (&k1));
-  CHECK (GNUNET_NO  == Peers_check_peer_known (&k1));
-
-
-  /* Flags */
-  Peers_insert_peer (&k1);
-
-  CHECK (GNUNET_NO == Peers_check_peer_flag (&k1, Peers_PULL_REPLY_PENDING));
-  CHECK (GNUNET_NO == Peers_check_peer_flag (&k1, Peers_ONLINE));
-  CHECK (GNUNET_NO == Peers_check_peer_flag (&k1, Peers_TO_DESTROY));
-
-  CHECK (GNUNET_NO  == Peers_check_peer_flag (&k1, Peers_ONLINE));
-
-  Peers_set_peer_flag (&k1, Peers_ONLINE);
-  CHECK (GNUNET_YES == Peers_check_peer_flag (&k1, Peers_ONLINE));
-  CHECK (GNUNET_NO  == Peers_check_peer_flag (&k1, Peers_TO_DESTROY));
-  CHECK (GNUNET_YES == Peers_check_peer_flag (&k1, Peers_ONLINE));
-  CHECK (GNUNET_NO  == Peers_check_peer_flag (&k1, Peers_TO_DESTROY));
-
-  /* Check send intention */
-  CHECK (GNUNET_NO == Peers_check_peer_send_intention (&k1));
-
-  /* Check existence of sending channel */
-  CHECK (GNUNET_NO == Peers_check_sending_channel_exists (&k1));
-
-  /* Check role of channels */
-  CHECK (GNUNET_YES == Peers_check_channel_role (&k1,
-                                                 NULL,
-                                                 Peers_CHANNEL_ROLE_SENDING));
-  CHECK (GNUNET_YES == Peers_check_channel_role (&k1,
-                                                 NULL,
-                                                 Peers_CHANNEL_ROLE_RECEIVING));
-
-  CHECK (GNUNET_YES == Peers_schedule_operation (&k1, peer_op));
-
-  Peers_terminate ();
-  return 0;
-}
-
-
-int
-main (int argc, char *argv[])
-{
-  GNUNET_log_setup ("test_service_rps_peers", 
-                    "WARNING",
-                    NULL);
-  return check ();
-}
-
-/* end of test_service_rps_peers.c */
diff --git a/src/set/Makefile.am b/src/set/Makefile.am
index 14667d0ef..df17fa1ab 100644
--- a/src/set/Makefile.am
+++ b/src/set/Makefile.am
@@ -52,7 +52,7 @@ gnunet_set_ibf_profiler_LDADD = \
 gnunet_service_set_SOURCES = \
  gnunet-service-set.c gnunet-service-set.h \
  gnunet-service-set_union.c gnunet-service-set_union.h \
- gnunet-service-set_intersection.c \
+ gnunet-service-set_intersection.c gnunet-service-set_intersection.h \
  ibf.c ibf.h \
  gnunet-service-set_union_strata_estimator.c gnunet-service-set_union_strata_estimator.h \
  gnunet-service-set_protocol.h
diff --git a/src/set/gnunet-service-set_union.c b/src/set/gnunet-service-set_union.c
index 730124495..9586dcf27 100644
--- a/src/set/gnunet-service-set_union.c
+++ b/src/set/gnunet-service-set_union.c
@@ -364,7 +364,7 @@ fail_union_operation (struct Operation *op)
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_SET_ResultMessage *msg;
 
-  LOG (GNUNET_ERROR_TYPE_ERROR,
+  LOG (GNUNET_ERROR_TYPE_WARNING,
        "union operation failed\n");
   ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_RESULT);
   msg->result_status = htons (GNUNET_SET_STATUS_FAILURE);
@@ -1404,7 +1404,7 @@ send_client_done (void *cls)
   }
 
   if (PHASE_DONE != op->state->phase) {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
+    LOG (GNUNET_ERROR_TYPE_WARNING,
          "union operation failed\n");
     ev = GNUNET_MQ_msg (rm, GNUNET_MESSAGE_TYPE_SET_RESULT);
     rm->result_status = htons (GNUNET_SET_STATUS_FAILURE);
diff --git a/src/social/gnunet-service-social.c b/src/social/gnunet-service-social.c
index dee68fdb8..5b2a8ba9b 100644
--- a/src/social/gnunet-service-social.c
+++ b/src/social/gnunet-service-social.c
@@ -96,7 +96,7 @@ static struct GNUNET_CONTAINER_MultiHashMap *apps_places;
  * Application subscriptions per place.
  * H(place_pub_key) -> H(app_id)
  */
-static struct GNUNET_CONTAINER_MultiHashMap *places_apps;
+//static struct GNUNET_CONTAINER_MultiHashMap *places_apps;
 
 /**
  * Connected applications.
@@ -255,10 +255,10 @@ struct Place
   uint8_t is_ready;
 
   /**
-   * Is the client disconnected?
+   * Is the client disconnecting?
    * #GNUNET_YES or #GNUNET_NO
    */
-  uint8_t is_disconnected;
+  uint8_t is_disconnecting;
 
   /**
    * Is this a host (#GNUNET_YES), or guest (#GNUNET_NO)?
@@ -348,7 +348,7 @@ struct Guest
   /**
    * Join request to be transmitted to the master on join.
    */
-  struct GNUNET_MessageHeader *join_req;
+  struct GNUNET_MessageHeader *join_req; // FIXME: not used!
 
   /**
    * Join decision received from PSYC.
@@ -487,8 +487,6 @@ cleanup_host (struct Host *hst)
 {
   struct Place *plc = &hst->place;
 
-  if (NULL != hst->master)
-    GNUNET_PSYC_master_stop (hst->master, GNUNET_NO, NULL, NULL); // FIXME
   GNUNET_CONTAINER_multihashmap_destroy (hst->join_reqs);
   GNUNET_CONTAINER_multihashmap_destroy (hst->relay_msgs);
   GNUNET_CONTAINER_multihashmap_remove (hosts, &plc->pub_key_hash, plc);
@@ -505,7 +503,7 @@ cleanup_guest (struct Guest *gst)
   struct GNUNET_CONTAINER_MultiHashMap *
     plc_gst = GNUNET_CONTAINER_multihashmap_get (place_guests,
                                                  &plc->pub_key_hash);
-  GNUNET_assert (NULL != plc_gst); // FIXME
+  GNUNET_assert (NULL != plc_gst);
   GNUNET_CONTAINER_multihashmap_remove (plc_gst, &plc->ego_pub_hash, gst);
 
   if (0 == GNUNET_CONTAINER_multihashmap_size (plc_gst))
@@ -520,8 +518,6 @@ cleanup_guest (struct Guest *gst)
     GNUNET_free (gst->join_req);
   if (NULL != gst->relays)
     GNUNET_free (gst->relays);
-  if (NULL != gst->slave)
-    GNUNET_PSYC_slave_part (gst->slave, GNUNET_NO, NULL, NULL); // FIXME
   GNUNET_CONTAINER_multihashmap_remove (guests, &plc->pub_key_hash, plc);
 }
 
@@ -537,8 +533,8 @@ cleanup_place (void *cls)
   struct Place *plc = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Cleaning up place %s\n",
-              plc, GNUNET_h2s (&plc->pub_key_hash));
+              "cleaning up place %s\n",
+              GNUNET_h2s (&plc->pub_key_hash));
 
   (GNUNET_YES == plc->is_host)
     ? cleanup_host ((struct Host *) plc)
@@ -583,12 +579,19 @@ client_notify_disconnect (void *cls,
   {
     if (cli->client == client)
     {
-      GNUNET_CONTAINER_DLL_remove (plc->clients_head, plc->clients_tail, cli);
+      GNUNET_CONTAINER_DLL_remove (plc->clients_head,
+                                   plc->clients_tail,
+                                   cli);
       GNUNET_free (cli);
       break;
     }
     cli = cli->next;
   }
+  if (GNUNET_YES == plc->is_disconnecting)
+  {
+    GNUNET_PSYC_slicer_destroy (plc->slicer);
+    GNUNET_free (plc);
+  }
 }
 
 
@@ -605,46 +608,55 @@ client_notify_connect (void *cls,
                        struct GNUNET_SERVICE_Client *client,
                        struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client connected: %p\n", client);
+  struct Client *c = GNUNET_new (struct Client);
 
-  struct Client *c = GNUNET_malloc (sizeof (*c));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p connected with queue %p\n",
+              client,
+              mq);
   c->client = client;
-
   return c;
 }
 
 
 /**
- * Send message to a client.
- */
-static inline void
-client_send_msg (struct GNUNET_SERVICE_Client *client,
-                 const struct GNUNET_MessageHeader *msg)
-{
-  struct GNUNET_MQ_Envelope *
-    env = GNUNET_MQ_msg_copy (msg);
-
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
-                  env);
-}
-
-
-/**
- * Send message to all clients connected to a place.
+ * Send message to all clients connected to a place and
+ * takes care of freeing @env.
  */
 static void
 place_send_msg (const struct Place *plc,
-                 const struct GNUNET_MessageHeader *msg)
+                struct GNUNET_MQ_Envelope *env)
 {
+  struct ClientListItem *cli = plc->clients_head;
+  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Sending message to clients of place.\n", plc);
-
-  struct ClientListItem *cli = plc->clients_head;
   while (NULL != cli)
   {
-    client_send_msg (cli->client, msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending message to client %p\n",
+                cli);
+    GNUNET_MQ_send_copy (GNUNET_SERVICE_client_get_mq (cli->client),
+                         env);
     cli = cli->next;
   }
+  GNUNET_MQ_discard (env);
+}
+
+
+static void
+place_send_leave_ack (struct Place *plc)
+{
+  struct GNUNET_MQ_Envelope *env;
+  
+  for (struct ClientListItem *cli = plc->clients_head;
+       NULL != cli;
+       cli = cli->next)
+  {
+    env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cli->client),
+                    env); 
+  }
 }
 
 
@@ -666,23 +678,21 @@ static void
 client_send_result (struct GNUNET_SERVICE_Client *client, uint64_t op_id,
                     int64_t result_code, const void *data, uint16_t data_size)
 {
+  struct GNUNET_MQ_Envelope *env;
   struct GNUNET_OperationResultMessage *res;
 
-  res = GNUNET_malloc (sizeof (*res) + data_size);
-  res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE);
-  res->header.size = htons (sizeof (*res) + data_size);
+  env = GNUNET_MQ_msg_extra (res,
+                             data_size,
+                             GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE);
   res->result_code = GNUNET_htonll (result_code);
   res->op_id = op_id;
   if (0 < data_size)
     GNUNET_memcpy (&res[1], data, data_size);
-
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Sending result to client for operation #%" PRIu64 ": "
               "%" PRId64 " (size: %u)\n",
               client, GNUNET_ntohll (op_id), result_code, data_size);
-
-  client_send_msg (client, &res->header);
-  GNUNET_free (res);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
 }
 
 
@@ -690,19 +700,21 @@ static void
 client_send_host_enter_ack (struct GNUNET_SERVICE_Client *client,
                             struct Host *hst, uint32_t result)
 {
+  struct GNUNET_MQ_Envelope *env;
+  struct HostEnterAck *hack;
   struct Place *plc = &hst->place;
 
-  struct HostEnterAck hack;
-  hack.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK);
-  hack.header.size = htons (sizeof (hack));
-  hack.result_code = htonl (result);
-  hack.max_message_id = GNUNET_htonll (plc->max_message_id);
-  hack.place_pub_key = plc->pub_key;
+  env = GNUNET_MQ_msg (hack,
+                       GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK); 
+  hack->result_code = htonl (result);
+  hack->max_message_id = GNUNET_htonll (plc->max_message_id);
+  hack->place_pub_key = plc->pub_key;
 
   if (NULL != client)
-    client_send_msg (client, &hack.header);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
   else
-    place_send_msg (plc, &hack.header);
+    place_send_msg (plc, env);
 }
 
 
@@ -736,7 +748,8 @@ psyc_recv_join_request (void *cls,
   GNUNET_CRYPTO_hash (slave_key, sizeof (*slave_key), &slave_key_hash);
   GNUNET_CONTAINER_multihashmap_put (hst->join_reqs, &slave_key_hash, jh,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  place_send_msg (&hst->place, &req->header);
+  place_send_msg (&hst->place,
+                  GNUNET_MQ_msg_copy (&req->header));
 }
 
 
@@ -746,18 +759,29 @@ psyc_recv_join_request (void *cls,
 static void
 psyc_slave_connected (void *cls, int result, uint64_t max_message_id)
 {
+  struct GNUNET_PSYC_CountersResultMessage *res;
+  struct GNUNET_MQ_Envelope *env;
   struct Guest *gst = cls;
   struct Place *plc = &gst->place;
+
   plc->max_message_id = max_message_id;
   plc->is_ready = GNUNET_YES;
+  env = GNUNET_MQ_msg (res,
+                       GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
+  res->result_code =
+    (result != GNUNET_SYSERR) ? htonl (GNUNET_OK) : htonl (GNUNET_SYSERR);
+  res->max_message_id = GNUNET_htonll (plc->max_message_id);
+  place_send_msg (plc, env);
+}
 
-  struct GNUNET_PSYC_CountersResultMessage res;
-  res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
-  res.header.size = htons (sizeof (res));
-  res.result_code = htonl (result);
-  res.max_message_id = GNUNET_htonll (plc->max_message_id);
 
-  place_send_msg (plc, &res.header);
+static void
+slave_parted_after_join_decision (void *cls)
+{
+  struct Guest *gst = cls;
+
+  GNUNET_assert (NULL != gst->join_dcsn);
+  place_send_msg (&gst->place, GNUNET_MQ_msg_copy (&gst->join_dcsn->header));
 }
 
 
@@ -771,7 +795,21 @@ psyc_recv_join_dcsn (void *cls,
                      const struct GNUNET_PSYC_Message *join_msg)
 {
   struct Guest *gst = cls;
-  place_send_msg (&gst->place, &dcsn->header);
+
+  gst->join_dcsn = GNUNET_malloc (dcsn->header.size);
+  GNUNET_memcpy (gst->join_dcsn,
+                 dcsn,
+                 dcsn->header.size);
+  if (GNUNET_NO == is_admitted)
+  {
+    GNUNET_PSYC_slave_part (gst->slave,
+                            GNUNET_NO,
+                            &slave_parted_after_join_decision,
+                            gst);
+    gst->slave = NULL;
+    return;
+  }
+  place_send_msg (&gst->place, GNUNET_MQ_msg_copy (&gst->join_dcsn->header));
 }
 
 
@@ -792,7 +830,7 @@ psyc_recv_message (void *cls,
 
   GNUNET_PSYC_slicer_message (plc->slicer, msg);
 
-  place_send_msg (plc, &msg->header);
+  place_send_msg (plc, GNUNET_MQ_msg_copy (&msg->header));
 }
 
 
@@ -1096,9 +1134,6 @@ place_init (struct Place *plc)
 static int
 place_add (const struct PlaceEnterRequest *ereq)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding place to hashmap:\n");
-
   struct EgoPlacePublicKey ego_place_pub_key = {
     .ego_pub_key = ereq->ego_pub_key,
     .place_pub_key = ereq->place_pub_key,
@@ -1173,7 +1208,9 @@ app_place_add (const char *app_id,
     return GNUNET_NO;
 
   if (GNUNET_SYSERR == place_add (ereq))
+  {
     return GNUNET_SYSERR;
+  }
 
   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (app_places, &ego_place_pub_hash, NULL,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
@@ -1181,32 +1218,6 @@ app_place_add (const char *app_id,
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
-
-  struct GNUNET_HashCode place_pub_hash;
-  GNUNET_CRYPTO_hash (&ereq->place_pub_key, sizeof (ereq->place_pub_key), &place_pub_hash);
-
-  struct GNUNET_CONTAINER_MultiHashMap *
-    place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &place_pub_hash);
-  if (NULL == place_apps)
-  {
-    place_apps = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
-    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (places_apps, &place_pub_hash, place_apps,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    {
-      GNUNET_break (0);
-    }
-  }
-
-  size_t app_id_size = strlen (app_id) + 1;
-  void *app_id_value = GNUNET_malloc (app_id_size);
-  GNUNET_memcpy (app_id_value, app_id, app_id_size);
-
-  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (place_apps, &app_id_hash, app_id_value,
-                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-  {
-    GNUNET_break (0);
-  }
-
   return GNUNET_OK;
 }
 
@@ -1223,7 +1234,10 @@ static int
 app_place_save (const char *app_id,
                 const struct PlaceEnterRequest *ereq)
 {
-  app_place_add (app_id, ereq);
+  if (GNUNET_SYSERR == app_place_add (app_id, ereq))
+  {
+    GNUNET_assert (0);
+  }
 
   if (NULL == dir_places)
     return GNUNET_SYSERR;
@@ -1304,18 +1318,6 @@ app_place_remove (const char *app_id,
   if (NULL != app_places)
     GNUNET_CONTAINER_multihashmap_remove (app_places, &place_pub_hash, NULL);
 
-  struct GNUNET_CONTAINER_MultiHashMap *
-    place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &place_pub_hash);
-  if (NULL != place_apps)
-  {
-    void *app_id_value = GNUNET_CONTAINER_multihashmap_get (place_apps, &app_id_hash);
-    if (NULL != app_id_value)
-    {
-      GNUNET_CONTAINER_multihashmap_remove (place_apps, &app_id_hash, app_id_value);
-      GNUNET_free (app_id_value);
-    }
-  }
-
   int ret = GNUNET_OK;
 
   if (0 != unlink (app_place_filename))
@@ -1407,6 +1409,124 @@ msg_proc_parse (const struct MsgProcRequest *mpreq,
 }
 
 
+void
+app_notify_place (const struct GNUNET_MessageHeader *msg,
+                  struct GNUNET_SERVICE_Client *client)
+{
+  struct AppPlaceMessage *amsg;
+  struct GNUNET_MQ_Envelope *env;
+  uint16_t msg_size = ntohs (msg->size);
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Sending place notification of type %u to client.\n",
+              client, ntohs (msg->type));
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER:
+  {
+    struct HostEnterRequest *hreq = (struct HostEnterRequest *) msg;
+    if (msg_size < sizeof (struct HostEnterRequest))
+      return;
+    env = GNUNET_MQ_msg (amsg,
+                         GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE);
+    // FIXME: also notify about not entered places
+    amsg->place_state = GNUNET_SOCIAL_PLACE_STATE_ENTERED;
+    amsg->is_host = GNUNET_YES;
+    amsg->ego_pub_key = hreq->ego_pub_key;
+    amsg->place_pub_key = hreq->place_pub_key;
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
+    break;
+  }
+  case GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER:
+  {
+    if (msg_size < sizeof (struct GuestEnterRequest))
+      return;
+    struct GuestEnterRequest *greq = (struct GuestEnterRequest *) msg;
+    env = GNUNET_MQ_msg (amsg,
+                         GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE);
+    // FIXME: also notify about not entered places
+    amsg->place_state = GNUNET_SOCIAL_PLACE_STATE_ENTERED;
+    amsg->is_host = GNUNET_NO;
+    amsg->ego_pub_key = greq->ego_pub_key;
+    amsg->place_pub_key = greq->place_pub_key;
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
+    break;
+  }
+  default:
+    return;
+  }
+}
+
+
+void
+app_notify_place_end (struct GNUNET_SERVICE_Client *client)
+{
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Sending end of place list notification to client\n",
+              client);
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+}
+
+
+void
+app_notify_ego (struct Ego *ego, struct GNUNET_SERVICE_Client *client)
+{
+  struct AppEgoMessage *emsg;
+  struct GNUNET_MQ_Envelope *env;
+  size_t name_size = strlen (ego->name) + 1;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Sending ego notification to client: %s\n",
+              client, ego->name);
+  env = GNUNET_MQ_msg_extra (emsg,
+                             name_size,
+                             GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO);
+  GNUNET_CRYPTO_ecdsa_key_get_public (&ego->key, &emsg->ego_pub_key);
+  GNUNET_memcpy (&emsg[1], ego->name, name_size);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+}
+
+
+void
+app_notify_ego_end (struct GNUNET_SERVICE_Client *client)
+{
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Sending end of ego list notification to client\n",
+              client);
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+}
+
+
+int
+app_place_entry_notify (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MessageHeader *
+    msg = GNUNET_CONTAINER_multihashmap_get (places, key);
+  if (NULL != msg)
+    app_notify_place (msg, cls);
+  return GNUNET_YES;
+}
+
+
+int
+ego_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  app_notify_ego (value, cls);
+  return GNUNET_YES;
+}
+
+
 static int
 check_client_msg_proc_set (void *cls,
                            const struct MsgProcRequest *mpreq)
@@ -1518,9 +1638,8 @@ static void
 handle_client_host_enter (void *cls,
                           const struct HostEnterRequest *hr)
 {
-   struct Client *c = cls;
+  struct Client *c = cls;
   struct GNUNET_SERVICE_Client *client = c->client;
-
   struct HostEnterRequest *
     hreq = (struct HostEnterRequest *) GNUNET_copy_message (&hr->header);
 
@@ -1578,7 +1697,7 @@ handle_client_host_enter (void *cls,
   if (ret != GNUNET_SYSERR)
   {
 
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "%p Client connected as host to place %s.\n",
                 hst, GNUNET_h2s (&plc->pub_key_hash));
 
@@ -1586,6 +1705,7 @@ handle_client_host_enter (void *cls,
     cli->client = client;
     GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
     c->place = plc;
+    app_notify_place (&hreq->header, client);
   }
 
   GNUNET_CRYPTO_eddsa_key_clear (&hreq->place_key);
@@ -1622,8 +1742,12 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
   struct Ego *ego = GNUNET_CONTAINER_multihashmap_get (egos, &ego_pub_hash);
 
   if (NULL == ego)
+  {
     return GNUNET_SYSERR;
+  }
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "entering as guest\n");
   struct GNUNET_HashCode place_pub_hash;
   GNUNET_CRYPTO_hash (&greq->place_pub_key, sizeof (greq->place_pub_key),
                       &place_pub_hash);
@@ -1635,9 +1759,16 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
   if (NULL != plc_gst)
     gst = GNUNET_CONTAINER_multihashmap_get (plc_gst, &ego_pub_hash);
 
-  if (NULL == gst || NULL == gst->slave)
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "plc_gst = %p, gst = %p\n",
+              plc_gst,
+              gst);
+  if (NULL == gst)
   {
     gst = GNUNET_new (struct Guest);
+  }
+  if (NULL == gst->slave)
+  {
     gst->origin = greq->origin;
     gst->relay_count = ntohl (greq->relay_count);
 
@@ -1710,11 +1841,12 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
       plc_gst = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
       (void) GNUNET_CONTAINER_multihashmap_put (place_guests, &plc->pub_key_hash, plc_gst,
                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-    }
-    (void) GNUNET_CONTAINER_multihashmap_put (plc_gst, &plc->ego_pub_hash, gst,
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-    (void) GNUNET_CONTAINER_multihashmap_put (guests, &plc->pub_key_hash, gst,
+      (void) GNUNET_CONTAINER_multihashmap_put (plc_gst, &plc->ego_pub_hash, gst,
+                                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+      (void) GNUNET_CONTAINER_multihashmap_put (guests, &plc->pub_key_hash, gst,
                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+
+    }
     gst->slave
       = GNUNET_PSYC_slave_join (cfg, &plc->pub_key, &plc->ego_key,
                                 gst->join_flags, &gst->origin,
@@ -1724,6 +1856,9 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
                                 &psyc_recv_join_dcsn,
                                 gst, join_msg);
     plc->channel = GNUNET_PSYC_slave_get_channel (gst->slave);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "slave entered channel %p\n",
+                plc->channel);
     ret = GNUNET_YES;
   }
 
@@ -1734,78 +1869,96 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
 
 
 static int
-check_client_guest_enter (void *cls,
-                          const struct GuestEnterRequest *greq)
-{
-  return GNUNET_OK;
-}
-
-
-/**
- * Handle a connecting client entering a place as guest.
- */
-static void
-handle_client_guest_enter (void *cls,
-                           const struct GuestEnterRequest *greq)
+client_guest_enter (struct Client *c,
+                    const struct GuestEnterRequest *greq)
 {
-  struct Client *c = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "client_guest_enter\n");
+  struct GNUNET_PSYC_CountersResultMessage *result_msg;
+  struct GNUNET_MQ_Envelope *env;
   struct GNUNET_SERVICE_Client *client = c->client;
-
   uint16_t remaining = ntohs (greq->header.size) - sizeof (*greq);
   const char *app_id = NULL;
   uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &greq[1],
                                                     remaining, 1, &app_id);
-  if (0 == offset)
-  {
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (client);
-    return;
-  }
-
   struct Guest *gst = NULL;
   struct Place *plc = NULL;
 
+  if (0 == offset)
+  {
+    return GNUNET_SYSERR;
+  }
   switch (guest_enter (greq, &gst))
   {
   case GNUNET_YES:
+  {
     plc = c->place = &gst->place;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "guest entered successfully to local place %s\n",
+                GNUNET_h2s (&plc->pub_key_hash));
     plc->guest = gst;
     app_place_save (app_id, (const struct PlaceEnterRequest *) greq);
+    app_notify_place (&greq->header, client);
     break;
-
+  }
   case GNUNET_NO:
   {
     plc = c->place = &gst->place;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "guest re-entered successfully to local place %s\n",
+                GNUNET_h2s (&plc->pub_key_hash));
     plc->guest = gst;
-
-    struct GNUNET_PSYC_CountersResultMessage res;
-    res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
-    res.header.size = htons (sizeof (res));
-    res.result_code = htonl (GNUNET_OK);
-    res.max_message_id = GNUNET_htonll (plc->max_message_id);
-
-    client_send_msg (client, &res.header);
+    env = GNUNET_MQ_msg (result_msg,
+                         GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
+    result_msg->result_code = htonl (GNUNET_OK);
+    result_msg->max_message_id = GNUNET_htonll (plc->max_message_id);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
     if (NULL != gst->join_dcsn)
-      client_send_msg (client, &gst->join_dcsn->header);
-
+    { 
+      env = GNUNET_MQ_msg_copy (&gst->join_dcsn->header);
+      GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                      env);
+    }
     break;
   }
   case GNUNET_SYSERR:
-    GNUNET_break (0);
-    GNUNET_SERVICE_client_drop (client);
-    return;
+  {
+    return GNUNET_SYSERR;
+  }
   }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Client connected as guest to place %s.\n",
-              gst, GNUNET_h2s (&plc->pub_key_hash));
 
   struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
   cli->client = client;
   GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
+  return GNUNET_OK;
+}
 
-  c->place = plc;
-  GNUNET_SERVICE_client_continue (client);
+
+static int
+check_client_guest_enter (void *cls,
+                          const struct GuestEnterRequest *greq)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a connecting client entering a place as guest.
+ */
+static void
+handle_client_guest_enter (void *cls,
+                           const struct GuestEnterRequest *greq)
+{
+  struct Client *c = cls;
+
+  if (GNUNET_SYSERR == client_guest_enter (c, greq))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (c->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (c->client);
 }
 
 
@@ -1830,7 +1983,7 @@ gns_result_guest_enter (void *cls, uint32_t rd_count,
 {
   struct GuestEnterByNameClosure *gcls = cls;
   struct Client *c = gcls->client;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p GNS result: %u records.\n",
               c, rd_count);
 
@@ -1882,7 +2035,7 @@ gns_result_guest_enter (void *cls, uint32_t rd_count,
   p += relay_size;
   GNUNET_memcpy (p, gcls->join_msg, join_msg_size);
 
-  handle_client_guest_enter (c, greq);
+  client_guest_enter (c, greq);
 
   GNUNET_free (gcls->app_id);
   if (NULL != gcls->password)
@@ -1960,118 +2113,7 @@ handle_client_guest_enter_by_name (void *cls,
                      GNUNET_GNSRECORD_TYPE_PLACE,
                      GNUNET_GNS_LO_DEFAULT,
                      &gns_result_guest_enter, gcls);
-}
-
-
-void
-app_notify_place (struct GNUNET_MessageHeader *msg,
-                  struct GNUNET_SERVICE_Client *client)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending place notification of type %u to client.\n",
-              client, ntohs (msg->type));
-
-  uint16_t msg_size = ntohs (msg->size);
-  struct AppPlaceMessage amsg;
-  amsg.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE);
-  amsg.header.size = htons (sizeof (amsg));
-  // FIXME: also notify about not entered places
-  amsg.place_state = GNUNET_SOCIAL_PLACE_STATE_ENTERED;
-
-  switch (ntohs (msg->type))
-  {
-  case GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER:
-    if (msg_size < sizeof (struct HostEnterRequest))
-      return;
-    struct HostEnterRequest *hreq = (struct HostEnterRequest *) msg;
-    amsg.is_host = GNUNET_YES;
-    amsg.ego_pub_key = hreq->ego_pub_key;
-    amsg.place_pub_key = hreq->place_pub_key;
-    break;
-
-  case GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER:
-    if (msg_size < sizeof (struct GuestEnterRequest))
-      return;
-    struct GuestEnterRequest *greq = (struct GuestEnterRequest *) msg;
-    amsg.is_host = GNUNET_NO;
-    amsg.ego_pub_key = greq->ego_pub_key;
-    amsg.place_pub_key = greq->place_pub_key;
-    break;
-
-  default:
-    return;
-  }
-
-  client_send_msg (client, &amsg.header);
-}
-
-
-void
-app_notify_place_end (struct GNUNET_SERVICE_Client *client)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending end of place list notification to client\n",
-              client);
-
-  struct GNUNET_MessageHeader msg;
-  msg.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END);
-  msg.size = htons (sizeof (msg));
-
-  client_send_msg (client, &msg);
-}
-
-
-void
-app_notify_ego (struct Ego *ego, struct GNUNET_SERVICE_Client *client)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending ego notification to client: %s\n",
-              client, ego->name);
-
-  size_t name_size = strlen (ego->name) + 1;
-  struct AppEgoMessage *emsg = GNUNET_malloc (sizeof (*emsg) + name_size);
-  emsg->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO);
-  emsg->header.size = htons (sizeof (*emsg) + name_size);
-
-  GNUNET_CRYPTO_ecdsa_key_get_public (&ego->key, &emsg->ego_pub_key);
-  GNUNET_memcpy (&emsg[1], ego->name, name_size);
-
-  client_send_msg (client, &emsg->header);
-  GNUNET_free (emsg);
-}
-
-
-void
-app_notify_ego_end (struct GNUNET_SERVICE_Client *client)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Sending end of ego list notification to client\n",
-              client);
-
-  struct GNUNET_MessageHeader msg;
-  msg.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END);
-  msg.size = htons (sizeof (msg));
-
-  client_send_msg (client, &msg);
-}
-
-
-int
-app_place_entry_notify (void *cls, const struct GNUNET_HashCode *key, void *value)
-{
-  struct GNUNET_MessageHeader *
-    msg = GNUNET_CONTAINER_multihashmap_get (places, key);
-  if (NULL != msg)
-    app_notify_place (msg, cls);
-  return GNUNET_YES;
-}
-
-
-int
-ego_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
-{
-  app_notify_ego (value, cls);
-  return GNUNET_YES;
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -2154,13 +2196,15 @@ handle_client_app_detach (void *cls,
 }
 
 
-int
-app_places_entry_remove (void *cls, const struct GNUNET_HashCode *key, void *value)
+static void
+place_leave_cb (void *cls)
 {
   struct Place *plc = cls;
-  const char *app_id = value;
-  app_place_remove (app_id, &plc->ego_pub_key, &plc->pub_key);
-  return GNUNET_YES;
+
+  place_send_leave_ack (plc);
+  (GNUNET_YES == plc->is_host)
+    ? cleanup_host ((struct Host *) plc)
+    : cleanup_guest ((struct Guest *) plc);
 }
 
 
@@ -2174,6 +2218,11 @@ handle_client_place_leave (void *cls,
   struct Client *c = cls;
   struct GNUNET_SERVICE_Client *client = c->client;
   struct Place *plc = c->place;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "got leave request from %s for place %s",
+              plc->is_host? "host" : "slave",
+              GNUNET_h2s (&plc->pub_key_hash)); 
   if (NULL == plc)
   {
     GNUNET_break (0);
@@ -2181,40 +2230,28 @@ handle_client_place_leave (void *cls,
     return;
   }
 
-  /* FIXME: remove all app subscriptions and leave this place  */
-
-  struct GNUNET_CONTAINER_MultiHashMap *
-    place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &plc->pub_key_hash);
-  if (NULL != place_apps)
+  if (GNUNET_YES != plc->is_disconnecting)
   {
-    GNUNET_CONTAINER_multihashmap_iterate (place_apps, app_places_entry_remove, plc);
-  }
-
-  /* FIXME: disconnect from the network, but keep local connection for history access */
-
-  /* Disconnect all clients connected to the place */
-  struct ClientListItem *cli = plc->clients_head, *next;
-  while (NULL != cli)
-  {
-    GNUNET_CONTAINER_DLL_remove (plc->clients_head, plc->clients_tail, cli);
-    GNUNET_SERVICE_client_drop (cli->client);
-    next = cli->next;
-    GNUNET_free (cli);
-    cli = next;
-  }
-
-  if (GNUNET_YES != plc->is_disconnected)
-  {
-    plc->is_disconnected = GNUNET_YES;
-    if (NULL != plc->tmit_msgs_head)
-    { /* Send pending messages to PSYC before cleanup. */
-      psyc_transmit_message (plc);
+    plc->is_disconnecting = GNUNET_YES;
+    if (plc->is_host)
+    {
+      struct Host *host = plc->host;
+      GNUNET_assert (NULL != host);
+      GNUNET_PSYC_master_stop (host->master, GNUNET_NO, &place_leave_cb, plc);
     }
     else
     {
-      cleanup_place (plc);
+      struct Guest *guest = plc->guest;
+      GNUNET_assert (NULL != guest);
+      GNUNET_PSYC_slave_part (guest->slave, GNUNET_NO, &place_leave_cb, plc);
     }
   }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "got leave request but place is already leaving\n");
+  }
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -2273,6 +2310,9 @@ handle_client_join_decision (void *cls,
     ? (struct GNUNET_PSYC_Message *) &dcsn[1]
     : NULL;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "jcls.msg = %p\n",
+              jcls.msg);
   struct GNUNET_HashCode slave_pub_hash;
   GNUNET_CRYPTO_hash (&dcsn->slave_pub_key, sizeof (dcsn->slave_pub_key),
                       &slave_pub_hash);
@@ -2302,10 +2342,11 @@ handle_client_join_decision (void *cls,
 static void
 send_message_ack (struct Place *plc, struct GNUNET_SERVICE_Client *client)
 {
-  struct GNUNET_MessageHeader res;
-  res.size = htons (sizeof (res));
-  res.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK);
-  client_send_msg (client, &res);
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
 }
 
 
@@ -2437,7 +2478,6 @@ psyc_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
   {
     *data_size = 0;
     tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
-    plc->is_disconnected = GNUNET_YES;
     GNUNET_SERVICE_client_drop (tmit_frag->client);
     GNUNET_SCHEDULER_add_now (&cleanup_place, plc);
     return ret;
@@ -2479,11 +2519,7 @@ psyc_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
     {
       psyc_transmit_message (plc);
     }
-    else if (GNUNET_YES == plc->is_disconnected)
-    {
-      /* FIXME: handle partial message (when still in_transmit) */
-      cleanup_place (plc);
-    }
+    /* FIXME: handle partial message (when still in_transmit) */
   }
   return ret;
 }
@@ -2597,7 +2633,6 @@ psyc_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
     *data_size = 0;
     ret = GNUNET_SYSERR;
     tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
-    plc->is_disconnected = GNUNET_YES;
     GNUNET_SERVICE_client_drop (tmit_frag->client);
     GNUNET_SCHEDULER_add_now (&cleanup_place, plc);
   }
@@ -2862,26 +2897,26 @@ psyc_transmit_queue_message (struct Place *plc,
 }
 
 
-/**
- * Cancel transmission of current message to PSYC.
- *
- * @param plc     Place to send to.
- * @param client  Client the message originates from.
- */
-static void
-psyc_transmit_cancel (struct Place *plc, struct GNUNET_SERVICE_Client *client)
-{
-  uint16_t type = GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL;
-
-  struct GNUNET_MessageHeader msg;
-  msg.size = htons (sizeof (msg));
-  msg.type = htons (type);
-
-  psyc_transmit_queue_message (plc, client, sizeof (msg), &msg, type, type, NULL);
-  psyc_transmit_message (plc);
-
-  /* FIXME: cleanup */
-}
+///**
+// * Cancel transmission of current message to PSYC.
+// *
+// * @param plc   Place to send to.
+// * @param client  Client the message originates from.
+// */
+//static void
+//psyc_transmit_cancel (struct Place *plc, struct GNUNET_SERVICE_Client *client)
+//{
+//  uint16_t type = GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL;
+//
+//  struct GNUNET_MessageHeader msg;
+//  msg.size = htons (sizeof (msg));
+//  msg.type = htons (type);
+//
+//  psyc_transmit_queue_message (plc, client, sizeof (msg), &msg, type, type, NULL);
+//  psyc_transmit_message (plc);
+//
+//  /* FIXME: cleanup */
+//}
 
 
 static int
@@ -2902,17 +2937,19 @@ handle_client_psyc_message (void *cls,
   struct Client *c = cls;
   struct GNUNET_SERVICE_Client *client = c->client;
   struct Place *plc = c->place;
+  int ret;
+
   if (NULL == plc)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "received PSYC message for non-existing client %p\n",
+                client);
     GNUNET_break (0);
     GNUNET_SERVICE_client_drop (client);
     return;
   }
-
-  int ret = GNUNET_SYSERR;
-
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Received message from client.\n", plc);
+              "%p Received message of type %d from client.\n", plc, ntohs (msg->type));
   GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, msg);
 
   if (GNUNET_YES != plc->is_ready)
@@ -2933,20 +2970,19 @@ handle_client_psyc_message (void *cls,
                 "%p Received message with invalid payload size (%u) from client.\n",
                 plc, psize);
     GNUNET_break (0);
-    psyc_transmit_cancel (plc, client);
     GNUNET_SERVICE_client_drop (client);
     return;
   }
 
-  uint16_t first_ptype = 0, last_ptype = 0;
-  if (GNUNET_SYSERR
-      == GNUNET_PSYC_receive_check_parts (psize, (const char *) &msg[1],
-                                          &first_ptype, &last_ptype))
+  uint16_t first_ptype = 0;
+  uint16_t last_ptype = 0;
+  if (GNUNET_SYSERR ==
+      GNUNET_PSYC_receive_check_parts (psize, (const char *) &msg[1],
+                                       &first_ptype, &last_ptype))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "%p Received invalid message part from client.\n", plc);
     GNUNET_break (0);
-    psyc_transmit_cancel (plc, client);
     GNUNET_SERVICE_client_drop (client);
     return;
   }
@@ -2963,20 +2999,19 @@ handle_client_psyc_message (void *cls,
       c->tmit_msg = NULL;
     ret = psyc_transmit_message (plc);
   }
-
+  else
+  {
+    ret = GNUNET_SYSERR;
+  }
   if (GNUNET_OK != ret)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "%p Received invalid message part from client.\n", plc);
     GNUNET_break (0);
-    psyc_transmit_cancel (plc, client);
-    ret = GNUNET_SYSERR;
-  }
-
-  if (GNUNET_OK == ret)
-    GNUNET_SERVICE_client_continue (client);
-  else
     GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -3006,7 +3041,7 @@ psyc_recv_history_message (void *cls, const struct GNUNET_PSYC_MessageHeader *ms
   GNUNET_memcpy (&res[1], msg, size);
 
   /** @todo FIXME: send only to requesting client */
-  place_send_msg (plc, &res->header);
+  place_send_msg (plc, GNUNET_MQ_msg_copy (&res->header));
 
   GNUNET_free (res);
 }
@@ -3108,29 +3143,24 @@ psyc_recv_state_var (void *cls,
                      uint32_t value_size,
                      uint32_t full_value_size)
 {
+  struct GNUNET_OperationResultMessage *result_msg;
+  struct GNUNET_MQ_Envelope *env;
   struct OperationClosure *opcls = cls;
   struct Client *c = opcls->client;
   struct Place *plc = c->place;
+  uint16_t size = ntohs (mod->size);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Received state variable %s from PSYC\n",
               plc, name);
-
-  uint16_t size = ntohs (mod->size);
-
-  struct GNUNET_OperationResultMessage *
-    res = GNUNET_malloc (sizeof (*res) + size);
-  res->header.size = htons (sizeof (*res) + size);
-  res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT);
-  res->op_id = opcls->op_id;
-  res->result_code = GNUNET_htonll (GNUNET_OK);
-
-  GNUNET_memcpy (&res[1], mod, size);
-
+  env = GNUNET_MQ_msg_extra (result_msg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT);
+  result_msg->op_id = opcls->op_id;
+  result_msg->result_code = GNUNET_htonll (GNUNET_OK);
+  GNUNET_memcpy (&result_msg[1], mod, size);
   /** @todo FIXME: send only to requesting client */
-  place_send_msg (plc, &res->header);
-
-  GNUNET_free (res);
+  place_send_msg (plc, env);
 }
 
 
@@ -3184,7 +3214,7 @@ handle_client_state_get (void *cls,
   uint16_t size = ntohs (req->header.size);
   const char *name = (const char *) &req[1];
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p State get #%" PRIu64 ": %s\n",
               plc, GNUNET_ntohll (req->op_id), name);
 
@@ -3382,7 +3412,7 @@ path_basename (const char *path)
   if (NULL != basename)
     basename++;
 
-  if (NULL == basename || '\0' == basename)
+  if (NULL == basename || '\0' == *basename)
     return NULL;
 
   return basename;
@@ -3468,7 +3498,10 @@ file_place_load (void *cls, const char *place_filename)
     return GNUNET_OK;
   }
 
-  app_place_add (plcls->app_id, ereq);
+  if (GNUNET_SYSERR == app_place_add (plcls->app_id, ereq))
+  {
+    GNUNET_assert (0);
+  }
   GNUNET_free (ereq);
   return GNUNET_OK;
 }
@@ -3523,6 +3556,10 @@ identity_recv_ego (void *cls, struct GNUNET_IDENTITY_Ego *id_ego,
   if (NULL == id_ego) // end of initial list of egos
     return;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "social service received ego %s\n",
+              name);
+
   struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
   GNUNET_IDENTITY_ego_get_public_key (id_ego, &ego_pub_key);
 
@@ -3571,6 +3608,9 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *c,
      struct GNUNET_SERVICE_Handle *svc)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "starting social service\n");
+
   cfg = c;
   service = svc;
   GNUNET_CRYPTO_get_peer_identity (cfg, &this_peer);
@@ -3583,7 +3623,7 @@ run (void *cls,
   apps = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
   places = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
   apps_places = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
-  places_apps = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
+  //places_apps = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
 
   id = GNUNET_IDENTITY_connect (cfg, &identity_recv_ego, NULL);
   gns = GNUNET_GNS_connect (cfg);
diff --git a/src/social/gnunet-social.c b/src/social/gnunet-social.c
index de680b11c..12c5bf2e1 100644
--- a/src/social/gnunet-social.c
+++ b/src/social/gnunet-social.c
@@ -283,7 +283,7 @@ exit_fail ()
 static void
 host_left (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "The host has left the place.\n");
   exit_success ();
 }
@@ -309,7 +309,7 @@ host_leave ()
 static void
 guest_left (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Guest has left the place.\n");
 }
 
@@ -518,7 +518,7 @@ look_var (void *cls,
           uint32_t value_size,
           uint32_t full_value_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Received var: %s\n%.*s\n",
               name, value_size, (const char *) value);
 }
@@ -558,7 +558,7 @@ slicer_recv_method (void *cls,
                     const char *method_name)
 {
   method_received = method_name;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Received method for message ID %" PRIu64 ":\n"
               "%s (flags: %x)\n",
               message_id, method_name, ntohl (meth->flags));
@@ -584,7 +584,7 @@ slicer_recv_modifier (void *cls,
                       uint16_t full_value_size)
 {
 #if 0
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Received modifier for message ID %" PRIu64 ":\n"
               "%c%s: %.*s (size: %u)\n",
               message_id, oper, name, value_size, (const char *) value, value_size);
@@ -608,7 +608,7 @@ slicer_recv_data (void *cls,
                   uint16_t data_size)
 {
 #if 0
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Received data for message ID %" PRIu64 ":\n"
               "%.*s\n",
               message_id, data_size, (const char *) data);
@@ -631,7 +631,7 @@ slicer_recv_eom (void *cls,
                 uint8_t is_cancelled)
 {
   printf(".\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Received end of message ID %" PRIu64
               ", cancelled: %u\n",
               message_id, is_cancelled);
@@ -668,7 +668,7 @@ guest_recv_entry_decision (void *cls,
                            int is_admitted,
                            const struct GNUNET_PSYC_Message *entry_msg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Guest received entry decision %d\n",
               is_admitted);
 
@@ -683,7 +683,7 @@ guest_recv_entry_decision (void *cls,
     GNUNET_PSYC_message_parse (pmsg, &method_name, env, &data, &data_size);
     GNUNET_free (pmsg);
 
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                 "%s\n%.*s\n",
                 method_name, data_size, (const char *) data);
   }
@@ -704,7 +704,7 @@ guest_recv_local_enter (void *cls, int result,
                         uint64_t max_message_id)
 {
   char *pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Guest entered local place: %s, max_message_id: %" PRIu64 "\n",
               pub_str, max_message_id);
   GNUNET_free (pub_str);
@@ -802,7 +802,7 @@ host_answer_door (void *cls,
   char *
     nym_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Entry request: %s\n", nym_str);
   GNUNET_free (nym_str);
 
@@ -840,7 +840,7 @@ host_farewell (void *cls,
   char *
     nym_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Farewell: %s\n", nym_str);
   GNUNET_free (nym_str);
 }
@@ -856,7 +856,7 @@ host_entered (void *cls, int result,
 {
   place_pub_key = *pub_key;
   char *pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Host entered: %s, max_message_id: %" PRIu64 "\n",
               pub_str, max_message_id);
   GNUNET_free (pub_str);
diff --git a/src/social/social_api.c b/src/social/social_api.c
index d57d16cfb..89843831b 100644
--- a/src/social/social_api.c
+++ b/src/social/social_api.c
@@ -183,6 +183,7 @@ struct GNUNET_SOCIAL_Place
    */
   struct GNUNET_PSYC_Slicer *slicer;
 
+  // FIXME: do we need is_disconnecing like on the psyc and multicast APIs?
   /**
    * Function called after disconnected from the service.
    */
@@ -371,6 +372,68 @@ struct ZoneAddNymHandle
 };
 
 
+/*** CLEANUP / DISCONNECT ***/
+
+
+static void
+host_cleanup (struct GNUNET_SOCIAL_Host *hst)
+{
+  if (NULL != hst->slicer)
+  {
+    GNUNET_PSYC_slicer_destroy (hst->slicer);
+    hst->slicer = NULL;
+  }
+  GNUNET_free (hst);
+}
+
+
+static void
+guest_cleanup (struct GNUNET_SOCIAL_Guest *gst)
+{
+  GNUNET_free (gst);
+}
+
+
+static void
+place_cleanup (struct GNUNET_SOCIAL_Place *plc)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "cleaning up place %p\n",
+              plc);
+  if (NULL != plc->tmit)
+  {
+    GNUNET_PSYC_transmit_destroy (plc->tmit);
+    plc->tmit = NULL;
+  }
+  if (NULL != plc->connect_env)
+  {
+    GNUNET_MQ_discard (plc->connect_env);
+    plc->connect_env = NULL;
+  }
+  if (NULL != plc->mq)
+  {
+    GNUNET_MQ_destroy (plc->mq);
+    plc->mq = NULL;
+  }
+  if (NULL != plc->disconnect_cb)
+  {
+    plc->disconnect_cb (plc->disconnect_cls);
+    plc->disconnect_cb = NULL;
+  }
+
+  (GNUNET_YES == plc->is_host)
+    ? host_cleanup ((struct GNUNET_SOCIAL_Host *) plc)
+    : guest_cleanup ((struct GNUNET_SOCIAL_Guest *) plc);
+}
+
+
+static void
+place_disconnect (struct GNUNET_SOCIAL_Place *plc)
+{
+  place_cleanup (plc);
+}
+
+
 /*** NYM ***/
 
 static struct GNUNET_SOCIAL_Nym *
@@ -428,7 +491,7 @@ host_recv_notice_place_leave_method (void *cls,
 
   struct GNUNET_SOCIAL_Nym *nym = nym_get_or_create (&msg->slave_pub_key);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Host received method for message ID %" PRIu64 " from nym %s: %s\n",
               message_id, GNUNET_h2s (&nym->pub_key_hash), method_name);
 
@@ -436,7 +499,7 @@ host_recv_notice_place_leave_method (void *cls,
   hst->notice_place_leave_env = GNUNET_PSYC_env_create ();
 
   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&hst->notice_place_leave_nym->pub_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "_notice_place_leave: got method from nym %s (%s).\n",
               GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
   GNUNET_free (str);
@@ -458,7 +521,7 @@ host_recv_notice_place_leave_modifier (void *cls,
   if (NULL == hst->notice_place_leave_env)
     return;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Host received modifier for _notice_place_leave message with ID %" PRIu64 ":\n"
               "%c%s: %.*s\n",
               message_id, oper, name, value_size, (const char *) value);
@@ -485,7 +548,7 @@ host_recv_notice_place_leave_eom (void *cls,
     return;
 
   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&hst->notice_place_leave_nym->pub_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "_notice_place_leave: got EOM from nym %s (%s).\n",
               GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
   GNUNET_free (str);
@@ -1015,100 +1078,24 @@ handle_app_place_end (void *cls,
 }
 
 
-/*** CLEANUP / DISCONNECT ***/
-
-
-static void
-host_cleanup (struct GNUNET_SOCIAL_Host *hst)
-{
-  if (NULL != hst->slicer)
-  {
-    GNUNET_PSYC_slicer_destroy (hst->slicer);
-    hst->slicer = NULL;
-  }
-  GNUNET_free (hst);
-}
-
-
+/**
+ * Handler for a #GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK message received
+ * from the social service.
+ *
+ * @param cls the place of type `struct GNUNET_SOCIAL_Place`
+ * @param msg the message received from the service
+ */
 static void
-guest_cleanup (struct GNUNET_SOCIAL_Guest *gst)
+handle_place_leave_ack (void *cls,
+                        const struct GNUNET_MessageHeader *msg)
 {
-  GNUNET_free (gst);
-}
-
+  struct GNUNET_SOCIAL_Place *plc = cls;
 
-static void
-place_cleanup (struct GNUNET_SOCIAL_Place *plc)
-{
-  struct GNUNET_HashCode place_pub_hash;
-  GNUNET_CRYPTO_hash (&plc->pub_key, sizeof (plc->pub_key), &place_pub_hash);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s place cleanup: %s\n",
-              GNUNET_YES == plc->is_host ? "host" : "guest",
-              GNUNET_h2s (&place_pub_hash));
-
-  if (NULL != plc->tmit)
-  {
-    GNUNET_PSYC_transmit_destroy (plc->tmit);
-    plc->tmit = NULL;
-  }
-  if (NULL != plc->connect_env)
-  {
-    GNUNET_MQ_discard (plc->connect_env);
-    plc->connect_env = NULL;
-  }
-  if (NULL != plc->mq)
-  {
-    GNUNET_MQ_destroy (plc->mq);
-    plc->mq = NULL;
-  }
-  if (NULL != plc->disconnect_cb)
-  {
-    plc->disconnect_cb (plc->disconnect_cls);
-    plc->disconnect_cb = NULL;
-  }
-
-  (GNUNET_YES == plc->is_host)
-    ? host_cleanup ((struct GNUNET_SOCIAL_Host *) plc)
-    : guest_cleanup ((struct GNUNET_SOCIAL_Guest *) plc);
-}
-
-
-void
-place_disconnect (struct GNUNET_SOCIAL_Place *plc,
-                  GNUNET_ContinuationCallback cb,
-                  void *cls)
-{
-  plc->disconnect_cb = cb;
-  plc->disconnect_cls = cls;
-
-  if (NULL != plc->mq)
-  {
-    struct GNUNET_MQ_Envelope *env = GNUNET_MQ_get_last_envelope (plc->mq);
-    if (NULL != env)
-    {
-      GNUNET_MQ_notify_sent (env, (GNUNET_SCHEDULER_TaskCallback) place_cleanup, plc);
-    }
-    else
-    {
-      place_cleanup (plc);
-    }
-  }
-  else
-  {
-    place_cleanup (plc);
-  }
-}
-
-
-void
-place_leave (struct GNUNET_SOCIAL_Place *plc)
-{
-  struct GNUNET_MessageHeader *msg;
-  struct GNUNET_MQ_Envelope *
-    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE);
-
-  GNUNET_MQ_send (plc->mq, env);
+              "%s left place %p\n",
+              plc->is_host ? "host" : "guest", 
+              plc);
+  place_disconnect (plc);  
 }
 
 
@@ -1168,6 +1155,10 @@ host_connect (struct GNUNET_SOCIAL_Host *hst)
                              GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK,
                              struct HostEnterAck,
                              hst),
+    GNUNET_MQ_hd_fixed_size (place_leave_ack,
+                             GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK,
+                             struct GNUNET_MessageHeader,
+                             plc),
     GNUNET_MQ_hd_var_size (host_enter_request,
                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
                            struct GNUNET_PSYC_JoinRequestMessage,
@@ -1516,6 +1507,9 @@ GNUNET_SOCIAL_host_announce (struct GNUNET_SOCIAL_Host *hst,
                              void *notify_data_cls,
                              enum GNUNET_SOCIAL_AnnounceFlags flags)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "PSYC_transmit_message for host, method: %s\n",
+              method_name);
   if (GNUNET_OK ==
       GNUNET_PSYC_transmit_message (hst->plc.tmit, method_name, env,
                                     NULL, notify_data, notify_data_cls, flags))
@@ -1580,7 +1574,11 @@ GNUNET_SOCIAL_host_disconnect (struct GNUNET_SOCIAL_Host *hst,
                                GNUNET_ContinuationCallback disconnect_cb,
                                void *cls)
 {
-  place_disconnect (&hst->plc, disconnect_cb, cls);
+  struct GNUNET_SOCIAL_Place *plc = &hst->plc;
+
+  plc->disconnect_cb = disconnect_cb;
+  plc->disconnect_cls = cls;
+  place_disconnect (plc);
 }
 
 
@@ -1607,10 +1605,15 @@ GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *hst,
                           GNUNET_ContinuationCallback disconnect_cb,
                           void *cls)
 {
+  struct GNUNET_MQ_Envelope *envelope;
+
   GNUNET_SOCIAL_host_announce (hst, "_notice_place_closing", env, NULL, NULL,
                                GNUNET_SOCIAL_ANNOUNCE_NONE);
-  place_leave (&hst->plc);
-  GNUNET_SOCIAL_host_disconnect (hst, disconnect_cb, cls);
+  hst->plc.disconnect_cb = disconnect_cb;
+  hst->plc.disconnect_cls = cls;
+  envelope = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE);
+  GNUNET_MQ_send (hst->plc.mq,
+                  envelope);
 }
 
 
@@ -1670,6 +1673,10 @@ guest_connect (struct GNUNET_SOCIAL_Guest *gst)
                              GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK,
                              struct GNUNET_PSYC_CountersResultMessage,
                              gst),
+    GNUNET_MQ_hd_fixed_size (place_leave_ack,
+                             GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK,
+                             struct GNUNET_MessageHeader,
+                             plc),
     GNUNET_MQ_hd_var_size (guest_enter_decision,
                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION,
                            struct GNUNET_PSYC_JoinDecisionMessage,
@@ -1896,6 +1903,64 @@ GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_SOCIAL_App *app,
 }
 
 
+struct ReconnectContext
+{
+  struct GNUNET_SOCIAL_Guest *guest;
+  int *result;
+  int64_t *max_message_id;
+  GNUNET_SOCIAL_GuestEnterCallback enter_cb;
+  void *enter_cls;
+};
+
+
+static void
+guest_enter_reconnect_cb (void *cls,
+                          int result,
+                          const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
+                          uint64_t max_message_id)
+{
+  struct ReconnectContext *reconnect_ctx = cls;
+
+  GNUNET_assert (NULL != reconnect_ctx);
+  reconnect_ctx->result = GNUNET_new (int);
+  *(reconnect_ctx->result) = result; 
+  reconnect_ctx->max_message_id = GNUNET_new (int64_t);
+  *(reconnect_ctx->max_message_id) = max_message_id;
+}
+
+
+static void
+guest_entry_dcsn_reconnect_cb (void *cls,
+                               int is_admitted,
+                               const struct GNUNET_PSYC_Message *entry_resp)
+{
+  struct ReconnectContext *reconnect_ctx = cls;
+  struct GNUNET_SOCIAL_Guest *gst = reconnect_ctx->guest;
+
+  GNUNET_assert (NULL != reconnect_ctx);
+  GNUNET_assert (NULL != reconnect_ctx->result);
+  GNUNET_assert (NULL != reconnect_ctx->max_message_id);
+  if (GNUNET_YES != is_admitted)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Guest was rejected after calling "
+                "GNUNET_SOCIAL_guest_enter_reconnect ()\n");
+  }
+  else if (NULL != reconnect_ctx->enter_cb)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "guest reconnected!\n");
+    reconnect_ctx->enter_cb (reconnect_ctx->enter_cls,
+                             *(reconnect_ctx->result),
+                             &gst->plc.pub_key,
+                             *(reconnect_ctx->max_message_id));
+  }
+  GNUNET_free (reconnect_ctx->result);
+  GNUNET_free (reconnect_ctx->max_message_id);
+  GNUNET_free (reconnect_ctx);
+}
+
+
 /**
  * Reconnect to an already entered place as guest.
  *
@@ -1906,8 +1971,8 @@ GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_SOCIAL_App *app,
  *        Flags for the entry.
  * @param slicer
  *        Slicer to use for processing incoming requests from guests.
- * @param local_enter_cb
- *        Called upon connection established to the social service.
+ * @param enter_cb
+ *        Called upon re-entering is complete.
  * @param entry_decision_cb
  *        Called upon receiving entry decision.
  *
@@ -1917,11 +1982,12 @@ struct GNUNET_SOCIAL_Guest *
 GNUNET_SOCIAL_guest_enter_reconnect (struct GNUNET_SOCIAL_GuestConnection *gconn,
                                      enum GNUNET_PSYC_SlaveJoinFlags flags,
                                      struct GNUNET_PSYC_Slicer *slicer,
-                                     GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
+                                     GNUNET_SOCIAL_GuestEnterCallback enter_cb,
                                      void *cls)
 {
   struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+  struct ReconnectContext *reconnect_ctx;
 
   uint16_t app_id_size = strlen (gconn->app->id) + 1;
   struct GuestEnterRequest *greq;
@@ -1940,10 +2006,15 @@ GNUNET_SOCIAL_guest_enter_reconnect (struct GNUNET_SOCIAL_GuestConnection *gconn
   plc->pub_key = gconn->plc_msg.place_pub_key;
   plc->ego_pub_key = gconn->plc_msg.ego_pub_key;
 
-  plc->op = GNUNET_OP_create ();
+  reconnect_ctx = GNUNET_new (struct ReconnectContext);
+  reconnect_ctx->guest = gst;
+  reconnect_ctx->enter_cb = enter_cb;
+  reconnect_ctx->enter_cls = cls;
 
-  gst->enter_cb = local_enter_cb;
-  gst->cb_cls = cls;
+  plc->op = GNUNET_OP_create ();
+  gst->enter_cb = &guest_enter_reconnect_cb;
+  gst->entry_dcsn_cb = &guest_entry_dcsn_reconnect_cb;
+  gst->cb_cls = reconnect_ctx;
 
   guest_connect (gst);
   return gst;
@@ -2028,7 +2099,11 @@ GNUNET_SOCIAL_guest_disconnect (struct GNUNET_SOCIAL_Guest *gst,
                                 GNUNET_ContinuationCallback disconnect_cb,
                                 void *cls)
 {
-  place_disconnect (&gst->plc, disconnect_cb, cls);
+  struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+
+  plc->disconnect_cb = disconnect_cb;
+  plc->disconnect_cls = cls;
+  place_disconnect (plc);
 }
 
 
@@ -2054,10 +2129,15 @@ GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Guest *gst,
                            GNUNET_ContinuationCallback disconnect_cb,
                            void *cls)
 {
+  struct GNUNET_MQ_Envelope *envelope;
+
   GNUNET_SOCIAL_guest_talk (gst, "_notice_place_leave", env, NULL, NULL,
                             GNUNET_SOCIAL_TALK_NONE);
-  place_leave (&gst->plc);
-  GNUNET_SOCIAL_guest_disconnect (gst, disconnect_cb, cls);
+  gst->plc.disconnect_cb = disconnect_cb;
+  gst->plc.disconnect_cls = cls;
+  envelope = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE);
+  GNUNET_MQ_send (gst->plc.mq,
+                  envelope);
 }
 
 
diff --git a/src/social/test_social.c b/src/social/test_social.c
index 64ef10125..4d95cf005 100644
--- a/src/social/test_social.c
+++ b/src/social/test_social.c
@@ -129,22 +129,22 @@ enum
   TEST_HOST_ANSWER_DOOR_REFUSE      =  4,
   TEST_GUEST_RECV_ENTRY_DCSN_REFUSE =  5,
   TEST_HOST_ANSWER_DOOR_ADMIT       =  6,
-  TEST_GUEST_RECV_ENTRY_DCSN_ADMIT  =  9,
-  TEST_HOST_ANNOUNCE                = 10,
-  TEST_HOST_ANNOUNCE_END            = 11,
-  TEST_GUEST_TALK                   = 12,
-  TEST_HOST_ANNOUNCE2               = 13,
-  TEST_HOST_ANNOUNCE2_END           = 14,
-  TEST_GUEST_HISTORY_REPLAY         = 15,
-  TEST_GUEST_HISTORY_REPLAY_LATEST  = 16,
-  TEST_GUEST_LOOK_AT                = 17,
-  TEST_GUEST_LOOK_FOR               = 18,
-  TEST_GUEST_LEAVE                  = 18,
-  TEST_ZONE_ADD_PLACE               = 20,
-  TEST_GUEST_ENTER_BY_NAME          = 21,
-  TEST_RECONNECT                    = 22,
-  TEST_GUEST_LEAVE2                 = 23,
-  TEST_HOST_LEAVE                   = 24,
+  TEST_GUEST_RECV_ENTRY_DCSN_ADMIT  =  7,
+  TEST_HOST_ANNOUNCE                =  8,
+  TEST_HOST_ANNOUNCE_END            =  9,
+  TEST_GUEST_TALK                   = 10,
+  TEST_HOST_ANNOUNCE2               = 11,
+  TEST_HOST_ANNOUNCE2_END           = 12,
+  TEST_GUEST_HISTORY_REPLAY         = 13,
+  TEST_GUEST_HISTORY_REPLAY_LATEST  = 14,
+  TEST_GUEST_LOOK_AT                = 15,
+  TEST_GUEST_LOOK_FOR               = 16,
+  TEST_GUEST_LEAVE                  = 17,
+  TEST_ZONE_ADD_PLACE               = 18,
+  TEST_GUEST_ENTER_BY_NAME          = 19,
+  TEST_RECONNECT                    = 20,
+  TEST_GUEST_LEAVE2                 = 21,
+  TEST_HOST_LEAVE                   = 22,
 } test;
 
 
@@ -180,10 +180,28 @@ host_announce2 ();
 
 
 /**
- * Clean up all resources used.
+ * Terminate the test case (failure).
+ *
+ * @param cls NULL
+ */
+static void
+end_badly (void *cls)
+{
+  end_badly_task = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+  res = 2;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Test FAILED.\n");
+}
+
+
+/**
+ * Terminate the test case (failure).
+ *
+ * @param cls NULL
  */
 static void
-cleanup ()
+end_shutdown (void *cls)
 {
   if (NULL != id)
   {
@@ -202,7 +220,11 @@ cleanup ()
     GNUNET_PSYC_slicer_destroy (host_slicer);
     host_slicer = NULL;
   }
-
+  if (NULL != end_badly_task)
+  {
+    GNUNET_SCHEDULER_cancel (end_badly_task);
+    end_badly_task = NULL;
+  }
   if (NULL != gst)
   {
     GNUNET_SOCIAL_guest_leave (gst, NULL, NULL, NULL);
@@ -216,21 +238,6 @@ cleanup ()
     hst_plc = NULL;
   }
   GNUNET_SOCIAL_app_disconnect (app, NULL, NULL);
-  GNUNET_SCHEDULER_shutdown ();
-}
-
-
-/**
- * Terminate the test case (failure).
- *
- * @param cls NULL
- */
-static void
-end_badly (void *cls)
-{
-  res = 1;
-  cleanup ();
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test FAILED.\n");
 }
 
 
@@ -242,9 +249,9 @@ end_badly (void *cls)
 static void
 end_normally (void *cls)
 {
+  GNUNET_SCHEDULER_shutdown ();
   res = 0;
-  cleanup ();
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Test PASSED.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Test PASSED.\n");
 }
 
 
@@ -254,7 +261,7 @@ end_normally (void *cls)
 static void
 end ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Ending tests.\n", test);
 
   if (end_badly_task != NULL)
@@ -271,7 +278,7 @@ transmit_resume (void *cls)
 {
   struct TransmitClosure *tmit = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Transmission resumed.\n", test);
   if (NULL != tmit->host_ann)
     GNUNET_SOCIAL_host_announce_resume (tmit->host_ann);
@@ -296,7 +303,7 @@ notify_data (void *cls, uint16_t *data_size, void *data)
   }
 
   uint16_t size = strlen (tmit->data[tmit->n]);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Transmit notify data: %u bytes available, "
               "processing fragment %u/%u (size %u).\n",
               test, *data_size, tmit->n + 1, tmit->data_count, size);
@@ -309,7 +316,7 @@ notify_data (void *cls, uint16_t *data_size, void *data)
 
   if (GNUNET_YES != tmit->paused && 0 < tmit->data_delay[tmit->n])
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                 "Test #%u: Transmission paused.\n", test);
     tmit->paused = GNUNET_YES;
     GNUNET_SCHEDULER_add_delayed (
@@ -331,7 +338,7 @@ notify_data (void *cls, uint16_t *data_size, void *data)
 static void
 host_left ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: The host has left the place.\n", test);
   end ();
 }
@@ -352,7 +359,7 @@ host_farewell2 (void *cls,
                const struct GNUNET_SOCIAL_Nym *nym,
                struct GNUNET_PSYC_Environment *env)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Nym left the place again.\n");
   GNUNET_SCHEDULER_add_now (&schedule_host_leave, NULL);
 }
@@ -365,13 +372,14 @@ host_reconnected (void *cls, int result,
 {
   place_pub_key = *home_pub_key;
   GNUNET_CRYPTO_hash (&place_pub_key, sizeof (place_pub_key), &place_pub_hash);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host reconnected to place %s\n",
               test, GNUNET_h2s (&place_pub_hash));
 
   is_host_reconnected = GNUNET_YES;
   if (GNUNET_YES == is_guest_reconnected)
   {
+    GNUNET_assert (NULL != gst);
     GNUNET_SCHEDULER_add_now (&schedule_guest_leave, NULL);
   }
 }
@@ -382,7 +390,7 @@ guest_reconnected (void *cls, int result,
                    const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
                    uint64_t max_message_id)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest reconnected to place: %d\n",
               test, result);
   GNUNET_assert (0 <= result);
@@ -390,6 +398,7 @@ guest_reconnected (void *cls, int result,
   is_guest_reconnected = GNUNET_YES;
   if (GNUNET_YES == is_host_reconnected)
   {
+    GNUNET_assert (NULL != gst);
     GNUNET_SCHEDULER_add_now (&schedule_guest_leave, NULL);
   }
 }
@@ -398,7 +407,7 @@ guest_reconnected (void *cls, int result,
 static void
 app_connected (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: App connected: %p\n", test, cls);
 }
 
@@ -411,21 +420,28 @@ app_recv_host (void *cls,
                enum GNUNET_SOCIAL_AppPlaceState place_state)
 {
   struct GNUNET_HashCode host_pub_hash;
-  GNUNET_CRYPTO_hash (host_pub_key, sizeof (*host_pub_key), &host_pub_hash);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_CRYPTO_hash (host_pub_key,
+                      sizeof (*host_pub_key),
+                      &host_pub_hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Got app host place notification: %s\n",
-              test, GNUNET_h2s (&host_pub_hash));
+              test,
+              GNUNET_h2s (&host_pub_hash));
 
   if (test == TEST_RECONNECT)
   {
     if (0 == memcmp (&place_pub_key, host_pub_key, sizeof (*host_pub_key)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Test #%u: Reconnecting to host place: %s\n",
                   test, GNUNET_h2s (&host_pub_hash));
-      hst = GNUNET_SOCIAL_host_enter_reconnect (hconn, host_slicer, host_reconnected,
-                                                host_answer_door, host_farewell2, NULL);
+      hst = GNUNET_SOCIAL_host_enter_reconnect (hconn, host_slicer,
+                                                &host_reconnected,
+                                                &host_answer_door,
+                                                &host_farewell2,
+                                                NULL);
     }
   }
 }
@@ -439,21 +455,30 @@ app_recv_guest (void *cls,
                 enum GNUNET_SOCIAL_AppPlaceState place_state)
 {
   struct GNUNET_HashCode guest_pub_hash;
-  GNUNET_CRYPTO_hash (guest_pub_key, sizeof (*guest_pub_key), &guest_pub_hash);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_CRYPTO_hash (guest_pub_key,
+                      sizeof (*guest_pub_key),
+                      &guest_pub_hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Got app guest place notification: %s\n",
               test, GNUNET_h2s (&guest_pub_hash));
 
   if (test == TEST_RECONNECT)
   {
-    if (0 == memcmp (&place_pub_key, guest_pub_key, sizeof (*guest_pub_key)))
+    if (0 == memcmp (&place_pub_key,
+                     guest_pub_key,
+                     sizeof (*guest_pub_key)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Test #%u: Reconnecting to guest place: %s\n",
                   test, GNUNET_h2s (&guest_pub_hash));
-      gst = GNUNET_SOCIAL_guest_enter_reconnect (gconn, GNUNET_PSYC_SLAVE_JOIN_NONE,
-                                                 guest_slicer, guest_reconnected, NULL);
+      gst = GNUNET_SOCIAL_guest_enter_reconnect (gconn,
+                                                 GNUNET_PSYC_SLAVE_JOIN_NONE,
+                                                 guest_slicer,
+                                                 &guest_reconnected,
+                                                 NULL);
+      GNUNET_assert (NULL != gst);
     }
   }
 }
@@ -478,7 +503,7 @@ app_recv_ego (void *cls,
               const char *name)
 {
   char *ego_pub_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (ego_pub_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Got app ego notification: %p %s %s\n",
               test, ego, name, ego_pub_str);
   GNUNET_free (ego_pub_str);
@@ -487,15 +512,30 @@ app_recv_ego (void *cls,
   {
     host_ego = ego;
     host_pub_key = ego_pub_key;
-    GNUNET_assert (TEST_IDENTITIES_CREATE == test);
-    enter_if_ready ();
+    if (TEST_IDENTITIES_CREATE == test)
+    {
+      enter_if_ready ();
+    }
+    else
+    {
+      GNUNET_assert (TEST_RECONNECT == test);
+    }
   }
   else if (NULL != strstr (name, guest_name))
   {
     guest_ego = ego;
     guest_pub_key = ego_pub_key;
-    GNUNET_assert (TEST_IDENTITIES_CREATE == test);
-    enter_if_ready ();
+    if (TEST_IDENTITIES_CREATE == test)
+    {
+      enter_if_ready ();
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+                  "test = %d\n",
+                  test);
+      GNUNET_assert (TEST_RECONNECT == test);
+    }
   }
 }
 
@@ -504,7 +544,6 @@ static void
 schedule_reconnect (void *cls)
 {
   test = TEST_RECONNECT;
-
   GNUNET_SOCIAL_host_disconnect (hst, NULL, NULL);
   GNUNET_SOCIAL_guest_disconnect (gst, NULL, NULL);
   hst = NULL;
@@ -512,10 +551,10 @@ schedule_reconnect (void *cls)
 
   GNUNET_SOCIAL_app_disconnect (app, NULL, NULL);
   app = GNUNET_SOCIAL_app_connect (cfg, app_id,
-                                   app_recv_ego,
-                                   app_recv_host,
-                                   app_recv_guest,
-                                   app_connected,
+                                   &app_recv_ego,
+                                   &app_recv_host,
+                                   &app_recv_guest,
+                                   &app_connected,
                                    NULL);
 }
 
@@ -524,7 +563,7 @@ static void
 host_recv_zone_add_place_result (void *cls, int64_t result,
                                  const void *data, uint16_t data_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Zone add place result: %" PRId64 " (%.*s).\n",
               test, result, data_size, (const char *) data);
   GNUNET_assert (GNUNET_YES == result);
@@ -538,7 +577,7 @@ static void
 zone_add_place ()
 {
   test = TEST_ZONE_ADD_PLACE;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Adding place to zone.\n", test);
 
   GNUNET_SOCIAL_zone_add_place (app, host_ego, "home", "let.me*in!",
@@ -557,7 +596,7 @@ host_farewell (void *cls,
     nym_key = GNUNET_SOCIAL_nym_get_pub_key (nym);
 
   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Farewell: nym %s (%s) has left the place.\n",
               test, GNUNET_h2s (GNUNET_SOCIAL_nym_get_pub_key_hash (nym)), str);
   GNUNET_free (str);
@@ -578,13 +617,13 @@ host_farewell (void *cls,
 static void
 guest_left (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: The guest has left the place.\n", test);
 }
 
 
 static void
-guest_leave()
+guest_leave ()
 {
   if (test < TEST_RECONNECT)
     test = TEST_GUEST_LEAVE;
@@ -615,11 +654,11 @@ guest_look_for_result (void *cls,
                        uint16_t data_size)
 {
   struct ResultClosure *rcls = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: guest_look_for_result: %" PRId64 "\n",
               test, result_code);
   GNUNET_assert (GNUNET_OK == result_code);
-  GNUNET_assert (3 == rcls->n);
+  GNUNET_assert (6 == rcls->n);
   GNUNET_free (rcls);
   GNUNET_SCHEDULER_add_now (&schedule_guest_leave, NULL);
 }
@@ -635,7 +674,7 @@ guest_look_for_var (void *cls,
 {
   struct ResultClosure *rcls = cls;
   rcls->n++;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: guest_look_for_var: %s\n%.*s\n",
               test, name, value_size, (const char *) value);
 }
@@ -656,7 +695,7 @@ guest_look_at_result (void *cls, int64_t result_code,
 {
   struct ResultClosure *rcls = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: guest_look_at_result: %" PRId64 "\n",
               test, result_code);
   GNUNET_assert (GNUNET_OK == result_code);
@@ -677,7 +716,7 @@ guest_look_at_var (void *cls,
   struct ResultClosure *rcls = cls;
   rcls->n++;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: guest_look_at_var: %s\n%.*s\n",
               test ,name, value_size, (const char *) value);
 }
@@ -696,7 +735,7 @@ static void
 guest_recv_history_replay_latest_result (void *cls, int64_t result,
                                          const void *data, uint16_t data_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received latest history replay result "
               "(%" PRIu32 " messages, %" PRId64 " fragments):\n"
               "%.*s\n",
@@ -725,7 +764,7 @@ static void
 guest_recv_history_replay_result (void *cls, int64_t result,
                                   const void *data, uint16_t data_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received history replay result: %" PRId64 "\n"
               "%.*s\n",
               test, result, data_size, (const char *) data);
@@ -756,7 +795,7 @@ guest_recv_method (void *cls,
                    uint64_t message_id,
                    const char *method_name)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received method for message ID %" PRIu64 ":\n"
               "%s (flags: %x)\n",
               test, message_id, method_name, ntohl (meth->flags));
@@ -775,7 +814,7 @@ guest_recv_modifier (void *cls,
                      uint16_t value_size,
                      uint16_t full_value_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received modifier for message ID %" PRIu64 ":\n"
               "%c%s: %.*s (size: %u)\n",
               test, message_id, oper, name, value_size, (const char *) value, value_size);
@@ -793,7 +832,7 @@ guest_recv_mod_foo_bar (void *cls,
                         uint16_t value_size,
                         uint16_t full_value_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received modifier matching _foo_bar for message ID %" PRIu64 ":\n"
               "%c%s: %.*s (size: %u)\n",
               test, message_id, oper, name, value_size, (const char *) value, value_size);
@@ -811,7 +850,7 @@ guest_recv_data (void *cls,
                  const void *data,
                  uint16_t data_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received data for message ID %" PRIu64 ":\n"
               "%.*s\n",
               test, message_id, data_size, (const char *) data);
@@ -826,7 +865,7 @@ guest_recv_eom (void *cls,
                 uint64_t message_id,
                 uint8_t is_cancelled)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received end of message ID %" PRIu64
               ", cancelled: %u\n",
               test, message_id, is_cancelled);
@@ -868,7 +907,7 @@ host_recv_method (void *cls,
                   uint64_t message_id,
                   const char *method_name)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host received method for message ID %" PRIu64 ":\n"
               "%s\n",
               test, message_id, method_name);
@@ -887,7 +926,7 @@ host_recv_modifier (void *cls,
                     uint16_t value_size,
                     uint16_t full_value_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host received modifier for message ID %" PRIu64 ":\n"
               "%c%s: %.*s\n",
               test, message_id, oper, name, value_size, (const char *) value);
@@ -902,7 +941,7 @@ host_recv_data (void *cls,
                 const void *data,
                 uint16_t data_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host received data for message ID %" PRIu64 ":\n"
               "%.*s\n",
               test, message_id, data_size, (const char *) data);
@@ -916,7 +955,7 @@ host_recv_eom (void *cls,
                uint64_t message_id,
                uint8_t is_cancelled)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host received end of message ID %" PRIu64
               ", cancelled: %u\n",
               test, message_id, is_cancelled);
@@ -981,7 +1020,7 @@ host_announce ()
 {
   test = TEST_HOST_ANNOUNCE;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host announcement.\n", test);
 
   tmit = (struct TransmitClosure) {};
@@ -1015,7 +1054,7 @@ host_announce2 ()
 
   test = TEST_HOST_ANNOUNCE2;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host announcement 2.\n", test);
 
   tmit = (struct TransmitClosure) {};
@@ -1025,7 +1064,7 @@ host_announce2 ()
   GNUNET_PSYC_env_add (tmit.env, GNUNET_PSYC_OP_ASSIGN,
                        "_foo2_bar", DATA2ARG ("FOO BAR"));
   GNUNET_PSYC_env_add (tmit.env, GNUNET_PSYC_OP_ASSIGN,
-                       "_foo2_bar", DATA2ARG ("FOO BAR BAZ"));
+                       "_foo2_bar_baz", DATA2ARG ("FOO BAR BAZ"));
   tmit.data[0] = "AAA BBB CCC ";
   tmit.data[1] = "ABC DEF GHI JKL.\n";
   tmit.data[2] = "TESTING ONE TWO THREE.\n";
@@ -1043,7 +1082,7 @@ guest_recv_entry_decision (void *cls,
                            int is_admitted,
                            const struct GNUNET_PSYC_Message *entry_msg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Guest received entry decision (try %u): %d.\n",
               test, join_req_count, is_admitted);
 
@@ -1068,7 +1107,8 @@ guest_recv_entry_decision (void *cls,
   {
   case TEST_GUEST_RECV_ENTRY_DCSN_REFUSE:
     GNUNET_assert (GNUNET_NO == is_admitted);
-    guest_enter ();
+    test = TEST_HOST_ANSWER_DOOR_ADMIT;
+    GNUNET_SOCIAL_guest_disconnect (gst, &guest_enter, NULL);
     break;
 
   case TEST_GUEST_RECV_ENTRY_DCSN_ADMIT:
@@ -1097,7 +1137,7 @@ host_answer_door (void *cls,
 {
   join_req_count++;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
               "Test #%u: Host received entry request from guest (try %u).\n",
               (uint8_t) test, join_req_count);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1118,7 +1158,7 @@ host_answer_door (void *cls,
     // fall through
 
   case TEST_GUEST_ENTER_BY_NAME:
-    join_resp = GNUNET_PSYC_message_create ("_notice_place_admit", env,
+   join_resp = GNUNET_PSYC_message_create ("_notice_place_admit", env,
                                             DATA2ARG ("Welcome, nym!"));
     GNUNET_SOCIAL_host_entry_decision (hst, nym, GNUNET_YES, join_resp);
     break;
@@ -1135,18 +1175,18 @@ guest_recv_local_enter (void *cls, int result,
                         const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
                         uint64_t max_message_id)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Test #%u: Guest entered to local place: %d\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Test #%u: Guest entered local place: %d\n",
               test, result);
-  GNUNET_assert (0 <= result);
+  GNUNET_assert (GNUNET_OK == result);
 }
 
 
 static void
 guest_enter ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Test #%u: Entering to place as guest.\n", test);
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Test #%u: Entering place as guest.\n", test);
 
   struct GuestEnterMessage *emsg = &guest_enter_msg;
 
@@ -1177,8 +1217,8 @@ static void
 guest_enter_by_name ()
 {
   test = TEST_GUEST_ENTER_BY_NAME;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Test #%u: Entering to place by name as guest.\n", test);
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Test #%u: Entering place by name as guest.\n", test);
 
   struct GuestEnterMessage *emsg = &guest_enter_msg;
 
@@ -1222,7 +1262,7 @@ guest_init ()
                                  guest_recv_data, guest_recv_eom, NULL);
   GNUNET_PSYC_slicer_modifier_add (guest_slicer, "_foo_bar",
                                    guest_recv_mod_foo_bar, &mod_foo_bar_rcls);
-  test = TEST_HOST_ANSWER_DOOR_ADMIT;
+  test = TEST_HOST_ANSWER_DOOR_REFUSE;
 
   GNUNET_SOCIAL_zone_add_nym (app, guest_ego, "host", host_pub_key,
                               GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES),
@@ -1270,8 +1310,8 @@ host_entered (void *cls, int result,
 {
   place_pub_key = *home_pub_key;
   GNUNET_CRYPTO_hash (&place_pub_key, sizeof (place_pub_key), &place_pub_hash);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Test #%u: Host entered to place %s\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Test #%u: Host entered place %s\n",
               test, GNUNET_h2s (&place_pub_hash));
   guest_enter ();
 }
@@ -1285,8 +1325,8 @@ host_enter ()
                                  host_recv_method, host_recv_modifier,
                                  host_recv_data, host_recv_eom, NULL);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Test #%u: Entering to place as host.\n", test);
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Test #%u: Entering place as host.\n", test);
   test = TEST_HOST_ENTER;
   hst = GNUNET_SOCIAL_host_enter (app, host_ego,
                                   GNUNET_PSYC_CHANNEL_PRIVATE,
@@ -1306,6 +1346,8 @@ start_app_if_ready ()
   {
     return;
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "starting app...\n");
   app = GNUNET_SOCIAL_app_connect (cfg,
                                    app_id,
                                    app_recv_ego,
@@ -1324,17 +1366,17 @@ identity_ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego,
   {
     if (ego == identity_host_ego)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Host ego deleted\n");
     }
     else if (ego == identity_guest_ego)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Guest ego deleted\n");
     }
     else if (0 == strcmp (name, host_name))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Created ego %s\n",
                   name);
       identity_host_ego = ego;
@@ -1342,7 +1384,7 @@ identity_ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego,
     }
     else if (0 == strcmp (name, guest_name))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                   "Created guest ego %s\n",
                   name);
       identity_guest_ego = ego;
@@ -1370,9 +1412,11 @@ run (void *cls,
 #endif
 {
   cfg = c;
+  res = 1;
   end_badly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                                  &end_badly, NULL);
-
+  GNUNET_SCHEDULER_add_shutdown (&end_shutdown,
+                                 NULL);
   GNUNET_CRYPTO_get_peer_identity (cfg, &this_peer);
 
   id = GNUNET_IDENTITY_connect (cfg, &identity_ego_cb, NULL);
diff --git a/src/social/test_social.conf b/src/social/test_social.conf
index e69de29bb..7cf858b1c 100644
--- a/src/social/test_social.conf
+++ b/src/social/test_social.conf
@@ -0,0 +1,19 @@
+@INLINE@ ../../contrib/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = /tmp/gnunet-test-social/
+
+[social]
+FORCESTART = YES
+
+[transport]
+PLUGINS = tcp
+
+[nat]
+DISABLEV6 = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
diff --git a/src/statistics/gnunet-service-statistics.c b/src/statistics/gnunet-service-statistics.c
index 0cb136b99..87e966a01 100644
--- a/src/statistics/gnunet-service-statistics.c
+++ b/src/statistics/gnunet-service-statistics.c
@@ -998,7 +998,9 @@ client_disconnect_cb (void *cls,
  *
  * @param cls NULL
  * @param message the message found on disk
- * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 inject_message (void *cls,
diff --git a/src/testbed/Makefile.am b/src/testbed/Makefile.am
index 94b981eee..e858e44b4 100644
--- a/src/testbed/Makefile.am
+++ b/src/testbed/Makefile.am
@@ -45,7 +45,7 @@ gnunet_service_testbed_SOURCES = \
   gnunet-service-testbed_oc.c \
   gnunet-service-testbed_cpustatus.c \
   gnunet-service-testbed_meminfo.c gnunet-service-testbed_meminfo.h \
-  gnunet-service-testbed_barriers.c \
+  gnunet-service-testbed_barriers.c gnunet-service-testbed_barriers.h \
   gnunet-service-testbed_connectionpool.c gnunet-service-testbed_connectionpool.h
 gnunet_service_testbed_LDADD = $(XLIB) \
  $(top_builddir)/src/util/libgnunetutil.la \
diff --git a/src/testbed/gnunet-daemon-testbed-underlay.c b/src/testbed/gnunet-daemon-testbed-underlay.c
index 0b6c44710..3605e0384 100644
--- a/src/testbed/gnunet-daemon-testbed-underlay.c
+++ b/src/testbed/gnunet-daemon-testbed-underlay.c
@@ -165,7 +165,8 @@ check_access (void *cls, const struct GNUNET_PeerIdentity * pid)
 
 
 static int
-get_identity (unsigned int offset, struct GNUNET_PeerIdentity *id)
+get_identity (unsigned int offset,
+              struct GNUNET_PeerIdentity *id)
 {
   struct GNUNET_CRYPTO_EddsaPrivateKey private_key;
 
@@ -174,7 +175,8 @@ get_identity (unsigned int offset, struct GNUNET_PeerIdentity *id)
   GNUNET_memcpy (&private_key,
                  hostkeys_data + (offset * GNUNET_TESTING_HOSTKEYFILESIZE),
                  GNUNET_TESTING_HOSTKEYFILESIZE);
-  GNUNET_CRYPTO_eddsa_key_get_public (&private_key, &id->public_key);
+  GNUNET_CRYPTO_eddsa_key_get_public (&private_key,
+                                      &id->public_key);
   return GNUNET_OK;
 }
 
diff --git a/src/testbed/gnunet-helper-testbed.c b/src/testbed/gnunet-helper-testbed.c
index 392f257dd..9601e7567 100644
--- a/src/testbed/gnunet-helper-testbed.c
+++ b/src/testbed/gnunet-helper-testbed.c
@@ -292,8 +292,9 @@ child_death_task (void *cls)
  *
  * @param cls identification of the client
  * @param message the actual message
- *
- * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 tokenizer_cb (void *cls,
@@ -359,7 +360,7 @@ tokenizer_cb (void *cls,
   cfg = GNUNET_CONFIGURATION_create ();
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_deserialize (cfg,
-                                        config, 
+                                        config,
                                         ul_config_size,
                                         NULL))
   {
diff --git a/src/testbed/gnunet-service-testbed_oc.c b/src/testbed/gnunet-service-testbed_oc.c
index 09849797c..11c45a0f5 100644
--- a/src/testbed/gnunet-service-testbed_oc.c
+++ b/src/testbed/gnunet-service-testbed_oc.c
@@ -261,7 +261,7 @@ struct OverlayConnectContext
   enum OverlayConnectContextType type;
 
   /**
-   * The id of the second peer which is has to connect to the first peer
+   * The id of the second peer which has to connect to the first peer
    */
   uint32_t other_peer_id;
 };
@@ -930,10 +930,10 @@ send_hello (void *cls)
              other_peer_str);
   GNUNET_free (other_peer_str);
   lp2c->ohh =
-      GNUNET_TRANSPORT_offer_hello (lp2c->tcc.cfg,
-                                    occ->hello,
-                                    &occ_hello_sent_cb,
-                                    occ);
+    GNUNET_TRANSPORT_offer_hello (lp2c->tcc.cfg,
+                                  occ->hello,
+                                  &occ_hello_sent_cb,
+                                  occ);
   if (NULL == lp2c->ohh)
   {
     GNUNET_break (0);
@@ -1001,6 +1001,11 @@ p2_transport_connect (struct OverlayConnectContext *occ)
 {
   struct Peer *peer2;
 
+  /* HUH? Why to *obtain* HELLO? Seems we use this to *SEND* the
+     HELLO! */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Connecting to transport of peer %s to obtain HELLO\n",
+              GNUNET_i2s (&occ->other_peer_identity));
   GNUNET_assert (NULL == occ->emsg);
   GNUNET_assert (NULL != occ->hello);
   GNUNET_assert (NULL == occ->ghh);
diff --git a/src/testbed/gnunet-testbed-profiler.c b/src/testbed/gnunet-testbed-profiler.c
index 9829bbf0d..0fa6d8172 100644
--- a/src/testbed/gnunet-testbed-profiler.c
+++ b/src/testbed/gnunet-testbed-profiler.c
@@ -175,9 +175,7 @@ controller_event_cb (void *cls,
       {
         printf ("\nAborting due to very high failure rate\n");
         print_overlay_links_summary ();
-        if (NULL != abort_task)
-          GNUNET_SCHEDULER_cancel (abort_task);
-        abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
+        GNUNET_SCHEDULER_shutdown ();
         return;
       }
     }
@@ -260,11 +258,12 @@ run (void *cls, char *const *args, const char *cfgfile,
   event_mask = 0;
   event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
   event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
-  GNUNET_TESTBED_run (hosts_file, cfg, num_peers, event_mask, controller_event_cb,
-                      NULL, &test_run, NULL);
+  GNUNET_TESTBED_run (hosts_file, cfg, num_peers, event_mask,
+                      &controller_event_cb, NULL,
+                      &test_run, NULL);
   abort_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &do_abort,
-                                    NULL);
+      GNUNET_SCHEDULER_add_shutdown (&do_abort,
+                                     NULL);
 }
 
 
@@ -310,6 +309,8 @@ main (int argc, char *const *argv)
   const char *binaryHelp = "gnunet-testbed-profiler [OPTIONS]";
   int ret;
 
+  unsetenv ("XDG_DATA_HOME");
+  unsetenv ("XDG_CONFIG_HOME");
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   result = GNUNET_SYSERR;
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am
index d65da6bb6..e8c1f5d4a 100644
--- a/src/transport/Makefile.am
+++ b/src/transport/Makefile.am
@@ -295,7 +295,7 @@ noinst_LTLIBRARIES = \
   libgnunet_plugin_transport_template.la
 
 libgnunet_plugin_transport_tcp_la_SOURCES = \
-  plugin_transport_tcp.c
+  plugin_transport_tcp.c 
 libgnunet_plugin_transport_tcp_la_LIBADD = \
   $(top_builddir)/src/hello/libgnunethello.la \
   $(top_builddir)/src/statistics/libgnunetstatistics.la \
@@ -1330,7 +1330,6 @@ test_transport_api_monitor_peers_peer2.conf\
 test_transport_api_monitor_validation_peer1.conf\
 test_transport_api_monitor_validation_peer2.conf\
 test_transport_defaults.conf\
-test_transport_startonly.conf\
 test_transport_api_disconnect_tcp_peer1.conf\
 test_transport_api_disconnect_tcp_peer2.conf\
 test_transport_api_timeout_http_peer1.conf\
@@ -1350,4 +1349,8 @@ test_transport_api_http_reverse_peer2.conf \
 perf_tcp_peer1.conf \
 perf_tcp_peer2.conf \
 test_transport_api_slow_ats_peer1.conf \
-test_transport_api_slow_ats_peer2.conf
+test_transport_api_slow_ats_peer2.conf \
+  tcp_connection_legacy.c \
+  tcp_server_mst_legacy.c \
+  tcp_server_legacy.c \
+  tcp_service_legacy.c
diff --git a/src/transport/gnunet-helper-transport-wlan-dummy.c b/src/transport/gnunet-helper-transport-wlan-dummy.c
index 63ed9c4b7..f02d8bdd7 100644
--- a/src/transport/gnunet-helper-transport-wlan-dummy.c
+++ b/src/transport/gnunet-helper-transport-wlan-dummy.c
@@ -121,6 +121,9 @@ send_mac_to_plugin (char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac)
  *
  * @param cls the 'struct SendBuffer' to copy the converted message to
  * @param hdr inbound message from the FIFO
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 stdin_send (void *cls,
@@ -167,6 +170,9 @@ stdin_send (void *cls,
  *
  * @param cls the 'struct SendBuffer' to copy to
  * @param hdr the message we received to copy to the buffer
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 file_in_send (void *cls,
diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c
index 6b354df98..124260c41 100644
--- a/src/transport/gnunet-service-transport.c
+++ b/src/transport/gnunet-service-transport.c
@@ -688,6 +688,8 @@ handle_client_hello (void *cls,
 {
   struct TransportClient *tc = cls;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Received HELLO message\n");
   GST_validation_handle_hello (message);
   GNUNET_SERVICE_client_continue (tc->client);
 }
@@ -2802,7 +2804,7 @@ run (void *cls,
   GNUNET_assert (NULL != GST_my_private_key);
 
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "My identity is `%4s'\n",
+             "My identity is `%s'\n",
              GNUNET_i2s_full (&GST_my_identity));
 
   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
diff --git a/src/transport/gnunet-service-transport_validation.c b/src/transport/gnunet-service-transport_validation.c
index 27c3c7041..cd5aeb5e2 100644
--- a/src/transport/gnunet-service-transport_validation.c
+++ b/src/transport/gnunet-service-transport_validation.c
@@ -1347,6 +1347,9 @@ GST_validation_handle_address (const struct GNUNET_HELLO_Address *address)
   if (NULL == papi)
   {
     /* This plugin is currently unvailable ... ignore */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "No plugin available for %s\n",
+                address->transport_name);
     return;
   }
   ve = find_validation_entry (address);
@@ -1358,6 +1361,13 @@ GST_validation_handle_address (const struct GNUNET_HELLO_Address *address)
                 GNUNET_i2s (&ve->address->peer));
     ve->revalidation_task = GNUNET_SCHEDULER_add_now (&revalidate_address, ve);
   }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Validation already running for address `%s' of %s\n",
+                GST_plugins_a2s (ve->address),
+                GNUNET_i2s (&ve->address->peer));
+  }
 }
 
 
@@ -1657,6 +1667,9 @@ GST_validation_handle_hello (const struct GNUNET_MessageHeader *hello)
               sizeof (struct GNUNET_PeerIdentity)))
   {
     /* got our own HELLO, how boring */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Validation received our own HELLO (%s), ignoring\n",
+                GNUNET_i2s (&pid));
     return GNUNET_OK;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/transport/plugin_transport_http_server.c b/src/transport/plugin_transport_http_server.c
index d9fade44f..6a9c1b0ba 100644
--- a/src/transport/plugin_transport_http_server.c
+++ b/src/transport/plugin_transport_http_server.c
@@ -1651,7 +1651,7 @@ server_send_callback (void *cls,
  *
  * @param cls current session as closure
  * @param message the message to be forwarded to transport service
- * @return #GNUNET_OK
+ * @return #GNUNET_OK (all OK)
  */
 static int
 server_receive_mst_cb (void *cls,
diff --git a/src/util/client.c b/src/util/client.c
index 3d74bff33..e5bf7e176 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -261,14 +261,27 @@ transmit_ready (void *cls)
   pos = (const char *) cstate->msg;
   len = ntohs (cstate->msg->size);
   GNUNET_assert (cstate->msg_off < len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "client: message of type %u trying to send with socket %p (MQ: %p\n",
+              ntohs(cstate->msg->type),
+              cstate->sock,
+              cstate->mq);
+
  RETRY:
   ret = GNUNET_NETWORK_socket_send (cstate->sock,
                                     &pos[cstate->msg_off],
                                     len - cstate->msg_off);
   if (-1 == ret)
   {
-    if (EINTR == errno)
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "client: error during sending message of type %u\n",
+                ntohs(cstate->msg->type));
+    if (EINTR == errno){
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "client: retrying message of type %u\n",
+                  ntohs(cstate->msg->type));
       goto RETRY;
+    }
     GNUNET_MQ_inject_error (cstate->mq,
                             GNUNET_MQ_ERROR_WRITE);
     return;
@@ -277,6 +290,9 @@ transmit_ready (void *cls)
   cstate->msg_off += ret;
   if (cstate->msg_off < len)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "client: rescheduling message of type %u\n",
+                ntohs(cstate->msg->type));
     cstate->send_task
       = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                         cstate->sock,
@@ -286,6 +302,9 @@ transmit_ready (void *cls)
       GNUNET_MQ_impl_send_in_flight (cstate->mq);
     return;
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "client: sending message of type %u successful\n",
+              ntohs(cstate->msg->type));
   cstate->msg = NULL;
   GNUNET_MQ_impl_send_continue (cstate->mq);
 }
@@ -297,7 +316,9 @@ transmit_ready (void *cls)
  *
  * @param cls the `struct ClientState`
  * @param msg message we received.
- * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
  */
 static int
 recv_message (void *cls,
@@ -306,7 +327,7 @@ recv_message (void *cls,
   struct ClientState *cstate = cls;
 
   if (GNUNET_YES == cstate->in_destroy)
-    return GNUNET_SYSERR;
+    return GNUNET_NO;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received message of type %u and size %u from %s\n",
        ntohs (msg->type),
@@ -315,7 +336,7 @@ recv_message (void *cls,
   GNUNET_MQ_inject_message (cstate->mq,
                             msg);
   if (GNUNET_YES == cstate->in_destroy)
-    return GNUNET_SYSERR;
+    return GNUNET_NO;
   return GNUNET_OK;
 }
 
@@ -371,8 +392,12 @@ connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq,
     GNUNET_SCHEDULER_cancel (cstate->recv_task);
   if (NULL != cstate->retry_task)
     GNUNET_SCHEDULER_cancel (cstate->retry_task);
-  if (NULL != cstate->sock)
+  if (NULL != cstate->sock){
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "client: destroying socket: %p\n",
+                cstate->sock);
     GNUNET_NETWORK_socket_close (cstate->sock);
+  }
   cancel_aps (cstate);
   GNUNET_free (cstate->service_name);
   GNUNET_free_non_null (cstate->hostname);
@@ -794,8 +819,12 @@ connection_client_send_impl (struct GNUNET_MQ_Handle *mq,
   GNUNET_assert (NULL == cstate->send_task);
   cstate->msg = msg;
   cstate->msg_off = 0;
-  if (NULL == cstate->sock)
+  if (NULL == cstate->sock){
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "client: message of type %u waiting for socket\n",
+                ntohs(msg->type));
     return; /* still waiting for connection */
+   }
   cstate->send_task
     = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                       cstate->sock,
diff --git a/src/util/mq.c b/src/util/mq.c
index 90b2aa968..8d71359ac 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -357,6 +357,12 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
   }
   GNUNET_assert (NULL == mq->envelope_head);
   mq->current_envelope = ev;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mq: sending message of type %u, queue empty (MQ: %p)\n",
+              ntohs(ev->mh->type),
+              mq);
+
   mq->send_impl (mq,
                  ev->mh,
                  mq->impl_state);
@@ -452,6 +458,11 @@ impl_send_continue (void *cls)
   GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
                                mq->envelope_tail,
                                mq->current_envelope);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mq: sending message of type %u from queue\n",
+              ntohs(mq->current_envelope->mh->type));
+
   mq->send_impl (mq,
                  mq->current_envelope->mh,
                  mq->impl_state);
@@ -840,6 +851,9 @@ GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
                                  ev);
     GNUNET_assert (0 < mq->queue_length);
     mq->queue_length--;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "MQ destroy drops message of type %u\n",
+                ntohs (ev->mh->type));
     GNUNET_MQ_discard (ev);
   }
   if (NULL != mq->current_envelope)
@@ -847,6 +861,9 @@ GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
     /* we can only discard envelopes that
      * are not queued! */
     mq->current_envelope->parent_queue = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "MQ destroy drops current message of type %u\n",
+                ntohs (mq->current_envelope->mh->type));
     GNUNET_MQ_discard (mq->current_envelope);
     mq->current_envelope = NULL;
     GNUNET_assert (0 < mq->queue_length);
@@ -928,6 +945,11 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
       GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
                                    mq->envelope_tail,
                                    mq->current_envelope);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "mq: sending canceled message of type %u queue\n",
+                  ntohs(ev->mh->type));
+
       mq->send_impl (mq,
                      mq->current_envelope->mh,
                      mq->impl_state);
diff --git a/src/util/mst.c b/src/util/mst.c
index 0d90c5d10..5e472965f 100644
--- a/src/util/mst.c
+++ b/src/util/mst.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2010, 2016 GNUnet e.V.
+     Copyright (C) 2010, 2016, 2017 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -126,6 +126,7 @@ GNUNET_MST_from_buffer (struct GNUNET_MessageStreamTokenizer *mst,
   int need_align;
   unsigned long offset;
   int ret;
+  int cbret;
 
   GNUNET_assert (mst->off <= mst->pos);
   GNUNET_assert (mst->pos <= mst->curr_buf);
@@ -229,9 +230,17 @@ do_align:
     if (one_shot == GNUNET_YES)
       one_shot = GNUNET_SYSERR;
     mst->off += want;
-  if (GNUNET_SYSERR == mst->cb (mst->cb_cls,
-                                hdr))
+    if (GNUNET_OK !=
+        (cbret = mst->cb (mst->cb_cls,
+                           hdr)))
+    {
+      if (GNUNET_SYSERR == cbret)
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Failure processing message of type %u and size %u\n",
+                    ntohs (hdr->type),
+                    ntohs (hdr->size));
       return GNUNET_SYSERR;
+    }
     if (mst->off == mst->pos)
     {
       /* reset to beginning of buffer, it's free right now! */
@@ -271,9 +280,17 @@ do_align:
       }
       if (one_shot == GNUNET_YES)
         one_shot = GNUNET_SYSERR;
-      if (GNUNET_SYSERR == mst->cb (mst->cb_cls,
-                                    hdr))
+      if (GNUNET_OK !=
+          (cbret = mst->cb (mst->cb_cls,
+                            hdr)))
+      {
+        if (GNUNET_SYSERR == cbret)
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                      "Failure processing message of type %u and size %u\n",
+                      ntohs (hdr->type),
+                      ntohs (hdr->size));
         return GNUNET_SYSERR;
+      }
       buf += want;
       size -= want;
     }
diff --git a/src/util/network.c b/src/util/network.c
index 942288613..cf5ef3e00 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -1223,7 +1223,7 @@ GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
  * @return POSIX file descriptor
  */
 int
-GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_fd (const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->fd;
 }
@@ -1236,7 +1236,7 @@ GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc)
  * @return sockaddr
  */
 struct sockaddr*
-GNUNET_NETWORK_get_addr (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_addr (const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->addr;
 }
@@ -1249,7 +1249,7 @@ GNUNET_NETWORK_get_addr (struct GNUNET_NETWORK_Handle *desc)
  * @return socklen_t for sockaddr
  */
 socklen_t
-GNUNET_NETWORK_get_addrlen (struct GNUNET_NETWORK_Handle *desc)
+GNUNET_NETWORK_get_addrlen (const struct GNUNET_NETWORK_Handle *desc)
 {
   return desc->addrlen;
 }
diff --git a/src/util/program.c b/src/util/program.c
index 92a9750f3..233792387 100644
--- a/src/util/program.c
+++ b/src/util/program.c
@@ -69,6 +69,16 @@ struct CommandContext
 
 
 /**
+ * task run when the scheduler shuts down
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_SPEEDUP_stop_ ();
+}
+
+
+/**
  * Initial task called by the scheduler for each
  * program.  Runs the program-specific main task.
  */
@@ -78,6 +88,7 @@ program_main (void *cls)
   struct CommandContext *cc = cls;
 
   GNUNET_SPEEDUP_start_(cc->cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
   GNUNET_RESOLVER_connect (cc->cfg);
   cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
 }
@@ -306,7 +317,6 @@ GNUNET_PROGRAM_run2 (int argc, char *const *argv, const char *binaryName,
   }
   ret = GNUNET_OK;
  cleanup:
-  GNUNET_SPEEDUP_stop_ ();
   GNUNET_CONFIGURATION_destroy (cfg);
   GNUNET_free_non_null (cc.cfgfile);
   GNUNET_free (cfg_fn);
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 540a60557..b96e4e6c4 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -89,12 +89,6 @@ struct GNUNET_SCHEDULER_Handle
    * @deprecated
    */
   struct GNUNET_NETWORK_FDSet *ws;
-
-  /**
-   * Driver we used for the event loop.
-   */
-  const struct GNUNET_SCHEDULER_Driver *driver;
-
 };
 
 
@@ -124,36 +118,40 @@ struct GNUNET_SCHEDULER_Task
   void *callback_cls;
 
   /**
-   * Handle to the scheduler's state.
+   * Information about which FDs are ready for this task (and why).
    */
-  const struct GNUNET_SCHEDULER_Handle *sh;
+  struct GNUNET_SCHEDULER_FdInfo *fds;
 
   /**
-   * Set of file descriptors this task is waiting
-   * for for reading.  Once ready, this is updated
-   * to reflect the set of file descriptors ready
-   * for operation.
+   * Storage location used for @e fds if we want to avoid
+   * a separate malloc() call in the common case that this
+   * task is only about a single FD.
    */
-  struct GNUNET_NETWORK_FDSet *read_set;
+  struct GNUNET_SCHEDULER_FdInfo fdx;
 
   /**
-   * Set of file descriptors this task is waiting for for writing.
-   * Once ready, this is updated to reflect the set of file
-   * descriptors ready for operation.
+   * Size of the @e fds array.
    */
-  struct GNUNET_NETWORK_FDSet *write_set;
+  unsigned int fds_len;
 
   /**
-   * Information about which FDs are ready for this task (and why).
+   * if this task is related to multiple FDs this array contains
+   * all FdInfo structs that were marked as ready by calling
+   * #GNUNET_SCHEDULER_task_ready
    */
-  const struct GNUNET_SCHEDULER_FdInfo *fds;
+  struct GNUNET_SCHEDULER_FdInfo *ready_fds;
 
   /**
-   * Storage location used for @e fds if we want to avoid
-   * a separate malloc() call in the common case that this
-   * task is only about a single FD.
+   * Size of the @e ready_fds array
    */
-  struct GNUNET_SCHEDULER_FdInfo fdx;
+  unsigned int ready_fds_len;
+
+  /**
+   * Do we own the network and file handles referenced by the FdInfo
+   * structs in the fds array. This will only be GNUNET_YES if the
+   * task was created by the #GNUNET_SCHEDULER_add_select function.
+   */
+  int own_handles;
 
   /**
    * Absolute timeout value for the task, or
@@ -169,11 +167,6 @@ struct GNUNET_SCHEDULER_Task
 #endif
 
   /**
-   * Size of the @e fds array.
-   */
-  unsigned int fds_len;
-
-  /**
    * Why is the task ready?  Set after task is added to ready queue.
    * Initially set to zero.  All reasons that have already been
    * satisfied (i.e.  read or write ready) will be set over time.
@@ -224,11 +217,72 @@ struct GNUNET_SCHEDULER_Task
   int num_backtrace_strings;
 #endif
 
+};
+
+
+/**
+ * A struct representing an event the select driver is waiting for
+ */
+struct Scheduled
+{
+  struct Scheduled *prev;
+
+  struct Scheduled *next;
+
+  /**
+   * the task, the event is related to
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * information about the network socket / file descriptor where
+   * the event is expected to occur
+   */
+  struct GNUNET_SCHEDULER_FdInfo *fdi;
+
+  /**
+   * the event types (multiple event types can be ORed) the select
+   * driver is expected to wait for
+   */
+  enum GNUNET_SCHEDULER_EventType et;
+};
+
+
+/**
+ * Driver context used by GNUNET_SCHEDULER_run
+ */
+struct DriverContext
+{
+  /**
+   * the head of a DLL containing information about the events the
+   * select driver is waiting for
+   */
+  struct Scheduled *scheduled_head;
 
+  /**
+   * the tail of a DLL containing information about the events the
+   * select driver is waiting for
+   */
+  struct Scheduled *scheduled_tail;
+
+  /**
+   * the time until the select driver will wake up again (after
+   * calling select)
+   */
+  struct GNUNET_TIME_Relative timeout;
 };
 
 
 /**
+ * The driver used for the event loop. Will be handed over to
+ * the scheduler in #GNUNET_SCHEDULER_run_from_driver(), peristed
+ * there in this variable for later use in functions like
+ * #GNUNET_SCHEDULER_add_select(), #add_without_sets() and
+ * #GNUNET_SCHEDULER_cancel().
+ */
+static const struct GNUNET_SCHEDULER_Driver *scheduler_driver;
+
+/**
  * Head of list of tasks waiting for an event.
  */
 static struct GNUNET_SCHEDULER_Task *pending_head;
@@ -330,6 +384,11 @@ static struct GNUNET_SCHEDULER_TaskContext tc;
  */
 static void *scheduler_select_cls;
 
+/**
+ * Scheduler handle used for the driver functions
+ */
+static struct GNUNET_SCHEDULER_Handle sh;
+
 
 /**
  * Sets the select function to use in the scheduler (scheduler_select).
@@ -364,115 +423,44 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
 
 
 /**
- * Update all sets and timeout for select.
- *
- * @param rs read-set, set to all FDs we would like to read (updated)
- * @param ws write-set, set to all FDs we would like to write (updated)
- * @param timeout next timeout (updated)
+ * chooses the nearest timeout from all pending tasks, to be used
+ * to tell the driver the next wakeup time (using its set_wakeup
+ * callback)
  */
-static void
-update_sets (struct GNUNET_NETWORK_FDSet *rs,
-             struct GNUNET_NETWORK_FDSet *ws,
-             struct GNUNET_TIME_Relative *timeout)
+struct GNUNET_TIME_Absolute
+get_timeout ()
 {
   struct GNUNET_SCHEDULER_Task *pos;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_TIME_Relative to;
+  struct GNUNET_TIME_Absolute timeout;
 
-  now = GNUNET_TIME_absolute_get ();
   pos = pending_timeout_head;
+  now = GNUNET_TIME_absolute_get ();
+  timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   if (NULL != pos)
   {
-    to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-    if (timeout->rel_value_us > to.rel_value_us)
-      *timeout = to;
     if (0 != pos->reason)
-      *timeout = GNUNET_TIME_UNIT_ZERO;
+    {
+      timeout = now;
+    }
+    else
+    {
+      timeout = pos->timeout;
+    }
   }
   for (pos = pending_head; NULL != pos; pos = pos->next)
   {
-    if (pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
+    if (0 != pos->reason)
     {
-      to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-      if (timeout->rel_value_us > to.rel_value_us)
-        *timeout = to;
+      timeout = now;
+    }
+    else if ((pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) &&
+             (timeout.abs_value_us > pos->timeout.abs_value_us))
+    {
+      timeout = pos->timeout;
     }
-    if (-1 != pos->read_fd)
-      GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
-    if (-1 != pos->write_fd)
-      GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
-    if (NULL != pos->read_set)
-      GNUNET_NETWORK_fdset_add (rs, pos->read_set);
-    if (NULL != pos->write_set)
-      GNUNET_NETWORK_fdset_add (ws, pos->write_set);
-    if (0 != pos->reason)
-      *timeout = GNUNET_TIME_UNIT_ZERO;
-  }
-}
-
-
-/**
- * Check if the ready set overlaps with the set we want to have ready.
- * If so, update the want set (set all FDs that are ready).  If not,
- * return #GNUNET_NO.
- *
- * @param ready set that is ready
- * @param want set that we want to be ready
- * @return #GNUNET_YES if there was some overlap
- */
-static int
-set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
-              struct GNUNET_NETWORK_FDSet *want)
-{
-  if ((NULL == want) || (NULL == ready))
-    return GNUNET_NO;
-  if (GNUNET_NETWORK_fdset_overlap (ready, want))
-  {
-    /* copy all over (yes, there maybe unrelated bits,
-     * but this should not hurt well-written clients) */
-    GNUNET_NETWORK_fdset_copy (want, ready);
-    return GNUNET_YES;
   }
-  return GNUNET_NO;
-}
-
-
-/**
- * Check if the given task is eligible to run now.
- * Also set the reason why it is eligible.
- *
- * @param task task to check if it is ready
- * @param now the current time
- * @param rs set of FDs ready for reading
- * @param ws set of FDs ready for writing
- * @return #GNUNET_YES if we can run it, #GNUNET_NO if not.
- */
-static int
-is_ready (struct GNUNET_SCHEDULER_Task *task,
-          struct GNUNET_TIME_Absolute now,
-          const struct GNUNET_NETWORK_FDSet *rs,
-          const struct GNUNET_NETWORK_FDSet *ws)
-{
-  enum GNUNET_SCHEDULER_Reason reason;
-
-  reason = task->reason;
-  if (now.abs_value_us >= task->timeout.abs_value_us)
-    reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-  if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
-      (((task->read_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd))) ||
-       (set_overlaps (rs, task->read_set))))
-    reason |= GNUNET_SCHEDULER_REASON_READ_READY;
-  if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
-      (((task->write_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
-       || (set_overlaps (ws, task->write_set))))
-    reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
-  if (0 == reason)
-    return GNUNET_NO;           /* not ready */
-  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
-  task->reason = reason;
-  return GNUNET_YES;
+  return timeout;
 }
 
 
@@ -495,51 +483,6 @@ queue_ready_task (struct GNUNET_SCHEDULER_Task *task)
 
 
 /**
- * Check which tasks are ready and move them
- * to the respective ready queue.
- *
- * @param rs FDs ready for reading
- * @param ws FDs ready for writing
- */
-static void
-check_ready (const struct GNUNET_NETWORK_FDSet *rs,
-             const struct GNUNET_NETWORK_FDSet *ws)
-{
-  struct GNUNET_SCHEDULER_Task *pos;
-  struct GNUNET_SCHEDULER_Task *next;
-  struct GNUNET_TIME_Absolute now;
-
-  now = GNUNET_TIME_absolute_get ();
-  while (NULL != (pos = pending_timeout_head))
-  {
-    if (now.abs_value_us >= pos->timeout.abs_value_us)
-      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-    if (0 == pos->reason)
-      break;
-    GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
-                                 pending_timeout_tail,
-                                 pos);
-    if (pending_timeout_last == pos)
-      pending_timeout_last = NULL;
-    queue_ready_task (pos);
-  }
-  pos = pending_head;
-  while (NULL != pos)
-  {
-    next = pos->next;
-    if (GNUNET_YES == is_ready (pos, now, rs, ws))
-    {
-      GNUNET_CONTAINER_DLL_remove (pending_head,
-                                   pending_tail,
-                                   pos);
-      queue_ready_task (pos);
-    }
-    pos = next;
-  }
-}
-
-
-/**
  * Request the shutdown of a scheduler.  Marks all tasks
  * awaiting shutdown as ready. Note that tasks
  * scheduled with #GNUNET_SCHEDULER_add_shutdown() AFTER this call
@@ -562,25 +505,6 @@ GNUNET_SCHEDULER_shutdown ()
 
 
 /**
- * Destroy a task (release associated resources)
- *
- * @param t task to destroy
- */
-static void
-destroy_task (struct GNUNET_SCHEDULER_Task *t)
-{
-  if (NULL != t->read_set)
-    GNUNET_NETWORK_fdset_destroy (t->read_set);
-  if (NULL != t->write_set)
-    GNUNET_NETWORK_fdset_destroy (t->write_set);
-#if EXECINFO
-  GNUNET_free (t->backtrace_strings);
-#endif
-  GNUNET_free (t);
-}
-
-
-/**
  * Output stack trace of task @a t.
  *
  * @param t task to dump stack trace of
@@ -592,88 +516,59 @@ dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
   unsigned int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Task %p trace %u: %s\n",
-         t,
-         i,
-         t->backtrace_strings[i]);
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+   "Task %p trace %u: %s\n",
+   t,
+   i,
+   t->backtrace_strings[i]);
 #endif
 }
 
 
 /**
- * Run at least one task in the highest-priority queue that is not
- * empty.  Keep running tasks until we are either no longer running
- * "URGENT" tasks or until we have at least one "pending" task (which
- * may become ready, hence we should select on it).  Naturally, if
- * there are no more ready tasks, we also return.
+ * Destroy a task (release associated resources)
  *
- * @param rs FDs ready for reading
- * @param ws FDs ready for writing
+ * @param t task to destroy
  */
 static void
-run_ready (struct GNUNET_NETWORK_FDSet *rs,
-           struct GNUNET_NETWORK_FDSet *ws)
+destroy_task (struct GNUNET_SCHEDULER_Task *t)
 {
-  enum GNUNET_SCHEDULER_Priority p;
-  struct GNUNET_SCHEDULER_Task *pos;
+  unsigned int i;
 
-  max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
-  do
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "destroying task %p\n",
+       t);
+
+  if (GNUNET_YES == t->own_handles)
   {
-    if (0 == ready_count)
-      return;
-    GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
-    /* yes, p>0 is correct, 0 is "KEEP" which should
-     * always be an empty queue (see assertion)! */
-    for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
-    {
-      pos = ready_head[p];
-      if (NULL != pos)
-        break;
-    }
-    GNUNET_assert (NULL != pos);        /* ready_count wrong? */
-    GNUNET_CONTAINER_DLL_remove (ready_head[p],
-                                 ready_tail[p],
-                                 pos);
-    ready_count--;
-    current_priority = pos->priority;
-    current_lifeness = pos->lifeness;
-    active_task = pos;
-#if PROFILE_DELAYS
-    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
-        DELAY_THRESHOLD.rel_value_us)
+    for (i = 0; i != t->fds_len; ++i)
     {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Task %p took %s to be scheduled\n",
-           pos,
-           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
-                                                   GNUNET_YES));
+      const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd;
+      const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh;
+      if (fd)
+      {
+        GNUNET_NETWORK_socket_free_memory_only_ ((struct GNUNET_NETWORK_Handle *) fd);
+      }
+      if (fh)
+      {
+        // FIXME: on WIN32 this is not enough! A function
+        // GNUNET_DISK_file_free_memory_only would be nice
+        GNUNET_free ((void *) fh);
+      }
     }
-#endif
-    tc.reason = pos->reason;
-    tc.read_ready = (NULL == pos->read_set) ? rs : pos->read_set;
-    if ((-1 != pos->read_fd) &&
-        (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
-      GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
-    tc.write_ready = (NULL == pos->write_set) ? ws : pos->write_set;
-    if ((-1 != pos->write_fd) &&
-        (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
-      GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
-    if ((0 != (tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
-        (-1 != pos->write_fd) &&
-        (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
-      GNUNET_assert (0);          // added to ready in previous select loop!
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Running task: %p\n",
-         pos);
-    pos->callback (pos->callback_cls);
-    dump_backtrace (pos);
-    active_task = NULL;
-    destroy_task (pos);
-    tasks_run++;
   }
-  while ((NULL == pending_head) || (p >= max_priority_added));
+  if (t->fds_len > 1)
+  {
+    GNUNET_array_grow (t->fds, t->fds_len, 0);
+  }
+  if (t->ready_fds_len > 0)
+  {
+    GNUNET_array_grow (t->ready_fds, t->ready_fds_len, 0);
+  }
+#if EXECINFO
+  GNUNET_free (t->backtrace_strings);
+#endif
+  GNUNET_free (t);
 }
 
 
@@ -700,22 +595,22 @@ sighandler_pipe ()
 #endif
 
 
-/**
- * Wait for a short time.
- * Sleeps for @a ms ms (as that should be long enough for virtually all
- * modern systems to context switch and allow another process to do
- * some 'real' work).
- *
- * @param ms how many ms to wait
- */
-static void
-short_wait (unsigned int ms)
-{
-  struct GNUNET_TIME_Relative timeout;
-
-  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms);
-  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
-}
+///**
+// * Wait for a short time.
+// * Sleeps for @a ms ms (as that should be long enough for virtually all
+// * modern systems to context switch and allow another process to do
+// * some 'real' work).
+// *
+// * @param ms how many ms to wait
+// */
+//static void
+//short_wait (unsigned int ms)
+//{
+//  struct GNUNET_TIME_Relative timeout;
+//
+//  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms);
+//  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
+//}
 
 
 /**
@@ -737,35 +632,31 @@ sighandler_shutdown ()
 }
 
 
-/**
- * Check if the system is still alive. Trigger shutdown if we
- * have tasks, but none of them give us lifeness.
- *
- * @return #GNUNET_OK to continue the main loop,
- *         #GNUNET_NO to exit
- */
-static int
-check_lifeness ()
+void
+shutdown_if_no_lifeness ()
 {
   struct GNUNET_SCHEDULER_Task *t;
 
   if (ready_count > 0)
-    return GNUNET_OK;
+    return;
   for (t = pending_head; NULL != t; t = t->next)
-    if (t->lifeness == GNUNET_YES)
-      return GNUNET_OK;
+    if (GNUNET_YES == t->lifeness)
+      return;
   for (t = shutdown_head; NULL != t; t = t->next)
-    if (t->lifeness == GNUNET_YES)
-      return GNUNET_OK;
+    if (GNUNET_YES == t->lifeness)
+      return;
   for (t = pending_timeout_head; NULL != t; t = t->next)
-    if (t->lifeness == GNUNET_YES)
-      return GNUNET_OK;
-  if (NULL != shutdown_head)
+    if (GNUNET_YES == t->lifeness)
+      return;
+  /* No lifeness! Cancel all pending tasks the driver knows about and shutdown */
+  t = pending_head;
+  while (NULL != t)
   {
-    GNUNET_SCHEDULER_shutdown ();
-    return GNUNET_OK;
+    struct GNUNET_SCHEDULER_Task *next = t->next;
+    GNUNET_SCHEDULER_cancel (t);
+    t = next;
   }
-  return GNUNET_NO;
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -787,204 +678,17 @@ void
 GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
                       void *task_cls)
 {
-    GNUNET_SCHEDULER_run_with_optional_signals(GNUNET_YES, task, task_cls);
-}
-
-void
-GNUNET_SCHEDULER_run_with_optional_signals (int install_signals,
-                                            GNUNET_SCHEDULER_TaskCallback task,
-                                            void *task_cls)
-{
-  struct GNUNET_NETWORK_FDSet *rs;
-  struct GNUNET_NETWORK_FDSet *ws;
-  struct GNUNET_TIME_Relative timeout;
-  int ret;
-  struct GNUNET_SIGNAL_Context *shc_int;
-  struct GNUNET_SIGNAL_Context *shc_term;
-#if (SIGTERM != GNUNET_TERM_SIG)
-  struct GNUNET_SIGNAL_Context *shc_gterm;
-#endif
-
-#ifndef MINGW
-  struct GNUNET_SIGNAL_Context *shc_quit;
-  struct GNUNET_SIGNAL_Context *shc_hup;
-  struct GNUNET_SIGNAL_Context *shc_pipe;
-#endif
-  unsigned long long last_tr;
-  unsigned int busy_wait_warning;
-  const struct GNUNET_DISK_FileHandle *pr;
-  char c;
-
-  GNUNET_assert (NULL == active_task);
-  rs = GNUNET_NETWORK_fdset_create ();
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_assert (NULL == shutdown_pipe_handle);
-  shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
-                                           GNUNET_NO,
-                                           GNUNET_NO,
-                                           GNUNET_NO);
-  GNUNET_assert (NULL != shutdown_pipe_handle);
-  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
-                                GNUNET_DISK_PIPE_END_READ);
-  GNUNET_assert (NULL != pr);
-  my_pid = getpid ();
-
-  if (GNUNET_YES == install_signals)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Registering signal handlers\n");
-    shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
-                                           &sighandler_shutdown);
-    shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
-                                           &sighandler_shutdown);
-#if (SIGTERM != GNUNET_TERM_SIG)
-    shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
-                                             &sighandler_shutdown);
-#endif
-#ifndef MINGW
-    shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
-                                            &sighandler_pipe);
-    shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
-                                            &sighandler_shutdown);
-    shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
-                                           &sighandler_shutdown);
-#endif
-  }
-
-  current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
-  current_lifeness = GNUNET_YES;
-  GNUNET_SCHEDULER_add_with_reason_and_priority (task,
-                                                 task_cls,
-                                                 GNUNET_SCHEDULER_REASON_STARTUP,
-                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT);
-  active_task = (void *) (long) -1;     /* force passing of sanity check */
-  GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
-                                          &GNUNET_OS_install_parent_control_handler,
-                                          NULL);
-  active_task = NULL;
-  last_tr = 0;
-  busy_wait_warning = 0;
-  while (GNUNET_OK == check_lifeness ())
-  {
-    GNUNET_NETWORK_fdset_zero (rs);
-    GNUNET_NETWORK_fdset_zero (ws);
-    timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-    update_sets (rs, ws, &timeout);
-    GNUNET_NETWORK_fdset_handle_set (rs, pr);
-    if (ready_count > 0)
-    {
-      /* no blocking, more work already ready! */
-      timeout = GNUNET_TIME_UNIT_ZERO;
-    }
-    if (NULL == scheduler_select)
-      ret = GNUNET_NETWORK_socket_select (rs,
-                                          ws,
-                                          NULL,
-                                          timeout);
-    else
-      ret = scheduler_select (scheduler_select_cls,
-                              rs,
-                              ws,
-                              NULL,
-                              timeout);
-    if (ret == GNUNET_SYSERR)
-    {
-      if (errno == EINTR)
-        continue;
-
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
-#ifndef MINGW
-#if USE_LSOF
-      char lsof[512];
-
-      snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
-      (void) close (1);
-      (void) dup2 (2, 1);
-      if (0 != system (lsof))
-        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
-                      "system");
-#endif
-#endif
-#if DEBUG_FDS
-      struct GNUNET_SCHEDULER_Task *t;
-
-      for (t = pending_head; NULL != t; t = t->next)
-      {
-        if (-1 != t->read_fd)
-        {
-          int flags = fcntl (t->read_fd, F_GETFD);
-          if ((flags == -1) && (errno == EBADF))
-            {
-              LOG (GNUNET_ERROR_TYPE_ERROR,
-                   "Got invalid file descriptor %d!\n",
-                   t->read_fd);
-              dump_backtrace (t);
-            }
-        }
-        if (-1 != t->write_fd)
-          {
-            int flags = fcntl (t->write_fd, F_GETFD);
-            if ((flags == -1) && (errno == EBADF))
-              {
-                LOG (GNUNET_ERROR_TYPE_ERROR,
-                     "Got invalid file descriptor %d!\n",
-                     t->write_fd);
-                dump_backtrace (t);
-              }
-          }
-      }
-#endif
-      GNUNET_assert (0);
-      break;
-    }
-
-    if ( (0 == ret) &&
-         (0 == timeout.rel_value_us) &&
-         (busy_wait_warning > 16) )
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Looks like we're busy waiting...\n");
-      short_wait (100);                /* mitigate */
-    }
-    check_ready (rs, ws);
-    run_ready (rs, ws);
-    if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
-    {
-      /* consume the signal */
-      GNUNET_DISK_file_read (pr, &c, sizeof (c));
-      /* mark all active tasks as ready due to shutdown */
-      GNUNET_SCHEDULER_shutdown ();
-    }
-    if (last_tr == tasks_run)
-    {
-      short_wait (1);
-      busy_wait_warning++;
-    }
-    else
-    {
-      last_tr = tasks_run;
-      busy_wait_warning = 0;
-    }
-  }
-
-  if (GNUNET_YES == install_signals)
-  {
-    GNUNET_SIGNAL_handler_uninstall (shc_int);
-    GNUNET_SIGNAL_handler_uninstall (shc_term);
-#if (SIGTERM != GNUNET_TERM_SIG)
-    GNUNET_SIGNAL_handler_uninstall (shc_gterm);
-#endif
-#ifndef MINGW
-    GNUNET_SIGNAL_handler_uninstall (shc_pipe);
-    GNUNET_SIGNAL_handler_uninstall (shc_quit);
-    GNUNET_SIGNAL_handler_uninstall (shc_hup);
-#endif
-  }
-
-  GNUNET_DISK_pipe_close (shutdown_pipe_handle);
-  shutdown_pipe_handle = NULL;
-  GNUNET_NETWORK_fdset_destroy (rs);
-  GNUNET_NETWORK_fdset_destroy (ws);
+  struct GNUNET_SCHEDULER_Driver *driver;
+  struct DriverContext context = {.scheduled_head = NULL,
+                                  .scheduled_tail = NULL,
+                                  .timeout = GNUNET_TIME_UNIT_FOREVER_REL};
+  
+  driver = GNUNET_SCHEDULER_driver_select ();
+  driver->cls = &context;
+
+  GNUNET_SCHEDULER_run_with_driver (driver, task, task_cls);
+  
+  GNUNET_free (driver);
 }
 
 
@@ -1029,9 +733,164 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
 }
 
 
+void
+init_fd_info (struct GNUNET_SCHEDULER_Task *t,
+              const struct GNUNET_NETWORK_Handle *const *read_nh,
+              unsigned int read_nh_len,
+              const struct GNUNET_NETWORK_Handle *const *write_nh,
+              unsigned int write_nh_len,
+              const struct GNUNET_DISK_FileHandle *const *read_fh,
+              unsigned int read_fh_len,
+              const struct GNUNET_DISK_FileHandle *const *write_fh,
+              unsigned int write_fh_len)
+{
+  // FIXME: if we have exactly two network handles / exactly two file handles
+  // and they are equal, we can make one FdInfo with both
+  // GNUNET_SCHEDULER_ET_IN and GNUNET_SCHEDULER_ET_OUT set.
+  struct GNUNET_SCHEDULER_FdInfo *fdi;
+
+  t->fds_len = read_nh_len + write_nh_len + read_fh_len + write_fh_len;
+  if (1 == t->fds_len)
+  {
+    fdi = &t->fdx;
+    t->fds = fdi;
+    if (1 == read_nh_len)
+    {
+      fdi->fd = *read_nh;
+      GNUNET_assert (NULL != fdi->fd);
+      fdi->et = GNUNET_SCHEDULER_ET_IN;
+      fdi->sock = GNUNET_NETWORK_get_fd (*read_nh);
+      t->read_fd = fdi->sock;
+      t->write_fd = -1;
+    }
+    else if (1 == write_nh_len)
+    {
+      fdi->fd = *write_nh;
+      GNUNET_assert (NULL != fdi->fd);
+      fdi->et = GNUNET_SCHEDULER_ET_OUT;
+      fdi->sock = GNUNET_NETWORK_get_fd (*write_nh);
+      t->read_fd = -1;
+      t->write_fd = fdi->sock;
+    }
+    else if (1 == read_fh_len)
+    {
+      fdi->fh = *read_fh;
+      GNUNET_assert (NULL != fdi->fh);
+      fdi->et = GNUNET_SCHEDULER_ET_IN;
+      fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32
+      t->read_fd = fdi->sock;
+      t->write_fd = -1;
+    }
+    else
+    {
+      fdi->fh = *write_fh;
+      GNUNET_assert (NULL != fdi->fh);
+      fdi->et = GNUNET_SCHEDULER_ET_OUT;
+      fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32
+      t->read_fd = -1;
+      t->write_fd = fdi->sock;
+    }
+  }
+  else
+  {
+    fdi = GNUNET_new_array (t->fds_len, struct GNUNET_SCHEDULER_FdInfo);
+    t->fds = fdi;
+    t->read_fd = -1;
+    t->write_fd = -1;
+    unsigned int i;
+    for (i = 0; i != read_nh_len; ++i)
+    {
+      fdi->fd = read_nh[i];
+      GNUNET_assert (NULL != fdi->fd);
+      fdi->et = GNUNET_SCHEDULER_ET_IN;
+      fdi->sock = GNUNET_NETWORK_get_fd (read_nh[i]);
+      ++fdi;
+    }
+    for (i = 0; i != write_nh_len; ++i)
+    {
+      fdi->fd = write_nh[i];
+      GNUNET_assert (NULL != fdi->fd);
+      fdi->et = GNUNET_SCHEDULER_ET_OUT;
+      fdi->sock = GNUNET_NETWORK_get_fd (write_nh[i]);
+      ++fdi;
+    }
+    for (i = 0; i != read_fh_len; ++i)
+    {
+      fdi->fh = read_fh[i];
+      GNUNET_assert (NULL != fdi->fh);
+      fdi->et = GNUNET_SCHEDULER_ET_IN;
+      fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32
+      ++fdi;
+    }
+    for (i = 0; i != write_fh_len; ++i)
+    {
+      fdi->fh = write_fh[i];
+      GNUNET_assert (NULL != fdi->fh);
+      fdi->et = GNUNET_SCHEDULER_ET_OUT;
+      fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32
+      ++fdi;
+    }
+  }
+}
+
+
+/**
+ * calls the given function @a func on each FdInfo related to @a t.
+ * Optionally updates the event type field in each FdInfo after calling
+ * @a func.
+ *
+ * @param t the task
+ * @param driver_func the function to call with each FdInfo contained in
+ *                    in @a t
+ * @param if_not_ready only call @a driver_func on FdInfos that are not
+ *                     ready
+ * @param et the event type to be set in each FdInfo after calling
+ *           @a driver_func on it, or -1 if no updating not desired.
+ */
+void driver_add_multiple (struct GNUNET_SCHEDULER_Task *t,
+                          enum GNUNET_SCHEDULER_EventType et)
+{
+  struct GNUNET_SCHEDULER_FdInfo *fdi;
+  int success = GNUNET_YES;
+
+  for (int i = 0; i != t->fds_len; ++i)
+  {
+    fdi = &t->fds[i];
+    success = scheduler_driver->add (scheduler_driver->cls, t, fdi) && success;
+    if (et != -1)
+    {
+      fdi->et = et;
+    }
+  }
+  if (GNUNET_YES != success)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "driver could not add task\n");
+  }
+}
+
+
+void
+shutdown_cb (void *cls)
+{
+  char c;
+  const struct GNUNET_DISK_FileHandle *pr;
+
+  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
+                                GNUNET_DISK_PIPE_END_READ);
+  GNUNET_assert (! GNUNET_DISK_handle_invalid (pr));
+  /* consume the signal */
+  GNUNET_DISK_file_read (pr, &c, sizeof (c));
+  /* mark all active tasks as ready due to shutdown */
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
 /**
  * Cancel the task with the specified identifier.
- * The task must not yet have run.
+ * The task must not yet have run. Only allowed to be called as long as the
+ * scheduler is running (#GNUNET_SCHEDULER_run or
+ * #GNUNET_SCHEDULER_run_with_driver has been called and has not returned yet).
  *
  * @param task id of the task to cancel
  * @return original closure of the task
@@ -1040,34 +899,50 @@ void *
 GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
 {
   enum GNUNET_SCHEDULER_Priority p;
+  int is_fd_task;
   void *ret;
 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "canceling task %p\n",
+       task);
+
+  /* scheduler must be running */
+  GNUNET_assert (NULL != scheduler_driver);
   GNUNET_assert ( (NULL != active_task) ||
-                  (GNUNET_NO == task->lifeness) );
-  if (! task->in_ready_list)
+      (GNUNET_NO == task->lifeness) );
+  is_fd_task = (NULL != task->fds);
+  if (is_fd_task)
   {
-    if ( (-1 == task->read_fd) &&
-         (-1 == task->write_fd) &&
-         (NULL == task->read_set) &&
-         (NULL == task->write_set) )
+    int del_result = scheduler_driver->del (scheduler_driver->cls, task);
+    if (GNUNET_OK != del_result)
     {
-      if (GNUNET_YES == task->on_shutdown)
-        GNUNET_CONTAINER_DLL_remove (shutdown_head,
-                                     shutdown_tail,
-                                     task);
-      else
-        GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
-                                     pending_timeout_tail,
-                                     task);
-      if (task == pending_timeout_last)
-        pending_timeout_last = NULL;
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "driver could not delete task\n");
+      GNUNET_assert (0);
     }
-    else
+  }
+  if (! task->in_ready_list)
+  {
+    if (is_fd_task)
     {
       GNUNET_CONTAINER_DLL_remove (pending_head,
                                    pending_tail,
                                    task);
     }
+    else if (GNUNET_YES == task->on_shutdown)
+    {
+      GNUNET_CONTAINER_DLL_remove (shutdown_head,
+                                   shutdown_tail,
+                                   task);
+    }
+    else
+    {
+      GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+                                   pending_timeout_tail,
+                                   task);
+      if (pending_timeout_last == task)
+        pending_timeout_last = NULL;
+    }
   }
   else
   {
@@ -1078,9 +953,6 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
     ready_count--;
   }
   ret = task->callback_cls;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Canceling task %p\n",
-       task);
   destroy_task (task);
   return ret;
 }
@@ -1101,7 +973,7 @@ init_backtrace (struct GNUNET_SCHEDULER_Task *t)
     = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
       backtrace_symbols (backtrace_array,
-                         t->num_backtrace_strings);
+       t->num_backtrace_strings);
   dump_backtrace (t);
 #endif
 }
@@ -1218,7 +1090,7 @@ GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
   pending_timeout_last = t;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task: %p\n",
+       "Adding task %p\n",
        t);
   init_backtrace (t);
   return t;
@@ -1238,8 +1110,8 @@ GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
  */
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
-                                            enum GNUNET_SCHEDULER_Priority priority,
-                                            GNUNET_SCHEDULER_TaskCallback task,
+              enum GNUNET_SCHEDULER_Priority priority,
+              GNUNET_SCHEDULER_TaskCallback task,
                                             void *task_cls)
 {
   return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
@@ -1307,12 +1179,12 @@ GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
                               GNUNET_SCHEDULER_TaskCallback task,
-                              void *task_cls)
+                              void *task_cls)
 {
   return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
-                                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                     task,
-                                                     task_cls);
+                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                 task,
+                 task_cls);
 }
 
 
@@ -1333,11 +1205,11 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
  */
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
-                          void *task_cls)
+                          void *task_cls)
 {
   return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO,
-                                       task,
-                                       task_cls);
+                                       task,
+                                       task_cls);
 }
 
 
@@ -1353,7 +1225,7 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
  */
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
-                               void *task_cls)
+                               void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
 
@@ -1370,12 +1242,12 @@ GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
   t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
   t->on_shutdown = GNUNET_YES;
-  t->lifeness = GNUNET_YES;
+  t->lifeness = GNUNET_NO;
   GNUNET_CONTAINER_DLL_insert (shutdown_head,
-                               shutdown_tail,
-                               t);
+                               shutdown_tail,
+                               t);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task: %p\n",
+       "Adding shutdown task %p\n",
        t);
   init_backtrace (t);
   return t;
@@ -1409,6 +1281,33 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 }
 
 
+#if DEBUG_FDS
+/**
+ * check a raw file descriptor and abort if it is bad (for debugging purposes)
+ *
+ * @param t the task related to the file descriptor
+ * @param raw_fd the raw file descriptor to check
+ */
+void
+check_fd (struct GNUNET_SCHEDULER_Task *t, int raw_fd)
+{
+  if (-1 != raw_fd)
+  {
+    int flags = fcntl (raw_fd, F_GETFD);
+
+    if ((flags == -1) && (errno == EBADF))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Got invalid file descriptor %d!\n",
+           raw_fd);
+      init_backtrace (t);
+      GNUNET_assert (0);
+    }
+  }
+}
+#endif
+
+
 /**
  * Schedule a new task to be run with a specified delay or when any of
  * the specified file descriptor sets is ready.  The delay can be used
@@ -1437,9 +1336,11 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 #ifndef MINGW
 static struct GNUNET_SCHEDULER_Task *
 add_without_sets (struct GNUNET_TIME_Relative delay,
-                  enum GNUNET_SCHEDULER_Priority priority,
-                  int rfd,
-                  int wfd,
+                  enum GNUNET_SCHEDULER_Priority priority,
+                  const struct GNUNET_NETWORK_Handle *read_nh,
+                  const struct GNUNET_NETWORK_Handle *write_nh,
+                  const struct GNUNET_DISK_FileHandle *read_fh,
+                  const struct GNUNET_DISK_FileHandle *write_fh,
                   GNUNET_SCHEDULER_TaskCallback task,
                   void *task_cls)
 {
@@ -1448,39 +1349,23 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
   GNUNET_assert (NULL != active_task);
   GNUNET_assert (NULL != task);
   t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+  init_fd_info (t,
+                &read_nh,
+                read_nh ? 1 : 0,
+                &write_nh,
+                write_nh ? 1 : 0,
+                &read_fh,
+                read_fh ? 1 : 0,
+                &write_fh,
+                write_fh ? 1 : 0);
   t->callback = task;
   t->callback_cls = task_cls;
 #if DEBUG_FDS
-  if (-1 != rfd)
-  {
-    int flags = fcntl (rfd, F_GETFD);
-
-    if ((flags == -1) && (errno == EBADF))
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "Got invalid file descriptor %d!\n",
-           rfd);
-      init_backtrace (t);
-      GNUNET_assert (0);
-    }
-  }
-  if (-1 != wfd)
-  {
-    int flags = fcntl (wfd, F_GETFD);
-
-    if (flags == -1 && errno == EBADF)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           "Got invalid file descriptor %d!\n",
-           wfd);
-      init_backtrace (t);
-      GNUNET_assert (0);
-    }
-  }
+  check_fd (t, NULL != read_nh ? GNUNET_NETWORK_get_fd (read_nh) : -1);
+  check_fd (t, NULL != write_nh ? GNUNET_NETWORK_get_fd (write_nh) : -1);
+  check_fd (t, NULL != read_fh ? read_fh->fd : -1);
+  check_fd (t, NULL != write_fh ? write_fh->fd : -1);
 #endif
-  t->read_fd = rfd;
-  GNUNET_assert (wfd >= -1);
-  t->write_fd = wfd;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
@@ -1490,11 +1375,9 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
   GNUNET_CONTAINER_DLL_insert (pending_head,
                                pending_tail,
                                t);
+  driver_add_multiple (t, GNUNET_SCHEDULER_ET_NONE);
   max_priority_added = GNUNET_MAX (max_priority_added,
                                    t->priority);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task %p\n",
-       t);
   init_backtrace (t);
   return t;
 }
@@ -1507,6 +1390,9 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready.  It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param rfd read file-descriptor
@@ -1522,8 +1408,8 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                                void *task_cls)
 {
   return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
-                                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                      rfd, task, task_cls);
+                  GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                  rfd, task, task_cls);
 }
 
 
@@ -1534,6 +1420,9 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  * socket being ready.  The task will be scheduled for execution once
  * either the delay has expired or the socket operation is ready.  It
  * will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param priority priority to use for the task
@@ -1545,9 +1434,9 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  */
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
-                                             enum GNUNET_SCHEDULER_Priority priority,
-                                             struct GNUNET_NETWORK_Handle *rfd,
-                                             GNUNET_SCHEDULER_TaskCallback task,
+               enum GNUNET_SCHEDULER_Priority priority,
+               struct GNUNET_NETWORK_Handle *rfd,
+               GNUNET_SCHEDULER_TaskCallback task,
                                              void *task_cls)
 {
   return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
@@ -1565,6 +1454,9 @@ GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready.  It will be run with the priority of
  * the calling task.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param wfd write file-descriptor
@@ -1592,6 +1484,9 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param priority priority of the task
@@ -1612,6 +1507,9 @@ GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
                                          GNUNET_SCHEDULER_TaskCallback task,
                                          void *task_cls)
 {
+  /* scheduler must be running */
+  GNUNET_assert (NULL != scheduler_driver);
+
 #if MINGW
   struct GNUNET_NETWORK_FDSet *s;
   struct GNUNET_SCHEDULER_Task * ret;
@@ -1627,10 +1525,13 @@ GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
   GNUNET_NETWORK_fdset_destroy (s);
   return ret;
 #else
+  GNUNET_assert (on_read || on_write);
   GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0);
   return add_without_sets (delay, priority,
-                           on_read  ? GNUNET_NETWORK_get_fd (fd) : -1,
-                           on_write ? GNUNET_NETWORK_get_fd (fd) : -1,
+                           on_read  ? fd : NULL,
+                           on_write ? fd : NULL,
+                           NULL,
+                           NULL,
                            task, task_cls);
 #endif
 }
@@ -1642,6 +1543,9 @@ GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready. It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param rfd read file-descriptor
@@ -1668,6 +1572,9 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready. It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param wfd write file-descriptor
@@ -1694,6 +1601,9 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * socket operation is ready.
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param delay when should this operation time out?
  * @param priority priority of the task
@@ -1712,6 +1622,9 @@ GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
                                          int on_read, int on_write,
                                          GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
 {
+  /* scheduler must be running */
+  GNUNET_assert (NULL != scheduler_driver);
+
 #if MINGW
   struct GNUNET_NETWORK_FDSet *s;
   struct GNUNET_SCHEDULER_Task * ret;
@@ -1727,19 +1640,70 @@ GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
   GNUNET_NETWORK_fdset_destroy (s);
   return ret;
 #else
-  int real_fd;
-
-  GNUNET_DISK_internal_file_handle_ (fd, &real_fd, sizeof (int));
-  GNUNET_assert (real_fd >= 0);
-  return add_without_sets (
-      delay, priority,
-      on_read  ? real_fd : -1,
-      on_write ? real_fd : -1,
-      task, task_cls);
+  GNUNET_assert (on_read || on_write);
+  GNUNET_assert (fd->fd >= 0);
+  return add_without_sets (delay, priority,
+                           NULL,
+                           NULL,
+                           on_read ? fd : NULL,
+                           on_write ? fd : NULL,
+                           task, task_cls);
 #endif
 }
 
 
+void
+extract_handles (struct GNUNET_SCHEDULER_Task *t,
+                 const struct GNUNET_NETWORK_FDSet *fdset,
+                 const struct GNUNET_NETWORK_Handle ***ntarget,
+                 unsigned int *extracted_nhandles,
+                 const struct GNUNET_DISK_FileHandle ***ftarget,
+                 unsigned int *extracted_fhandles)
+{
+  // FIXME: this implementation only works for unix, for WIN32 the file handles
+  // in fdset must be handled separately
+  const struct GNUNET_NETWORK_Handle **nhandles;
+  const struct GNUNET_DISK_FileHandle **fhandles;
+  unsigned int nhandles_len, fhandles_len;
+  int sock;
+
+  nhandles = NULL;
+  fhandles = NULL;
+  nhandles_len = 0;
+  fhandles_len = 0;
+  for (sock = 0; sock != fdset->nsds; ++sock)
+  {
+    if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (fdset, sock))
+    {
+      struct GNUNET_NETWORK_Handle *nhandle;
+      struct GNUNET_DISK_FileHandle *fhandle;
+
+      nhandle = GNUNET_NETWORK_socket_box_native (sock);
+      if (NULL != nhandle)
+      {
+        GNUNET_array_append (nhandles, nhandles_len, nhandle);
+      }
+      else
+      {
+        fhandle = GNUNET_DISK_get_handle_from_int_fd (sock);
+        if (NULL != fhandle)
+        {
+          GNUNET_array_append (fhandles, fhandles_len, fhandle);
+        }
+        else
+        {
+          GNUNET_assert (0);
+        }
+      }
+    }
+  }
+  *ntarget = nhandles_len > 0 ? nhandles : NULL;
+  *ftarget = fhandles_len > 0 ? fhandles : NULL;
+  *extracted_nhandles = nhandles_len;
+  *extracted_fhandles = fhandles_len;
+}
+
+
 /**
  * Schedule a new task to be run with a specified delay or when any of
  * the specified file descriptor sets is ready.  The delay can be used
@@ -1755,6 +1719,9 @@ GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
  *     || any-rs-ready
  *     || any-ws-ready) )
  * </code>
+ * Only allowed to be called as long as the scheduler is running
+ * (#GNUNET_SCHEDULER_run or #GNUNET_SCHEDULER_run_with_driver has been
+ * called and has not returned yet).
  *
  * @param prio how important is this task?
  * @param delay how long should we wait?
@@ -1774,13 +1741,20 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                              void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
-
-  if ( (NULL == rs) &&
-       (NULL == ws) )
+  const struct GNUNET_NETWORK_Handle **read_nhandles;
+  const struct GNUNET_NETWORK_Handle **write_nhandles;
+  const struct GNUNET_DISK_FileHandle **read_fhandles;
+  const struct GNUNET_DISK_FileHandle **write_fhandles;
+  unsigned int read_nhandles_len, write_nhandles_len,
+               read_fhandles_len, write_fhandles_len;
+
+  if (((NULL == rs) && (NULL == ws)) || ((0 == rs->nsds) && (0 == ws->nsds)))
     return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
                                                        prio,
                                                        task,
                                                        task_cls);
+  /* scheduler must be running */
+  GNUNET_assert (NULL != scheduler_driver);
   GNUNET_assert (NULL != active_task);
   GNUNET_assert (NULL != task);
   t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
@@ -1788,16 +1762,48 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   t->callback_cls = task_cls;
   t->read_fd = -1;
   t->write_fd = -1;
+  t->own_handles = GNUNET_YES;
+  read_nhandles = NULL;
+  write_nhandles = NULL;
+  read_fhandles = NULL;
+  write_fhandles = NULL;
+  read_nhandles_len = 0;
+  write_nhandles_len = 0;
+  read_fhandles_len = 0;
+  write_fhandles_len = 0;
   if (NULL != rs)
   {
-    t->read_set = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy (t->read_set, rs);
+    extract_handles (t,
+                     rs,
+                     &read_nhandles,
+                     &read_nhandles_len,
+                     &read_fhandles,
+                     &read_fhandles_len);
   }
   if (NULL != ws)
   {
-    t->write_set = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy (t->write_set, ws);
+    extract_handles (t,
+                     ws,
+                     &write_nhandles,
+                     &write_nhandles_len,
+                     &write_fhandles,
+                     &write_fhandles_len);
   }
+  init_fd_info (t,
+                read_nhandles,
+                read_nhandles_len,
+                write_nhandles,
+                write_nhandles_len,
+                read_fhandles,
+                read_fhandles_len,
+                write_fhandles,
+                write_fhandles_len);
+  /* free the arrays of pointers to network / file handles, the actual
+   * handles will be freed in destroy_task */
+  GNUNET_array_grow (read_nhandles, read_nhandles_len, 0);
+  GNUNET_array_grow (write_nhandles, write_nhandles_len, 0);
+  GNUNET_array_grow (read_fhandles, read_fhandles_len, 0);
+  GNUNET_array_grow (write_fhandles, write_fhandles_len, 0);
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
@@ -1810,8 +1816,9 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   GNUNET_CONTAINER_DLL_insert (pending_head,
                                pending_tail,
                                t);
+  driver_add_multiple (t, GNUNET_SCHEDULER_ET_NONE);
   max_priority_added = GNUNET_MAX (max_priority_added,
-                                   t->priority);
+           t->priority);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Adding task %p\n",
        t);
@@ -1822,17 +1829,18 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
 
 /**
  * Function used by event-loop implementations to signal the scheduler
- * that a particular @a task is ready due to an event of type @a et.
+ * that a particular @a task is ready due to an event specified in the
+ * et field of @a fdi.
  *
  * This function will then queue the task to notify the application
  * that the task is ready (with the respective priority).
  *
- * @param task the task that is ready, NULL for wake up calls
- * @param et information about why the task is ready
+ * @param task the task that is ready
+ * @param fdi information about the related FD
  */
 void
 GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
-                             enum GNUNET_SCHEDULER_EventType et)
+                             struct GNUNET_SCHEDULER_FdInfo *fdi)
 {
   enum GNUNET_SCHEDULER_Reason reason;
   struct GNUNET_TIME_Absolute now;
@@ -1842,17 +1850,20 @@ GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
   if (now.abs_value_us >= task->timeout.abs_value_us)
     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
-       (0 != (GNUNET_SCHEDULER_ET_IN & et)) )
+       (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)) )
     reason |= GNUNET_SCHEDULER_REASON_READ_READY;
   if ( (0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
-       (0 != (GNUNET_SCHEDULER_ET_OUT & et)) )
+       (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)) )
     reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
   reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
   task->reason = reason;
-  task->fds = &task->fdx;
-  task->fdx.et = et;
-  task->fds_len = 1;
-  queue_ready_task (task);
+  if (GNUNET_NO == task->in_ready_list)
+  {
+    GNUNET_CONTAINER_DLL_remove (pending_head,
+                                 pending_tail,
+                                 task);
+    queue_ready_task (task);
+  }
 }
 
 
@@ -1862,15 +1873,16 @@ GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
  * there are tasks left to run just to give other tasks a chance as
  * well.  If we return #GNUNET_YES, the driver should call this
  * function again as soon as possible, while if we return #GNUNET_NO
- * it must block until the operating system has more work as the
- * scheduler has no more work to do right now.
+ * it must block until either the operating system has more work (the
+ * scheduler has no more work to do right now) or the timeout set by
+ * the scheduler (using the set_wakeup callback) is reached.
  *
  * @param sh scheduler handle that was given to the `loop`
  * @return #GNUNET_OK if there are more tasks that are ready,
  *          and thus we would like to run more (yield to avoid
  *          blocking other activities for too long)
  *         #GNUNET_NO if we are done running tasks (yield to block)
- *         #GNUNET_SYSERR on error
+ *         #GNUNET_SYSERR on error, e.g. no tasks were ready
  */
 int
 GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
@@ -1894,9 +1906,27 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
       pending_timeout_last = NULL;
     queue_ready_task (pos);
   }
+  pos = pending_head;
+  while (NULL != pos)
+  {
+    struct GNUNET_SCHEDULER_Task *next = pos->next;
+    if (now.abs_value_us >= pos->timeout.abs_value_us)
+    {
+      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+      GNUNET_CONTAINER_DLL_remove (pending_head,
+                                   pending_tail,
+                                   pos);
+      queue_ready_task (pos);
+    }
+    pos = next;
+  }
 
   if (0 == ready_count)
-    return GNUNET_NO;
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "GNUNET_SCHEDULER_run_from_driver was called, but no tasks are ready!\n");
+    return GNUNET_SYSERR;
+  }
 
   /* find out which task priority level we are going to
      process this time */
@@ -1916,49 +1946,74 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
   while (NULL != (pos = ready_head[p]))
   {
     GNUNET_CONTAINER_DLL_remove (ready_head[p],
-                                 ready_tail[p],
-                                 pos);
+         ready_tail[p],
+         pos);
     ready_count--;
     current_priority = pos->priority;
     current_lifeness = pos->lifeness;
     active_task = pos;
 #if PROFILE_DELAYS
     if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
-        DELAY_THRESHOLD.rel_value_us)
+        DELAY_THRESHOLD.rel_value_us)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Task %p took %s to be scheduled\n",
-           pos,
-           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
-                                                   GNUNET_YES));
+           "Task %p took %s to be scheduled\n",
+           pos,
+           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
+                                                   GNUNET_YES));
     }
 #endif
     tc.reason = pos->reason;
     GNUNET_NETWORK_fdset_zero (sh->rs);
     GNUNET_NETWORK_fdset_zero (sh->ws);
+    // FIXME: do we have to remove FdInfos from fds if they are not ready?
     tc.fds_len = pos->fds_len;
     tc.fds = pos->fds;
-    tc.read_ready = (NULL == pos->read_set) ? sh->rs : pos->read_set;
-    if ( (-1 != pos->read_fd) &&
-         (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)) )
-      GNUNET_NETWORK_fdset_set_native (sh->rs,
-                                       pos->read_fd);
-    tc.write_ready = (NULL == pos->write_set) ? sh->ws : pos->write_set;
-    if ((-1 != pos->write_fd) &&
-        (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
-      GNUNET_NETWORK_fdset_set_native (sh->ws,
-                                       pos->write_fd);
+    for (int i = 0; i != pos->fds_len; ++i)
+    {
+      struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i];
+      if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et))
+      {
+        GNUNET_NETWORK_fdset_set_native (sh->rs,
+                                         fdi->sock);
+      }
+      if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et))
+      {
+        GNUNET_NETWORK_fdset_set_native (sh->ws,
+                                         fdi->sock);
+      }
+    }
+    tc.read_ready = sh->rs;
+    tc.write_ready = sh->ws;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Running task: %p\n",
-         pos);
+         "Running task %p\n",
+         pos);
+    GNUNET_assert (NULL != pos->callback);
     pos->callback (pos->callback_cls);
+    if (NULL != pos->fds)
+    {
+      int del_result = scheduler_driver->del (scheduler_driver->cls, pos);
+      if (GNUNET_OK != del_result)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             "driver could not delete task\n");
+        GNUNET_assert (0);
+      }
+    }
     active_task = NULL;
     dump_backtrace (pos);
     destroy_task (pos);
     tasks_run++;
   }
+  shutdown_if_no_lifeness ();
   if (0 == ready_count)
+  {
+    scheduler_driver->set_wakeup (scheduler_driver->cls,
+                                  get_timeout ());
     return GNUNET_NO;
+  }
+  scheduler_driver->set_wakeup (scheduler_driver->cls,
+                                GNUNET_TIME_absolute_get ()); 
   return GNUNET_OK;
 }
 
@@ -1981,8 +2036,8 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
  */
 int
 GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
-                                  GNUNET_SCHEDULER_TaskCallback task,
-                                  void *task_cls)
+                                  GNUNET_SCHEDULER_TaskCallback task,
+                                  void *task_cls)
 {
   int ret;
   struct GNUNET_SIGNAL_Context *shc_int;
@@ -1997,7 +2052,6 @@ GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
 #endif
   struct GNUNET_SCHEDULER_Task tsk;
   const struct GNUNET_DISK_FileHandle *pr;
-  struct GNUNET_SCHEDULER_Handle sh;
 
   /* general set-up */
   GNUNET_assert (NULL == active_task);
@@ -2009,54 +2063,56 @@ GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
   GNUNET_assert (NULL != shutdown_pipe_handle);
   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                 GNUNET_DISK_PIPE_END_READ);
-  GNUNET_assert (NULL != pr);
   my_pid = getpid ();
+  scheduler_driver = driver;
 
   /* install signal handlers */
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Registering signal handlers\n");
   shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
-                                           &sighandler_shutdown);
+             &sighandler_shutdown);
   shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
-                                            &sighandler_shutdown);
+              &sighandler_shutdown);
 #if (SIGTERM != GNUNET_TERM_SIG)
   shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
-                                             &sighandler_shutdown);
+               &sighandler_shutdown);
 #endif
 #ifndef MINGW
   shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
-                                            &sighandler_pipe);
+              &sighandler_pipe);
   shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
-                                            &sighandler_shutdown);
+              &sighandler_shutdown);
   shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
-                                           &sighandler_shutdown);
+             &sighandler_shutdown);
 #endif
 
   /* Setup initial tasks */
   current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
-  current_lifeness = GNUNET_YES;
+  current_lifeness = GNUNET_NO;
   memset (&tsk,
-          0,
-          sizeof (tsk));
+    0,
+    sizeof (tsk));
   active_task = &tsk;
-  tsk.sh = &sh;
+  GNUNET_SCHEDULER_add_now (&GNUNET_OS_install_parent_control_handler,
+                            NULL);
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                  pr,
+                                  &shutdown_cb,
+                                  NULL);
+  current_lifeness = GNUNET_YES;
   GNUNET_SCHEDULER_add_with_reason_and_priority (task,
                                                  task_cls,
                                                  GNUNET_SCHEDULER_REASON_STARTUP,
                                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
-  GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
-                                          &GNUNET_OS_install_parent_control_handler,
-                                          NULL);
   active_task = NULL;
-  driver->set_wakeup (driver->cls,
-                      GNUNET_TIME_absolute_get ());
-
+  scheduler_driver->set_wakeup (scheduler_driver->cls,
+                                get_timeout ());
   /* begin main event loop */
   sh.rs = GNUNET_NETWORK_fdset_create ();
   sh.ws = GNUNET_NETWORK_fdset_create ();
-  sh.driver = driver;
+  GNUNET_NETWORK_fdset_handle_set (sh.rs, pr);
   ret = driver->loop (driver->cls,
-                      &sh);
+                      &sh);
   GNUNET_NETWORK_fdset_destroy (sh.rs);
   GNUNET_NETWORK_fdset_destroy (sh.ws);
 
@@ -2073,20 +2129,215 @@ GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
 #endif
   GNUNET_DISK_pipe_close (shutdown_pipe_handle);
   shutdown_pipe_handle = NULL;
+  scheduler_driver = NULL;
   return ret;
 }
 
 
+int
+select_add (void *cls,
+            struct GNUNET_SCHEDULER_Task *task,
+            struct GNUNET_SCHEDULER_FdInfo *fdi)
+{
+  struct DriverContext *context = cls;
+  GNUNET_assert (NULL != context);
+  GNUNET_assert (NULL != task);
+  GNUNET_assert (NULL != fdi);
+  GNUNET_assert (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) ||
+                 0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et));
+
+  if (!((NULL != fdi->fd) ^ (NULL != fdi->fh)) || (fdi->sock < 0))
+  {
+    /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */
+    return GNUNET_SYSERR;
+  }
+
+  struct Scheduled *scheduled = GNUNET_new (struct Scheduled);
+  scheduled->task = task;
+  scheduled->fdi = fdi;
+  scheduled->et = fdi->et;
+
+  GNUNET_CONTAINER_DLL_insert (context->scheduled_head,
+                               context->scheduled_tail,
+                               scheduled);
+  return GNUNET_OK;
+}
+
+
+int
+select_del (void *cls,
+            struct GNUNET_SCHEDULER_Task *task)
+{
+  struct DriverContext *context;
+  struct Scheduled *pos;
+  int ret;
+
+  GNUNET_assert (NULL != cls);
+
+  context = cls;
+  ret = GNUNET_SYSERR;
+  pos = context->scheduled_head;
+  while (NULL != pos)
+  {
+    struct Scheduled *next = pos->next;
+    if (pos->task == task)
+    {
+      GNUNET_CONTAINER_DLL_remove (context->scheduled_head,
+                                   context->scheduled_tail,
+                                   pos);
+      GNUNET_free (pos);
+      ret = GNUNET_OK;
+    }
+    pos = next;
+  }
+  return ret;
+}
+
+
+int
+select_loop (void *cls,
+             struct GNUNET_SCHEDULER_Handle *sh)
+{
+  struct GNUNET_NETWORK_FDSet *rs;
+  struct GNUNET_NETWORK_FDSet *ws;
+  struct DriverContext *context;
+  int select_result;
+  int tasks_ready;
+ 
+  context = cls;
+  GNUNET_assert (NULL != context);
+  rs = GNUNET_NETWORK_fdset_create ();
+  ws = GNUNET_NETWORK_fdset_create ();
+  tasks_ready = GNUNET_NO;
+  while (NULL != context->scheduled_head ||
+         GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != context->timeout.rel_value_us)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "select timeout = %s\n",
+         GNUNET_STRINGS_relative_time_to_string (context->timeout, GNUNET_NO));
+
+    GNUNET_NETWORK_fdset_zero (rs);
+    GNUNET_NETWORK_fdset_zero (ws);
+    struct Scheduled *pos;
+    for (pos = context->scheduled_head; NULL != pos; pos = pos->next)
+    {
+      if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et))
+      {
+        GNUNET_NETWORK_fdset_set_native (rs, pos->fdi->sock);
+      }
+      if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et))
+      {
+        GNUNET_NETWORK_fdset_set_native (ws, pos->fdi->sock);
+      }
+    }
+    if (NULL == scheduler_select)
+    {
+      select_result = GNUNET_NETWORK_socket_select (rs,
+                                                    ws,
+                                                    NULL,
+                                                    context->timeout);
+    }
+    else
+    {
+      select_result = scheduler_select (scheduler_select_cls,
+                                        rs,
+                                        ws,
+                                        NULL,
+                                        context->timeout);
+    }
+    if (select_result == GNUNET_SYSERR)
+    {
+      if (errno == EINTR)
+        continue;
+
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
+#ifndef MINGW
+#if USE_LSOF
+      char lsof[512];
+
+      snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
+      (void) close (1);
+      (void) dup2 (2, 1);
+      if (0 != system (lsof))
+        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+                      "system");
+#endif
+#endif
+#if DEBUG_FDS
+      struct Scheduled *s;
+      for (s = context->scheduled_head; NULL != s; s = s->next)
+      {
+        int flags = fcntl (s->fdi->sock, F_GETFD);
+        if ((flags == -1) && (errno == EBADF))
+        {
+          LOG (GNUNET_ERROR_TYPE_ERROR,
+               "Got invalid file descriptor %d!\n",
+               s->fdi->sock);
+        }
+      }
+#endif
+      GNUNET_assert (0);
+      GNUNET_NETWORK_fdset_destroy (rs);
+      GNUNET_NETWORK_fdset_destroy (ws);
+      return GNUNET_SYSERR;
+    }
+    for (pos = context->scheduled_head; NULL != pos; pos = pos->next)
+    {
+      int is_ready = GNUNET_NO;
+      if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) &&
+          GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, pos->fdi->sock))
+      {
+        pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
+        is_ready = GNUNET_YES;
+      }
+      if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) &&
+          GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, pos->fdi->sock))
+      {
+        pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
+        is_ready = GNUNET_YES;
+      }
+      if (GNUNET_YES == is_ready)
+      {
+        GNUNET_SCHEDULER_task_ready (pos->task, pos->fdi);
+      }
+    }
+    tasks_ready = GNUNET_SCHEDULER_run_from_driver (sh);
+    GNUNET_assert (GNUNET_SYSERR != tasks_ready);
+  }
+  GNUNET_NETWORK_fdset_destroy (rs);
+  GNUNET_NETWORK_fdset_destroy (ws);
+  return GNUNET_OK; 
+}
+
+
+void
+select_set_wakeup(void *cls,
+                  struct GNUNET_TIME_Absolute dt)
+{
+  struct DriverContext *context = cls;
+  GNUNET_assert (NULL != context);
+ 
+  context->timeout = GNUNET_TIME_absolute_get_remaining (dt);
+}
+
+
 /**
  * Obtain the driver for using select() as the event loop.
  *
  * @return NULL on error
  */
-const struct GNUNET_SCHEDULER_Driver *
+struct GNUNET_SCHEDULER_Driver *
 GNUNET_SCHEDULER_driver_select ()
 {
-  GNUNET_break (0); // not implemented
-  return NULL;
+  struct GNUNET_SCHEDULER_Driver *select_driver;
+  select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver);
+
+  select_driver->loop = &select_loop;
+  select_driver->add = &select_add;
+  select_driver->del = &select_del;
+  select_driver->set_wakeup = &select_set_wakeup;
+
+  return select_driver;
 }
 
 
diff --git a/src/util/service.c b/src/util/service.c
index fcdf45a51..b4eb33caa 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -1932,6 +1932,11 @@ do_send (void *cls)
   size_t left;
   const char *buf;
 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "service: sending message with type %u",
+       ntohs(client->msg->type));
+
+
   client->send_task = NULL;
   buf = (const char *) client->msg;
   left = ntohs (client->msg->size) - client->msg_pos;
@@ -1941,6 +1946,8 @@ do_send (void *cls)
   GNUNET_assert (ret <= (ssize_t) left);
   if (0 == ret)
   {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "no data send");
     GNUNET_MQ_inject_error (client->mq,
                             GNUNET_MQ_ERROR_WRITE);
     return;
@@ -1958,6 +1965,9 @@ do_send (void *cls)
       if (EPIPE != errno)
         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                              "send");
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "socket send returned with error code %i",
+           errno);
       GNUNET_MQ_inject_error (client->mq,
                               GNUNET_MQ_ERROR_WRITE);
       return;
@@ -2402,7 +2412,7 @@ resume_client_receive (void *cls)
                          GNUNET_YES);
   if (GNUNET_SYSERR == ret)
   {
-    if (NULL != c->drop_task)
+    if (NULL == c->drop_task)
       GNUNET_SERVICE_client_drop (c);
     return;
   }
@@ -2431,6 +2441,7 @@ resume_client_receive (void *cls)
 void
 GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
 {
+  GNUNET_assert (NULL == c->drop_task);
   GNUNET_assert (GNUNET_YES == c->needs_continue);
   GNUNET_assert (NULL == c->recv_task);
   c->needs_continue = GNUNET_NO;
@@ -2513,6 +2524,24 @@ GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
 {
   struct GNUNET_SERVICE_Handle *sh = c->sh;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client dropped: %p (MQ: %p)\n",
+              c,
+              c->mq);
+
+#if EXECINFO
+  void *backtrace_array[MAX_TRACE_DEPTH];
+  int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
+    char **backtrace_strings =
+        backtrace_symbols (backtrace_array,
+         t->num_backtrace_strings);
+    for (unsigned int i = 0; i < num_backtrace_strings; i++)
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+     "client drop trace %u: %s\n",
+     i,
+     backtrace_strings[i]);
+#endif
+
   if (NULL != c->drop_task)
   {
     /* asked to drop twice! */
diff --git a/src/util/time.c b/src/util/time.c
index 19100ac36..5ffb19ec1 100644
--- a/src/util/time.c
+++ b/src/util/time.c
@@ -693,7 +693,7 @@ GNUNET_TIME_year_to_time (unsigned int year)
   }
   t.tm_year = year - 1900;
   t.tm_mday = 1;
-  t.tm_mon = 1;
+  t.tm_mon = 0;
   t.tm_wday = 1;
   t.tm_yday = 1;
   tp = mktime (&t);
diff --git a/src/vpn/gnunet-service-vpn.c b/src/vpn/gnunet-service-vpn.c
index d9daaa7e2..bdc638176 100644
--- a/src/vpn/gnunet-service-vpn.c
+++ b/src/vpn/gnunet-service-vpn.c
@@ -2218,6 +2218,9 @@ route_packet (struct DestinationEntry *destination,
  *
  * @param cls closure, NULL
  * @param message message we got from the client (VPN channel interface)
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
 message_token (void *cls,