185 files changed, 14912 insertions, 4254 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index d8a869acb..564923e28 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -45,6 +45,10 @@ if HAVE_POSTGRESQL
  POSTGRES_DIR = pq
 endif
 
+if HAVE_NOLIBGCRYPT19
+  SCALARPRODUCT_DIR = scalarproduct
+endif
+
 REST_DIR = rest
 
 
@@ -93,7 +97,7 @@ SUBDIRS = \
   seti \
   setu \
   consensus \
-  scalarproduct \
+  $(SCALARPRODUCT_DIR) \
   revocation \
   vpn \
   gns \
diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index 899b6f152..2ec913a0a 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -951,7 +951,8 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
    * 2) We're not connected to ARM.
    *    Cancel any reconnection attempts temporarily, then perform
    *    a service test.
-   */if (GNUNET_YES == h->currently_up)
+   */
+  if (GNUNET_YES == h->currently_up)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "ARM is already running\n");
@@ -970,7 +971,8 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
      yet complete the MQ handshake.  However, given that users
      are unlikely to hammer 'gnunet-arm -s' on a busy system,
      the above check should catch 99.99% of the cases where ARM
-     is already running. */LOG (GNUNET_ERROR_TYPE_DEBUG,
+     is already running. */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Starting ARM service\n");
   if (NULL == (sig = GNUNET_DISK_pipe (GNUNET_DISK_PF_NONE)))
   {
@@ -1003,13 +1005,13 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
                                                 op->rfd,
                                                 &notify_starting,
                                                 op);
+    GNUNET_DISK_pipe_close (sig);
   }
   else
   {
     op->async = GNUNET_SCHEDULER_add_now (&notify_starting,
                                           op);
   }
-  GNUNET_DISK_pipe_close (sig);
   return op;
 }
 
diff --git a/src/ats-tests/Makefile.am b/src/ats-tests/Makefile.am
index cc30f660a..00a312a72 100644
--- a/src/ats-tests/Makefile.am
+++ b/src/ats-tests/Makefile.am
@@ -41,6 +41,7 @@ libgnunetatstesting_la_SOURCES = \
   ats-testing-experiment.c ats-testing-preferences.c
 libgnunetatstesting_la_LIBADD = \
   $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
   $(top_builddir)/src/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/core/libgnunetcore.la \
   $(top_builddir)/src/transport/libgnunettransport.la \
diff --git a/src/block/block.c b/src/block/block.c
index 5abe64e69..975c0f747 100644
--- a/src/block/block.c
+++ b/src/block/block.c
@@ -134,10 +134,11 @@ GNUNET_BLOCK_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg)
 
   ctx = GNUNET_new (struct GNUNET_BLOCK_Context);
   ctx->cfg = cfg;
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_block_",
-                          (void *) cfg,
-                          &add_plugin,
-                          ctx);
+  GNUNET_PLUGIN_load_all_in_context (GNUNET_OS_project_data_default (),
+                                     "libgnunet_plugin_block_",
+                                     (void *) cfg,
+                                     &add_plugin,
+                                     ctx);
   return ctx;
 }
 
diff --git a/src/cadet/gnunet-service-cadet.c b/src/cadet/gnunet-service-cadet.c
index 2d3b548dd..c8d69e43d 100644
--- a/src/cadet/gnunet-service-cadet.c
+++ b/src/cadet/gnunet-service-cadet.c
@@ -1027,7 +1027,8 @@ handle_drop_message (void *cls,
   ch = lookup_channel (c,
                        message->ccn);
 
-  GCCH_assign_type_to_drop (ch, message);
+  if (NULL != ch)
+    GCCH_assign_type_to_drop (ch, message);
 
   GNUNET_SERVICE_client_continue (c->client);
 }
diff --git a/src/cadet/gnunet-service-cadet_channel.c b/src/cadet/gnunet-service-cadet_channel.c
index 6b22ae2b4..ae5d9210f 100644
--- a/src/cadet/gnunet-service-cadet_channel.c
+++ b/src/cadet/gnunet-service-cadet_channel.c
@@ -1858,6 +1858,7 @@ GCCH_handle_local_data (struct CadetChannel *ch,
     }
     else
     {
+      GNUNET_free (env);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
diff --git a/src/datacache/datacache.c b/src/datacache/datacache.c
index 1ae228b86..5fc5a7481 100644
--- a/src/datacache/datacache.c
+++ b/src/datacache/datacache.c
@@ -138,6 +138,7 @@ GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
   struct GNUNET_DATACACHE_Handle *ret;
   char *libname;
   char *name;
+  const struct GNUNET_OS_ProjectData *pd;
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_size (cfg, section, "QUOTA", &quota))
@@ -190,14 +191,25 @@ GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_asprintf (&libname, "libgnunet_plugin_datacache_%s", name);
   ret->short_name = name;
   ret->lib_name = libname;
+  /* Load the plugin within GNUnet's default context */
+  pd = GNUNET_OS_project_data_get ();
+  GNUNET_OS_init(GNUNET_OS_project_data_default ());
   ret->api = GNUNET_PLUGIN_load (libname, &ret->env);
-  if (ret->api == NULL)
+  GNUNET_OS_init(pd);
+  if (NULL == ret->api)
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Failed to load datacache plugin for `%s'\n"),
-         name);
-    GNUNET_DATACACHE_destroy (ret);
-    return NULL;
+    /* Try to load the plugin within the application's context
+       This normally happens when the application is not GNUnet itself but a
+       third party; inside GNUnet this is effectively a double failure. */
+    ret->api = GNUNET_PLUGIN_load (libname, &ret->env);
+    if (NULL == ret->api)
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Failed to load datacache plugin for `%s'\n"),
+           name);
+      GNUNET_DATACACHE_destroy (ret);
+      return NULL;
+    }
   }
   return ret;
 }
diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am
index 9f03311e1..3aaa734f2 100644
--- a/src/gns/Makefile.am
+++ b/src/gns/Makefile.am
@@ -80,9 +80,7 @@ bin_PROGRAMS = \
 noinst_PROGRAMS = \
   gnunet-gns-benchmark
 
-if LINUX
 bin_PROGRAMS += gnunet-bcd
-endif
 
 REST_PLUGIN = libgnunet_plugin_rest_gns.la
 
@@ -156,6 +154,7 @@ gnunet_bcd_SOURCES = \
  gnunet-bcd.c
 gnunet_bcd_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
   $(GN_LIBINTL) $(MHD_LIBS)
 gnunet_bcd_CFLAGS = $(MHD_CFLAGS) $(AM_CFLAGS)
 
diff --git a/src/gns/gns.conf.in b/src/gns/gns.conf.in
index 829a52d63..a458f69a2 100644
--- a/src/gns/gns.conf.in
+++ b/src/gns/gns.conf.in
@@ -25,8 +25,7 @@ INTERCEPT_DNS = NO
 # PREFIX = valgrind --leak-check=full --track-origins=yes
 
 # Zones
-.pin = DWJASSPE33MRN8T6Q0PENRNBTQY0E6ZYGTRCDP5DGPBF2CRJMJEG
-#.fr = TFDAXBXMAN40MCG4E8Y9Y1C6D16JCMDPH2VMD30KMB92SECEMYGG
+.pin = 000G001MF6DVMZZ4Y8XRZQDXM1PB3D3VGEK29ZHXBA57EPSNW1QBPKT8J0
 
 [gns-proxy]
 BINARY = gnunet-gns-proxy
diff --git a/src/gns/gnunet-bcd.c b/src/gns/gnunet-bcd.c
index f71f477ef..a2e94089c 100644
--- a/src/gns/gnunet-bcd.c
+++ b/src/gns/gnunet-bcd.c
@@ -27,6 +27,7 @@
 #include "platform.h"
 #include <microhttpd.h>
 #include "gnunet_util_lib.h"
+#include "gnunet_identity_service.h"
 #include "gnunet_mhd_compat.h"
 
 /**
@@ -148,7 +149,7 @@ access_handler_callback (void *cls,
     char *p;
     char *tmp;
     char *deffile;
-    struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+    struct GNUNET_IDENTITY_PublicKey pub;
     size_t slen;
     FILE *f;
     struct stat st;
@@ -166,9 +167,8 @@ access_handler_callback (void *cls,
       MHD_lookup_connection_value (connection, MHD_GET_ARGUMENT_KIND, "gnskey");
     if ((NULL == gnskey) ||
         (GNUNET_OK !=
-         GNUNET_CRYPTO_ecdsa_public_key_from_string (gnskey,
-                                                     strlen (gnskey),
-                                                     &pub)))
+         GNUNET_IDENTITY_public_key_from_string (gnskey,
+                                                 &pub)))
     {
       return MHD_queue_response (connection,
                                  MHD_HTTP_OK,
@@ -218,10 +218,10 @@ access_handler_callback (void *cls,
              (NULL == gns_nick) ? "" : gns_nick);
     fclose (f);
     GNUNET_asprintf (
-      &p,
-      "cd %s; cp %s gns-bcd.tex | pdflatex --enable-write18 gns-bcd.tex > /dev/null 2> /dev/null",
-      tmp,
-      resfile);
+                     &p,
+                     "cd %s; cp %s gns-bcd.tex | pdflatex --enable-write18 gns-bcd.tex > /dev/null 2> /dev/null",
+                     tmp,
+                     resfile);
     GNUNET_free (deffile);
     ret = system (p);
     if (WIFSIGNALED (ret) || (0 != WEXITSTATUS (ret)))
@@ -506,7 +506,7 @@ main (int argc, char *const *argv)
                                  "port",
                                  "PORT",
                                  gettext_noop (
-                                   "Run HTTP serve on port PORT (default is 8888)"),
+                                               "Run HTTP serve on port PORT (default is 8888)"),
                                  &port),
     GNUNET_GETOPT_OPTION_END
   };
@@ -523,8 +523,8 @@ main (int argc, char *const *argv)
                              options,
                              &run,
                              NULL))
-        ? 0
-        : 1;
+    ? 0
+    : 1;
   GNUNET_free_nz ((void *) argv);
   return ret;
 }
diff --git a/src/gns/gnunet-dns2gns.c b/src/gns/gnunet-dns2gns.c
index 0a9b7c861..06f4c9841 100644
--- a/src/gns/gnunet-dns2gns.c
+++ b/src/gns/gnunet-dns2gns.c
@@ -309,6 +309,14 @@ dns_result_processor (void *cls,
   }
   request->packet = GNUNET_DNSPARSER_parse ((char *) dns,
                                             r);
+  if (NULL == request->packet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to parse DNS response!\n"));
+    GNUNET_SCHEDULER_cancel (request->timeout_task);
+    do_timeout (request);
+    return;
+  }
   GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup);
   send_response (request);
 }
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 833a8da01..d02f0f576 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -1841,6 +1841,7 @@ create_response (void *cls,
   char *curlurl;
   char ipstring[INET6_ADDRSTRLEN];
   char ipaddr[INET6_ADDRSTRLEN + 2];
+  char *curl_hosts;
   const struct sockaddr *sa;
   const struct sockaddr_in *s4;
   const struct sockaddr_in6 *s6;
@@ -1900,6 +1901,14 @@ create_response (void *cls,
         GNUNET_break (0);
         return MHD_NO;
       }
+      GNUNET_asprintf (&curl_hosts,
+                       "%s:%d:%s",
+                       s5r->leho,
+                       port,
+                       ipaddr);
+      s5r->hosts = curl_slist_append (NULL,
+                                      curl_hosts);
+      GNUNET_free (curl_hosts);
     }
     else
     {
@@ -1949,21 +1958,13 @@ create_response (void *cls,
      * Pre-populate cache to resolve Hostname.
      * This is necessary as the DNS name in the CURLOPT_URL is used
      * for SNI http://de.wikipedia.org/wiki/Server_Name_Indication
-     */if (NULL != s5r->leho)
+     */
+    if ((NULL != s5r->leho) &&
+        (NULL != s5r->hosts))
     {
-      char *curl_hosts;
-
-      GNUNET_asprintf (&curl_hosts,
-                       "%s:%d:%s",
-                       s5r->leho,
-                       port,
-                       ipaddr);
-      s5r->hosts = curl_slist_append (NULL,
-                                      curl_hosts);
       curl_easy_setopt (s5r->curl,
                         CURLOPT_RESOLVE,
                         s5r->hosts);
-      GNUNET_free (curl_hosts);
     }
     if (s5r->is_gns)
     {
diff --git a/src/gns/gnunet-service-gns_interceptor.c b/src/gns/gnunet-service-gns_interceptor.c
index b53f4af6b..255f85598 100644
--- a/src/gns/gnunet-service-gns_interceptor.c
+++ b/src/gns/gnunet-service-gns_interceptor.c
@@ -323,7 +323,6 @@ handle_dns_request (void *cls,
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Received malformed DNS packet, leaving it untouched.\n");
     GNUNET_DNS_request_forward (rh);
-    GNUNET_DNSPARSER_free_packet (p);
     return;
   }
 
diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c
index 49c1b340a..2f8a55804 100644
--- a/src/gns/gnunet-service-gns_resolver.c
+++ b/src/gns/gnunet-service-gns_resolver.c
@@ -764,6 +764,7 @@ transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
       rd[i].data = pos->data;
       rd[i].data_size = pos->data_size;
       rd[i].record_type = pos->record_type;
+      rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
       /**
        * If this is a LEHO, we added this before. It must be a supplemental
        * record #LSD0001
@@ -772,12 +773,11 @@ transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
         rd[i].flags |= GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
       if (0 == pos->expiration_time)
       {
-        rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+        rd[i].flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
         rd[i].expiration_time = 0;
       }
       else
       {
-        rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
         rd[i].expiration_time = pos->expiration_time;
       }
       i++;
@@ -1764,6 +1764,8 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
       /**
        * Records other than GNS2DNS not allowed
        */
+      if (NULL != ns)
+        GNUNET_free (ns);
       return GNUNET_SYSERR;
     }
     off = 0;
@@ -1771,15 +1773,22 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
                                      rd[i].data_size,
                                      &off);
     ip = GNUNET_strdup (&((const char *) rd[i].data)[off]);
+    if ((NULL == n) ||
+        (NULL == ip))
+    {
+      GNUNET_break_op (0);
+      if (NULL != n)
+        GNUNET_free (n);
+      if (NULL != ip)
+        GNUNET_free (ip);
+      continue;
+    }
+
     off += strlen (ip) + 1;
 
-    if ((NULL == n) ||
-        (NULL == ip) ||
-        (off != rd[i].data_size))
+    if (off != rd[i].data_size)
     {
       GNUNET_break_op (0);
-      GNUNET_free (n);
-      GNUNET_free (ip);
       continue;
     }
     /* resolve 'ip' to determine the IP(s) of the DNS
@@ -1909,6 +1918,8 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                   _ ("Name `%s' cannot be converted to IDNA."),
                   tmp);
+      GNUNET_free (tmp);
+      GNUNET_free (ac);
       return GNUNET_SYSERR;
     }
     GNUNET_free (tmp);
@@ -1922,6 +1933,8 @@ recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh,
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _ ("GNS lookup resulted in DNS name that is too long (`%s')\n"),
                 ac->label);
+    GNUNET_free (ac->label);
+    GNUNET_free (ac);
     return GNUNET_SYSERR;
   }
   continue_with_gns2dns (ac);
diff --git a/src/gns/plugin_rest_gns.c b/src/gns/plugin_rest_gns.c
index 2ccb5be2b..3a35c9999 100644
--- a/src/gns/plugin_rest_gns.c
+++ b/src/gns/plugin_rest_gns.c
@@ -270,7 +270,9 @@ handle_gns_response (void *cls,
   result = json_dumps (result_obj, 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result);
   resp = GNUNET_REST_create_response (result);
-  MHD_add_response_header (resp, "Content-Type", "application/json");
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Content-Type",
+                                                    "application/json"));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free (result);
   json_decref (result_obj);
diff --git a/src/gnsrecord/gnsrecord.c b/src/gnsrecord/gnsrecord.c
index 8d5a6d95b..31749a629 100644
--- a/src/gnsrecord/gnsrecord.c
+++ b/src/gnsrecord/gnsrecord.c
@@ -102,15 +102,12 @@ init ()
   if (1 == once)
     return;
   once = 1;
-  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
-  const struct GNUNET_OS_ProjectData *dpd = GNUNET_OS_project_data_default ();
 
-  if (pd != dpd)
-    GNUNET_OS_init (dpd);
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_gnsrecord_", NULL,
-                          &add_plugin, NULL);
-  if (pd != dpd)
-    GNUNET_OS_init (pd);
+  GNUNET_PLUGIN_load_all_in_context (GNUNET_OS_project_data_default (),
+                                     "libgnunet_plugin_gnsrecord_",
+                                     NULL,
+                                     &add_plugin,
+                                     NULL);
 }
 
 
diff --git a/src/gnsrecord/gnsrecord_misc.c b/src/gnsrecord/gnsrecord_misc.c
index 82c38f19a..b907eed27 100644
--- a/src/gnsrecord/gnsrecord_misc.c
+++ b/src/gnsrecord/gnsrecord_misc.c
@@ -296,15 +296,20 @@ GNUNET_GNSRECORD_data_from_identity (const struct
                                      size_t *data_size,
                                      uint32_t *type)
 {
+  char *tmp;
   *type = ntohl (key->type);
   *data_size = GNUNET_IDENTITY_key_get_length (key);
   if (0 == *data_size)
     return GNUNET_SYSERR;
-  *data = GNUNET_malloc (*data_size);
-  return (GNUNET_IDENTITY_write_key_to_buffer (key, *data, *data_size) ==
-          *data_size?
-          GNUNET_OK :
-          GNUNET_SYSERR);
+  tmp = GNUNET_malloc (*data_size);
+  if (GNUNET_IDENTITY_write_key_to_buffer (key, tmp, *data_size)
+      != *data_size) {
+    GNUNET_free (tmp);
+    *data_size = 0;
+    return GNUNET_SYSERR;
+  }
+  *data = tmp;
+  return GNUNET_OK;
 }
 
 
@@ -350,7 +355,7 @@ GNUNET_GNSRECORD_block_get_expiration (const struct
   case GNUNET_GNSRECORD_TYPE_PKEY:
     return GNUNET_TIME_absolute_ntoh (block->ecdsa_block.expiration_time);
   default:
-    return GNUNET_TIME_absolute_get_zero_ ();
+    GNUNET_break (0); /* Hopefully we never get here, but we might */
   }
   return GNUNET_TIME_absolute_get_zero_ ();
 
diff --git a/src/gnsrecord/gnunet-gnsrecord-tvg.c b/src/gnsrecord/gnunet-gnsrecord-tvg.c
index 47b13bdab..d6b35544c 100644
--- a/src/gnsrecord/gnunet-gnsrecord-tvg.c
+++ b/src/gnsrecord/gnunet-gnsrecord-tvg.c
@@ -172,7 +172,7 @@ run (void *cls,
   fprintf (stdout, "RRBLOCK:\n");
   print_bytes (rrblock, block_size, 8);
   fprintf (stdout, "\n");
-
+  GNUNET_free (rdata);
 }
 
 
diff --git a/src/hello/hello-ng.c b/src/hello/hello-ng.c
index 85b304e18..96856a692 100644
--- a/src/hello/hello-ng.c
+++ b/src/hello/hello-ng.c
@@ -30,6 +30,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_ats_service.h"
 
+GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * Binary block we sign when we sign an address.
  */
@@ -48,9 +49,9 @@ struct SignedAddress
   /**
    * Hash of the address.
    */
-  struct GNUNET_HashCode h_addr;
+  struct GNUNET_HashCode addr_hash GNUNET_PACKED;
 };
-
+GNUNET_NETWORK_STRUCT_END
 
 /**
  * Build address record by signing raw information with private key.
@@ -78,7 +79,7 @@ GNUNET_HELLO_sign_address (
   sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
   sa.purpose.size = htonl (sizeof(sa));
   sa.mono_time = GNUNET_TIME_absolute_hton (mono_time);
-  GNUNET_CRYPTO_hash (address, strlen (address), &sa.h_addr);
+  GNUNET_CRYPTO_hash (address, strlen (address), &sa.addr_hash);
   GNUNET_CRYPTO_eddsa_sign (private_key, &sa, &sig);
   sig_str = NULL;
   (void) GNUNET_STRINGS_base64_encode (&sig, sizeof(sig), &sig_str);
@@ -161,7 +162,7 @@ GNUNET_HELLO_extract_address (const void *raw,
   sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
   sa.purpose.size = htonl (sizeof(sa));
   sa.mono_time = GNUNET_TIME_absolute_hton (raw_mono_time);
-  GNUNET_CRYPTO_hash (raw_addr, strlen (raw_addr), &sa.h_addr);
+  GNUNET_CRYPTO_hash (raw_addr, strlen (raw_addr), &sa.addr_hash);
   if (GNUNET_YES !=
       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS,
                                   &sa,
diff --git a/src/hello/test_hello-ng.c b/src/hello/test_hello-ng.c
index 82b1ab6c6..e6b1d42a0 100644
--- a/src/hello/test_hello-ng.c
+++ b/src/hello/test_hello-ng.c
@@ -26,7 +26,7 @@ main (int argc,
                              (void**)&res,
                              &res_len);
   GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-              "%s", res);
+              "%s\n", res);
   GNUNET_assert (NULL !=
                  GNUNET_HELLO_extract_address ((void**)res,
                                                res_len,
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index 5569c87ed..faef696a7 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -53,6 +53,7 @@ gnunetinclude_HEADERS = \
   gnunet_gnsrecord_lib.h \
   gnunet_gnsrecord_json_lib.h \
   gnunet_gnsrecord_plugin.h \
+  gnu_name_system_record_types.h \
   gnunet_hello_lib.h \
   gnunet_helper_lib.h \
   gnunet_identity_service.h \
@@ -112,7 +113,9 @@ gnunetinclude_HEADERS = \
   gnunet_strings_lib.h \
   gnunet_testbed_service.h \
   gnunet_testbed_logger_service.h \
+  gnunet_testbed_ng_service.h \
   gnunet_testing_lib.h \
+  gnunet_testing_ng_lib.h \
   gnunet_time_lib.h \
   gnunet_transport_service.h \
   gnunet_transport_application_service.h \
diff --git a/src/include/gnu_name_system_record_types.h b/src/include/gnu_name_system_record_types.h
new file mode 100644
index 000000000..b2cf45dc8
--- /dev/null
+++ b/src/include/gnu_name_system_record_types.h
@@ -0,0 +1,138 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2012-2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+#ifndef GNU_NAME_SYSTEM_RECORD_TYPES_H
+#define GNU_NAME_SYSTEM_RECORD_TYPES_H
+
+/**
+ * WARNING:
+ * This header is generated!
+ * In order to add GNS record types, you must register
+ * them in GANA, and then use the header generation script
+ * to create an update of this file. You may then replace this
+ * file with the update.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0 /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * GNS zone transfer
+ */
+#define GNUNET_GNSRECORD_TYPE_PKEY 65536
+
+/**
+ * GNS nick names
+ */
+#define GNUNET_GNSRECORD_TYPE_NICK 65537
+
+/**
+ * legacy hostnames
+ */
+#define GNUNET_GNSRECORD_TYPE_LEHO 65538
+
+/**
+ * VPN resolution
+ */
+#define GNUNET_GNSRECORD_TYPE_VPN 65539
+
+/**
+ * Delegation to DNS
+ */
+#define GNUNET_GNSRECORD_TYPE_GNS2DNS 65540
+
+/**
+ * Boxed records (see TLSA/SRV handling in GNS)
+ */
+#define GNUNET_GNSRECORD_TYPE_BOX 65541
+
+/**
+ * social place for SecuShare
+ */
+#define GNUNET_GNSRECORD_TYPE_PLACE 65542
+
+/**
+ * Endpoint for conversation
+ */
+#define GNUNET_GNSRECORD_TYPE_PHONE 65543
+
+/**
+ * identity attribute
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE 65544
+
+/**
+ * local ticket reference
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET 65545
+
+/**
+ * For ABD policies
+ */
+#define GNUNET_GNSRECORD_TYPE_DELEGATE 65548
+
+/**
+ * For ABD reverse lookups
+ */
+#define GNUNET_GNSRECORD_TYPE_ATTRIBUTE 65549
+
+/**
+ * for reclaim records
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF 65550
+
+/**
+ * For reclaim OIDC client names.
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_CLIENT 65552
+
+/**
+ * Used reclaimID OIDC client redirect URIs.
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT 65553
+
+/**
+ * Record type for an attribute attestation (e.g. JWT).
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL 65554
+
+/**
+ * Record type for a presentation of a credential.
+ */
+#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION 65555
+
+/**
+ * Record type for EDKEY zone delegations.
+ */
+#define GNUNET_GNSRECORD_TYPE_EDKEY 65556
+
+
+#if 0 /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/include/gnunet_gnsrecord_lib.h b/src/include/gnunet_gnsrecord_lib.h
index 0bf2ceed7..aff56146e 100644
--- a/src/include/gnunet_gnsrecord_lib.h
+++ b/src/include/gnunet_gnsrecord_lib.h
@@ -55,109 +55,9 @@ extern "C" {
 #define GNUNET_GNSRECORD_TYPE_ANY 0
 
 /**
- * Record type for GNS zone transfer ("PKEY").
+ * Include the record types generated from GANA
  */
-#define GNUNET_GNSRECORD_TYPE_PKEY GNUNET_IDENTITY_TYPE_ECDSA
-
-/**
- * Record type for GNS nick names ("NICK").
- */
-#define GNUNET_GNSRECORD_TYPE_NICK 65537
-
-/**
- * Record type for GNS legacy hostnames ("LEHO").
- */
-#define GNUNET_GNSRECORD_TYPE_LEHO 65538
-
-/**
- * Record type for VPN resolution
- */
-#define GNUNET_GNSRECORD_TYPE_VPN 65539
-
-/**
- * Record type for delegation to DNS.
- */
-#define GNUNET_GNSRECORD_TYPE_GNS2DNS 65540
-
-/**
- * Record type for a boxed record (see TLSA/SRV handling in GNS).
- */
-#define GNUNET_GNSRECORD_TYPE_BOX 65541
-
-/**
- * Record type for a social place.
- */
-#define GNUNET_GNSRECORD_TYPE_PLACE 65542
-
-/**
- * Record type for a phone (of CONVERSATION).
- */
-#define GNUNET_GNSRECORD_TYPE_PHONE 65543
-
-/**
- * Record type for identity attributes (of RECLAIM).
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE 65544
-
-/**
- * Record type for local ticket references
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET 65545
-
-/**
- * 65546 reserved
- */
-
-/**
- * 65547 deleted, free to use
- */
-
-/**
- * Record type for policies
- */
-#define GNUNET_GNSRECORD_TYPE_DELEGATE 65548
-
-/**
- * Record type for reverse lookups
- */
-#define GNUNET_GNSRECORD_TYPE_ATTRIBUTE 65549
-
-/**
- * Record type for reclaim records
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF 65550
-
-/**
- * Record type for RECLAIM master
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER 65551
-
-/**
- * Record type for reclaim OIDC clients
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_CLIENT 65552
-
-/**
- * Record type for reclaim OIDC redirect URIs
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT 65553
-
-/**
- * Record type for an attribute attestation
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL 65554
-
-/**
- * Record type for a presentation of a credential (used
- * in a ticket record set)
- */
-#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION 65555
-
-/**
- * Record type for EDKEY delegations.
- */
-#define GNUNET_GNSRECORD_TYPE_EDKEY GNUNET_IDENTITY_TYPE_EDDSA
-
+#include "gnu_name_system_record_types.h"
 
 /**
  * Flags that can be set for a record.
diff --git a/src/include/gnunet_messenger_service.h b/src/include/gnunet_messenger_service.h
index 389b6b8fd..99d4cf267 100644
--- a/src/include/gnunet_messenger_service.h
+++ b/src/include/gnunet_messenger_service.h
@@ -48,6 +48,14 @@ extern "C" {
 #include "gnunet_scheduler_lib.h"
 #include "gnunet_time_lib.h"
 
+/**
+ * Version number of GNUnet Messenger API.
+ */
+#define GNUNET_MESSENGER_VERSION 0x00000001
+
+/**
+ * Identifier of GNUnet MESSENGER Service.
+ */
 #define GNUNET_MESSENGER_SERVICE_NAME "messenger"
 
 /**
@@ -141,11 +149,18 @@ enum GNUNET_MESSENGER_MessageKind
   GNUNET_MESSENGER_KIND_PRIVATE = 14,
 
   /**
+   * The delete kind. The message contains a #GNUNET_MESSENGER_MessageDelete body.
+   */
+  GNUNET_MESSENGER_KIND_DELETE = 15,
+
+  /**
    * The unknown kind. The message contains an unknown body.
    */
   GNUNET_MESSENGER_KIND_UNKNOWN = 0
 };
 
+#define GNUNET_MESSENGER_KIND_MAX (GNUNET_MESSENGER_KIND_DELETE)
+
 /**
  * Get the name of a message <i>kind</i>.
  *
@@ -157,6 +172,9 @@ GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind);
 
 /**
  * The header of a #GNUNET_MESSENGER_Message.
+ * This allows authentification of the sender, temporal ordering and finding potentially missed messages.
+ *
+ * Message-header-size: 40+ bytes
  */
 struct GNUNET_MESSENGER_MessageHeader
 {
@@ -188,6 +206,9 @@ struct GNUNET_MESSENGER_MessageHeader
 
 /**
  * An info message body.
+ * This allows ensuring member ids are unique and this first message can be verified.
+ *
+ * Message-body-size: 8+ bytes
  */
 struct GNUNET_MESSENGER_MessageInfo
 {
@@ -197,13 +218,16 @@ struct GNUNET_MESSENGER_MessageInfo
   struct GNUNET_IDENTITY_PublicKey host_key;
 
   /**
-   * The new unique id for the receiver in a room.
+   * The version of GNUnet Messenger API.
    */
-  struct GNUNET_ShortHashCode unique_id;
+  uint32_t messenger_version;
 };
 
 /**
  * A join message body.
+ * This allows informing others about joining the room with a given key pair.
+ *
+ * Message-body-size: 4+ bytes
  */
 struct GNUNET_MESSENGER_MessageJoin
 {
@@ -215,6 +239,9 @@ struct GNUNET_MESSENGER_MessageJoin
 
 /**
  * A leave message body.
+ * This allows informing others about leaving the room.
+ *
+ * Message-body-size: 0 bytes
  */
 struct GNUNET_MESSENGER_MessageLeave
 {
@@ -222,6 +249,9 @@ struct GNUNET_MESSENGER_MessageLeave
 
 /**
  * A name message body.
+ * This allows replacing the current name with another one.
+ *
+ * Message-body-size: 0+ bytes
  */
 struct GNUNET_MESSENGER_MessageName
 {
@@ -233,6 +263,9 @@ struct GNUNET_MESSENGER_MessageName
 
 /**
  * A key message body.
+ * This allows replacing the current key pair with another one.
+ *
+ * Message-body-size: 4+ bytes
  */
 struct GNUNET_MESSENGER_MessageKey
 {
@@ -244,6 +277,9 @@ struct GNUNET_MESSENGER_MessageKey
 
 /**
  * A peer message body.
+ * This allows informing others to open a peer as a door to the current room.
+ *
+ * Message-body-size: 32 bytes
  */
 struct GNUNET_MESSENGER_MessagePeer
 {
@@ -255,6 +291,9 @@ struct GNUNET_MESSENGER_MessagePeer
 
 /**
  * An id message body.
+ * This allows replacing the member id with a newly unique generated one.
+ *
+ * Message-body-size: 8 bytes
  */
 struct GNUNET_MESSENGER_MessageId
 {
@@ -266,6 +305,9 @@ struct GNUNET_MESSENGER_MessageId
 
 /**
  * A miss message body.
+ * This allows informing others about a disconnection of any door.
+ *
+ * Message-body-size: 32 bytes
  */
 struct GNUNET_MESSENGER_MessageMiss
 {
@@ -277,6 +319,9 @@ struct GNUNET_MESSENGER_MessageMiss
 
 /**
  * A merge message body.
+ * This allows merging message history branches together.
+ *
+ * Message-body-size: 16 bytes
  */
 struct GNUNET_MESSENGER_MessageMerge
 {
@@ -288,6 +333,9 @@ struct GNUNET_MESSENGER_MessageMerge
 
 /**
  * A request message body.
+ * This allows requesting the content of a specific message which is currently missing.
+ *
+ * Message-body-size: 16 bytes
  */
 struct GNUNET_MESSENGER_MessageRequest
 {
@@ -299,6 +347,9 @@ struct GNUNET_MESSENGER_MessageRequest
 
 /**
  * An invite message body.
+ * This allows sharing information about other rooms in form of an invitation.
+ *
+ * Message-body-size: 48 bytes
  */
 struct GNUNET_MESSENGER_MessageInvite
 {
@@ -315,6 +366,9 @@ struct GNUNET_MESSENGER_MessageInvite
 
 /**
  * A text message body.
+ * This allows general communication in text form.
+ *
+ * Message-body-size: 0+ bytes
  */
 struct GNUNET_MESSENGER_MessageText
 {
@@ -326,6 +380,9 @@ struct GNUNET_MESSENGER_MessageText
 
 /**
  * A file message body.
+ * This allows sending necessary details about an uploaded encrypted file to allow access to it.
+ *
+ * Message-body-size: 335+ bytes
  */
 struct GNUNET_MESSENGER_MessageFile
 {
@@ -352,6 +409,9 @@ struct GNUNET_MESSENGER_MessageFile
 
 /**
  * A private message body.
+ * This allows to encapsulate any message to be encrypted for only one specific member to receive in a room.
+ *
+ * Message-body-size: 32+ bytes
  */
 struct GNUNET_MESSENGER_MessagePrivate
 {
@@ -372,6 +432,25 @@ struct GNUNET_MESSENGER_MessagePrivate
 };
 
 /**
+ * A delete message body
+ * This allows deletion of an own previous message with any custom automatic delay.
+ *
+ * Message-body-size: 24 bytes
+ */
+struct GNUNET_MESSENGER_MessageDelete
+{
+  /**
+   * The hash of the message to delete.
+   */
+  struct GNUNET_HashCode hash;
+
+  /**
+   * The delay of the delete operation to get processed.
+   */
+  struct GNUNET_TIME_RelativeNBO delay;
+};
+
+/**
  * The unified body of a #GNUNET_MESSENGER_Message.
  */
 struct GNUNET_MESSENGER_MessageBody
@@ -392,6 +471,7 @@ struct GNUNET_MESSENGER_MessageBody
     struct GNUNET_MESSENGER_MessageText text;
     struct GNUNET_MESSENGER_MessageFile file;
     struct GNUNET_MESSENGER_MessagePrivate private;
+    struct GNUNET_MESSENGER_MessageDelete delete;
   };
 };
 
@@ -412,11 +492,27 @@ struct GNUNET_MESSENGER_Message
 };
 
 /**
+ * Enum for the different supported flags used by message handling
+ */
+enum GNUNET_MESSENGER_MessageFlags
+{
+  /**
+   * The none flag. The flag indicates that the message is not affected by any special context.
+   */
+  GNUNET_MESSENGER_FLAG_NONE = 0,
+
+  /**
+   * The private flag. The flag indicates that the message was privately encrypted.
+   */
+  GNUNET_MESSENGER_FLAG_PRIVATE = 1,
+};
+
+/**
  * Method called whenever the EGO of a <i>handle</i> changes or if the first connection fails
  * to load a valid EGO and the anonymous key pair will be used instead.
  *
- * @param cls Closure from <i>GNUNET_MESSENGER_connect</i>
- * @param handle Messenger handle
+ * @param[in/out] cls Closure from #GNUNET_MESSENGER_connect
+ * @param[in/out] handle Messenger handle
  */
 typedef void
 (*GNUNET_MESSENGER_IdentityCallback) (void *cls, struct GNUNET_MESSENGER_Handle *handle);
@@ -424,25 +520,45 @@ typedef void
 /**
  * Method called whenever a message is sent or received from a <i>room</i>.
  *
- * @param cls Closure from <i>GNUNET_MESSENGER_connect</i>
- * @param room Room handle
- * @param message Newly received or sent message
- * @param hash Hash identifying the message
+ * The flag <i>private_message</i> will be #GNUNET_YES if a message was
+ * received privately, otherwise #GNUNET_NO.
+ *
+ * @param[in/out] cls Closure from #GNUNET_MESSENGER_connect
+ * @param[in] room Room handle
+ * @param[in] sender Sender of message
+ * @param[in] message Newly received or sent message
+ * @param[in] hash Hash identifying the message
+ * @param[in] flags Flags of the message
  */
 typedef void
-(*GNUNET_MESSENGER_MessageCallback) (void *cls, const struct GNUNET_MESSENGER_Room *room,
-                                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+(*GNUNET_MESSENGER_MessageCallback) (void *cls, struct GNUNET_MESSENGER_Room *room,
+                                     const struct GNUNET_MESSENGER_Contact *sender,
+                                     const struct GNUNET_MESSENGER_Message *message,
+                                     const struct GNUNET_HashCode *hash,
+                                     enum GNUNET_MESSENGER_MessageFlags flags);
+
+/**
+ * Method called for each member in a <i>room</i> during iteration. If the method returns
+ * #GNUNET_YES the iteration continues, otherwise it will quit the iteration.
+ *
+ * @param[in/out] cls Closure from #GNUNET_MESSENGER_iterate_members
+ * @param[in] room Room handle
+ * @param[in] contact Contact handle
+ */
+typedef int
+(*GNUNET_MESSENGER_MemberCallback) (void* cls, struct GNUNET_MESSENGER_Room *room,
+                                    const struct GNUNET_MESSENGER_Contact *contact);
 
 /**
  * Set up a handle for the messenger related functions and connects to all necessary services. It will look up the ego
  * key identified by its <i>name</i> and use it for signing all messages from the handle.
  *
- * @param cfg Configuration to use
- * @param name Name to look up an ego or NULL to stay anonymous
- * @param identity_callback Function called when the EGO of the handle changes
- * @param identity_cls Closure for the <i>identity_callback</i> handler
- * @param msg_callback Function called when a new message is sent or received
- * @param msg_cls Closure for the <i>msg_callback</i> handler
+ * @param[in] cfg Configuration to use
+ * @param[in] name Name to look up an ego or NULL to stay anonymous
+ * @param[in] identity_callback Function called when the EGO of the handle changes
+ * @param[in/out] identity_cls Closure for the <i>identity_callback</i> handler
+ * @param[in] msg_callback Function called when a new message is sent or received
+ * @param[in/out] msg_cls Closure for the <i>msg_callback</i> handler
  * @return Messenger handle to use, NULL on error
  */
 struct GNUNET_MESSENGER_Handle*
@@ -458,8 +574,8 @@ GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const c
  * Keep in mind that this will fully delete the old ego key (if any is used) even if any other service wants to use it
  * as default.
  *
- * @param handle Messenger handle to use
- * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ * @param[in/out] handle Messenger handle to use
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
 GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle);
@@ -467,7 +583,7 @@ GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle);
 /**
  * Disconnect all of the messengers used services and clears up its used memory.
  *
- * @param handle Messenger handle to use
+ * @param[in/out] handle Messenger handle to use
  */
 void
 GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle);
@@ -475,7 +591,7 @@ GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle);
 /**
  * Get the name (if specified, otherwise NULL) used by the messenger.
  *
- * @param handle Messenger handle to use
+ * @param[in] handle Messenger handle to use
  * @return Name used by the messenger or NULL
  */
 const char*
@@ -483,21 +599,21 @@ GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle);
 
 /**
  * Set the name for the messenger. This will rename the currently used ego and move all stored files related to the current
- * name to its new directory. If anything fails during this process the function returns GNUNET_NO and the name for
+ * name to its new directory. If anything fails during this process the function returns #GNUNET_NO and the name for
  * the messenger won't change as specified.
  *
- * @param handle Messenger handle to use
- * @param name Name for the messenger to change to
- * @return GNUNET_YES on success, GNUNET_NO on failure and GNUNET_SYSERR if <i>handle</i> is NULL
+ * @param[in/out] handle Messenger handle to use
+ * @param[in] name Name for the messenger to change to
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure and #GNUNET_SYSERR if <i>handle</i> is NULL
  */
 int
 GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name);
 
 /**
- * Get the public key used by the messenger.
+ * Get the public key used by the messenger or NULL if the anonymous key was used.
  *
- * @param handle Messenger handle to use
- * @return Used ego's public key
+ * @param[in] handle Messenger handle to use
+ * @return Used ego's public key or NULL
  */
 const struct GNUNET_IDENTITY_PublicKey*
 GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
@@ -509,38 +625,38 @@ GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
  * Notice that there can only be one room related to a specific <i>key</i>. So trying to open two rooms with the same
  * <i>key</i> will result in opening the room once but returning the handle both times because the room stays open.
  *
- * You can also open a room after entering it through a <b>door</b> using <i>GNUNET_MESSENGER_entry_room(...)</i>. This
+ * You can also open a room after entering it through a <b>door</b> using #GNUNET_MESSENGER_enter_room. This
  * will notify all entered <b>doors</b> to list you as new <b>door</b>.
  *
  * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
  *
- * @param handle Messenger handle to use
- * @param key Hash identifying the port
+ * @param[in/out] handle Messenger handle to use
+ * @param[in] key Hash identifying the port
  * @return Room handle, NULL on error
  */
 struct GNUNET_MESSENGER_Room*
 GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
 
 /**
- * Enter a room to send and receive messages through a <b>door</b> opened using <i>GNUNET_MESSENGER_open_room(...)</i>.
+ * Enter a room to send and receive messages through a <b>door</b> opened using #GNUNET_MESSENGER_open_room.
  *
  * Notice that there can only be one room related to a specific <i>key</i>. So trying to enter two rooms with the same
  * <i>key</i> will result in entering the room once but returning the handle both times because the room stays entered.
  * You can however enter a room through multiple <b>doors</b> in parallel which results in connecting both ends. But
  * entering the room through the same <b>door</b> won't have any effect after the first time.
  *
- * You can also enter a room through a <b>door</b> after opening it using <i>GNUNET_MESSENGER_open_room(...)</i>. But the
+ * You can also enter a room through a <b>door</b> after opening it using #GNUNET_MESSENGER_open_room. But the
  * <b>door</b> may not be your own peer identity.
  *
  * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
  *
- * @param handle Messenger handle to use
- * @param door Peer identity of an open <b>door</b>
- * @param key Hash identifying the port
+ * @param[in/out] handle Messenger handle to use
+ * @param[in] door Peer identity of an open <b>door</b>
+ * @param[in] key Hash identifying the port
  * @return Room handle, NULL on error
  */
 struct GNUNET_MESSENGER_Room*
-GNUNET_MESSENGER_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
+GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
                              const struct GNUNET_HashCode *key);
 
 /**
@@ -550,37 +666,37 @@ GNUNET_MESSENGER_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struc
  * ( After a member closes a <b>door</b>, all members entered through that specific <b>door</b> have to use another one
  * or open the room on their own. )
  *
- * @param room Room handle
+ * @param[in/out] room Room handle
  */
 void
 GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room);
 
 /**
- * Get the contact of a member in a <i>room</i> identified by their <i>id</i>.
+ * Get the contact of a member in a <i>room</i> which sent a specific message identified with a given <i>hash</i>.
  *
  * Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.
  *
- * @param room Room handle
- * @param id Hash identifying a member
- * @return Contact handle, NULL if <i>id</i> is not in use
+ * @param[in] room Room handle
+ * @param[in] hash Hash identifying a message
+ * @return Contact handle, NULL otherwise
  */
 struct GNUNET_MESSENGER_Contact*
-GNUNET_MESSENGER_get_member (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id);
+GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
 
 /**
  * Get the name used by the <i>contact</i>.
  *
- * @param contact Contact handle
+ * @param[in] contact Contact handle
  * @return Name of <i>contact</i> or NULL
  */
 const char*
 GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact);
 
 /**
- * Get the public key used by the <i>contact</i>.
+ * Get the public key used by the <i>contact</i> or NULL if the anonymous key was used.
  *
- * @param contact Contact handle
- * @return Public key of the ego used by <i>contact</i>
+ * @param[in] contact Contact handle
+ * @return Public key of the ego used by <i>contact</i> or NULL
  */
 const struct GNUNET_IDENTITY_PublicKey*
 GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact);
@@ -593,22 +709,44 @@ GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact
  *
  * Notice that all messages sent and received are also stored and can be propagated to new members entering the room.
  *
- * @param room Room handle
- * @param message New message to send
+ * If you provide a specific <i>contact</i> as receiver of the given message, the message will automatically be
+ * encrypted and sent as a private message (see #GNUNET_MESSENGER_MessagePrivate). Therefore the selected contact
+ * will be the only member receiving the actual message.
+ *
+ * Sending a message to all members in a given room can be done by providing NULL as contact.
+ *
+ * @param[in/out] room Room handle
+ * @param[in] message New message to send
+ * @param[in] contact Contact or NULL
  */
 void
-GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message);
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_MESSENGER_Contact* contact);
 
 /**
  * Get the message in a <i>room</i> identified by its <i>hash</i>.
  *
- * @param room Room handle
- * @param hash Hash identifying a message
+ * @param[in] room Room handle
+ * @param[in] hash Hash identifying a message
  * @return Message struct or NULL if no message with that hash is known
  */
 const struct GNUNET_MESSENGER_Message*
 GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
 
+/**
+ * Iterates through all members of a given <i>room</i> and calls a selected <i>callback</i>
+ * for each of them with a provided closure. The callback will receive the contact of each
+ * member. The function returns the amount of members iterated with the given callback.
+ *
+ * @param[in] room Room handle
+ * @param[in] callback Function called for each member
+ * @param[in] cls Closure for the <i>callback</i> handler
+ * @return Amount of members iterated
+ */
+int
+GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback,
+                                  void* cls);
+
 #if 0 /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_plugin_lib.h b/src/include/gnunet_plugin_lib.h
index ffffcab8b..d265eb343 100644
--- a/src/include/gnunet_plugin_lib.h
+++ b/src/include/gnunet_plugin_lib.h
@@ -122,6 +122,28 @@ GNUNET_PLUGIN_load_all (const char *basename,
 
 
 /**
+ * Load all compatible plugins with the given base name while inside the given
+ * context (i.e. a specific project data structure.)
+ *
+ * Note that the library must export symbols called `basename_ANYTHING_init`
+ * and `basename_ANYTHING__done`.  These will be called when the library is
+ * loaded and unloaded respectively.
+ *
+ * @param ctx the context used to find the plugins
+ * @param basename basename of the plugins to load
+ * @param arg argument to the plugin initialization function
+ * @param cb function to call for each plugin found
+ * @param cb_cls closure for @a cb
+ */
+void
+GNUNET_PLUGIN_load_all_in_context (const struct GNUNET_OS_ProjectData *ctx,
+                                   const char *basename,
+                                   void *arg,
+                                   GNUNET_PLUGIN_LoaderCallback cb,
+                                   void *cb_cls);
+
+
+/**
  * Unload plugin (runs the "done" callback and returns whatever "done"
  * returned).  The plugin is then unloaded.
  *
diff --git a/src/include/gnunet_testbed_ng_service.h b/src/include/gnunet_testbed_ng_service.h
new file mode 100644
index 000000000..370617e68
--- /dev/null
+++ b/src/include/gnunet_testbed_ng_service.h
@@ -0,0 +1,216 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @author t3sserakt
+ *
+ * @file
+ * API for writing tests and creating large-scale emulation testbeds for GNUnet with command pattern.
+ *
+ * @defgroup testbed  Testbed service
+ * Writing tests and creating large-scale emulation testbeds for GNUnet with command pattern.
+ *
+ * @see [Documentation](https://docs.gnunet.org/handbook/gnunet.html#TESTBED-NG-Subsystem)
+ *
+ * @{
+ */
+
+#ifndef GNUNET_TESTBED_NG_SERVICE_H
+#define GNUNET_TESTBED_NG_SERVICE_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+
+struct TngState;
+
+struct PeerCmdState
+{
+  /**
+   * The label of a controller command.
+   */
+  const char *controller_label;
+
+  /**
+   * Handle to operation
+   */
+  struct GNUNET_TESTBED_Operation *operation;
+
+  /**
+   * Name of the host, use "NULL" for localhost.
+   */
+  const char *hostname;
+
+  /**
+   * Username to use for the login; may be NULL.
+   */
+  const char *username;
+
+  /**
+   * Port number to use for ssh; use 0 to let ssh decide.
+   */
+  uint16_t port;
+
+  /**
+   * The configuration to use as a template while starting a controller
+   * on this host.  Operation queue sizes specific to a host are also
+   * read from this configuration handle.
+   */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * The host to run peers and controllers on
+   */
+  struct GNUNET_TESTBED_Host *host;
+
+  /**
+   * Abort task identifier
+   */
+  struct GNUNET_SCHEDULER_Task *abort_task;
+
+  /**
+   * Flag indicating if peer is ready.
+   */
+  int peer_ready;
+
+  /**
+   * Flag indicating controller is going down.
+   */
+  int peer_going_down;
+
+  /**
+   * Interpreter state.
+   */
+  struct GNUNET_TESTING_Interpreter *is;
+
+  /**
+   * Peer to start
+   */
+  struct GNUNET_TESTBED_Peer *peer;
+};
+
+struct ControllerState
+{
+  /**
+   * The ip address of the controller which will be set as TRUSTED
+   * HOST(all connections form this ip are permitted by the testbed) when
+   * starting testbed controller at host. This can either be a single ip
+   * address or a network address in CIDR notation.
+   */
+  const char *trusted_ip;
+
+  /**
+   * Name of the host, use "NULL" for localhost.
+   */
+  const char *hostname;
+
+  /**
+   * Username to use for the login; may be NULL.
+   */
+  const char *username;
+
+  /**
+   * Port number to use for ssh; use 0 to let ssh decide.
+   */
+  uint16_t port;
+
+  /**
+   * The configuration to use as a template while starting a controller
+   * on this host.  Operation queue sizes specific to a host are also
+   * read from this configuration handle.
+   */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * The host to run peers and controllers on
+   */
+  struct GNUNET_TESTBED_Host *host;
+
+  /**
+   * The controller process
+   */
+  struct GNUNET_TESTBED_ControllerProc *cp;
+
+  /**
+   * The controller handle
+   */
+  struct GNUNET_TESTBED_Controller *controller;
+
+  /**
+   * A bit mask with set of events to call the controller for.
+   */
+  uint64_t event_mask;
+
+  /**
+   * Abort task identifier
+   */
+  struct GNUNET_SCHEDULER_Task *abort_task;
+
+  /**
+   * Handle for host registration
+   */
+  struct GNUNET_TESTBED_HostRegistrationHandle *reg_handle;
+
+  /**
+   * Flag indicating if host create with controller is ready.
+   */
+  int host_ready;
+
+  /**
+   * Flag indicating controller is going down.
+   */
+  int controller_going_down;
+
+  /**
+   * Interpreter state.
+   */
+  struct GNUNET_TESTING_Interpreter *is;
+};
+
+/**
+ * Offer data from trait
+ *
+ * @param cmd command to extract the controller from.
+ * @param pt pointer to controller.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTBED_get_trait_controller (const struct GNUNET_TESTING_Command *cmd,
+                                     struct GNUNET_TESTBED_Controller **
+                                     controller);
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_controller (const char *label,
+                               const char *trusted_ip,
+                               const char *hostname,
+                               const char *username,
+                               uint16_t port,
+                               struct GNUNET_CONFIGURATION_Handle *cfg,
+                               uint64_t event_mask);
+
+void
+GNUNET_TESTBED_shutdown_controller (struct ControllerState *cs);
+
+void
+GNUNET_TESTBED_shutdown_peer (struct PeerCmdState *ps);
+
+void
+GNUNET_TESTBED_shutdown_service (struct TngState *ss);
+
+#endif
diff --git a/src/include/gnunet_testbed_service.h b/src/include/gnunet_testbed_service.h
index 70cbfa90d..acdfb2034 100644
--- a/src/include/gnunet_testbed_service.h
+++ b/src/include/gnunet_testbed_service.h
@@ -27,7 +27,7 @@
  * @defgroup testbed  Testbed service
  * Writing tests and creating large-scale emulation testbeds for GNUnet.
  *
- * @see [Documentation](https://gnunet.org/gnunet-testbed-subsystem)
+ * @see [Documentation](https://docs.gnunet.org/handbook/gnunet.html#TESTBED-Subsystem)
  *
  * @{
  */
diff --git a/src/include/gnunet_testing_ng_lib.h b/src/include/gnunet_testing_ng_lib.h
new file mode 100644
index 000000000..001d92aad
--- /dev/null
+++ b/src/include/gnunet_testing_ng_lib.h
@@ -0,0 +1,833 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @brief API for writing an interpreter to test GNUnet components
+ * @author Christian Grothoff <christian@grothoff.org>
+ * @author Marcello Stanisci
+ * @author t3sserakt
+ */
+#ifndef GNUNET_TESTING_NG_LIB_H
+#define GNUNET_TESTING_NG_LIB_H
+
+#include "gnunet_util_lib.h"
+
+
+/* ********************* Helper functions ********************* */
+
+/**
+ * Print failing line number and trigger shutdown.  Useful
+ * quite any time after the command "run" method has been called.
+ */
+#define GNUNET_TESTING_FAIL(is) \
+  do \
+  { \
+    GNUNET_break (0); \
+    GNUNET_TESTING_interpreter_fail (is); \
+    return; \
+  } while (0)
+
+
+/* ******************* Generic interpreter logic ************ */
+
+/**
+ * Global state of the interpreter, used by a command
+ * to access information about other commands.
+ */
+struct GNUNET_TESTING_Interpreter;
+
+/**
+ * A command to be run by the interpreter.
+ */
+struct GNUNET_TESTING_Command
+{
+
+  /**
+   * Closure for all commands with command-specific context information.
+   */
+  void *cls;
+
+  /**
+   * Label for the command.
+   */
+  const char *label;
+
+  /**
+   * Runs the command.  Note that upon return, the interpreter
+   * will not automatically run the next command, as the command
+   * may continue asynchronously in other scheduler tasks.  Thus,
+   * the command must ensure to eventually call
+   * #GNUNET_TESTING_interpreter_next() or
+   * #GNUNET_TESTING_interpreter_fail().
+   *
+   * If this function creates some asynchronous activity, it should
+   * initialize @e finish to a function that can be used to wait for
+   * the asynchronous activity to terminate.
+   *
+   * @param cls closure
+   * @param cmd command being run
+   * @param i interpreter state
+   */
+  void
+  (*run)(void *cls,
+         const struct GNUNET_TESTING_Command *cmd,
+         struct GNUNET_TESTING_Interpreter *i);
+
+  /**
+   * Wait for any asynchronous execution of @e run to conclude,
+   * then call finish_cont. Finish may only be called once per command.
+   *
+   * This member may be NULL if this command is a synchronous command,
+   * and also should be set to NULL once the command has finished.
+   *
+   * @param cls closure
+   * @param cont function to call upon completion, can be NULL
+   * @param cont_cls closure for @a cont
+   */
+  bool
+  (*finish)(void *cls,
+            GNUNET_SCHEDULER_TaskCallback cont,
+            void *cont_cls);
+
+  /**
+   * Task for running the finish function.
+   */
+  struct GNUNET_SCHEDULER_Task *finish_task;
+
+  /**
+   * Clean up after the command.  Run during forced termination
+   * (CTRL-C) or test failure or test success.
+   *
+   * @param cls closure
+   * @param cmd command being cleaned up
+   */
+  void
+  (*cleanup)(void *cls,
+             const struct GNUNET_TESTING_Command *cmd);
+
+  /**
+   * Extract information from a command that is useful for other
+   * commands.
+   *
+   * @param cls closure
+   * @param[out] ret result (could be anything)
+   * @param trait name of the trait
+   * @param index index number of the object to extract.
+   * @return #GNUNET_OK on success
+   */
+  int
+  (*traits)(void *cls,
+            const void **ret,
+            const char *trait,
+            unsigned int index);
+
+  /**
+   * When did the execution of this command start?
+   */
+  struct GNUNET_TIME_Absolute start_time;
+
+  /**
+   * When did the execution of this command finish?
+   */
+  struct GNUNET_TIME_Absolute finish_time;
+
+  /**
+   * When did we start the last run of this command?  Delta to @e finish_time
+   * gives the latency for the last successful run.  Useful in case @e
+   * num_tries was positive and the command was run multiple times.  In that
+   * case, the @e start_time gives the time when we first tried to run the
+   * command, so the difference between @e start_time and @e finish_time would
+   * be the time all of the @e num_tries took, while the delta to @e
+   * last_req_time is the time the last (successful) execution took.
+   */
+  struct GNUNET_TIME_Absolute last_req_time;
+
+  /**
+   * How often did we try to execute this command? (In case it is a request
+   * that is repated.)  Note that a command must have some build-in retry
+   * mechanism for this value to be useful.
+   */
+  unsigned int num_tries;
+
+  /**
+   * In case @e asynchronous_finish is true, how long should we wait for this
+   * command to complete? If @e finish did not complete after this amount of
+   * time, the interpreter will fail.  Should be set generously to ensure
+   * tests do not fail on slow systems.
+   */
+  struct GNUNET_TIME_Relative default_timeout;
+
+  /**
+   * If "true", the interpreter should not immediately call
+   * @e finish, even if @e finish is non-NULL.  Otherwise,
+   * #TALER_TESTING_cmd_finish() must be used
+   * to ensure that a command actually completed.
+   */
+  bool asynchronous_finish;
+
+};
+
+
+/**
+ * Struct to use for command-specific context information closure of a command waiting
+ * for another command.
+ */
+struct SyncState
+{
+  /**
+   * Closure for all commands with command-specific context information.
+   */
+  void *cls;
+
+  /**
+   * The asynchronous command the synchronous command of this closure waits for.
+   */
+  const struct GNUNET_TESTING_Command *async_cmd;
+
+  /**
+   * Task for running the finish method of the asynchronous task the command is waiting for.
+   */
+  struct GNUNET_SCHEDULER_Task *finish_task;
+
+  /**
+   * When did the execution of this commands finish function start?
+   */
+  struct GNUNET_TIME_Absolute start_finish_time;
+};
+
+/**
+ * Lookup command by label.
+ *
+ * @param label label of the command to lookup.
+ * @return the command, if it is found, or NULL.
+ */
+const struct GNUNET_TESTING_Command *
+GNUNET_TESTING_interpreter_lookup_command (
+  const char *label);
+
+
+/**
+ * Obtain label of the command being now run.
+ *
+ * @param is interpreter state.
+ * @return the label.
+ */
+const char *
+GNUNET_TESTING_interpreter_get_current_label (
+  struct GNUNET_TESTING_Interpreter *is);
+
+
+/**
+ * Current command failed, clean up and fail the test case.
+ *
+ * @param is interpreter state.
+ */
+void
+GNUNET_TESTING_interpreter_fail (struct GNUNET_TESTING_Interpreter *is);
+
+
+/**
+ * Create command array terminator.
+ *
+ * @return a end-command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_end (void);
+
+
+/**
+ * Turn asynchronous command into non blocking command by setting asynchronous_finish to true.
+ *
+ * @param cmd command to make synchronous.
+ * @return a finish-command.
+ */
+const struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_make_unblocking (const struct GNUNET_TESTING_Command cmd);
+
+
+/**
+ * Create (synchronous) command that waits for another command to finish.
+ * If @a cmd_ref did not finish after @a timeout, this command will fail
+ * the test case.
+ *
+ * @param finish_label label for this command
+ * @param cmd_ref reference to a previous command which we should
+ *        wait for (call `finish()` on)
+ * @param timeout how long to wait at most for @a cmd_ref to finish
+ * @return a finish-command.
+ */
+const struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_finish (const char *finish_label,
+                           const char *cmd_ref,
+                           struct GNUNET_TIME_Relative timeout);
+
+
+/**
+ * Make the instruction pointer point to @a target_label
+ * only if @a counter is greater than zero.
+ *
+ * @param label command label
+ * @param target_label label of the new instruction pointer's destination after the jump;
+ *                     must be before the current instruction
+ * @param counter counts how many times the rewinding is to happen.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_rewind_ip (const char *label,
+                              const char *target_label,
+                              unsigned int counter);
+
+
+/**
+ * Wait until we receive SIGCHLD signal.  Then obtain the process trait of the
+ * current command, wait on the the zombie and continue with the next command.
+ *
+ * @param is interpreter state.
+ */
+// void
+// GNUNET_TESTING_wait_for_sigchld (struct GNUNET_TESTING_Interpreter *is);
+// => replace with child_management.c
+
+
+/**
+ * Start scheduling loop with signal handlers and run the
+ * test suite with the @a commands.
+ *
+ * @param cfg_name name of configuration file to use
+ * @param commands the list of command to execute
+ * @param timeout how long to wait for each command to execute
+ * @return #GNUNET_OK if all is okay, != #GNUNET_OK otherwise.
+ *         non-GNUNET_OK codes are #GNUNET_SYSERR most of the
+ *         times.
+ */
+int
+GNUNET_TESTING_run (const char *cfg_filename,
+                    struct GNUNET_TESTING_Command *commands,
+                    struct GNUNET_TIME_Relative timeout);
+
+
+/**
+ * Look for substring in a programs' name.
+ *
+ * @param prog program's name to look into
+ * @param marker chunk to find in @a prog
+ */
+int
+GNUNET_TESTING_has_in_name (const char *prog,
+                            const char *marker);
+
+
+/* ************** Specific interpreter commands ************ */
+
+/**
+ * Create a "signal" CMD.
+ *
+ * @param label command label.
+ * @param process_label label of a command that has a process trait
+ * @param process_index index of the process trait at @a process_label
+ * @param signal signal to send to @a process.
+ * @return the command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_signal (const char *label,
+                           const char *process_label,
+                           unsigned int process_index,
+                           int signal);
+
+
+/**
+ * Sleep for @a duration.
+ *
+ * @param label command label.
+ * @param duration time to sleep
+ * @return the command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_sleep (const char *label,
+                          struct GNUNET_TIME_Relative duration);
+
+
+/**
+ * Create a "batch" command.  Such command takes a end_CMD-terminated array of
+ * CMDs and executed them.  Once it hits the end CMD, it passes the control to
+ * the next top-level CMD, regardless of it being another batch or ordinary
+ * CMD.
+ *
+ * @param label the command label.
+ * @param batch array of CMDs to execute.
+ * @return the command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_batch (const char *label,
+                          struct GNUNET_TESTING_Command *batch);
+
+
+/**
+ * Test if this command is a batch command.
+ *
+ * @return false if not, true if it is a batch command
+ */
+// TODO: figure out if this needs to be exposed in the public API.
+int
+GNUNET_TESTING_cmd_is_batch (const struct GNUNET_TESTING_Command *cmd);
+
+
+/**
+ * Advance internal pointer to next command.
+ *
+ * @param is interpreter state.
+ */
+// TODO: figure out if this needs to be exposed in the public API.
+void
+GNUNET_TESTING_cmd_batch_next (struct GNUNET_TESTING_Interpreter *is);
+
+
+/**
+ * Obtain what command the batch is at.
+ *
+ * @return cmd current batch command
+ */
+// TODO: figure out if this needs to be exposed in the public API.
+struct GNUNET_TESTING_Command *
+GNUNET_TESTING_cmd_batch_get_current (const struct GNUNET_TESTING_Command *cmd);
+
+
+/**
+ * Set what command the batch should be at.
+ *
+ * @param cmd current batch command
+ * @param new_ip where to move the IP
+ */
+// TODO: figure out if this needs to be exposed in the public API.
+void
+GNUNET_TESTING_cmd_batch_set_current (const struct GNUNET_TESTING_Command *cmd,
+                                      unsigned int new_ip);
+
+
+/**
+ * Performance counter.
+ */
+struct GNUNET_TESTING_Timer
+{
+  /**
+   * For which type of commands.
+   */
+  const char *prefix;
+
+  /**
+   * Total time spend in all commands of this type.
+   */
+  struct GNUNET_TIME_Relative total_duration;
+
+  /**
+   * Total time spend waiting for the *successful* exeuction
+   * in all commands of this type.
+   */
+  struct GNUNET_TIME_Relative success_latency;
+
+  /**
+   * Number of commands summed up.
+   */
+  unsigned int num_commands;
+
+  /**
+   * Number of retries summed up.
+   */
+  unsigned int num_retries;
+};
+
+
+/**
+ * Obtain performance data from the interpreter.
+ *
+ * @param timers what commands (by label) to obtain runtimes for
+ * @return the command
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_stat (struct GNUNET_TESTING_Timer *timers);
+
+
+/* *** Generic trait logic for implementing traits ********* */
+
+/**
+ * A trait.
+ */
+struct GNUNET_TESTING_Trait
+{
+  /**
+   * Index number associated with the trait.  This gives the
+   * possibility to have _multiple_ traits on offer under the
+   * same name.
+   */
+  unsigned int index;
+
+  /**
+   * Trait type, for example "reserve-pub" or "coin-priv".
+   */
+  const char *trait_name;
+
+  /**
+   * Pointer to the piece of data to offer.
+   */
+  const void *ptr;
+};
+
+
+/**
+ * "end" trait.  Because traits are offered into arrays,
+ * this type of trait is used to mark the end of such arrays;
+ * useful when iterating over those.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_trait_end (void);
+
+
+/**
+ * Extract a trait.
+ *
+ * @param traits the array of all the traits.
+ * @param[out] ret where to store the result.
+ * @param trait type of the trait to extract.
+ * @param index index number of the trait to extract.
+ * @return #GNUNET_OK when the trait is found.
+ */
+int
+GNUNET_TESTING_get_trait (const struct GNUNET_TESTING_Trait *traits,
+                          const void **ret,
+                          const char *trait,
+                          unsigned int index);
+
+
+/* ****** Specific traits supported by this component ******* */
+
+/**
+ * Obtain location where a command stores a pointer to a process.
+ *
+ * @param cmd command to extract trait from.
+ * @param index which process to pick if @a cmd
+ *        has multiple on offer.
+ * @param[out] processp set to the address of the pointer to the
+ *        process.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_process (const struct GNUNET_TESTING_Command *cmd,
+                                  unsigned int index,
+                                  struct GNUNET_OS_Process ***processp);
+
+
+/**
+ * Offer location where a command stores a pointer to a process.
+ *
+ * @param index offered location index number, in case there are
+ *        multiple on offer.
+ * @param processp process location to offer.
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_process (unsigned int index,
+                                   struct GNUNET_OS_Process **processp);
+
+
+/**
+ * Offer number trait, 32-bit version.
+ *
+ * @param index the number's index number.
+ * @param n number to offer.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_uint32 (unsigned int index,
+                                  const uint32_t *n);
+
+
+/**
+ * Obtain a "number" value from @a cmd, 32-bit version.
+ *
+ * @param cmd command to extract the number from.
+ * @param index the number's index number.
+ * @param[out] n set to the number coming from @a cmd.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_uint32 (const struct GNUNET_TESTING_Command *cmd,
+                                 unsigned int index,
+                                 const uint32_t **n);
+
+
+/**
+ * Offer number trait, 64-bit version.
+ *
+ * @param index the number's index number.
+ * @param n number to offer.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_uint64 (unsigned int index,
+                                  const uint64_t *n);
+
+
+/**
+ * Obtain a "number" value from @a cmd, 64-bit version.
+ *
+ * @param cmd command to extract the number from.
+ * @param index the number's index number.
+ * @param[out] n set to the number coming from @a cmd.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_uint64 (const struct GNUNET_TESTING_Command *cmd,
+                                 unsigned int index,
+                                 const uint64_t **n);
+
+
+/**
+ * Offer number trait, 64-bit signed version.
+ *
+ * @param index the number's index number.
+ * @param n number to offer.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_int64 (unsigned int index,
+                                 const int64_t *n);
+
+
+/**
+ * Obtain a "number" value from @a cmd, 64-bit signed version.
+ *
+ * @param cmd command to extract the number from.
+ * @param index the number's index number.
+ * @param[out] n set to the number coming from @a cmd.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_int64 (const struct GNUNET_TESTING_Command *cmd,
+                                unsigned int index,
+                                const int64_t **n);
+
+
+/**
+ * Offer a number.
+ *
+ * @param index the number's index number.
+ * @param n the number to offer.
+ * @return #GNUNET_OK on success.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_uint (unsigned int index,
+                                const unsigned int *i);
+
+
+/**
+ * Obtain a number from @a cmd.
+ *
+ * @param cmd command to extract the number from.
+ * @param index the number's index number.
+ * @param[out] n set to the number coming from @a cmd.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_uint (const struct GNUNET_TESTING_Command *cmd,
+                               unsigned int index,
+                               const unsigned int **n);
+
+/**
+ * Obtain a string from @a cmd.
+ *
+ * @param cmd command to extract the subject from.
+ * @param index index number associated with the transfer
+ *        subject to offer.
+ * @param[out] s where to write the offered
+ *        string.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_string (
+  const struct GNUNET_TESTING_Command *cmd,
+  unsigned int index,
+  const char **s);
+
+
+/**
+ * Offer string subject.
+ *
+ * @param index index number associated with the transfer
+ *        subject being offered.
+ * @param s string to offer.
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_string (unsigned int index,
+                                  const char *s);
+
+/**
+ * Offer a command in a trait.
+ *
+ * @param index always zero.  Commands offering this
+ *        kind of traits do not need this index.  For
+ *        example, a "meta" CMD returns always the
+ *        CMD currently being executed.
+ * @param cmd wire details to offer.
+ *
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_cmd (unsigned int index,
+                               const struct GNUNET_TESTING_Command *cmd);
+
+
+/**
+ * Obtain a command from @a cmd.
+ *
+ * @param cmd command to extract the command from.
+ * @param index always zero.  Commands offering this
+ *        kind of traits do not need this index.  For
+ *        example, a "meta" CMD returns always the
+ *        CMD currently being executed.
+ * @param[out] _cmd where to write the wire details.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_cmd (const struct GNUNET_TESTING_Command *cmd,
+                              unsigned int index,
+                              struct GNUNET_TESTING_Command **_cmd);
+
+
+/**
+ * Obtain a uuid from @a cmd.
+ *
+ * @param cmd command to extract the uuid from.
+ * @param index which amount to pick if @a cmd has multiple
+ *        on offer
+ * @param[out] uuid where to write the uuid.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_uuid (const struct GNUNET_TESTING_Command *cmd,
+                               unsigned int index,
+                               struct GNUNET_Uuid **uuid);
+
+
+/**
+ * Offer a uuid in a trait.
+ *
+ * @param index which uuid to offer, in case there are
+ *        multiple available.
+ * @param uuid the uuid to offer.
+ *
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_uuid (unsigned int index,
+                                const struct GNUNET_Uuid *uuid);
+
+
+/**
+ * Obtain a absolute time from @a cmd.
+ *
+ * @param cmd command to extract trait from
+ * @param index which time stamp to pick if
+ *        @a cmd has multiple on offer.
+ * @param[out] time set to the wanted WTID.
+ * @return #GNUNET_OK on success
+ */
+int
+GNUNET_TESTING_get_trait_absolute_time (
+  const struct GNUNET_TESTING_Command *cmd,
+  unsigned int index,
+  const struct GNUNET_TIME_Absolute **time);
+
+
+/**
+ * Offer a absolute time.
+ *
+ * @param index associate the object with this index
+ * @param time which object should be returned
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_absolute_time (
+  unsigned int index,
+  const struct GNUNET_TIME_Absolute *time);
+
+
+/**
+ * Obtain a relative time from @a cmd.
+ *
+ * @param cmd command to extract trait from
+ * @param index which time to pick if
+ *        @a cmd has multiple on offer.
+ * @param[out] time set to the wanted WTID.
+ * @return #GNUNET_OK on success
+ */
+int
+GNUNET_TESTING_get_trait_relative_time (
+  const struct GNUNET_TESTING_Command *cmd,
+  unsigned int index,
+  const struct GNUNET_TIME_Relative **time);
+
+
+/**
+ * Offer a relative time.
+ *
+ * @param index associate the object with this index
+ * @param time which object should be returned
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_relative_time (
+  unsigned int index,
+  const struct GNUNET_TIME_Relative *time);
+
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param now when the command was started.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_hello_world_birth (const char *label,
+                                      struct GNUNET_TIME_Absolute *now);
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param message initial message.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_hello_world (const char *label,
+                                const char *birthLabel,
+                                char *message);
+
+/**
+ * Offer data from trait
+ *
+ * @param cmd command to extract the url from.
+ * @param pt which url is to be picked, in case
+ *        multiple are offered.
+ * @param[out] url where to write the url.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_what_am_i (const struct GNUNET_TESTING_Command *cmd,
+                                    char **what_am_i);
+
+#endif
diff --git a/src/json/json_helper.c b/src/json/json_helper.c
index 621487f0a..32b262a87 100644
--- a/src/json/json_helper.c
+++ b/src/json/json_helper.c
@@ -28,9 +28,6 @@
 #include "gnunet_json_lib.h"
 
 
-/**
- * End of a parser specification.
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_end ()
 {
@@ -84,14 +81,6 @@ parse_fixed_data (void *cls,
 }
 
 
-/**
- * Variable size object (in network byte order, encoded using Crockford
- * Base32hex encoding).
- *
- * @param name name of the JSON field
- * @param[out] obj pointer where to write the data, must have @a size bytes
- * @param size number of bytes expected in @a obj
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_fixed (const char *name,
                         void *obj,
@@ -168,6 +157,7 @@ static void
 clean_variable_data (void *cls,
                      struct GNUNET_JSON_Specification *spec)
 {
+  (void) cls;
   if (0 != *spec->size_ptr)
   {
     GNUNET_free (*(void **) spec->ptr);
@@ -177,14 +167,6 @@ clean_variable_data (void *cls,
 }
 
 
-/**
- * Variable size object (in network byte order, encoded using
- * Crockford Base32hex encoding).
- *
- * @param name name of the JSON field
- * @param[out] obj pointer where to write the data, will be allocated
- * @param[out] size where to store the number of bytes allocated for @a obj
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_varsize (const char *name,
                           void **obj,
@@ -221,6 +203,7 @@ parse_string (void *cls,
 {
   const char *str;
 
+  (void) cls;
   str = json_string_value (root);
   if (NULL == str)
   {
@@ -232,12 +215,6 @@ parse_string (void *cls,
 }
 
 
-/**
- * The expected field stores a string.
- *
- * @param name name of the JSON field
- * @param strptr where to store a pointer to the field
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_string (const char *name,
                          const char **strptr)
@@ -301,12 +278,6 @@ clean_object (void *cls,
 }
 
 
-/**
- * JSON object.
- *
- * @param name name of the JSON field
- * @param[out] jsonp where to store the JSON found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_json (const char *name,
                        json_t **jsonp)
@@ -356,12 +327,6 @@ parse_bool (void *cls,
 }
 
 
-/**
- * boolean.
- *
- * @param name name of the JSON field
- * @param[out] b where to store the boolean found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_bool (const char *name,
                        bool *b)
@@ -412,12 +377,6 @@ parse_u8 (void *cls,
 }
 
 
-/**
- * 8-bit integer.
- *
- * @param name name of the JSON field
- * @param[out] u8 where to store the integer found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_uint8 (const char *name,
                         uint8_t *u8)
@@ -468,12 +427,6 @@ parse_u16 (void *cls,
 }
 
 
-/**
- * 16-bit integer.
- *
- * @param name name of the JSON field
- * @param[out] u16 where to store the integer found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_uint16 (const char *name,
                          uint16_t *u16)
@@ -524,12 +477,6 @@ parse_u32 (void *cls,
 }
 
 
-/**
- * 32-bit integer.
- *
- * @param name name of the JSON field
- * @param[out] u32 where to store the integer found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_uint32 (const char *name,
                          uint32_t *u32)
@@ -575,12 +522,6 @@ parse_u64 (void *cls,
 }
 
 
-/**
- * 64-bit integer.
- *
- * @param name name of the JSON field
- * @param[out] u64 where to store the integer found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_uint64 (const char *name,
                          uint64_t *u64)
@@ -626,12 +567,6 @@ parse_i64 (void *cls,
 }
 
 
-/**
- * 64-bit signed integer.
- *
- * @param name name of the JSON field
- * @param[out] i64 where to store the integer found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_int64 (const char *name,
                         int64_t *i64)
@@ -705,12 +640,6 @@ parse_abs_time (void *cls,
 }
 
 
-/**
- * Absolute time.
- *
- * @param name name of the JSON field
- * @param[out] at where to store the absolute time found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_absolute_time (const char *name,
                                 struct GNUNET_TIME_Absolute *at)
@@ -759,12 +688,6 @@ parse_abs_time_nbo (void *cls,
 }
 
 
-/**
- * Absolute time in network byte order.
- *
- * @param name name of the JSON field
- * @param[out] at where to store the absolute time found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_absolute_time_nbo (const char *name,
                                     struct GNUNET_TIME_AbsoluteNBO *at)
@@ -836,12 +759,6 @@ parse_rel_time (void *cls,
 }
 
 
-/**
- * Relative time.
- *
- * @param name name of the JSON field
- * @param[out] rt where to store the relative time found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_relative_time (const char *name,
                                 struct GNUNET_TIME_Relative *rt)
@@ -929,12 +846,6 @@ clean_rsa_public_key (void *cls,
 }
 
 
-/**
- * Specification for parsing an RSA public key.
- *
- * @param name name of the JSON field
- * @param pk where to store the RSA key found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_rsa_public_key (const char *name,
                                  struct GNUNET_CRYPTO_RsaPublicKey **pk)
@@ -1023,12 +934,6 @@ clean_rsa_signature (void *cls,
 }
 
 
-/**
- * Specification for parsing an RSA signature.
- *
- * @param name name of the JSON field
- * @param sig where to store the RSA signature found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_rsa_signature (const char *name,
                                 struct GNUNET_CRYPTO_RsaSignature **sig)
@@ -1073,12 +978,6 @@ parse_boolean (void *cls,
 }
 
 
-/**
- * Boolean (true mapped to GNUNET_YES, false mapped to GNUNET_NO).
- *
- * @param name name of the JSON field
- * @param[out] boolean where to store the boolean found under @a name
- */
 struct GNUNET_JSON_Specification
 GNUNET_JSON_spec_boolean (const char *name,
                           int *boolean)
diff --git a/src/messenger/.gitignore b/src/messenger/.gitignore
index 9de3fb304..ed78c5562 100644
--- a/src/messenger/.gitignore
+++ b/src/messenger/.gitignore
@@ -2,3 +2,13 @@ gnunet-service-messenger
 gnunet-messenger
 test_messenger_api
 test_messenger_anonymous
+test_messenger_sync_client
+test_messenger_async_client
+test_messenger_worst_client
+test_messenger_sync_p2p
+test_messenger_async_p2p
+test_messenger_worst_p2p
+test_messenger_server
+test_messenger_growth
+test_messenger_ring
+test_messenger_adapt
diff --git a/src/messenger/Makefile.am b/src/messenger/Makefile.am
index d9694420b..3fc532e7e 100644
--- a/src/messenger/Makefile.am
+++ b/src/messenger/Makefile.am
@@ -25,32 +25,23 @@ bin_PROGRAMS = \
  gnunet-messenger
 
 lib_LTLIBRARIES = \
-  libgnunetmessenger_common.la \
   libgnunetmessenger.la \
   $(EXP_LIB)
 
-libgnunetmessenger_common_la_SOURCES = \
-  messenger_api_ego.h \
-  messenger_api_message.c messenger_api_message.h \
-  messenger_api_list_tunnels.c messenger_api_list_tunnels.h
-libgnunetmessenger_common_la_LIBADD = \
-  $(top_builddir)/src/util/libgnunetutil.la \
-  $(top_builddir)/src/identity/libgnunetidentity.la \
-  $(XLIB) \
-  $(LTLIBINTL)
-libgnunetmessenger_common_la_LDFLAGS = \
-  $(GN_LIB_LDFLAGS)  \
-  -version-info 0:0:0
-
 libgnunetmessenger_la_SOURCES = \
   messenger_api.c \
+  messenger_api_ego.h \
   messenger_api_contact.c messenger_api_contact.h \
+  messenger_api_contact_store.c messenger_api_contact_store.h \
+  messenger_api_message.c messenger_api_message.h \
+  messenger_api_list_tunnels.c messenger_api_list_tunnels.h \
+  messenger_api_util.c messenger_api_util.h \
   messenger_api_handle.c messenger_api_handle.h \
   messenger_api_room.c messenger_api_room.h
 libgnunetmessenger_la_LIBADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/cadet/libgnunetcadet.la \
   $(top_builddir)/src/identity/libgnunetidentity.la \
-  libgnunetmessenger_common.la \
   $(XLIB) \
   $(LTLIBINTL)
 libgnunetmessenger_la_LDFLAGS = \
@@ -60,10 +51,8 @@ libgnunetmessenger_la_LDFLAGS = \
 gnunet_messenger_SOURCES = \
  gnunet-messenger.c
 gnunet_messenger_LDADD = \
- libgnunetmessenger_common.la \
  libgnunetmessenger.la \
- $(top_builddir)/src/util/libgnunetutil.la \
- $(top_builddir)/src/identity/libgnunetidentity.la
+ $(top_builddir)/src/util/libgnunetutil.la
 gnunet_messenger_LDFLAGS = \
   $(GN_LIBINTL)
 
@@ -72,29 +61,42 @@ gnunet_service_messenger_SOURCES = \
   gnunet-service-messenger_service.c gnunet-service-messenger_service.h \
   gnunet-service-messenger_list_handles.c gnunet-service-messenger_list_handles.h \
   gnunet-service-messenger_list_messages.c gnunet-service-messenger_list_messages.h \
+  gnunet-service-messenger_member_session.c gnunet-service-messenger_member_session.h \
+  gnunet-service-messenger_member.c gnunet-service-messenger_member.h \
+  gnunet-service-messenger_member_store.c gnunet-service-messenger_member_store.h \
   gnunet-service-messenger_message_handle.c gnunet-service-messenger_message_handle.h \
   gnunet-service-messenger_message_kind.c gnunet-service-messenger_message_kind.h \
   gnunet-service-messenger_message_recv.c gnunet-service-messenger_message_recv.h \
   gnunet-service-messenger_message_send.c gnunet-service-messenger_message_send.h \
+  gnunet-service-messenger_message_state.c gnunet-service-messenger_message_state.h \
   gnunet-service-messenger_message_store.c gnunet-service-messenger_message_store.h \
+  gnunet-service-messenger_operation_store.c gnunet-service-messenger_operation_store.h \
+  gnunet-service-messenger_operation.c gnunet-service-messenger_operation.h \
   gnunet-service-messenger_basement.c gnunet-service-messenger_basement.h \
-  gnunet-service-messenger_contact.c gnunet-service-messenger_contact.h \
+  gnunet-service-messenger_ego_store.c gnunet-service-messenger_ego_store.h \
   gnunet-service-messenger_handle.c gnunet-service-messenger_handle.h \
   gnunet-service-messenger_room.c gnunet-service-messenger_room.h \
-  gnunet-service-messenger_tunnel.c gnunet-service-messenger_tunnel.h \
-  gnunet-service-messenger_util.c gnunet-service-messenger_util.h
+  gnunet-service-messenger_tunnel.c gnunet-service-messenger_tunnel.h
 gnunet_service_messenger_LDADD = \
+  libgnunetmessenger.la \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/cadet/libgnunetcadet.la \
   $(top_builddir)/src/identity/libgnunetidentity.la \
-  libgnunetmessenger_common.la \
-  libgnunetmessenger.la \
   $(GN_LIBINTL)
 
 check_PROGRAMS = \
   test_messenger_api \
   test_messenger_anonymous \
-  test_messenger_comm0
+  test_messenger_sync_client \
+  test_messenger_async_client \
+  test_messenger_worst_client \
+  test_messenger_sync_p2p \
+  test_messenger_async_p2p \
+  test_messenger_worst_p2p \
+  test_messenger_server \
+  test_messenger_growth \
+  test_messenger_ring \
+  test_messenger_adapt
 
 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;
@@ -105,7 +107,6 @@ endif
 test_messenger_api_SOURCES = \
   test_messenger.c
 test_messenger_api_LDADD = \
-  libgnunetmessenger_common.la \
   libgnunetmessenger.la \
   $(top_builddir)/src/testing/libgnunettesting.la \
   $(top_builddir)/src/util/libgnunetutil.la
@@ -113,18 +114,107 @@ test_messenger_api_LDADD = \
 test_messenger_anonymous_SOURCES = \
   test_messenger_anonymous.c
 test_messenger_anonymous_LDADD = \
-  libgnunetmessenger_common.la \
   libgnunetmessenger.la \
   $(top_builddir)/src/testing/libgnunettesting.la \
   $(top_builddir)/src/util/libgnunetutil.la
 
-test_messenger_comm0_SOURCES = \
-  test_messenger_comm0.c
-test_messenger_comm0_LDADD = \
-  libgnunetmessenger_common.la \
+test_messenger_sync_client_SOURCES = \
+  test_messenger_sync_client.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_sync_client_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_async_client_SOURCES = \
+  test_messenger_async_client.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_async_client_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_worst_client_SOURCES = \
+  test_messenger_worst_client.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_worst_client_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+
+test_messenger_sync_p2p_SOURCES = \
+  test_messenger_sync_p2p.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_sync_p2p_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_async_p2p_SOURCES = \
+  test_messenger_async_p2p.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_async_p2p_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+
+test_messenger_worst_p2p_SOURCES = \
+  test_messenger_worst_p2p.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_worst_p2p_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_server_SOURCES = \
+  test_messenger_server.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_server_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_growth_SOURCES = \
+  test_messenger_growth.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_growth_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_ring_SOURCES = \
+  test_messenger_ring.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_ring_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+  
+test_messenger_adapt_SOURCES = \
+  test_messenger_adapt.c \
+  testing_messenger_barrier.c testing_messenger_barrier.h \
+  testing_messenger_setup.c testing_messenger_setup.h
+test_messenger_adapt_LDADD = \
   libgnunetmessenger.la \
   $(top_builddir)/src/testbed/libgnunettestbed.la \
-  $(top_builddir)/src/testbed-logger/libgnunettestbedlogger.la \
   $(top_builddir)/src/testing/libgnunettesting.la \
   $(top_builddir)/src/util/libgnunetutil.la
 
diff --git a/src/messenger/gnunet-messenger.c b/src/messenger/gnunet-messenger.c
index 579e5c3ad..094ae398d 100644..100755
--- a/src/messenger/gnunet-messenger.c
+++ b/src/messenger/gnunet-messenger.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -34,29 +34,38 @@ struct GNUNET_MESSENGER_Handle *messenger;
 /**
  * Function called whenever a message is received or sent.
  *
- * @param cls Closure
- * @param room Room
- * @param message Message
- * @param hash Hash of message
+ * @param[in/out] cls Closure
+ * @param[in] room Room
+ * @param[in] sender Sender of message
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @param[in] flags Flags of message
  */
 void
-on_message (void *cls, const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-            const struct GNUNET_HashCode *hash)
+on_message (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender,
+            const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
+            enum GNUNET_MESSENGER_MessageFlags flags)
 {
-  struct GNUNET_MESSENGER_Contact *sender = GNUNET_MESSENGER_get_member (room, &(message->header.sender_id));
-
   const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
 
   if (!sender_name)
     sender_name = "anonymous";
 
+  printf ("[%s] ", GNUNET_sh2s(&(message->header.sender_id)));
+
+  if (flags & GNUNET_MESSENGER_FLAG_PRIVATE)
+    printf ("*");
+
   switch (message->header.kind)
   {
   case GNUNET_MESSENGER_KIND_JOIN:
     {
-      printf ("* '%s' joined the room! [ %u %u %u %u ]\n", sender_name, message->body.join.key.ecdsa_key.q_y[0],
-              message->body.join.key.ecdsa_key.q_y[1], message->body.join.key.ecdsa_key.q_y[2],
-              message->body.join.key.ecdsa_key.q_y[3]);
+      printf ("* '%s' joined the room!\n", sender_name);
+      break;
+    }
+  case GNUNET_MESSENGER_KIND_NAME:
+    {
+      printf ("* '%s' gets renamed to '%s'\n", sender_name, message->body.name.name);
       break;
     }
   case GNUNET_MESSENGER_KIND_LEAVE:
@@ -76,6 +85,7 @@ on_message (void *cls, const struct GNUNET_MESSENGER_Room *room, const struct GN
     }
   default:
     {
+      printf ("~ message: %s\n", GNUNET_MESSENGER_name_of_kind(message->header.kind));
       break;
     }
   }
@@ -86,7 +96,7 @@ struct GNUNET_SCHEDULER_Task *read_task;
 /**
  * Task to shut down this application.
  *
- * @param cls Closure
+ * @param[in/out] cls Closure
  */
 static void
 shutdown_hook (void *cls)
@@ -108,10 +118,24 @@ listen_stdio (void *cls);
 
 #define MAX_BUFFER_SIZE 60000
 
+static int
+iterate_send_private_message (void *cls, struct GNUNET_MESSENGER_Room *room,
+                              const struct GNUNET_MESSENGER_Contact *contact)
+{
+  struct GNUNET_MESSENGER_Message *message = cls;
+
+  if (GNUNET_MESSENGER_contact_get_key(contact))
+    GNUNET_MESSENGER_send_message (room, message, contact);
+
+  return GNUNET_YES;
+}
+
+int private_mode;
+
 /**
  * Task run in stdio mode, after some data is available at stdin.
  *
- * @param cls Closure
+ * @param[in/out] cls Closure
  */
 static void
 read_stdio (void *cls)
@@ -140,7 +164,10 @@ read_stdio (void *cls)
   message.header.kind = GNUNET_MESSENGER_KIND_TEXT;
   message.body.text.text = buffer;
 
-  GNUNET_MESSENGER_send_message (room, &message);
+  if (GNUNET_YES == private_mode)
+    GNUNET_MESSENGER_iterate_members(room, iterate_send_private_message, &message);
+  else
+    GNUNET_MESSENGER_send_message (room, &message, NULL);
 
   read_task = GNUNET_SCHEDULER_add_now (listen_stdio, cls);
 }
@@ -148,7 +175,7 @@ read_stdio (void *cls)
 /**
  * Wait for input on STDIO and send it out over the #ch.
  *
- * @param cls Closure
+ * @param[in/out] cls Closure
  */
 static void
 listen_stdio (void *cls)
@@ -160,10 +187,8 @@ listen_stdio (void *cls)
   GNUNET_NETWORK_fdset_set_native (rs, 0);
 
   read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-  GNUNET_TIME_UNIT_FOREVER_REL,
-                                           rs,
-                                           NULL,
-                                           &read_stdio, cls);
+                                           GNUNET_TIME_UNIT_FOREVER_REL, rs,
+                                           NULL, &read_stdio, cls);
 
   GNUNET_NETWORK_fdset_destroy (rs);
 }
@@ -171,7 +196,7 @@ listen_stdio (void *cls)
 /**
  * Initial task to startup application.
  *
- * @param cls Closure
+ * @param[in/out] cls Closure
  */
 static void
 idle (void *cls)
@@ -192,8 +217,8 @@ struct GNUNET_SCHEDULER_Task *shutdown_task;
 /**
  * Function called when an identity is retrieved.
  *
- * @param cls Closure
- * @param handle Handle of messenger service
+ * @param[in/out] cls Closure
+ * @param[in/out] handle Handle of messenger service
  */
 static void
 on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
@@ -204,18 +229,12 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
   if (room_key)
     GNUNET_CRYPTO_hash (room_key, strlen (room_key), &key);
 
+  struct GNUNET_PeerIdentity door_peer;
   struct GNUNET_PeerIdentity *door = NULL;
 
-  if (door_id)
-  {
-    door = GNUNET_new(struct GNUNET_PeerIdentity);
-
-    if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (door_id, strlen (door_id), &(door->public_key)))
-    {
-      GNUNET_free(door);
-      door = NULL;
-    }
-  }
+  if ((door_id) &&
+      (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string (door_id, strlen (door_id), &(door_peer.public_key))))
+    door = &door_peer;
 
   const char *name = GNUNET_MESSENGER_get_name (handle);
 
@@ -230,7 +249,7 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
   {
     printf ("* You try to entry a room...\n");
 
-    room = GNUNET_MESSENGER_entry_room (messenger, door, &key);
+    room = GNUNET_MESSENGER_enter_room (messenger, door, &key);
   }
   else
   {
@@ -246,17 +265,26 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
   if (!room)
     GNUNET_SCHEDULER_shutdown ();
   else
+  {
+    struct GNUNET_MESSENGER_Message message;
+    message.header.kind = GNUNET_MESSENGER_KIND_NAME;
+    message.body.name.name = GNUNET_strdup(name);
+
+    GNUNET_MESSENGER_send_message (room, &message, NULL);
+    GNUNET_free(message.body.name.name);
+
     GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (), GNUNET_SCHEDULER_PRIORITY_IDLE, idle,
                                                 room);
+  }
 }
 
 /**
  * Main function that will be run by the scheduler.
  *
- * @param cls closure
- * @param args remaining command-line arguments
- * @param cfgfile name of the configuration file used (for saving, can be NULL!)
- * @param cfg configuration
+ * @param[in/out] cls closure
+ * @param[in] args remaining command-line arguments
+ * @param[in] cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param[in] cfg configuration
  */
 static void
 run (void *cls, char *const*args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
@@ -269,38 +297,24 @@ run (void *cls, char *const*args, const char *cfgfile, const struct GNUNET_CONFI
 /**
  * The main function to obtain messenger information.
  *
- * @param argc number of arguments from the command line
- * @param argv command line arguments
- * @return 0 ok, 1 on error
+ * @param[in] argc number of arguments from the command line
+ * @param[in] argv command line arguments
+ * @return #EXIT_SUCCESS ok, #EXIT_FAILURE on error
  */
 int
 main (int argc, char **argv)
 {
   const char *description = "Open and connect to rooms using the MESSENGER to chat.";
 
-  struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_string ('d',
-                                 "door",
-                                 "PEERIDENTITY",
-                                 "peer identity to entry into the room",
-                                 &door_id),
-    GNUNET_GETOPT_option_string ('e',
-                                 "ego",
-                                 "IDENTITY",
-                                 "identity to use for messaging",
-                                 &ego_name),
-    GNUNET_GETOPT_option_string ('r',
-                                 "room",
-                                 "ROOMKEY",
-                                 "key of the room to connect to",
-                                 &room_key),
-    GNUNET_GETOPT_OPTION_END };
-
-  return (GNUNET_OK == GNUNET_PROGRAM_run (argc,
-                                           argv,
-                                           "gnunet-messenger\0",
-                                           gettext_noop(description),
-                                           options,
-                                           &run,
-                                           NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+  {
+    GNUNET_GETOPT_option_string ('d', "door", "PEERIDENTITY", "peer identity to entry into the room", &door_id),
+    GNUNET_GETOPT_option_string ('e', "ego", "IDENTITY", "identity to use for messaging", &ego_name),
+    GNUNET_GETOPT_option_string ('r', "room", "ROOMKEY", "key of the room to connect to", &room_key),
+    GNUNET_GETOPT_option_flag ('p', "private", "flag to enable private mode", &private_mode),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-messenger\0", gettext_noop(description), options, &run,
+  NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
 }
diff --git a/src/messenger/gnunet-service-messenger.c b/src/messenger/gnunet-service-messenger.c
index 2c92305c4..7edd76d32 100644..100755
--- a/src/messenger/gnunet-service-messenger.c
+++ b/src/messenger/gnunet-service-messenger.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,6 +25,8 @@
 
 #include "gnunet-service-messenger.h"
 
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_message_kind.h"
 #include "gnunet-service-messenger_service.h"
 #include "messenger_api_message.h"
 
@@ -52,7 +54,7 @@ handle_create (void *cls, const struct GNUNET_MESSENGER_CreateMessage *msg)
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle created with name: %s\n", name);
 
-  setup_handle_name (msg_client->handle, strlen (name) > 0? name : NULL);
+  setup_handle_name (msg_client->handle, strlen (name) > 0 ? name : NULL);
 
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
@@ -62,8 +64,7 @@ handle_update (void *cls, const struct GNUNET_MESSENGER_UpdateMessage *msg)
 {
   struct GNUNET_MESSENGER_Client *msg_client = cls;
 
-  if (GNUNET_OK != update_handle (msg_client->handle))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Name is required to update key!\n");
+  update_handle (msg_client->handle);
 
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
@@ -92,8 +93,7 @@ handle_set_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handles name is now: %s\n", name);
 
-  if (GNUNET_YES != set_handle_name (msg_client->handle, name))
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No valid name: %s\n", name);
+  set_handle_name (msg_client->handle, name);
 
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
@@ -103,15 +103,13 @@ handle_room_open (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 {
   struct GNUNET_MESSENGER_Client *msg_client = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening room: %s\n",
-             GNUNET_h2s (&(msg->key)));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening room: %s\n", GNUNET_h2s (&(msg->key)));
 
   if (GNUNET_YES == open_handle_room (msg_client->handle, &(msg->key)))
   {
-    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+    const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (msg_client->handle, &(msg->key));
 
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening room with member id: %s\n",
-               GNUNET_sh2s (member_id));
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening room with member id: %s\n", GNUNET_sh2s (member_id));
 
     struct GNUNET_MESSENGER_RoomMessage *response;
     struct GNUNET_MQ_Envelope *env;
@@ -121,8 +119,7 @@ handle_room_open (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
     GNUNET_MQ_send (msg_client->handle->mq, env);
   }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Opening room failed: %s\n",
-               GNUNET_h2s (&(msg->key)));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Opening room failed: %s\n", GNUNET_h2s (&(msg->key)));
 
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
@@ -132,15 +129,13 @@ handle_room_entry (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 {
   struct GNUNET_MESSENGER_Client *msg_client = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entering room: %s, %s\n",
-             GNUNET_h2s (&(msg->key)), GNUNET_i2s (&(msg->door)));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entering room: %s, %s\n", GNUNET_h2s (&(msg->key)), GNUNET_i2s (&(msg->door)));
 
   if (GNUNET_YES == entry_handle_room (msg_client->handle, &(msg->door), &(msg->key)))
   {
-    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+    const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (msg_client->handle, &(msg->key));
 
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entering room with member id: %s\n",
-               GNUNET_sh2s (member_id));
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entering room with member id: %s\n", GNUNET_sh2s (member_id));
 
     struct GNUNET_MESSENGER_RoomMessage *response;
     struct GNUNET_MQ_Envelope *env;
@@ -151,8 +146,8 @@ handle_room_entry (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
     GNUNET_MQ_send (msg_client->handle->mq, env);
   }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Entrance into room failed: %s, %s\n",
-               GNUNET_h2s (&(msg->key)), GNUNET_i2s (&(msg->door)));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Entrance into room failed: %s, %s\n", GNUNET_h2s (&(msg->key)),
+               GNUNET_i2s (&(msg->door)));
 
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
@@ -166,10 +161,9 @@ handle_room_close (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 
   if (GNUNET_YES == close_handle_room (msg_client->handle, &(msg->key)))
   {
-    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+    const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (msg_client->handle, &(msg->key));
 
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closing room with member id: %s\n",
-               GNUNET_sh2s (member_id));
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closing room with member id: %s\n", GNUNET_sh2s (member_id));
 
     struct GNUNET_MESSENGER_RoomMessage *response;
     struct GNUNET_MQ_Envelope *env;
@@ -187,17 +181,43 @@ handle_room_close (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 static int
 check_send_message (void *cls, const struct GNUNET_MESSENGER_SendMessage *msg)
 {
-  const uint16_t full_length = ntohs (msg->header.size) - sizeof(msg->header);
+  const uint16_t full_length = ntohs (msg->header.size);
 
-  if (full_length < sizeof(msg->key))
+  if (full_length < sizeof(*msg))
     return GNUNET_NO;
 
-  const uint16_t length = full_length - sizeof(msg->key);
+  const enum GNUNET_MESSENGER_MessageFlags flags = (
+      (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
+  );
+
+  const uint16_t length = full_length - sizeof(*msg);
   const char *buffer = ((const char*) msg) + sizeof(*msg);
 
+  ssize_t key_length = 0;
+
+  if (!(flags & GNUNET_MESSENGER_FLAG_PRIVATE))
+    goto check_for_message;
+
+  struct GNUNET_IDENTITY_PublicKey public_key;
+
+  key_length = GNUNET_IDENTITY_read_key_from_buffer(&public_key, buffer, length);
+
+check_for_message:
+  if (key_length < 0)
+    return GNUNET_NO;
+
+  const uint16_t msg_length = length - key_length;
+  const char* msg_buffer = buffer + key_length;
+
   struct GNUNET_MESSENGER_Message message;
 
-  if (GNUNET_YES != decode_message (&message, length, buffer))
+  if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN))
+    return GNUNET_NO;
+
+  if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer, GNUNET_NO, NULL))
+    return GNUNET_NO;
+
+  if (GNUNET_YES != filter_message_sending(&message))
     return GNUNET_NO;
 
   return GNUNET_OK;
@@ -208,42 +228,115 @@ handle_send_message (void *cls, const struct GNUNET_MESSENGER_SendMessage *msg)
 {
   struct GNUNET_MESSENGER_Client *msg_client = cls;
 
+  const enum GNUNET_MESSENGER_MessageFlags flags = (
+      (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
+  );
+
   const struct GNUNET_HashCode *key = &(msg->key);
   const char *buffer = ((const char*) msg) + sizeof(*msg);
 
   const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
+  ssize_t key_length = 0;
+
+  struct GNUNET_IDENTITY_PublicKey public_key;
+
+  if (flags & GNUNET_MESSENGER_FLAG_PRIVATE)
+    key_length = GNUNET_IDENTITY_read_key_from_buffer(
+        &public_key, buffer, length
+    );
+
+  const uint16_t msg_length = length - key_length;
+  const char* msg_buffer = buffer + key_length;
 
   struct GNUNET_MESSENGER_Message message;
-  decode_message (&message, length, buffer);
+  decode_message (&message, msg_length, msg_buffer, GNUNET_NO, NULL);
+
+  if ((flags & GNUNET_MESSENGER_FLAG_PRIVATE) &&
+      (GNUNET_YES != encrypt_message(&message, &public_key)))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Encrypting message failed: Message got dropped!\n");
+
+    goto end_handling;
+  }
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending message: %s to %s\n",
-             GNUNET_MESSENGER_name_of_kind (message.header.kind),
-             GNUNET_h2s (key));
+             GNUNET_MESSENGER_name_of_kind (message.header.kind), GNUNET_h2s (key));
 
   if (GNUNET_YES != send_handle_message (msg_client->handle, key, &message))
     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message failed: %s to %s\n",
-               GNUNET_MESSENGER_name_of_kind (message.header.kind),
-               GNUNET_h2s (key));
+               GNUNET_MESSENGER_name_of_kind (message.header.kind), GNUNET_h2s (key));
 
+end_handling:
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
 
 static void
-handle_get_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
+callback_found_message (void *cls, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  if (!message)
+  {
+    send_room_message(room, msg_client->handle, create_message_request(hash));
+    return;
+  }
+
+  struct GNUNET_MESSENGER_MemberStore *store = get_room_member_store(room);
+
+  struct GNUNET_MESSENGER_Member *member = get_store_member_of(store, message);
+
+  if (!member)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sender of message (%s) unknown!\n", GNUNET_h2s (hash));
+    return;
+  }
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, hash);
+
+  if (session)
+    notify_handle_message (msg_client->handle, get_room_key(room), session, message, hash);
+}
+
+static void
+handle_get_message (void *cls, const struct GNUNET_MESSENGER_GetMessage *msg)
 {
   struct GNUNET_MESSENGER_Client *msg_client = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Requesting message from room: %s\n",
-             GNUNET_h2s (&(msg->key)));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Requesting message from room: %s\n", GNUNET_h2s (&(msg->key)));
 
   struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (messenger, &(msg->key));
 
-  if (room)
-    get_room_message (room, msg_client->handle, &(msg->hash), GNUNET_YES);
-  else
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Room not found: %s\n",
-               GNUNET_h2s (&(msg->key)));
+  if (!room)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Room not found: %s\n", GNUNET_h2s (&(msg->key)));
+    goto end_handling;
+  }
+
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+
+  struct GNUNET_MESSENGER_Member *member = get_store_member(member_store, get_handle_member_id(
+      msg_client->handle, &(msg->key)
+  ));
+
+  if (!member)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Member not valid to request a message!\n");
+    goto end_handling;
+  }
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session(member, &(get_handle_ego(msg_client->handle)->pub));
+
+  if (!session)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Session not valid to request a message!\n");
+    goto end_handling;
+  }
+
+  request_room_message (room, &(msg->hash), session, callback_found_message, msg_client);
 
+end_handling:
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
 
@@ -271,16 +364,16 @@ callback_client_disconnect (void *cls, struct GNUNET_SERVICE_Client *client, voi
 /**
  * Setup MESSENGER internals.
  *
- * @param cls closure
- * @param config configuration to use
- * @param service the initialized service
+ * @param[in/out] cls closure
+ * @param[in] config configuration to use
+ * @param[in/out] service the initialized service
  */
 static void
 run (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service)
 {
   messenger = create_service (config, service);
 
-  if ((!messenger) || (!messenger->cadet) || (!messenger->identity))
+  if (!messenger)
     GNUNET_SCHEDULER_shutdown ();
 }
 
@@ -302,5 +395,5 @@ GNUNET_SERVICE_MAIN(
     GNUNET_MQ_hd_fixed_size( room_entry, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, struct GNUNET_MESSENGER_RoomMessage, NULL ),
     GNUNET_MQ_hd_fixed_size( room_close, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, struct GNUNET_MESSENGER_RoomMessage, NULL ),
     GNUNET_MQ_hd_var_size( send_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE, struct GNUNET_MESSENGER_SendMessage, NULL ),
-    GNUNET_MQ_hd_fixed_size( get_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, struct GNUNET_MESSENGER_RecvMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( get_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, struct GNUNET_MESSENGER_GetMessage, NULL ),
     GNUNET_MQ_handler_end());
diff --git a/src/messenger/gnunet-service-messenger.h b/src/messenger/gnunet-service-messenger.h
index 85a1d2549..253fbaadb 100644
--- a/src/messenger/gnunet-service-messenger.h
+++ b/src/messenger/gnunet-service-messenger.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -74,7 +74,6 @@ struct GNUNET_MESSENGER_NameMessage
 struct GNUNET_MESSENGER_KeyMessage
 {
   struct GNUNET_MessageHeader header;
-  struct GNUNET_IDENTITY_PublicKey pubkey;
 };
 
 /**
@@ -105,7 +104,20 @@ struct GNUNET_MESSENGER_MemberMessage
 struct GNUNET_MESSENGER_SendMessage
 {
   struct GNUNET_MessageHeader header;
+
   struct GNUNET_HashCode key;
+  uint32_t flags;
+};
+
+/**
+ * Message to request something from a room
+ */
+struct GNUNET_MESSENGER_GetMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode hash;
 };
 
 /**
@@ -114,8 +126,12 @@ struct GNUNET_MESSENGER_SendMessage
 struct GNUNET_MESSENGER_RecvMessage
 {
   struct GNUNET_MessageHeader header;
+
   struct GNUNET_HashCode key;
+  struct GNUNET_HashCode sender;
+  struct GNUNET_HashCode context;
   struct GNUNET_HashCode hash;
+  uint32_t flags;
 };
 
 #endif //GNUNET_SERVICE_MESSENGER_H
diff --git a/src/messenger/gnunet-service-messenger_basement.c b/src/messenger/gnunet-service-messenger_basement.c
index 190cf2de5..f302c8d66 100644
--- a/src/messenger/gnunet-service-messenger_basement.c
+++ b/src/messenger/gnunet-service-messenger_basement.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -28,6 +28,8 @@
 size_t
 count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels *tunnels)
 {
+  GNUNET_assert(tunnels);
+
   const struct GNUNET_MESSENGER_ListTunnel *element;
   size_t count = 0;
 
diff --git a/src/messenger/gnunet-service-messenger_basement.h b/src/messenger/gnunet-service-messenger_basement.h
index 0a1a9b126..b19aec405 100644
--- a/src/messenger/gnunet-service-messenger_basement.h
+++ b/src/messenger/gnunet-service-messenger_basement.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -31,34 +31,34 @@
 /**
  * Returns the count of peers in a list (typically from the basement of a room).
  *
- * @param tunnels List of peer identities
+ * @param[in] tunnels List of peer identities
  * @return Count of the entries in the list
  */
 size_t
 count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels *tunnels);
 
 /**
- * Returns GNUNET_YES or GNUNET_NO to determine if the peer at index <i>src</i> should
+ * Returns #GNUNET_YES or #GNUNET_NO to determine if the peer at index <i>src</i> should
  * or should not connect outgoing to the peer at index <i>dst</i> to construct a complete
  * basement with a given <i>count</i> of peers.
  *
- * @param count Count of peers
- * @param src Source index
- * @param dst Destination index
- * @return GNUNET_YES or GNUNET_NO based on topologic requirement
+ * @param[in] count Count of peers
+ * @param[in] src Source index
+ * @param[in] dst Destination index
+ * @return #GNUNET_YES or #GNUNET_NO based on topologic requirement
  */
 int
 should_connect_tunnel_to (size_t count, size_t src, size_t dst);
 
 /**
- * Returns GNUNET_YES or GNUNET_NO to determine if the peers of index <i>src</i> and
+ * Returns #GNUNET_YES or #GNUNET_NO to determine if the peers of index <i>src</i> and
  * index <i>dst</i> should be connected in any direction to construct a complete
  * basement with a given <i>count</i> of peers.
  *
- * @param count Count of peers
- * @param src Source index
- * @param dst Destination index
- * @return GNUNET_YES or GNUNET_NO based on topologic requirement
+ * @param[in] count Count of peers
+ * @param[in] src Source index
+ * @param[in] dst Destination index
+ * @return #GNUNET_YES or #GNUNET_NO based on topologic requirement
  */
 int
 required_connection_between (size_t count, size_t src, size_t dst);
diff --git a/src/messenger/gnunet-service-messenger_contact.c b/src/messenger/gnunet-service-messenger_contact.c
deleted file mode 100644
index 1ec125402..000000000
--- a/src/messenger/gnunet-service-messenger_contact.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-   This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
-
-   GNUnet is free software: you can redistribute it and/or modify it
-   under the terms of the GNU Affero General Public License as published
-   by the Free Software Foundation, either version 3 of the License,
-   or (at your option) any later version.
-
-   GNUnet is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-   SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @author Tobias Frisch
- * @file src/messenger/gnunet-service-messenger_contact.c
- * @brief GNUnet MESSENGER service
- */
-
-#include "gnunet-service-messenger_contact.h"
-
-struct GNUNET_MESSENGER_SrvContact*
-create_contact (const struct GNUNET_IDENTITY_PublicKey *key)
-{
-  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_new(struct GNUNET_MESSENGER_SrvContact);
-
-  contact->name = NULL;
-  contact->rc = 0;
-
-  GNUNET_memcpy(&(contact->public_key), key, sizeof(contact->public_key));
-
-  return contact;
-}
-
-void
-destroy_contact (struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  if (contact->name)
-    GNUNET_free(contact->name);
-
-  GNUNET_free(contact);
-}
-
-const char*
-get_contact_name (const struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  return contact->name;
-}
-
-void
-set_contact_name (struct GNUNET_MESSENGER_SrvContact *contact, const char *name)
-{
-  GNUNET_assert(name);
-
-  if (contact->name)
-    GNUNET_free(contact->name);
-
-  contact->name = GNUNET_strdup(name);
-}
-
-const struct GNUNET_IDENTITY_PublicKey*
-get_contact_key (const struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  return &(contact->public_key);
-}
-
-void
-increase_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  contact->rc++;
-}
-
-int
-decrease_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  if (contact->rc > 0)
-    contact->rc--;
-
-  return contact->rc ? GNUNET_NO : GNUNET_YES;
-}
-
-const struct GNUNET_HashCode*
-get_contact_id_from_key (const struct GNUNET_MESSENGER_SrvContact *contact)
-{
-  static struct GNUNET_HashCode id;
-
-  GNUNET_CRYPTO_hash (&(contact->public_key), sizeof(contact->public_key), &id);
-
-  return &id;
-}
diff --git a/src/messenger/gnunet-service-messenger_contact.h b/src/messenger/gnunet-service-messenger_contact.h
deleted file mode 100644
index 4a4f8bf0f..000000000
--- a/src/messenger/gnunet-service-messenger_contact.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-   This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
-
-   GNUnet is free software: you can redistribute it and/or modify it
-   under the terms of the GNU Affero General Public License as published
-   by the Free Software Foundation, either version 3 of the License,
-   or (at your option) any later version.
-
-   GNUnet is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-   SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @author Tobias Frisch
- * @file src/messenger/gnunet-service-messenger_contact.h
- * @brief GNUnet MESSENGER service
- */
-
-#ifndef GNUNET_SERVICE_MESSENGER_CONTACT_H
-#define GNUNET_SERVICE_MESSENGER_CONTACT_H
-
-#include "platform.h"
-#include "gnunet_crypto_lib.h"
-#include "gnunet_identity_service.h"
-
-struct GNUNET_MESSENGER_SrvContact
-{
-  char *name;
-  size_t rc;
-
-  struct GNUNET_IDENTITY_PublicKey public_key;
-};
-
-/**
- * Creates and allocates a new contact with a given public <i>key</i> from an EGO.
- *
- * @param key Public key
- * @return New contact
- */
-struct GNUNET_MESSENGER_SrvContact*
-create_contact (const struct GNUNET_IDENTITY_PublicKey *key);
-
-/**
- * Destroys a contact and frees its memory fully.
- *
- * @param contact Contact
- */
-void
-destroy_contact (struct GNUNET_MESSENGER_SrvContact *contact);
-
-/**
- * Returns the current name of a given <i>contact</i> or NULL if no valid name was assigned yet.
- *
- * @param contact Contact
- * @return Name of the contact or NULL
- */
-const char*
-get_contact_name (const struct GNUNET_MESSENGER_SrvContact *contact);
-
-/**
- * Changes the current name of a given <i>contact</i> by copying it from the parameter <i>name</i>.
- *
- * @param contact Contact
- * @param name Valid name (may not be NULL!)
- */
-void
-set_contact_name (struct GNUNET_MESSENGER_SrvContact *contact, const char *name);
-
-/**
- * Returns the public key of a given <i>contact</i>.
- *
- * @param contact Contact
- * @return Public key of the contact
- */
-const struct GNUNET_IDENTITY_PublicKey*
-get_contact_key (const struct GNUNET_MESSENGER_SrvContact *contact);
-
-/**
- * Increases the reference counter of a given <i>contact</i> which is zero as default.
- *
- * @param contact Contact
- */
-void
-increase_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact);
-
-/**
- * Decreases the reference counter if possible (can not underflow!) of a given <i>contact</i>
- * and returns GNUNET_YES if the counter is equal to zero, otherwise GNUNET_NO.
- *
- * @param contact Contact
- * @return GNUNET_YES or GNUNET_NO depending on the reference counter
- */
-int
-decrease_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact);
-
-/**
- * Returns the resulting hashcode of the public key from a given <i>contact</i>.
- *
- * @param contact Contact
- * @return Hash of the contacts public key
- */
-const struct GNUNET_HashCode*
-get_contact_id_from_key (const struct GNUNET_MESSENGER_SrvContact *contact);
-
-#endif //GNUNET_SERVICE_MESSENGER_CONTACT_H
diff --git a/src/messenger/gnunet-service-messenger_ego_store.c b/src/messenger/gnunet-service-messenger_ego_store.c
new file mode 100644
index 000000000..3b069fcf5
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_ego_store.c
@@ -0,0 +1,295 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_ego_store.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_ego_store.h"
+
+#include "gnunet-service-messenger_handle.h"
+
+static void
+callback_update_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
+{
+  if ((!ego) || (!identifier))
+    return;
+
+  struct GNUNET_MESSENGER_EgoStore *store = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New ego in use: '%s'\n", identifier);
+
+  update_store_ego (store, identifier, GNUNET_IDENTITY_ego_get_private_key (ego));
+}
+
+void
+init_ego_store(struct GNUNET_MESSENGER_EgoStore *store, const struct GNUNET_CONFIGURATION_Handle *config)
+{
+  GNUNET_assert ((store) && (config));
+
+  store->cfg = config;
+  store->identity = GNUNET_IDENTITY_connect (config, &callback_update_ego, store);
+  store->egos = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  store->lu_start = NULL;
+  store->lu_end = NULL;
+
+  store->op_start = NULL;
+  store->op_end = NULL;
+}
+
+
+static int
+iterate_destroy_egos (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Ego *ego = value;
+  GNUNET_free(ego);
+  return GNUNET_YES;
+}
+
+void
+clear_ego_store(struct GNUNET_MESSENGER_EgoStore *store)
+{
+  GNUNET_assert (store);
+
+  struct GNUNET_MESSENGER_EgoOperation *op;
+
+  while (store->op_start)
+  {
+    op = store->op_start;
+
+    GNUNET_IDENTITY_cancel (op->operation);
+    GNUNET_CONTAINER_DLL_remove (store->op_start, store->op_end, op);
+
+    if (op->identifier)
+      GNUNET_free (op->identifier);
+
+    GNUNET_free (op);
+  }
+
+  struct GNUNET_MESSENGER_EgoLookup *lu;
+
+  while (store->lu_start)
+  {
+    lu = store->lu_start;
+
+    GNUNET_IDENTITY_ego_lookup_cancel(lu->lookup);
+    GNUNET_CONTAINER_DLL_remove (store->lu_start, store->lu_end, lu);
+
+    if (lu->identifier)
+      GNUNET_free(lu->identifier);
+
+    GNUNET_free (lu);
+  }
+
+  GNUNET_CONTAINER_multihashmap_iterate (store->egos, iterate_destroy_egos, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (store->egos);
+
+  if (store->identity)
+  {
+    GNUNET_IDENTITY_disconnect (store->identity);
+
+    store->identity = NULL;
+  }
+}
+
+static void
+callback_ego_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *emsg)
+{
+  struct GNUNET_MESSENGER_EgoOperation *element = cls;
+  struct GNUNET_MESSENGER_EgoStore *store = element->store;
+
+  GNUNET_assert(element->identifier);
+
+  if (emsg)
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", emsg);
+
+  if (key)
+  {
+    struct GNUNET_MESSENGER_SrvHandle *handle = element->handle;
+
+    struct GNUNET_MESSENGER_Ego *msg_ego = update_store_ego (store, element->identifier, key);
+
+    set_handle_ego (handle, msg_ego);
+  }
+  else
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Creating ego failed!\n");
+
+  GNUNET_CONTAINER_DLL_remove (store->op_start, store->op_end, element);
+  GNUNET_free (element->identifier);
+  GNUNET_free (element);
+}
+
+void
+create_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                  void *handle)
+{
+  GNUNET_assert ((store) && (identifier));
+
+  struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct GNUNET_MESSENGER_EgoOperation);
+
+  element->store = store;
+  element->handle = handle;
+
+  element->identifier = GNUNET_strdup (identifier);
+
+  element->operation = GNUNET_IDENTITY_create (store->identity, identifier, NULL,
+                                               GNUNET_IDENTITY_TYPE_ECDSA, callback_ego_create, element);
+
+  GNUNET_CONTAINER_DLL_insert (store->op_start, store->op_end, element);
+}
+
+static void
+callback_ego_lookup (void *cls, struct GNUNET_IDENTITY_Ego *ego)
+{
+  struct GNUNET_MESSENGER_EgoLookup *element = cls;
+  struct GNUNET_MESSENGER_EgoStore *store = element->store;
+
+  GNUNET_assert(element->identifier);
+
+  struct GNUNET_MESSENGER_Ego *msg_ego;
+
+  if (ego)
+    msg_ego = update_store_ego (
+        store, element->identifier, GNUNET_IDENTITY_ego_get_private_key(ego)
+    );
+  else
+    msg_ego = NULL;
+
+  if (element->cb)
+    element->cb(element->cls, element->identifier, msg_ego);
+
+  GNUNET_CONTAINER_DLL_remove (store->lu_start, store->lu_end, element);
+  GNUNET_free (element->identifier);
+  GNUNET_free (element);
+}
+
+void
+lookup_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                 GNUNET_MESSENGER_EgoLookupCallback lookup, void *cls)
+{
+  GNUNET_assert (store);
+
+  if (!identifier)
+  {
+    lookup(cls, identifier, NULL);
+    return;
+  }
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
+
+  struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (store->egos, &hash);
+
+  if (ego)
+    lookup(cls, identifier, ego);
+  else
+  {
+    struct GNUNET_MESSENGER_EgoLookup *element = GNUNET_new (struct GNUNET_MESSENGER_EgoLookup);
+
+    element->store = store;
+
+    element->cb = lookup;
+    element->cls = cls;
+
+    element->identifier = GNUNET_strdup (identifier);
+
+    element->lookup = GNUNET_IDENTITY_ego_lookup(store->cfg, identifier, callback_ego_lookup, element);
+
+    GNUNET_CONTAINER_DLL_insert (store->lu_start, store->lu_end, element);
+  }
+}
+
+struct GNUNET_MESSENGER_Ego*
+update_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                 const struct GNUNET_IDENTITY_PrivateKey *key)
+{
+  GNUNET_assert ((store) && (identifier) && (key));
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
+
+  struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (store->egos, &hash);
+
+  if (!ego)
+  {
+    ego = GNUNET_new(struct GNUNET_MESSENGER_Ego);
+    GNUNET_CONTAINER_multihashmap_put (store->egos, &hash, ego, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+
+  GNUNET_memcpy(&(ego->priv), key, sizeof(*key));
+
+  if (GNUNET_OK != GNUNET_IDENTITY_key_get_public (key, &(ego->pub)))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating invalid ego key failed!\n");
+
+  return ego;
+}
+
+static void
+callback_ego_rename (void *cls, const char *emsg)
+{
+  struct GNUNET_MESSENGER_EgoOperation *element = cls;
+  struct GNUNET_MESSENGER_EgoStore *store = element->store;
+
+  GNUNET_assert(element->identifier);
+
+  if (emsg)
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", emsg);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier), &hash);
+
+  struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (store->egos, &hash);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->egos, &hash, ego))
+  {
+    GNUNET_CRYPTO_hash ((char*) element->handle, strlen ((char*) element->handle), &hash);
+
+    GNUNET_CONTAINER_multihashmap_put (store->egos, &hash, ego,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+  else
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Renaming ego failed!\n");
+
+  GNUNET_free (element->handle);
+
+  GNUNET_CONTAINER_DLL_remove (store->op_start, store->op_end, element);
+  GNUNET_free (element->identifier);
+  GNUNET_free (element);
+}
+
+void
+rename_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *old_identifier,
+                  const char *new_identifier)
+{
+  GNUNET_assert ((store) && (old_identifier) && (new_identifier));
+
+  struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct GNUNET_MESSENGER_EgoOperation);
+
+  element->store = store;
+  element->handle = GNUNET_strdup (new_identifier);
+
+  element->identifier = GNUNET_strdup (old_identifier);
+
+  element->operation = GNUNET_IDENTITY_rename (store->identity, old_identifier, new_identifier, callback_ego_rename, element);
+
+  GNUNET_CONTAINER_DLL_insert (store->op_start, store->op_end, element);
+}
diff --git a/src/messenger/gnunet-service-messenger_ego_store.h b/src/messenger/gnunet-service-messenger_ego_store.h
new file mode 100644
index 000000000..41f14fff2
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_ego_store.h
@@ -0,0 +1,152 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_ego_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_EGO_STORE_H
+#define GNUNET_SERVICE_MESSENGER_EGO_STORE_H
+
+#include "platform.h"
+#include "gnunet_container_lib.h"
+
+#include "messenger_api_ego.h"
+
+struct GNUNET_MESSENGER_Ego;
+struct GNUNET_MESSENGER_EgoStore;
+
+typedef void
+(*GNUNET_MESSENGER_EgoLookupCallback) (void *cls, const char *identifier,
+                                       const struct GNUNET_MESSENGER_Ego *ego);
+
+struct GNUNET_MESSENGER_EgoLookup
+{
+  struct GNUNET_MESSENGER_EgoLookup *prev;
+  struct GNUNET_MESSENGER_EgoLookup *next;
+
+  struct GNUNET_IDENTITY_EgoLookup *lookup;
+
+  struct GNUNET_MESSENGER_EgoStore *store;
+
+  GNUNET_MESSENGER_EgoLookupCallback cb;
+  void *cls;
+
+  char *identifier;
+};
+
+struct GNUNET_MESSENGER_EgoOperation
+{
+  struct GNUNET_MESSENGER_EgoOperation *prev;
+  struct GNUNET_MESSENGER_EgoOperation *next;
+
+  struct GNUNET_IDENTITY_Operation *operation;
+
+  struct GNUNET_MESSENGER_EgoStore *store;
+  void *handle;
+
+  char *identifier;
+};
+
+struct GNUNET_MESSENGER_EgoStore
+{
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  struct GNUNET_IDENTITY_Handle *identity;
+  struct GNUNET_CONTAINER_MultiHashMap *egos;
+
+  struct GNUNET_MESSENGER_EgoLookup *lu_start;
+  struct GNUNET_MESSENGER_EgoLookup *lu_end;
+
+  struct GNUNET_MESSENGER_EgoOperation *op_start;
+  struct GNUNET_MESSENGER_EgoOperation *op_end;
+};
+
+/**
+ * Initializes an EGO-store as fully empty.
+ *
+ * @param[out] store EGO-store
+ * @param[in] config Configuration handle
+ */
+void
+init_ego_store (struct GNUNET_MESSENGER_EgoStore *store, const struct GNUNET_CONFIGURATION_Handle *config);
+
+/**
+ * Clears an EGO-store, wipes its content and deallocates its memory.
+ *
+ * @param[in/out] store EGO-store
+ */
+void
+clear_ego_store (struct GNUNET_MESSENGER_EgoStore *store);
+
+/**
+ * Creates a new EGO which will be registered to a <i>store</i> under
+ * a specific <i>identifier</i>. A given <i>handle</i> will be informed
+ * about the creation and changes its EGO accordingly.
+ *
+ * @param[in/out] store EGO-store
+ * @param[in] identifier Identifier string
+ * @param[in/out] handle Handle or NULL
+ */
+void
+create_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                  void *handle);
+
+/**
+ * Lookups an EGO which was registered to a <i>store</i> under
+ * a specific <i>identifier</i>.
+ *
+ * @param[in/out] store EGO-store
+ * @param[in] identifier Identifier string
+ * @param[in] lookup Lookup callback (non-NULL)
+ * @param[in] cls Closure
+ */
+void
+lookup_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                  GNUNET_MESSENGER_EgoLookupCallback lookup, void *cls);
+
+/**
+ * Updates the registration of an EGO to a <i>store</i> under
+ * a specific <i>identifier</i> with a new <i>key</i>.
+ *
+ * @param[in/out] store EGO-store
+ * @param[in] identifier Identifier string
+ * @param[in] key Private EGO key
+ * @return Updated EGO
+ */
+struct GNUNET_MESSENGER_Ego*
+update_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *identifier,
+                  const struct GNUNET_IDENTITY_PrivateKey *key);
+
+/**
+ * Updates the location of a registered EGO in a <i>store</i> to
+ * a different one under a specific <i>new_identifier<i> replacing
+ * its old one.
+ *
+ * @param[in/out] store EGO-store
+ * @param[in] old_identifier Old identifier string
+ * @param[in] new_identifier New identifier string
+ */
+void
+rename_store_ego (struct GNUNET_MESSENGER_EgoStore *store, const char *old_identifier,
+                  const char *new_identifier);
+
+#endif //GNUNET_SERVICE_MESSENGER_EGO_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_handle.c b/src/messenger/gnunet-service-messenger_handle.c
index 38ad6fbb4..4d2318d62 100644
--- a/src/messenger/gnunet-service-messenger_handle.c
+++ b/src/messenger/gnunet-service-messenger_handle.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -28,18 +28,19 @@
 #include "gnunet-service-messenger.h"
 #include "gnunet-service-messenger_message_kind.h"
 
+#include "messenger_api_util.h"
+
 struct GNUNET_MESSENGER_SrvHandle*
 create_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
 {
+  GNUNET_assert((service) && (mq));
+
   struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct GNUNET_MESSENGER_SrvHandle);
 
   handle->service = service;
   handle->mq = mq;
 
   handle->name = NULL;
-
-  handle->operation = NULL;
-
   handle->ego = NULL;
 
   handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
@@ -58,11 +59,10 @@ iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *val
 void
 destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  if (handle->service->dir)
-   save_handle_configuration(handle);
+  GNUNET_assert(handle);
 
-  if (handle->operation)
-    GNUNET_IDENTITY_cancel (handle->operation);
+  if (handle->service->dir)
+    save_handle_configuration (handle);
 
   if (handle->name)
     GNUNET_free(handle->name);
@@ -74,8 +74,10 @@ destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 }
 
 void
-get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
+get_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
 {
+  GNUNET_assert((handle) && (dir));
+
   if (name)
     GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
                      DIR_SEPARATOR, name, DIR_SEPARATOR);
@@ -87,11 +89,15 @@ get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *n
 static int
 create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
-  struct GNUNET_ShortHashCode *random_id = generate_service_new_member_id (handle->service, key);
+  GNUNET_assert((handle) && (key));
+
+  struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
 
   if (!random_id)
     return GNUNET_NO;
 
+  generate_free_member_id (random_id, NULL);
+
   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, random_id,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
   {
@@ -99,8 +105,8 @@ create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const
     return GNUNET_NO;
   }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n",
-             GNUNET_sh2s(random_id), GNUNET_h2s(key));
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (random_id),
+             GNUNET_h2s (key));
 
   return GNUNET_YES;
 }
@@ -108,48 +114,61 @@ create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const
 const struct GNUNET_ShortHashCode*
 get_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 }
 
-void
+int
 change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
                          const struct GNUNET_ShortHashCode *unique_id)
 {
-  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
-
-  if (member_id)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Changed a member id (%s) for room (%s) ",
-               GNUNET_sh2s(member_id), GNUNET_h2s(key));
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "into (%s).\n",
-               GNUNET_sh2s(unique_id));
-
-    GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
-
-    struct GNUNET_MESSENGER_MemberMessage *msg;
-    struct GNUNET_MQ_Envelope *env;
+  GNUNET_assert((handle) && (key) && (unique_id));
 
-    env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
-
-    GNUNET_memcpy(&(msg->key), key, sizeof(*key));
-    GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
+  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 
-    GNUNET_MQ_send (handle->mq, env);
-  }
-  else
+  if (!member_id)
   {
     member_id = GNUNET_new(struct GNUNET_ShortHashCode);
     GNUNET_memcpy(member_id, unique_id, sizeof(*member_id));
 
     if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, member_id,
                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    {
       GNUNET_free(member_id);
+      return GNUNET_SYSERR;
+    }
   }
+
+  if (0 == GNUNET_memcmp(unique_id, member_id))
+    goto send_message_to_client;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (member_id),
+             GNUNET_h2s (key));
+
+  GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
+
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n", GNUNET_sh2s (unique_id));
+
+  struct GNUNET_MESSENGER_MemberMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+send_message_to_client:
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+
+  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
+  GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
+
+  GNUNET_MQ_send (handle->mq, env);
+  return GNUNET_OK;
 }
 
 static void
 change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 {
+  GNUNET_assert(handle);
+
   if (handle->name)
     GNUNET_free(handle->name);
 
@@ -173,25 +192,67 @@ change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 }
 
 static void
-change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Ego *ego)
+change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
 {
+  GNUNET_assert(handle);
+
   handle->ego = ego;
 
-  ego = get_handle_ego(handle);
+  ego = get_handle_ego (handle);
+
+  const uint16_t length = GNUNET_IDENTITY_key_get_length(&(ego->pub));
 
   struct GNUNET_MESSENGER_KeyMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);
+  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);
 
-  GNUNET_memcpy(&(msg->pubkey), &(ego->pub), sizeof(ego->pub));
+  char *extra = ((char*) msg) + sizeof(*msg);
+
+  if (GNUNET_IDENTITY_write_key_to_buffer(&(ego->pub), extra, length) < 0)
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Could not write key to buffer.\n");
 
   GNUNET_MQ_send (handle->mq, env);
 }
 
-struct GNUNET_MESSENGER_Ego*
-get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle)
+struct GNUNET_MESSENGER_MessageHandle
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_Message *message;
+};
+
+static int
+iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
+
+  send_handle_message (msg_handle->handle, key, msg_handle->message);
+
+  return GNUNET_YES;
+}
+
+void
+set_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
+{
+  GNUNET_assert((handle) && (ego));
+
+  struct GNUNET_MESSENGER_MessageHandle msg_handle;
+
+  msg_handle.handle = handle;
+  msg_handle.message = create_message_key (&(ego->priv));
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
+
+  destroy_message (msg_handle.message);
+
+  change_handle_ego (handle, ego);
+}
+
+const struct GNUNET_MESSENGER_Ego*
+get_handle_ego (const struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert(handle);
+
   static struct GNUNET_MESSENGER_Ego anonymous;
   static int read_keys = 0;
 
@@ -200,99 +261,86 @@ get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle)
 
   if (!read_keys)
   {
-    struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous ();
-    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key(ego), sizeof(anonymous.priv));
-    GNUNET_IDENTITY_ego_get_public_key(ego, &(anonymous.pub));
+    struct GNUNET_IDENTITY_Ego *ego = GNUNET_IDENTITY_ego_get_anonymous ();
+    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key (ego), sizeof(anonymous.priv));
+    GNUNET_IDENTITY_ego_get_public_key (ego, &(anonymous.pub));
     read_keys = 1;
   }
 
   return &anonymous;
 }
 
-void
-setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+static void
+callback_setup_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting up handle...\n");
+
   change_handle_name (handle, name);
-  change_handle_ego (handle, handle->name? lookup_service_ego(handle->service, handle->name) : NULL);
+  change_handle_ego (handle, ego);
 
   if (handle->service->dir)
-   load_handle_configuration(handle);
+    load_handle_configuration (handle);
 }
 
-struct GNUNET_MESSENGER_MessageHandle
-{
-  struct GNUNET_MESSENGER_SrvHandle *handle;
-  struct GNUNET_MESSENGER_Message *message;
-};
-
-static int
-iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+void
+setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 {
-  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
+  GNUNET_assert(handle);
 
-  send_handle_message (msg_handle->handle, key, msg_handle->message);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return GNUNET_YES;
+  lookup_store_ego (store, name, callback_setup_handle_name, handle);
 }
 
 static void
-callback_ego_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *emsg)
+callback_update_handle (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
   struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  handle->operation = NULL;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating handle...\n");
 
-  if (emsg)
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", emsg);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  if (key)
-  {
-    struct GNUNET_MESSENGER_MessageHandle msg_handle;
-
-    msg_handle.handle = handle;
-    msg_handle.message = create_message_key (key);
-
-    GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
-
-    destroy_message (msg_handle.message);
-
-    update_service_ego(handle->service, handle->name, key);
-
-    change_handle_ego (handle, lookup_service_ego(handle->service, handle->name));
-  }
+  if (!ego)
+    create_store_ego(store, handle->name, handle);
+  else
+    change_handle_ego (handle, ego);
 }
 
-int
+void
 update_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
   GNUNET_assert(handle);
 
   if (!handle->name)
-    return GNUNET_SYSERR;
-
-  struct GNUNET_MESSENGER_Ego *ego = lookup_service_ego(handle->service, handle->name);
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating handle failed: Name is required!\n");
+    return;
+  }
 
-  if (!ego)
-    handle->operation = GNUNET_IDENTITY_create (handle->service->identity, handle->name, NULL,
-                                                GNUNET_IDENTITY_TYPE_ECDSA, callback_ego_create, handle);
-  else
-    change_handle_ego (handle, ego);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return GNUNET_OK;
+  lookup_store_ego (store, handle->name, callback_update_handle, handle);
 }
 
-int
-set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+static void
+callback_set_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
-  GNUNET_assert(handle);
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  if ((name) && (lookup_service_ego(handle->service, name)))
-    return GNUNET_NO;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Renaming handle...\n");
+
+  if (ego)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is occupied! (%s)\n", name);
+    return;
+  }
 
-  struct GNUNET_IDENTITY_Operation *operation = handle->operation;
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  if (handle->name)
-    handle->operation = GNUNET_IDENTITY_rename (handle->service->identity, handle->name, name, NULL, NULL);
+  int rename_ego_in_store = handle->ego? GNUNET_YES : GNUNET_NO;
 
   char *old_dir;
   get_handle_data_subdir (handle, handle->name, &old_dir);
@@ -323,29 +371,42 @@ set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
     destroy_message (msg_handle.message);
 
     change_handle_name (handle, name);
-
-    if (operation)
-      GNUNET_IDENTITY_cancel (operation);
   }
   else
+    rename_ego_in_store = GNUNET_NO;
+
+  GNUNET_free(old_dir);
+  GNUNET_free(new_dir);
+
+  if (GNUNET_YES == rename_ego_in_store)
+    rename_store_ego(store, handle->name, name);
+}
+
+void
+set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+{
+  GNUNET_assert(handle);
+
+  if (!name)
   {
-    if (handle->operation)
-    {
-      GNUNET_IDENTITY_cancel (handle->operation);
+    if (handle->ego)
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is required!\n");
+    else
+      change_handle_name (handle, name);
 
-      handle->operation = operation;
-    }
+    return;
   }
 
-  GNUNET_free(old_dir);
-  GNUNET_free(new_dir);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return (result == 0 ? GNUNET_OK : GNUNET_NO);
+  lookup_store_ego (store, name, callback_set_handle_name, handle);
 }
 
 int
 open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
     return GNUNET_NO;
 
@@ -356,6 +417,8 @@ int
 entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door,
                    const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (door) && (key));
+
   if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
     return GNUNET_NO;
 
@@ -365,6 +428,8 @@ entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
 int
 close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   if (!get_handle_member_id (handle, key))
     return GNUNET_NO;
 
@@ -373,8 +438,10 @@ close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
 
 int
 send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
-                     struct GNUNET_MESSENGER_Message *message)
+                     const struct GNUNET_MESSENGER_Message *message)
 {
+  GNUNET_assert((handle) && (key) && (message));
+
   const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, key);
 
   if (!id)
@@ -391,45 +458,120 @@ send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNU
     return GNUNET_NO;
   }
 
-  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_Message *msg = copy_message(message);
 
-  GNUNET_memcpy(&(message->header.sender_id), id, sizeof(*id));
+  GNUNET_memcpy(&(msg->header.sender_id), id, sizeof(*id));
 
-  send_room_message (room, handle, message, &hash);
-  return GNUNET_YES;
+  return send_room_message (room, handle, msg);
+}
+
+static const struct GNUNET_HashCode*
+get_next_member_session_contect(const struct GNUNET_MESSENGER_MemberSession *session)
+{
+  if (session->next)
+    return get_next_member_session_contect (session->next);
+  else
+    return get_member_session_context(session);
+}
+
+void
+notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                       const struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((handle) && (key) && (session) && (message) && (hash));
+
+  if ((!handle->mq) || (!get_handle_member_id (handle, key)))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
+    return;
+  }
+
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->contact);
+
+  struct GNUNET_HashCode sender;
+  GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
+
+  const struct GNUNET_HashCode *context = get_next_member_session_contect (session);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying client about message: %s\n", GNUNET_h2s (hash));
+
+  struct GNUNET_MESSENGER_Message *private_message = NULL;
+
+  if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
+  {
+    private_message = copy_message(message);
+
+    if (GNUNET_YES != decrypt_message(private_message, &(get_handle_ego(handle)->priv)))
+    {
+      destroy_message(private_message);
+      private_message = NULL;
+    }
+    else
+      message = private_message;
+  }
+
+  struct GNUNET_MESSENGER_RecvMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  uint16_t length = get_message_size (message, GNUNET_YES);
+
+  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
+
+  GNUNET_memcpy(&(msg->key), key, sizeof(msg->key));
+  GNUNET_memcpy(&(msg->sender), &sender, sizeof(msg->sender));
+  GNUNET_memcpy(&(msg->context), context, sizeof(msg->context));
+  GNUNET_memcpy(&(msg->hash), hash, sizeof(msg->hash));
+
+  msg->flags = (uint32_t) (
+      private_message? GNUNET_MESSENGER_FLAG_PRIVATE : GNUNET_MESSENGER_FLAG_NONE
+  );
+
+  char *buffer = ((char*) msg) + sizeof(*msg);
+  encode_message (message, length, buffer, GNUNET_YES);
+
+  if (private_message)
+    destroy_message(private_message);
+
+  GNUNET_MQ_send (handle->mq, env);
 }
 
-static int callback_scan_for_rooms(void* cls, const char *filename) {
-  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
+static int
+callback_scan_for_rooms (void *cls, const char *filename)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
 
-  if ((GNUNET_YES == GNUNET_DISK_file_test(filename)) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_parse(cfg, filename)))
+  if ((GNUNET_YES == GNUNET_DISK_file_test (filename)) && (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, filename)))
   {
     struct GNUNET_HashCode key;
     struct GNUNET_ShortHashCode member_id;
 
-    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "key", &key, sizeof(key))) &&
-        (GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "member_id", &member_id, sizeof(member_id))))
-      change_handle_member_id(handle, &key, &member_id);
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "key", &key, sizeof(key))) &&
+        (GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "member_id", &member_id, sizeof(member_id))))
+      change_handle_member_id (handle, &key, &member_id);
   }
 
-  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_CONFIGURATION_destroy (cfg);
   return GNUNET_OK;
 }
 
-void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle) {
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+void
+load_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert(handle);
 
-  if (GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_YES))
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_YES))
   {
-    char* scan_dir;
-    GNUNET_asprintf(&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+    char *scan_dir;
+    GNUNET_asprintf (&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
 
-    if (GNUNET_OK == GNUNET_DISK_directory_test(scan_dir, GNUNET_YES))
-      GNUNET_DISK_directory_scan(scan_dir, callback_scan_for_rooms, handle);
+    if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
+      GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_rooms, handle);
 
     GNUNET_free(scan_dir);
   }
@@ -438,63 +580,64 @@ void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle) {
 }
 
 static int
-iterate_save_rooms(void* cls, const struct GNUNET_HashCode* key, void* value)
+iterate_save_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
-  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
-  struct GNUNET_ShortHashCode* member_id = value;
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+  struct GNUNET_ShortHashCode *member_id = value;
 
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
 
-  char* filename;
-  GNUNET_asprintf(&filename, "%s%s%c%s.cfg",
-                  id_dir, "rooms", DIR_SEPARATOR,
-                  GNUNET_h2s(key));
+  char *filename;
+  GNUNET_asprintf (&filename, "%s%s%c%s.cfg", id_dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (key));
 
   GNUNET_free(id_dir);
 
-  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
 
-  char* key_data = GNUNET_STRINGS_data_to_string_alloc(key, sizeof(*key));
+  char *key_data = GNUNET_STRINGS_data_to_string_alloc (key, sizeof(*key));
 
   if (key_data)
   {
-    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "key", key_data);
+    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "key", key_data);
 
     GNUNET_free(key_data);
   }
 
-  char* member_id_data = GNUNET_STRINGS_data_to_string_alloc(member_id, sizeof(*member_id));
+  char *member_id_data = GNUNET_STRINGS_data_to_string_alloc (member_id, sizeof(*member_id));
 
   if (member_id_data)
   {
-    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "member_id", member_id_data);
+    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "member_id", member_id_data);
 
     GNUNET_free(member_id_data);
   }
 
-  GNUNET_CONFIGURATION_write(cfg, filename);
-  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_CONFIGURATION_write (cfg, filename);
+  GNUNET_CONFIGURATION_destroy (cfg);
 
   GNUNET_free(filename);
 
   return GNUNET_YES;
 }
 
-void save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
+void
+save_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+  GNUNET_assert(handle);
+
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
 
-  if ((GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_NO)) ||
-      (GNUNET_OK == GNUNET_DISK_directory_create(id_dir)))
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_NO)) || (GNUNET_OK
+      == GNUNET_DISK_directory_create (id_dir)))
   {
-    char* save_dir;
-    GNUNET_asprintf(&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+    char *save_dir;
+    GNUNET_asprintf (&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
 
-    if ((GNUNET_YES == GNUNET_DISK_directory_test(save_dir, GNUNET_NO)) ||
-        (GNUNET_OK == GNUNET_DISK_directory_create(save_dir)))
-      GNUNET_CONTAINER_multihashmap_iterate(handle->member_ids, iterate_save_rooms, handle);
+    if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+        (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+      GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_save_rooms, handle);
 
     GNUNET_free(save_dir);
   }
diff --git a/src/messenger/gnunet-service-messenger_handle.h b/src/messenger/gnunet-service-messenger_handle.h
index 81cf377a8..70b2cac6d 100644
--- a/src/messenger/gnunet-service-messenger_handle.h
+++ b/src/messenger/gnunet-service-messenger_handle.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -35,6 +35,7 @@
 #include "gnunet_mq_lib.h"
 
 #include "gnunet-service-messenger_service.h"
+#include "gnunet-service-messenger_member_session.h"
 
 #include "messenger_api_ego.h"
 #include "messenger_api_message.h"
@@ -46,9 +47,7 @@ struct GNUNET_MESSENGER_SrvHandle
 
   char *name;
 
-  struct GNUNET_IDENTITY_Operation *operation;
-
-  struct GNUNET_MESSENGER_Ego *ego;
+  const struct GNUNET_MESSENGER_Ego *ego;
 
   struct GNUNET_CONTAINER_MultiHashMap *member_ids;
 };
@@ -56,8 +55,8 @@ struct GNUNET_MESSENGER_SrvHandle
 /**
  * Creates and allocates a new handle related to a <i>service</i> and using a given <i>mq</i> (message queue).
  *
- * @param service MESSENGER Service
- * @param mq Message queue
+ * @param[in/out] service MESSENGER Service
+ * @param[in/out] mq Message queue
  * @return New handle
  */
 struct GNUNET_MESSENGER_SrvHandle*
@@ -66,7 +65,7 @@ create_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle
 /**
  * Destroys a handle and frees its memory fully.
  *
- * @param handle Handle
+ * @param[in/out] handle Handle
  */
 void
 destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
@@ -75,52 +74,63 @@ destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
  * Writes the path of the directory for a given <i>handle</i> using a specific <i>name</i> to the parameter
  * <i>dir</i>. This directory will be used to store data regarding the handle and its messages.
  *
- * @param handle Handle
- * @param name Potential name of the handle
- * @param dir[out] Path to store data
+ * @param[in] handle Handle
+ * @param[in] name Potential name of the handle
+ * @param[out] dir Path to store data
  */
 void
-get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir);
+get_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir);
 
 /**
  * Returns the member id of a given <i>handle</i> in a specific <i>room</i>.
  *
  * If the handle is not a member of the specific <i>room</i>, NULL gets returned.
  *
- * @param handle Handle
- * @param key Key of a room
+ * @param[in] handle Handle
+ * @param[in] key Key of a room
  * @return Member id or NULL
  */
 const struct GNUNET_ShortHashCode*
 get_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
 
 /**
- * Changes the member id of a given <i>handle</i> in a specific <i>room</i> to match a <i>unique_id</i>.
+ * Changes the member id of a given <i>handle</i> in a specific <i>room</i> to match a <i>unique_id</i>
+ * and returns GNUNET_OK on success.
  *
  * The client connected to the <i>handle</i> will be informed afterwards automatically.
  *
- * @param handle Handle
- * @param key Key of a room
- * @param unique_id Unique member id
+ * @param[in/out] handle Handle
+ * @param[in] key Key of a room
+ * @param[in] unique_id Unique member id
+ * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
  */
-void
+int
 change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
                          const struct GNUNET_ShortHashCode *unique_id);
 
 /**
+ * Sets the EGO used by a given <i>handle</i>.
+ *
+ * @param[in/out] handle Handle
+ * @param[in] ego EGO keypair
+ */
+void
+set_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego);
+
+/**
  * Returns the EGO used by a given <i>handle</i>.
  *
- * @param handle Handle
+ * @param[in] handle Handle
  * @return EGO keypair
  */
-struct GNUNET_MESSENGER_Ego*
-get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle);
+const struct GNUNET_MESSENGER_Ego*
+get_handle_ego (const struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
  * Tries to set the name and EGO key of a <i>handle</i> initially by looking up a specific <i>name</i>.
  *
- * @param handle Handle
- * @param name Name (optionally: valid EGO name)
+ * @param[in/out] handle Handle
+ * @param[in] name Name (optionally: valid EGO name)
  */
 void
 setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name);
@@ -129,10 +139,9 @@ setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name);
  * Tries to change the keypair of an EGO of a <i>handle</i> under the same name and informs all rooms
  * about the change automatically.
  *
- * @param handle Handle
- * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ * @param[in/out] handle Handle
  */
-int
+void
 update_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
@@ -141,20 +150,19 @@ update_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
  *
  * The client connected to the <i>handle</i> will be informed afterwards automatically.
  *
- * @param handle Handle
- * @param name New name
- * @return GNUNET_OK on success, otherwise GNUNET_NO
+ * @param[in/out] handle Handle
+ * @param[in] name New name
  */
-int
+void
 set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name);
 
 /**
  * Makes a given <i>handle</i> a member of the room using a specific <i>key</i> and opens the
  * room from the handles service.
  *
- * @param handle Handle
- * @param key Key of a room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] handle Handle
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
@@ -163,10 +171,10 @@ open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET
  * Makes a given <i>handle</i> a member of the room using a specific <i>key</i> and enters the room
  * through a tunnel to a peer identified by a given <i>door</i> (peer identity).
  *
- * @param handle Handle
- * @param door Peer identity
- * @param key Key of a room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] handle Handle
+ * @param[in] door Peer identity
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door,
@@ -176,9 +184,9 @@ entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
  * Removes the membership of the room using a specific <i>key</i> and closes it if no other handle
  * from this service is still a member of it.
  *
- * @param handle Handle
- * @param key Key of a room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] handle Handle
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
@@ -186,31 +194,45 @@ close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
 /**
  * Sends a <i>message</i> from a given <i>handle</i> to the room using a specific <i>key</i>.
  *
- * @param handle Handle
- * @param key Key of a room
- * @param message Message
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] handle Handle
+ * @param[in] key Key of a room
+ * @param[in] message Message
+ * @return #GNUNET_YES on success, #GNUNET_NO or #GNUNET_SYSERR otherwise.
  */
 int
 send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
-                     struct GNUNET_MESSENGER_Message *message);
+                     const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Notifies the handle that a new message was received or sent.
+ *
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
+ * @param[in] session Member session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ */
+void
+notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                       const struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Loads member ids and other potential configuration from a given <i>handle</i> which
  * depends on the given name the <i>handle</i> uses.
  *
- * @param handle Handle
+ * @param[out] handle Handle
  */
 void
-load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle);
+load_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
  * Saves member ids and other potential configuration from a given <i>handle</i> which
  * depends on the given name the <i>handle</i> uses.
  *
- * @param handle Handle
+ * @param[in] handle Handle
  */
 void
-save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle);
+save_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle);
 
 #endif //GNUNET_SERVICE_MESSENGER_HANDLE_H
diff --git a/src/messenger/gnunet-service-messenger_list_handles.c b/src/messenger/gnunet-service-messenger_list_handles.c
index 16a160dea..adcbf6a42 100644
--- a/src/messenger/gnunet-service-messenger_list_handles.c
+++ b/src/messenger/gnunet-service-messenger_list_handles.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -55,8 +55,10 @@ clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles)
 }
 
 void
-add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle)
+add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert((handles) && (handle));
+
   struct GNUNET_MESSENGER_ListHandle *element = GNUNET_new(struct GNUNET_MESSENGER_ListHandle);
 
   element->handle = handle;
@@ -65,8 +67,10 @@ add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle)
 }
 
 int
-remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle)
+remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert((handles) && (handle));
+
   struct GNUNET_MESSENGER_ListHandle *element;
 
   for (element = handles->head; element; element = element->next)
@@ -82,9 +86,11 @@ remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle)
   return GNUNET_YES;
 }
 
-void*
-find_list_handle_by_member (struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key)
+struct GNUNET_MESSENGER_SrvHandle*
+find_list_handle_by_member (const struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handles) && (key));
+
   struct GNUNET_MESSENGER_ListHandle *element;
 
   for (element = handles->head; element; element = element->next)
diff --git a/src/messenger/gnunet-service-messenger_list_handles.h b/src/messenger/gnunet-service-messenger_list_handles.h
index fe92cc58a..9f7ca725f 100644
--- a/src/messenger/gnunet-service-messenger_list_handles.h
+++ b/src/messenger/gnunet-service-messenger_list_handles.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -30,12 +30,14 @@
 #include "gnunet_crypto_lib.h"
 #include "gnunet_container_lib.h"
 
+struct GNUNET_MESSENGER_SrvHandle;
+
 struct GNUNET_MESSENGER_ListHandle
 {
   struct GNUNET_MESSENGER_ListHandle *prev;
   struct GNUNET_MESSENGER_ListHandle *next;
 
-  void *handle;
+  struct GNUNET_MESSENGER_SrvHandle *handle;
 };
 
 struct GNUNET_MESSENGER_ListHandles
@@ -45,17 +47,17 @@ struct GNUNET_MESSENGER_ListHandles
 };
 
 /**
- * Initializes list of handles as empty list.
+ * Initializes list of <i>handles</i> as empty list.
  *
- * @param handles List of handles
+ * @param[out] handles List of handles
  */
 void
 init_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
 
 /**
- * Destroys remaining handles and clears the list.
+ * Destroys remaining <i>handles</i> and clears the list.
  *
- * @param handles List of handles
+ * @param[in/out] handles List of handles
  */
 void
 clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
@@ -63,34 +65,34 @@ clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
 /**
  * Adds a specific <i>handle</i> to the end of the list.
  *
- * @param handles List of handles
- * @param handle Handle
+ * @param[in/out] handles List of handles
+ * @param[in/out] handle Handle
  */
 void
-add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle);
+add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
- * Removes the first entry matching with a specific <i>handle</i> from the list and
- * returns GNUNET_YES on success or GNUNET_NO on failure.
+ * Removes the first entry matching with a specific <i>handle</i> from the list of
+ * <i>handles</i> and returns #GNUNET_YES on success or #GNUNET_NO on failure.
  *
- * @param handles List of handles
- * @param handle Handle
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] handles List of handles
+ * @param[in/out] handle Handle
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
-remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle);
+remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
- * Searches linearly through the list of handles for members of a specific room
+ * Searches linearly through the list of <i>handles</i> for members of a specific room
  * which is identified by a given <i>key</i>.
  *
  * If no handle is found which is a current member, NULL gets returned.
  *
- * @param handles List of handles
- * @param key Common key of a room
+ * @param[in] handles List of handles
+ * @param[in] key Common key of a room
  * @return First handle which is a current member
  */
-void*
-find_list_handle_by_member (struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key);
+struct GNUNET_MESSENGER_SrvHandle*
+find_list_handle_by_member (const struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key);
 
 #endif //GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
diff --git a/src/messenger/gnunet-service-messenger_list_messages.c b/src/messenger/gnunet-service-messenger_list_messages.c
index c4f1f7043..bb6086e41 100644
--- a/src/messenger/gnunet-service-messenger_list_messages.c
+++ b/src/messenger/gnunet-service-messenger_list_messages.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -54,6 +54,8 @@ clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages)
 void
 add_to_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((messages) && (hash));
+
   struct GNUNET_MESSENGER_ListMessage *element = GNUNET_new(struct GNUNET_MESSENGER_ListMessage);
 
   GNUNET_memcpy(&(element->hash), hash, sizeof(struct GNUNET_HashCode));
@@ -62,8 +64,21 @@ add_to_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const stru
 }
 
 void
+copy_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_MESSENGER_ListMessages *origin)
+{
+  GNUNET_assert((messages) && (origin));
+
+  struct GNUNET_MESSENGER_ListMessage *element;
+
+  for (element = origin->head; element; element = element->next)
+    add_to_list_messages (messages, &(element->hash));
+}
+
+void
 remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((messages) && (hash));
+
   struct GNUNET_MESSENGER_ListMessage *element;
 
   for (element = messages->head; element; element = element->next)
@@ -74,3 +89,62 @@ remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const
       break;
     }
 }
+
+void
+load_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
+{
+  GNUNET_assert((messages) && (path));
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (path))
+    return;
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_READ, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_HashCode hash;
+  ssize_t len;
+
+  do {
+    len = GNUNET_DISK_file_read(handle, &hash, sizeof(hash));
+
+    if (len != sizeof(hash))
+      break;
+
+    add_to_list_messages(messages, &hash);
+  } while (len == sizeof(hash));
+
+  GNUNET_DISK_file_close(handle);
+}
+
+void
+save_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
+{
+  GNUNET_assert((messages) && (path));
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_MESSENGER_ListMessage *element;
+
+  for (element = messages->head; element; element = element->next)
+    GNUNET_DISK_file_write(handle, &(element->hash), sizeof(element->hash));
+
+  GNUNET_DISK_file_sync(handle);
+  GNUNET_DISK_file_close(handle);
+}
diff --git a/src/messenger/gnunet-service-messenger_list_messages.h b/src/messenger/gnunet-service-messenger_list_messages.h
index 266c30ec6..9ace84cbf 100644
--- a/src/messenger/gnunet-service-messenger_list_messages.h
+++ b/src/messenger/gnunet-service-messenger_list_messages.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -29,6 +29,7 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 #include "gnunet_container_lib.h"
+#include "gnunet_disk_lib.h"
 
 struct GNUNET_MESSENGER_ListMessage
 {
@@ -47,7 +48,7 @@ struct GNUNET_MESSENGER_ListMessages
 /**
  * Initializes list of message hashes as empty list.
  *
- * @param messages List of hashes
+ * @param[out] messages List of hashes
  */
 void
 init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
@@ -55,7 +56,7 @@ init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
 /**
  * Clears the list of message hashes.
  *
- * @param messages List of hashes
+ * @param[in/out] messages List of hashes
  */
 void
 clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
@@ -63,19 +64,46 @@ clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
 /**
  * Adds a specific <i>hash</i> from a message to the end of the list.
  *
- * @param messages List of hashes
- * @param hash Hash of message
+ * @param[in/out] messages List of hashes
+ * @param[in] hash Hash of message
  */
 void
 add_to_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash);
 
 /**
+ * Copies all message hashes from an <i>origin</i> to another list.
+ *
+ * @param[in/out] messages Destination list of hashes
+ * @param[in] origin Source list of hashes
+ */
+void
+copy_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_MESSENGER_ListMessages *origin);
+
+/**
  * Removes the first entry with a matching <i>hash</i> from the list.
  *
- * @param messages List of hashes
- * @param hash Hash of message
+ * @param[in/out] messages List of hashes
+ * @param[in] hash Hash of message
  */
 void
 remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash);
 
+/**
+ * Loads the list of message hashes from a file under a given <i>path</i>.
+ *
+ * @param[out] messages List of hashes
+ * @param[in] path Path of file
+ */
+void
+load_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const char *path);
+
+/**
+ * Saves the list of message hashes to a file under a given <i>path</i>.
+ *
+ * @param[in] messages List of hashes
+ * @param[in] path Path of file
+ */
+void
+save_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const char *path);
+
 #endif //GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
diff --git a/src/messenger/gnunet-service-messenger_member.c b/src/messenger/gnunet-service-messenger_member.c
new file mode 100755
index 000000000..7f00e8438
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member.c
@@ -0,0 +1,385 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_member.h"
+
+#include "gnunet-service-messenger_member_session.h"
+
+struct GNUNET_MESSENGER_Member*
+create_member (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert (store);
+
+  struct GNUNET_MESSENGER_Member *member = GNUNET_new(struct GNUNET_MESSENGER_Member);
+
+  member->store = store;
+
+  if (id)
+    GNUNET_memcpy(&(member->id), id, sizeof(member->id));
+  else if (GNUNET_YES != generate_free_member_id(&(member->id), store->members))
+  {
+    GNUNET_free (member);
+    return NULL;
+  }
+
+  member->sessions = GNUNET_CONTAINER_multihashmap_create(2, GNUNET_NO);
+
+  return member;
+}
+
+static int
+iterate_destroy_session (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+  destroy_member_session(session);
+  return GNUNET_YES;
+}
+
+void
+destroy_member (struct GNUNET_MESSENGER_Member *member)
+{
+  GNUNET_assert((member) && (member->sessions));
+
+  GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_destroy_session, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (member->sessions);
+
+  GNUNET_free (member);
+}
+
+const struct GNUNET_ShortHashCode*
+get_member_id (const struct GNUNET_MESSENGER_Member *member)
+{
+  GNUNET_assert (member);
+
+  return &(member->id);
+}
+
+static int
+callback_scan_for_sessions (void *cls, const char *filename)
+{
+  struct GNUNET_MESSENGER_Member *member = cls;
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (filename, GNUNET_YES))
+  {
+    char *directory;
+
+    GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR);
+
+    load_member_session(member, directory);
+  }
+
+  return GNUNET_OK;
+}
+
+void
+load_member (struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  char *config_file;
+  GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg");
+
+  struct GNUNET_MESSENGER_Member *member = NULL;
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
+    goto free_config;
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
+  {
+    struct GNUNET_ShortHashCode id;
+
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id, sizeof(id)))
+      goto destroy_config;
+
+    member = add_store_member(store, &id);
+  }
+
+destroy_config:
+
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+free_config:
+  GNUNET_free(config_file);
+
+  if (!member)
+    return;
+
+  char *scan_dir;
+  GNUNET_asprintf (&scan_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
+
+  if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
+    GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_sessions, member);
+
+  GNUNET_free(scan_dir);
+}
+
+static int
+iterate_load_next_session (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  const char* sessions_directory = cls;
+
+  char* load_dir;
+  GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key), DIR_SEPARATOR);
+
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (load_dir, GNUNET_YES))
+    load_member_session_next (session, load_dir);
+
+  GNUNET_free (load_dir);
+  return GNUNET_YES;
+}
+
+void
+load_member_next_sessions (const struct GNUNET_MESSENGER_Member *member, const char *directory)
+{
+  GNUNET_assert ((member) && (directory));
+
+  char* load_dir;
+  GNUNET_asprintf (&load_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
+
+  GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_load_next_session, load_dir);
+
+  GNUNET_free(load_dir);
+}
+
+static int
+iterate_save_session (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  const char* sessions_directory = cls;
+
+  char* save_dir;
+  GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key), DIR_SEPARATOR);
+
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+    save_member_session (session, save_dir);
+
+  GNUNET_free (save_dir);
+  return GNUNET_YES;
+}
+
+void
+save_member (struct GNUNET_MESSENGER_Member *member, const char *directory)
+{
+  GNUNET_assert ((member) && (directory));
+
+  char *config_file;
+  GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg");
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id), sizeof(member->id));
+
+  if (id_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string (cfg, "member", "id", id_data);
+
+    GNUNET_free(id_data);
+  }
+
+  GNUNET_CONFIGURATION_write (cfg, config_file);
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+  GNUNET_free(config_file);
+
+  char* save_dir;
+  GNUNET_asprintf (&save_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+    GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_save_session, save_dir);
+
+  GNUNET_free(save_dir);
+}
+
+static void
+sync_session_contact_from_next (struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
+{
+  GNUNET_assert((session) && (next));
+
+  if (session == next)
+    return;
+
+  if (next->next)
+    sync_session_contact_from_next (session, next->next);
+  else
+    session->contact = next->contact;
+}
+
+static int
+iterate_sync_session_contact (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+
+  if (session->next)
+    sync_session_contact_from_next (session, session->next);
+
+  return GNUNET_YES;
+}
+
+void
+sync_member_contacts (struct GNUNET_MESSENGER_Member *member)
+{
+  GNUNET_assert ((member) && (member->sessions));
+
+  GNUNET_CONTAINER_multihashmap_iterate (member->sessions, iterate_sync_session_contact, NULL);
+}
+
+struct GNUNET_MESSENGER_MemberSession*
+get_member_session (const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *public_key)
+{
+  GNUNET_assert ((member) && (public_key));
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+
+  return GNUNET_CONTAINER_multihashmap_get(member->sessions, &hash);
+}
+
+struct GNUNET_MESSENGER_ClosureSearchSession {
+  const struct GNUNET_MESSENGER_Message *message;
+  const struct GNUNET_HashCode *hash;
+
+  struct GNUNET_MESSENGER_MemberSession *match;
+};
+
+static int
+iterate_search_session (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureSearchSession* search = cls;
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+
+  if (GNUNET_OK != verify_member_session_as_sender(session, search->message, search->hash))
+    return GNUNET_YES;
+
+  search->match = session;
+  return GNUNET_NO;
+}
+
+static struct GNUNET_MESSENGER_MemberSession*
+try_member_session (struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *public_key)
+{
+  struct GNUNET_MESSENGER_MemberSession* session = get_member_session(member, public_key);
+
+  if (session)
+    return session;
+
+  session = create_member_session(member, public_key);
+
+  if (session)
+    add_member_session(member, session);
+
+  return session;
+}
+
+struct GNUNET_MESSENGER_MemberSession*
+get_member_session_of (struct GNUNET_MESSENGER_Member *member, const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((member) && (message) && (hash) &&
+                 (0 == GNUNET_memcmp(&(member->id), &(message->header.sender_id))));
+
+  if (GNUNET_MESSENGER_KIND_INFO == message->header.kind)
+    return try_member_session(member, &(message->body.info.host_key));
+  else if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
+    return try_member_session(member, &(message->body.join.key));
+
+  struct GNUNET_MESSENGER_ClosureSearchSession search;
+
+  search.message = message;
+  search.hash = hash;
+
+  search.match = NULL;
+  GNUNET_CONTAINER_multihashmap_iterate(member->sessions, iterate_search_session, &search);
+
+  return search.match;
+}
+
+void
+add_member_session (struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
+{
+  if (!session)
+    return;
+
+  GNUNET_assert((member) && (session->member == member));
+
+  const struct GNUNET_IDENTITY_PublicKey *public_key = get_member_session_public_key(session);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
+      member->sessions, &hash, session,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Adding a member session failed: %s\n",
+               GNUNET_h2s(&hash));
+}
+
+void
+remove_member_session (struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
+{
+  GNUNET_assert ((member) && (session) && (session->member == member));
+
+  const struct GNUNET_IDENTITY_PublicKey *public_key = get_member_session_public_key(session);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(member->sessions, &hash, session))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Removing a member session failed: %s\n",
+               GNUNET_h2s(&hash));
+}
+
+struct GNUNET_MESSENGER_ClosureIterateSessions {
+  GNUNET_MESSENGER_MemberIteratorCallback it;
+  void *cls;
+};
+
+static int
+iterate_member_sessions_it (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureIterateSessions *iterate = cls;
+  struct GNUNET_MESSENGER_MemberSession *session = value;
+
+  return iterate->it (iterate->cls, get_member_session_public_key(session), session);
+}
+
+int
+iterate_member_sessions (struct GNUNET_MESSENGER_Member *member, GNUNET_MESSENGER_MemberIteratorCallback it, void *cls)
+{
+  GNUNET_assert ((member) && (member->sessions) && (it));
+
+  struct GNUNET_MESSENGER_ClosureIterateSessions iterate;
+
+  iterate.it = it;
+  iterate.cls = cls;
+
+  return GNUNET_CONTAINER_multihashmap_iterate(member->sessions, iterate_member_sessions_it, &iterate);
+}
diff --git a/src/messenger/gnunet-service-messenger_member.h b/src/messenger/gnunet-service-messenger_member.h
new file mode 100644
index 000000000..fb2e57cfb
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member.h
@@ -0,0 +1,170 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MEMBER_H
+#define GNUNET_SERVICE_MESSENGER_MEMBER_H
+
+#include "messenger_api_contact.h"
+
+#include "gnunet-service-messenger_list_messages.h"
+#include "gnunet-service-messenger_member_store.h"
+#include "messenger_api_message.h"
+#include "messenger_api_util.h"
+
+struct GNUNET_MESSENGER_Member
+{
+  struct GNUNET_MESSENGER_MemberStore *store;
+  struct GNUNET_ShortHashCode id;
+
+  struct GNUNET_CONTAINER_MultiHashMap *sessions;
+};
+
+/**
+ * Creates and allocates a new member of a <i>room</i> with an optionally defined or
+ * random <i>id</i>.
+ *
+ * If the creation fails, NULL gets returned.
+ *
+ * @param[in/out] store Member store
+ * @param[in] id Member id or NULL
+ * @return New member or NULL
+ */
+struct GNUNET_MESSENGER_Member*
+create_member (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Destroys a member and frees its memory fully.
+ *
+ * @param[in/out] member Member
+ */
+void
+destroy_member (struct GNUNET_MESSENGER_Member *member);
+
+/**
+ * Returns the current id of a given <i>member</i>.
+ *
+ * @param[in] member Member
+ * @return Member id
+ */
+const struct GNUNET_ShortHashCode*
+get_member_id (const struct GNUNET_MESSENGER_Member *member);
+
+/**
+ * Loads data from a <i>directory</i> into a new allocated and created member
+ * of a <i>store</i> if the required information can be read from the content
+ * of the given directory.
+ *
+ * @param[out] store Member store
+ * @param[in] directory Path to a directory
+ */
+void
+load_member (struct GNUNET_MESSENGER_MemberStore *store, const char *directory);
+
+/**
+ * Loads data about next sessions from a <i>directory</i> into an empty loaded
+ * <i>member</i> which does not contain a fully built session graph yet.
+ *
+ * @param[in/out] member Member
+ * @param[in] directory Path to a directory
+ */
+void
+load_member_next_sessions (const struct GNUNET_MESSENGER_Member *member, const char *directory);
+
+/**
+ * Saves data from a <i>member</i> into a directory which
+ * can be load to restore the member completely.
+ *
+ * @param[in] member Member
+ * @param[in] directory Path to a directory
+ */
+void
+save_member (struct GNUNET_MESSENGER_Member *member, const char *directory);
+
+/**
+ * Synchronizes contacts between all sessions from a given <i>member</i>
+ * and other sessions which are linked to them.
+ *
+ * @param[in/out] member Member
+ */
+void
+sync_member_contacts (struct GNUNET_MESSENGER_Member *member);
+
+/**
+ * Returns the member session of a <i>member</i> identified by a given public key.
+ * If the member does not provide a session with the given key, NULL gets returned.
+ *
+ * @param[in] member Member
+ * @param[in] public_key Public key of EGO
+ * @return Member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+get_member_session (const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *public_key);
+
+/**
+ * Returns the member session of a <i>member</i> using a public key which can verify
+ * the signature of a given <i>message</i> and its <i>hash</i>. If the member does
+ * not provide a matching session, NULL gets returned.
+ *
+ * @param[in] member Member
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @return Member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+get_member_session_of (struct GNUNET_MESSENGER_Member *member, const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash);
+
+/**
+ * Adds a given member <i>session</i> to its <i>member</i>.
+ *
+ * @param[in/out] member Member
+ * @param[in/out] session Member session
+ */
+void
+add_member_session (struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session);
+
+/**
+ * Removes a given member <i>session</i> from its <i>member</i>.
+ *
+ * @param[in/out] member Member
+ * @param[in/out] session Member session
+ */
+void
+remove_member_session (struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session);
+
+/**
+ * Iterate through all member sessions currently connected to a given <i>member</i>
+ * and call the provided iterator callback with a selected closure. The function
+ * will return the amount of member sessions it iterated through.
+ *
+ * @param[in/out] member Member
+ * @param[in] it Iterator callback
+ * @param[in/out] cls Closure
+ * @return Amount of sessions iterated through
+ */
+int
+iterate_member_sessions (struct GNUNET_MESSENGER_Member *member, GNUNET_MESSENGER_MemberIteratorCallback it, void* cls);
+
+#endif //GNUNET_SERVICE_MESSENGER_MEMBER_H
diff --git a/src/messenger/gnunet-service-messenger_member_session.c b/src/messenger/gnunet-service-messenger_member_session.c
new file mode 100644
index 000000000..690c703b2
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member_session.c
@@ -0,0 +1,743 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member_session.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_member_session.h"
+
+#include "gnunet-service-messenger_room.h"
+#include "gnunet-service-messenger_message_store.h"
+
+#include "messenger_api_contact_store.h"
+
+struct GNUNET_MESSENGER_MemberSession*
+create_member_session (struct GNUNET_MESSENGER_Member *member,
+                       const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  if ((!member) || (!pubkey) || (!(member->store)))
+    return NULL;
+
+  struct GNUNET_MESSENGER_MemberSession *session = GNUNET_new(struct GNUNET_MESSENGER_MemberSession);
+  session->member = member;
+
+  GNUNET_memcpy(&(session->public_key), pubkey, sizeof(session->public_key));
+
+  get_context_from_member (
+      get_member_session_key (session),
+      get_member_session_id (session),
+      &(session->context)
+  );
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store(session->member->store);
+
+  session->contact = get_store_contact(
+      store,
+      get_member_session_context (session),
+      get_member_session_public_key (session)
+  );
+
+  if (!(session->contact))
+  {
+    GNUNET_free(session);
+    return NULL;
+  }
+
+  increase_contact_rc (session->contact);
+
+  session->history = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
+
+  init_list_messages(&(session->messages));
+
+  session->prev = NULL;
+  session->next = NULL;
+
+  session->start = GNUNET_TIME_absolute_get();
+
+  session->closed = GNUNET_NO;
+  session->completed = GNUNET_NO;
+
+  return session;
+}
+
+static void
+check_member_session_completion (struct GNUNET_MESSENGER_MemberSession *session)
+{
+  GNUNET_assert (session);
+
+  if (!session->messages.tail)
+  {
+    session->completed = GNUNET_YES;
+    goto completion;
+  }
+
+  const struct GNUNET_HashCode* start = &(session->messages.head->hash);
+  const struct GNUNET_HashCode* end = &(session->messages.tail->hash);
+
+  struct GNUNET_MESSENGER_ListMessages level;
+  init_list_messages(&level);
+
+  add_to_list_messages(&level, end);
+
+  struct GNUNET_MESSENGER_MessageStore *store = get_room_message_store(session->member->store->room);
+
+  struct GNUNET_MESSENGER_ListMessages list;
+  init_list_messages(&list);
+
+  while (level.head)
+  {
+    struct GNUNET_MESSENGER_ListMessage *element;
+
+    for (element = level.head; element; element = element->next)
+    {
+      const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link(
+          store, &(element->hash), GNUNET_NO
+      );
+
+      if (!link)
+        continue;
+
+      add_to_list_messages(&list, &(link->first));
+
+      if (GNUNET_YES == link->multiple)
+        add_to_list_messages(&list, &(link->second));
+    }
+
+    clear_list_messages(&level);
+
+    for (element = list.head; element; element = element->next)
+      if (GNUNET_YES == check_member_session_history(session, &(element->hash), GNUNET_YES))
+        break;
+
+    if (element)
+      if (0 != GNUNET_CRYPTO_hash_cmp(&(element->hash), start))
+        add_to_list_messages(&level, &(element->hash));
+      else
+        session->completed = GNUNET_YES;
+    else
+      copy_list_messages(&level, &list);
+
+    clear_list_messages(&list);
+  }
+
+completion:
+  if (GNUNET_YES == is_member_session_completed(session))
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (session->history);
+
+    struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store(session->member->store);
+
+    if ((session->contact) && (GNUNET_YES == decrease_contact_rc (session->contact)))
+      remove_store_contact (
+          store,
+          session->contact,
+          get_member_session_context(session)
+      );
+
+    session->contact = NULL;
+  }
+}
+
+static int
+iterate_copy_history (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberSession *next = cls;
+
+  GNUNET_CONTAINER_multihashmap_put(next->history, key, (value? next : NULL),
+                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+
+  return GNUNET_YES;
+}
+
+struct GNUNET_MESSENGER_MemberSession*
+switch_member_session (struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash)
+{
+  if ((!session) || (!message) || (!hash))
+    return NULL;
+
+  GNUNET_assert((GNUNET_MESSENGER_KIND_ID == message->header.kind) ||
+                (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
+
+  struct GNUNET_MESSENGER_MemberSession *next = GNUNET_new(struct GNUNET_MESSENGER_MemberSession);
+
+  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
+    next->member = add_store_member(session->member->store, &(message->body.id.id));
+  else
+    next->member = session->member;
+
+  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
+    GNUNET_memcpy(&(next->public_key), &(message->body.key.key), sizeof(next->public_key));
+  else
+    GNUNET_memcpy(&(next->public_key), get_member_session_public_key(session), sizeof(next->public_key));
+
+  get_context_from_member (
+      get_member_session_key (next),
+      get_member_session_id (next),
+      &(next->context)
+  );
+
+  update_store_contact(
+      get_member_contact_store(next->member->store),
+      get_member_session_contact(session),
+      get_member_session_context(session),
+      get_member_session_context(next),
+      get_member_session_public_key(next)
+  );
+
+  next->contact = get_member_session_contact(session);
+
+  if (!(next->contact))
+  {
+    GNUNET_free(next);
+    return NULL;
+  }
+
+  increase_contact_rc (next->contact);
+
+  next->history = GNUNET_CONTAINER_multihashmap_create(
+      GNUNET_CONTAINER_multihashmap_size(session->history), GNUNET_NO
+  );
+
+  GNUNET_CONTAINER_multihashmap_iterate(session->history, iterate_copy_history, next);
+
+  init_list_messages(&(next->messages));
+  copy_list_messages(&(next->messages), &(session->messages));
+
+  session->next = next;
+  next->prev = session;
+  next->next = NULL;
+
+  next->start = GNUNET_TIME_absolute_get();
+
+  session->closed = GNUNET_YES;
+  next->closed = GNUNET_NO;
+  next->completed = GNUNET_NO;
+
+  check_member_session_completion (session);
+
+  return next;
+}
+
+void
+destroy_member_session(struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert (session);
+
+  GNUNET_CONTAINER_multihashmap_destroy (session->history);
+
+  clear_list_messages (&(session->messages));
+
+  struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (session);
+
+  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
+    remove_store_contact (
+        get_member_contact_store(session->member->store),
+        contact,
+        get_member_session_context(session)
+    );
+
+  GNUNET_free(session);
+}
+
+int
+reset_member_session (struct GNUNET_MESSENGER_MemberSession* session,
+                      const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((session) && (hash));
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store(session->member->store);
+  struct GNUNET_MESSENGER_Contact *contact = get_store_contact(
+      store,
+      get_member_session_context (session),
+      get_member_session_public_key (session)
+  );
+
+  if (!contact)
+    return GNUNET_SYSERR;
+
+  if (contact == session->contact)
+    goto clear_messages;
+
+  session->contact = contact;
+  increase_contact_rc (session->contact);
+
+clear_messages:
+  clear_list_messages(&(session->messages));
+  add_to_list_messages(&(session->messages), hash);
+
+  session->next = NULL;
+  session->closed = GNUNET_NO;
+  session->completed = GNUNET_NO;
+
+  return GNUNET_OK;
+}
+
+void
+close_member_session (struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert (session);
+
+  session->closed = GNUNET_YES;
+  check_member_session_completion (session);
+}
+
+int
+is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  return session->closed;
+}
+
+int
+is_member_session_completed (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  return session->completed;
+}
+
+struct GNUNET_TIME_Absolute
+get_member_session_start (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  if (session->prev)
+    return get_member_session_start(session->prev);
+
+  return session->start;
+}
+
+const struct GNUNET_HashCode*
+get_member_session_key (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert((session) && (session->member));
+
+  return get_member_store_key(session->member->store);
+}
+
+const struct GNUNET_ShortHashCode*
+get_member_session_id (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  return get_member_id(session->member);
+}
+
+const struct GNUNET_IDENTITY_PublicKey*
+get_member_session_public_key (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  return &(session->public_key);
+}
+
+const struct GNUNET_HashCode*
+get_member_session_context (const struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert(session);
+
+  return &(session->context);
+}
+
+struct GNUNET_MESSENGER_Contact*
+get_member_session_contact (struct GNUNET_MESSENGER_MemberSession* session)
+{
+  GNUNET_assert (session);
+
+  return session->contact;
+}
+
+int verify_member_session_as_sender (const struct GNUNET_MESSENGER_MemberSession *session,
+                                     const struct GNUNET_MESSENGER_Message *message,
+                                     const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((session) && (message) && (hash));
+
+  if (GNUNET_YES == is_member_session_completed(session))
+    return GNUNET_SYSERR;
+
+  if (0 != GNUNET_memcmp(get_member_session_id(session), &(message->header.sender_id)))
+    return GNUNET_SYSERR;
+
+  return verify_message(message, hash, get_member_session_public_key(session));
+}
+
+int
+check_member_session_history (const struct GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash, int ownership)
+{
+  GNUNET_assert((session) && (hash));
+
+  if (GNUNET_YES == ownership)
+    return (NULL != GNUNET_CONTAINER_multihashmap_get(session->history, hash)? GNUNET_YES : GNUNET_NO);
+  else
+    return GNUNET_CONTAINER_multihashmap_contains(session->history, hash);
+}
+
+static void
+update_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session,
+                             const struct GNUNET_HashCode *hash, int ownership)
+{
+  GNUNET_assert ((session) && (hash));
+
+  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(session->history, hash, (GNUNET_YES == ownership? session : NULL),
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) && (session->next))
+    update_member_chain_history (session->next, hash, ownership);
+}
+
+void
+update_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
+                               const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((session) && (message) && (hash));
+
+  if (GNUNET_YES == is_member_session_completed(session))
+    return;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating sessions history (%s) += (%s)\n",
+             GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
+
+  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
+  {
+    if (GNUNET_YES == is_message_session_bound (message))
+      add_to_list_messages(&(session->messages), hash);
+
+    update_member_chain_history (session, hash, GNUNET_YES);
+  }
+  else
+    update_member_chain_history (session, hash, GNUNET_NO);
+
+  if (GNUNET_YES == session->closed)
+    check_member_session_completion(session);
+}
+
+static void
+clear_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session,
+                            const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((session) && (hash));
+
+  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all(session->history, hash)) && (session->next))
+    clear_member_session_history(session->next, hash);
+}
+
+void
+clear_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((session) && (hash));
+
+  clear_member_chain_history (session, hash);
+}
+
+struct GNUNET_MESSENGER_MemberSessionHistoryEntry
+{
+  struct GNUNET_HashCode hash;
+  unsigned char ownership;
+};
+
+static void
+load_member_session_history (struct GNUNET_MESSENGER_MemberSession *session, const char *path)
+{
+  GNUNET_assert((session) && (path));
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (path))
+    return;
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_READ, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_MESSENGER_MemberSessionHistoryEntry entry;
+  ssize_t len;
+
+  int status;
+
+  do {
+    len = GNUNET_DISK_file_read(handle, &(entry.hash), sizeof(entry.hash));
+
+    if (len != sizeof(entry.hash))
+      break;
+
+    len = GNUNET_DISK_file_read(handle, &(entry.ownership), sizeof(entry.ownership));
+
+    if (len != sizeof(entry.ownership))
+      break;
+
+    status = GNUNET_CONTAINER_multihashmap_put(session->history, &(entry.hash), (entry.ownership? session : NULL),
+                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  } while (status == GNUNET_OK);
+
+  GNUNET_DISK_file_close(handle);
+}
+
+void
+load_member_session (struct GNUNET_MESSENGER_Member *member, const char *directory)
+{
+  GNUNET_assert ((member) && (directory));
+
+  char *config_file;
+  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
+
+  struct GNUNET_MESSENGER_MemberSession *session = NULL;
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
+    goto free_config;
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
+  {
+    char *key_data;
+
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "key", &key_data))
+      goto destroy_config;
+
+    struct GNUNET_IDENTITY_PublicKey key;
+
+    enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &key);
+
+    GNUNET_free(key_data);
+
+    if (GNUNET_OK != key_return)
+      goto destroy_config;
+
+    session = create_member_session(member, &key);
+
+    unsigned long long numeric_value;
+
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "start", &numeric_value))
+      session->start.abs_value_us = numeric_value;
+
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "closed", &numeric_value))
+      session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
+
+    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "completed", &numeric_value))
+      session->completed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
+  }
+
+destroy_config:
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+free_config:
+  GNUNET_free(config_file);
+
+  if (!session)
+    return;
+
+  char *history_file;
+  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
+
+  load_member_session_history (session, history_file);
+  GNUNET_free(history_file);
+
+  char *messages_file;
+  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
+
+  load_list_messages(&(session->messages), messages_file);
+  GNUNET_free(messages_file);
+
+  add_member_session(member, session);
+}
+
+static struct GNUNET_MESSENGER_MemberSession*
+get_cycle_safe_next_session (struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
+{
+  if (!next)
+    return NULL;
+
+  struct GNUNET_MESSENGER_MemberSession *check = next;
+
+  do {
+    if (check == session)
+      return NULL;
+
+    check = check->next;
+  } while (check);
+
+  return next;
+}
+
+void
+load_member_session_next (struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
+{
+  GNUNET_assert ((session) && (directory));
+
+  char *config_file;
+  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
+    goto free_config;
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
+  {
+    char *key_data;
+
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "next_key", &key_data))
+      goto destroy_config;
+
+    struct GNUNET_IDENTITY_PublicKey next_key;
+
+    enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &next_key);
+
+    GNUNET_free(key_data);
+
+    if (GNUNET_OK != key_return)
+      goto destroy_config;
+
+    struct GNUNET_ShortHashCode next_id;
+
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id", &next_id, sizeof(next_id)))
+      goto destroy_config;
+
+    struct GNUNET_MESSENGER_Member *member = get_store_member(session->member->store, &next_id);
+
+    session->next = get_cycle_safe_next_session(
+        session, member? get_member_session (member, &next_key) : NULL
+    );
+
+    if (session->next)
+      session->next->prev = session;
+  }
+
+destroy_config:
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+free_config:
+  GNUNET_free(config_file);
+}
+
+static int
+iterate_save_member_session_history_hentries (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_DISK_FileHandle *handle = cls;
+  unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
+
+  GNUNET_DISK_file_write(handle, key, sizeof(*key));
+  GNUNET_DISK_file_write(handle, &ownership, sizeof(ownership));
+
+  return GNUNET_YES;
+}
+
+static void
+save_member_session_history (struct GNUNET_MESSENGER_MemberSession *session, const char *path)
+{
+  GNUNET_assert((session) && (path));
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  GNUNET_CONTAINER_multihashmap_iterate(
+      session->history,
+      iterate_save_member_session_history_hentries,
+      handle
+  );
+
+  GNUNET_DISK_file_sync(handle);
+  GNUNET_DISK_file_close(handle);
+}
+
+void
+save_member_session (struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
+{
+  GNUNET_assert ((session) && (directory));
+
+  char *config_file;
+  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  char *key_data = GNUNET_IDENTITY_public_key_to_string(get_member_session_public_key(session));
+
+  if (key_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
+
+    GNUNET_free(key_data);
+  }
+
+  if (session->next)
+  {
+    const struct GNUNET_ShortHashCode *next_id = get_member_session_id(session->next);
+
+    char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id, sizeof(*next_id));
+
+    if (next_id_data)
+    {
+      GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id", next_id_data);
+
+      GNUNET_free(next_id_data);
+    }
+
+    key_data = GNUNET_IDENTITY_public_key_to_string(get_member_session_public_key(session->next));
+
+    if (key_data)
+    {
+      GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key", key_data);
+
+      GNUNET_free(key_data);
+    }
+  }
+
+  GNUNET_CONFIGURATION_set_value_number(cfg, "session", "start", session->start.abs_value_us);
+
+  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed", session->closed);
+  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed", session->completed);
+
+  GNUNET_CONFIGURATION_write (cfg, config_file);
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+  GNUNET_free(config_file);
+
+  char *history_file;
+  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
+
+  save_member_session_history (session, history_file);
+  GNUNET_free(history_file);
+
+  char *messages_file;
+  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
+
+  save_list_messages(&(session->messages), messages_file);
+  GNUNET_free(messages_file);
+}
diff --git a/src/messenger/gnunet-service-messenger_member_session.h b/src/messenger/gnunet-service-messenger_member_session.h
new file mode 100644
index 000000000..fa9c6b829
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member_session.h
@@ -0,0 +1,288 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member_session.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MEMBER_SESSION_H
+#define GNUNET_SERVICE_MESSENGER_MEMBER_SESSION_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_time_lib.h"
+
+#include "gnunet-service-messenger_member.h"
+
+#include "messenger_api_contact.h"
+
+struct GNUNET_MESSENGER_MemberSession {
+  struct GNUNET_MESSENGER_Member *member;
+
+  struct GNUNET_IDENTITY_PublicKey public_key;
+  struct GNUNET_HashCode context;
+
+  struct GNUNET_MESSENGER_Contact *contact;
+
+  struct GNUNET_CONTAINER_MultiHashMap *history;
+  struct GNUNET_MESSENGER_ListMessages messages;
+
+  struct GNUNET_MESSENGER_MemberSession* prev;
+  struct GNUNET_MESSENGER_MemberSession* next;
+
+  struct GNUNET_TIME_Absolute start;
+
+  int closed;
+  int completed;
+};
+
+/**
+ * Creates and allocates a new member session of a <i>member</i> with a given
+ * public key.
+ *
+ * If the creation fails, NULL gets returned.
+ *
+ * @param[in/out] member Member
+ * @param[in] pubkey Public key of EGO
+ * @return New member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+create_member_session (struct GNUNET_MESSENGER_Member *member,
+                       const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Creates and allocates a new member session closing and replacing a given
+ * other <i>session</i> of the same member. The new session could have significant
+ * changes to the members public key or its member id depending on the used
+ * <i>message</i> to switch session. The new session will be linked to the old
+ * one.
+ *
+ * @param[in/out] session Old member session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @return New member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+switch_member_session (struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash);
+
+/**
+ * Destroys a member session and frees its memory fully.
+ *
+ * @param[in/out] session Member session
+ */
+void
+destroy_member_session(struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Resets a given member <i>session</i> which re-opens a member
+ * session for new usage. Every connection to other sessions will be
+ * be dropped. The member sessions messages will be cleared but old
+ * history from uncompleted sessions however can be reused!
+ *
+ * @param[in/out] session Member session
+ * @param[in] hash Hash of initial message (JOIN message!)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
+ */
+int
+reset_member_session (struct GNUNET_MESSENGER_MemberSession* session,
+                      const struct GNUNET_HashCode *hash);
+
+/**
+ * Closes a given member <i>session</i> which opens the request
+ * for completion of the given member session.
+ *
+ * Closing a session may complete a session and can't be used without
+ * a reset! ( @see #reset_member_session() )
+ *
+ * @param[in/out] session Member session
+ */
+void
+close_member_session (struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns if the given member <i>session</i> has been closed.
+ *
+ * @param[in] session Member session
+ * @return #GNUNET_YES or #GNUNET_NO
+ */
+int
+is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns if the given member <i>session</i> has been completed.
+ *
+ * A completed member session can't verify any message as its own and
+ * it won't add any message to its history.
+ *
+ * @param[in] session Member session
+ * @return #GNUNET_YES or #GNUNET_NO
+ */
+int
+is_member_session_completed (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns the timestamp of the member <i>session</i>'s start.
+ *
+ * @param[in] session Member session
+ * @return Absolute timestamp
+ */
+struct GNUNET_TIME_Absolute
+get_member_session_start (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns the key of the room a given member <i>session</i> belongs to.
+ *
+ * @param[in] session Member session
+ * @return Key of room
+ */
+const struct GNUNET_HashCode*
+get_member_session_key (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns the member id of a given member <i>session</i>.
+ *
+ * @param[in] session Member session
+ * @return Member id
+ */
+const struct GNUNET_ShortHashCode*
+get_member_session_id (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns the public key from an EGO of a given member <i>session</i>.
+ *
+ * @param[in] session Member session
+ * @return Public key of EGO
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+get_member_session_public_key (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Returns the member context of a given member <i>session</i>.
+ *
+ * @param[in] session Member session
+ * @return Member context as hash
+ */
+const struct GNUNET_HashCode*
+get_member_session_context (const struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Retruns the contact which is connected to a given member <i>session</i>.
+ *
+ * @param[in] session Member session
+ * @return Contact
+ */
+struct GNUNET_MESSENGER_Contact*
+get_member_session_contact (struct GNUNET_MESSENGER_MemberSession* session);
+
+/**
+ * Verifies a given member <i>session</i> as sender of a selected <i>message</i> and
+ * its <i>hash</i>. The function returns #GNUNET_OK if the message session is verified
+ * as sender, otherwise #GNUNET_SYSERR.
+ *
+ * @see #is_member_session_completed() for verification.
+ *
+ * @param[in] session Member session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+int
+verify_member_session_as_sender (const struct GNUNET_MESSENGER_MemberSession *session,
+                                 const struct GNUNET_MESSENGER_Message *message,
+                                 const struct GNUNET_HashCode *hash);
+
+/**
+ * Checks the history of a <i>session</i> for a specific message which is identified
+ * by its <i>hash</i> and if the <i>ownership</i> flag is set, if the message is
+ * owned by the sessions contact.
+ *
+ * @param[in] session Member session
+ * @param[in] hash Hash of message
+ * @param[in] ownership Ownership flag
+ * @return #GNUNET_YES if found, otherwise #GNUNET_NO
+ */
+int
+check_member_session_history (const struct GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash, int ownership);
+
+/**
+ * Adds a given <i>message</i> to the history of a <i>session</i> using the messages
+ * <i>hash</i>. The ownership will be set automatically.
+ *
+ * @see #is_member_session_completed() for updating a history.
+ *
+ * @param[in/out] session Member session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ */
+void
+update_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
+                               const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_HashCode *hash);
+
+/**
+ * Removes a message from the history of a <i>session</i> using the messages
+ * <i>hash</i>.
+ *
+ * @param[in/out] session Member session
+ * @param[in] hash Hash of message
+ */
+void
+clear_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash);
+
+/**
+ * Loads data from a <i>directory</i> into a new allocated and created member
+ * session of a <i>member</i> if the required information can be read from the
+ * content of the given directory.
+ *
+ * @param[out] member Member
+ * @param[in] directory Path to a directory
+ */
+void
+load_member_session (struct GNUNET_MESSENGER_Member *member, const char *directory);
+
+/**
+ * Loads the connection from one <i>session</i> to another through the
+ * next attribute. Necessary information will be loaded from a configuration
+ * file inside of a given <i>directory</i>.
+ *
+ * @param[in/out] session Member session
+ * @param[in] directory Path to a directory
+ */
+void
+load_member_session_next (struct GNUNET_MESSENGER_MemberSession *session, const char *directory);
+
+/**
+ * Saves data from a member <i>session</i> into a <i>directory</i> which can be
+ * load to restore the member session completely.
+ *
+ * @param[in] session Member session
+ * @param[in] directory Path to a directory
+ */
+void
+save_member_session (struct GNUNET_MESSENGER_MemberSession *session, const char *directory);
+
+#endif //GNUNET_SERVICE_MESSENGER_MEMBER_SESSION_H
diff --git a/src/messenger/gnunet-service-messenger_member_store.c b/src/messenger/gnunet-service-messenger_member_store.c
new file mode 100644
index 000000000..2925965d4
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member_store.c
@@ -0,0 +1,250 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member_store.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_member_store.h"
+
+#include "gnunet-service-messenger_member.h"
+#include "gnunet-service-messenger_service.h"
+#include "gnunet-service-messenger_room.h"
+
+void
+init_member_store (struct GNUNET_MESSENGER_MemberStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert ((store) && (room));
+
+  store->room = room;
+  store->members = GNUNET_CONTAINER_multishortmap_create(8, GNUNET_NO);
+}
+
+static int
+iterate_destroy_members (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Member *member = value;
+  destroy_member(member);
+  return GNUNET_YES;
+}
+
+void
+clear_member_store (struct GNUNET_MESSENGER_MemberStore *store)
+{
+  GNUNET_assert ((store) && (store->members));
+
+  GNUNET_CONTAINER_multishortmap_iterate (store->members, iterate_destroy_members, NULL);
+  GNUNET_CONTAINER_multishortmap_destroy (store->members);
+}
+
+
+struct GNUNET_MESSENGER_ContactStore*
+get_member_contact_store (struct GNUNET_MESSENGER_MemberStore *store)
+{
+  GNUNET_assert ((store) && (store->room));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = store->room;
+
+  return get_service_contact_store(room->service);
+}
+
+const struct GNUNET_HashCode*
+get_member_store_key (const struct GNUNET_MESSENGER_MemberStore *store)
+{
+  GNUNET_assert (store);
+
+  return get_room_key((const struct GNUNET_MESSENGER_SrvRoom*) store->room);
+}
+
+static int
+callback_scan_for_members (void *cls, const char *filename)
+{
+  struct GNUNET_MESSENGER_MemberStore *store = cls;
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (filename, GNUNET_YES))
+  {
+    char *directory;
+
+    GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR);
+
+    load_member(store, directory);
+
+    GNUNET_free(directory);
+  }
+
+  return GNUNET_OK;
+}
+
+static int
+iterate_load_next_member_sessions (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
+{
+  const char *sync_dir = cls;
+
+  struct GNUNET_MESSENGER_Member *member = value;
+
+  if (!member)
+    return GNUNET_YES;
+
+  char *member_dir;
+  GNUNET_asprintf (&member_dir, "%s%s%c", sync_dir, GNUNET_sh2s(id), DIR_SEPARATOR);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (member_dir, GNUNET_YES))
+    load_member_next_sessions (member, member_dir);
+
+  GNUNET_free(member_dir);
+  return GNUNET_YES;
+}
+
+static int
+iterate_sync_member_contacts (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
+{
+  struct GNUNET_MESSENGER_Member *member = value;
+
+  if (!member)
+    return GNUNET_YES;
+
+  sync_member_contacts (member);
+  return GNUNET_YES;
+}
+
+void
+load_member_store (struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  char *scan_dir;
+  GNUNET_asprintf (&scan_dir, "%s%s%c", directory, "members", DIR_SEPARATOR);
+
+  if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
+    GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_members, store);
+
+  GNUNET_CONTAINER_multishortmap_iterate(store->members, iterate_load_next_member_sessions, scan_dir);
+  GNUNET_CONTAINER_multishortmap_iterate(store->members, iterate_sync_member_contacts, NULL);
+
+  GNUNET_free(scan_dir);
+}
+
+static int
+iterate_save_members (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
+{
+  const char *save_dir = cls;
+
+  struct GNUNET_MESSENGER_Member *member = value;
+
+  if (!member)
+    return GNUNET_YES;
+
+  char *member_dir;
+  GNUNET_asprintf (&member_dir, "%s%s%c", save_dir, GNUNET_sh2s(id), DIR_SEPARATOR);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (member_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (member_dir)))
+    save_member(member, member_dir);
+
+  GNUNET_free(member_dir);
+  return GNUNET_YES;
+}
+
+void
+save_member_store (struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  char* save_dir;
+  GNUNET_asprintf (&save_dir, "%s%s%c", directory, "members", DIR_SEPARATOR);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+    GNUNET_CONTAINER_multishortmap_iterate(store->members, iterate_save_members, save_dir);
+
+  GNUNET_free(save_dir);
+}
+
+struct GNUNET_MESSENGER_Member*
+get_store_member (const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert ((store) && (store->members) && (id));
+
+  return GNUNET_CONTAINER_multishortmap_get (store->members, id);
+}
+
+struct GNUNET_MESSENGER_Member*
+get_store_member_of (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_MESSENGER_Message *message)
+{
+  if ((GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_JOIN == message->header.kind))
+    return add_store_member(store, &(message->header.sender_id));
+  else
+    return get_store_member(store, &(message->header.sender_id));
+}
+
+struct GNUNET_MESSENGER_Member*
+add_store_member (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert ((store) && (store->members));
+
+  struct GNUNET_MESSENGER_Member *member = id? get_store_member(store, id) : NULL;
+
+  if (member)
+    return member;
+
+  member = create_member(store, id);
+
+  if (!member)
+    return NULL;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (store->members, get_member_id(member), member,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    destroy_member(member);
+    return NULL;
+  }
+
+  return member;
+}
+
+struct GNUNET_MESSENGER_ClosureIterateMembers {
+  GNUNET_MESSENGER_MemberIteratorCallback it;
+  void *cls;
+};
+
+static int
+iterate_store_members_it (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureIterateMembers *iterate = cls;
+  struct GNUNET_MESSENGER_Member *member = value;
+
+  return iterate_member_sessions(member, iterate->it, iterate->cls);
+}
+
+int
+iterate_store_members (struct GNUNET_MESSENGER_MemberStore *store, GNUNET_MESSENGER_MemberIteratorCallback it,
+                       void* cls)
+{
+  GNUNET_assert ((store) && (store->members) && (it));
+
+  struct GNUNET_MESSENGER_ClosureIterateMembers iterate;
+
+  iterate.it = it;
+  iterate.cls = cls;
+
+  return GNUNET_CONTAINER_multishortmap_iterate(store->members, iterate_store_members_it, &iterate);
+}
diff --git a/src/messenger/gnunet-service-messenger_member_store.h b/src/messenger/gnunet-service-messenger_member_store.h
new file mode 100644
index 000000000..859e4683d
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_member_store.h
@@ -0,0 +1,151 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_member_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MEMBER_STORE_H
+#define GNUNET_SERVICE_MESSENGER_MEMBER_STORE_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_identity_service.h"
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_SrvRoom;
+
+struct GNUNET_MESSENGER_Member;
+struct GNUNET_MESSENGER_MemberSession;
+
+struct GNUNET_MESSENGER_MemberStore
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+
+  struct GNUNET_CONTAINER_MultiShortmap *members;
+};
+
+typedef int (*GNUNET_MESSENGER_MemberIteratorCallback) (
+    void *cls,
+    const struct GNUNET_IDENTITY_PublicKey *public_key,
+    struct GNUNET_MESSENGER_MemberSession *session);
+
+/**
+ * Initializes a member <i>store</i> as fully empty connected to a <i>room</i>.
+ *
+ * @param[out] store Member store
+ * @param room Room
+ */
+void
+init_member_store (struct GNUNET_MESSENGER_MemberStore *store, struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Clears a member <i>store</i>, wipes its content and deallocates its memory.
+ *
+ * @param[in/out] store Member store
+ */
+void
+clear_member_store (struct GNUNET_MESSENGER_MemberStore *store);
+
+/**
+ * Returns the used contact store of a given member <i>store</i>.
+ *
+ * @param[in/out] store Member store
+ * @return Contact store
+ */
+struct GNUNET_MESSENGER_ContactStore*
+get_member_contact_store (struct GNUNET_MESSENGER_MemberStore *store);
+
+/**
+ * Returns the shared secret you need to access a room of the <i>store</i>.
+ *
+ * @param[in] store Member store
+ * @return Shared secret
+ */
+const struct GNUNET_HashCode*
+get_member_store_key (const struct GNUNET_MESSENGER_MemberStore *store);
+
+/**
+ * Loads members from a directory into a member <i>store</i>.
+ *
+ * @param[out] store Member store
+ * @param[in] directory Path to a directory
+ */
+void
+load_member_store (struct GNUNET_MESSENGER_MemberStore *store, const char *directory);
+
+/**
+ * Saves members from a member <i>store</i> into a directory.
+ *
+ * @param[in] store Member store
+ * @param[in] directory Path to a directory
+ */
+void
+save_member_store (struct GNUNET_MESSENGER_MemberStore *store, const char *directory);
+
+/**
+ * Returns the member in a <i>store</i> identified by a given <i>id</i>. If the <i>store</i>
+ * does not contain a member with the given <i>id</i>, NULL gets returned.
+ *
+ * @param[in] store Member store
+ * @param[in] id Member id
+ * @return Member or NULL
+ */
+struct GNUNET_MESSENGER_Member*
+get_store_member (const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Returns the member of a <i>store</i> using a sender id of a given <i>message</i>.
+ * If the member does not provide a matching session, NULL gets returned.
+ *
+ * @param[in/out] store Member store
+ * @param[in] message Message
+ * @return Member or NULL
+ */
+struct GNUNET_MESSENGER_Member*
+get_store_member_of (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Adds a member to a <i>store</i> under a specific <i>id</i> and returns it on success.
+ *
+ * @param[in/out] store Member store
+ * @param[in] id Member id
+ * @return Member or NULL
+ */
+struct GNUNET_MESSENGER_Member*
+add_store_member (struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Iterate through all member sessions currently connected to the members of the given
+ * member <i>store</i> and call the provided iterator callback with a selected closure.
+ * The function will return the amount of members it iterated through.
+ *
+ * @param[in/out] store Member store
+ * @param[in] it Iterator callback
+ * @param[in/out] cls Closure
+ * @return Amount of members iterated through
+ */
+int
+iterate_store_members (struct GNUNET_MESSENGER_MemberStore *store, GNUNET_MESSENGER_MemberIteratorCallback it,
+                       void* cls);
+
+#endif //GNUNET_SERVICE_MESSENGER_MEMBER_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_message_handle.c b/src/messenger/gnunet-service-messenger_message_handle.c
index 1652435c8..1d489310c 100644
--- a/src/messenger/gnunet-service-messenger_message_handle.c
+++ b/src/messenger/gnunet-service-messenger_message_handle.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,75 +25,66 @@
 
 #include "gnunet-service-messenger_message_handle.h"
 
-void
-handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+static void
+handle_session_switch (struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
-
-  if (!contact)
-    add_room_contact (room, &(message->header.sender_id), &(message->body.join.key));
-
-  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
-
-  if (!info)
-  {
-    info = GNUNET_new(struct GNUNET_MESSENGER_MemberInfo);
-
-    info->access = GNUNET_MESSENGER_MEMBER_UNKNOWN;
-    init_list_messages (&(info->session_messages));
-  }
-  else
-    clear_list_messages (&(info->session_messages));
+  struct GNUNET_MESSENGER_MemberSession *next = switch_member_session(session, message, hash);
 
-  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_put (room->member_infos, &(message->header.sender_id), info,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    add_to_list_messages (&(info->session_messages), hash);
+  if (next != session)
+    add_member_session(next->member, next);
 }
 
 void
-handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
-
-  if (info)
-    clear_list_messages (&(info->session_messages));
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member (%s) joins room (%s).\n",
+             GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s(get_room_key(room)));
+
+  if (GNUNET_OK != reset_member_session(session, hash))
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Resetting member session failed!\n");
+
+  solve_room_member_collisions (
+      room,
+      &(message->body.join.key),
+      &(message->header.sender_id),
+      GNUNET_TIME_absolute_ntoh(message->header.timestamp)
+  );
 }
 
 void
-handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
-
-  if (contact)
-    set_contact_name (contact, message->body.name.name);
-
-  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member (%s) leaves room (%s).\n",
+             GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s(get_room_key(room)));
 
-  if (info)
-    add_to_list_messages (&(info->session_messages), hash);
+  close_member_session(session);
 }
 
 void
-handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
+  struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact(session);
 
-  if (contact)
-    swap_service_contact_by_pubkey (room->service, contact, &(message->body.key.key));
+  if (!contact)
+    return;
 
-  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+  set_contact_name (contact, message->body.name.name);
+}
 
-  if (info)
-    add_to_list_messages (&(info->session_messages), hash);
+void
+handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                    const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  handle_session_switch (session, message, hash);
 }
 
 void
-handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   if (GNUNET_NO == contains_list_tunnels (&(room->basement), &(message->body.peer.peer)))
     add_to_list_tunnels (&(room->basement), &(message->body.peer.peer));
@@ -103,20 +94,22 @@ handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSEN
 }
 
 void
-handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
-
-  if (info)
-    add_to_list_messages (&(info->session_messages), hash);
-
-  switch_room_member_id (room, &(message->header.sender_id), &(message->body.id.id), hash);
+  handle_session_switch (session, message, hash);
+
+  solve_room_member_collisions (
+      room,
+      get_member_session_public_key(session),
+      &(message->body.id.id),
+      GNUNET_TIME_absolute_ntoh(message->header.timestamp)
+  );
 }
 
 void
-handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (&(room->basement), &(message->body.peer.peer), NULL);
 
@@ -128,3 +121,16 @@ handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSEN
   if (room->peer_message)
     rebuild_room_basement_structure (room);
 }
+
+void
+handle_message_delete (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_TIME_Relative delay = GNUNET_TIME_relative_ntoh (message->body.delete.delay);
+  struct GNUNET_TIME_Absolute action = GNUNET_TIME_absolute_ntoh (message->header.timestamp);
+
+  action = GNUNET_TIME_absolute_add (action, delay);
+  delay = GNUNET_TIME_absolute_get_difference (GNUNET_TIME_absolute_get (), action);
+
+  delete_room_message (room, session, &(message->body.delete.hash), delay);
+}
diff --git a/src/messenger/gnunet-service-messenger_message_handle.h b/src/messenger/gnunet-service-messenger_message_handle.h
index d091e1d11..844142b77 100644
--- a/src/messenger/gnunet-service-messenger_message_handle.h
+++ b/src/messenger/gnunet-service-messenger_message_handle.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -31,6 +31,7 @@
 
 #include "gnunet-service-messenger_message_kind.h"
 
+#include "gnunet-service-messenger_member_session.h"
 #include "gnunet-service-messenger_tunnel.h"
 #include "messenger_api_message.h"
 
@@ -38,91 +39,104 @@
  * Handles a received or sent join message to make changes of current member information.
  * (add matching member and clear member info)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message JOIN-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message JOIN-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent leave message to make changes of current member information.
  * (remove matching member and clear member info)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message LEAVE-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message LEAVE-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent name message to rename a current member.
  * (change name of matching member)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message NAME-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message NAME-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent key message to change the key of a member and rearrange the contacts accordingly.
  * (move the member in the contacts and change its key)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message KEY-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message KEY-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                    const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent peer message to make changes of the basement in the room.
  * (add a new peer to the basement and restructure connections based on updated list of peers)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message PEER-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message PEER-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent id message to change a members id.
  * (change id of matching member)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message ID-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message ID-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received or sent miss message to drop a peer from the basement in the room.
  * (remove a peer from the basement and restructure connections based on updated list of peers)
  *
- * @param room Room of the message
- * @param tunnel Receiving/sending connection (may be NULL)
- * @param message MISS-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message MISS-Message
+ * @param[in] hash Hash of the message
  */
 void
-handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent delete message to delete a specific message from the store.
+ * (remove a message from the store of a room under a given delay)
+ *
+ * @param[in/out] room Room of the message
+ * @param[in/out] session Member session
+ * @param[in] message DELETE-Message
+ * @param[in] hash Hash of the message
+ */
+void
+handle_message_delete (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 #endif //GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
diff --git a/src/messenger/gnunet-service-messenger_message_kind.c b/src/messenger/gnunet-service-messenger_message_kind.c
index 9c829fe09..ef9bbfd2e 100644
--- a/src/messenger/gnunet-service-messenger_message_kind.c
+++ b/src/messenger/gnunet-service-messenger_message_kind.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -24,11 +24,15 @@
  */
 
 #include "gnunet-service-messenger_message_kind.h"
-#include "gnunet-service-messenger_util.h"
+
+#include "messenger_api_util.h"
 
 struct GNUNET_MESSENGER_Message*
-create_message_info (struct GNUNET_MESSENGER_Ego *ego, struct GNUNET_CONTAINER_MultiShortmap *members)
+create_message_info (const struct GNUNET_MESSENGER_Ego *ego)
 {
+  if (!ego)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_INFO);
 
   if (!message)
@@ -36,18 +40,17 @@ create_message_info (struct GNUNET_MESSENGER_Ego *ego, struct GNUNET_CONTAINER_M
 
   GNUNET_memcpy(&(message->body.info.host_key), &(ego->pub), sizeof(ego->pub));
 
-  if (GNUNET_YES == generate_free_member_id (&(message->body.info.unique_id), members))
-    return message;
-  else
-  {
-    destroy_message (message);
-    return NULL;
-  }
+  message->body.info.messenger_version = GNUNET_MESSENGER_VERSION;
+
+  return message;
 }
 
 struct GNUNET_MESSENGER_Message*
-create_message_join (struct GNUNET_MESSENGER_Ego *ego)
+create_message_join (const struct GNUNET_MESSENGER_Ego *ego)
 {
+  if (!ego)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_JOIN);
 
   if (!message)
@@ -67,6 +70,9 @@ create_message_leave ()
 struct GNUNET_MESSENGER_Message*
 create_message_name (const char *name)
 {
+  if (!name)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_NAME);
 
   if (!message)
@@ -79,6 +85,9 @@ create_message_name (const char *name)
 struct GNUNET_MESSENGER_Message*
 create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key)
 {
+  if (!key)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_KEY);
 
   if (!message)
@@ -91,6 +100,9 @@ create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key)
 struct GNUNET_MESSENGER_Message*
 create_message_peer (const struct GNUNET_MESSENGER_Service *service)
 {
+  if (!service)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_PEER);
 
   if (!message)
@@ -108,6 +120,9 @@ create_message_peer (const struct GNUNET_MESSENGER_Service *service)
 struct GNUNET_MESSENGER_Message*
 create_message_id (const struct GNUNET_ShortHashCode *unique_id)
 {
+  if (!unique_id)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_ID);
 
   if (!message)
@@ -121,6 +136,9 @@ create_message_id (const struct GNUNET_ShortHashCode *unique_id)
 struct GNUNET_MESSENGER_Message*
 create_message_miss (const struct GNUNET_PeerIdentity *peer)
 {
+  if (!peer)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_MISS);
 
   if (!message)
@@ -136,6 +154,9 @@ create_message_miss (const struct GNUNET_PeerIdentity *peer)
 struct GNUNET_MESSENGER_Message*
 create_message_merge (const struct GNUNET_HashCode *previous)
 {
+  if (!previous)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_MERGE);
 
   if (!message)
@@ -149,6 +170,9 @@ create_message_merge (const struct GNUNET_HashCode *previous)
 struct GNUNET_MESSENGER_Message*
 create_message_request (const struct GNUNET_HashCode *hash)
 {
+  if (!hash)
+    return NULL;
+
   struct GNUNET_HashCode zero;
   memset (&zero, 0, sizeof(zero));
 
@@ -168,6 +192,9 @@ create_message_request (const struct GNUNET_HashCode *hash)
 struct GNUNET_MESSENGER_Message*
 create_message_invite (const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
 {
+  if ((!door) || (!key))
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_INVITE);
 
   if (!message)
@@ -182,6 +209,9 @@ create_message_invite (const struct GNUNET_PeerIdentity *door, const struct GNUN
 struct GNUNET_MESSENGER_Message*
 create_message_text (const char *text)
 {
+  if (!text)
+    return NULL;
+
   struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_TEXT);
 
   if (!message)
@@ -190,3 +220,20 @@ create_message_text (const char *text)
   message->body.text.text = GNUNET_strdup(text);
   return message;
 }
+
+struct GNUNET_MESSENGER_Message*
+create_message_delete (const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
+{
+  if (!hash)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_DELETE);
+
+  if (!message)
+    return NULL;
+
+  GNUNET_memcpy(&(message->body.delete.hash), hash, sizeof(struct GNUNET_HashCode));
+  message->body.delete.delay = GNUNET_TIME_relative_hton (delay);
+
+  return message;
+}
diff --git a/src/messenger/gnunet-service-messenger_message_kind.h b/src/messenger/gnunet-service-messenger_message_kind.h
index dd89d0b2f..c098868c0 100644
--- a/src/messenger/gnunet-service-messenger_message_kind.h
+++ b/src/messenger/gnunet-service-messenger_message_kind.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -30,31 +30,32 @@
 #include "gnunet_container_lib.h"
 #include "gnunet_crypto_lib.h"
 #include "gnunet_identity_service.h"
+#include "gnunet_time_lib.h"
 
 #include "messenger_api_message.h"
 #include "gnunet-service-messenger_service.h"
 #include "messenger_api_ego.h"
 
 /**
- * Creates and allocates a new info message containing the hosts public key and a newly generated unique member id.
+ * Creates and allocates a new info message containing the hosts EGO public key and a newly generated unique member id.
  * (all values are stored as copy)
  *
- * @param ego EGO of the host
- * @param members Map of all assigned member ids
+ * @param[in] ego EGO of the host
+ * @param[in] members Map of all assigned member ids
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
-create_message_info (struct GNUNET_MESSENGER_Ego *ego, struct GNUNET_CONTAINER_MultiShortmap *members);
+create_message_info (const struct GNUNET_MESSENGER_Ego *ego);
 
 /**
- * Creates and allocates a new join message containing the clients public key.
+ * Creates and allocates a new join message containing the clients EGO public key.
  * (all values are stored as copy)
  *
- * @param ego EGO of the client
+ * @param[in] ego EGO of the client
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
-create_message_join (struct GNUNET_MESSENGER_Ego *ego);
+create_message_join (const struct GNUNET_MESSENGER_Ego *ego);
 
 /**
  * Creates and allocates a new leave message.
@@ -68,17 +69,17 @@ create_message_leave ();
  * Creates and allocates a new name message containing the <i>name</i> to change to.
  * (all values are stored as copy)
  *
- * @param name New name
+ * @param[in] name New name
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_name (const char *name);
 
 /**
- * Creates and allocates a new key message containing the public key to change to derived
+ * Creates and allocates a new key message containing the public <i>key</i> to change to derived
  * from its private counterpart. (all values are stored as copy)
  *
- * @param key Private key of EGO
+ * @param[in] key Private key of EGO
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
@@ -88,7 +89,7 @@ create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key);
  * Creates and allocates a new peer message containing a services peer identity.
  * (all values are stored as copy)
  *
- * @param service Service
+ * @param[in] service Service
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
@@ -98,38 +99,38 @@ create_message_peer (const struct GNUNET_MESSENGER_Service *service);
  * Creates and allocates a new id message containing the unique member id to change to.
  * (all values are stored as copy)
  *
- * @param unique_id Unique member id
+ * @param[in] unique_id Unique member id
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_id (const struct GNUNET_ShortHashCode *unique_id);
 
 /**
- * Creates and allocates a new miss message containing the missing peer identity.
+ * Creates and allocates a new miss message containing the missing <i>peer</i> identity.
  * (all values are stored as copy)
  *
- * @param peer Missing peer identity
+ * @param[in] peer Missing peer identity
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_miss (const struct GNUNET_PeerIdentity *peer);
 
 /**
- * Creates and allocates a new merge message containing the hash of a second previous message
+ * Creates and allocates a new merge message containing the hash of a second <i>previous</i> message
  * besides the regular previous message mentioned in a messages header.
  * (all values are stored as copy)
  *
- * @param previous Hash of message
+ * @param[in] previous Hash of message
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_merge (const struct GNUNET_HashCode *previous);
 
 /**
- * Creates and allocates a new request message containing the hash of a missing message.
+ * Creates and allocates a new request message containing the <i>hash</i> of a missing message.
  * (all values are stored as copy)
  *
- * @param hash Hash of message
+ * @param[in] hash Hash of message
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
@@ -140,21 +141,32 @@ create_message_request (const struct GNUNET_HashCode *hash);
  * to a room using a given <i>key</i> as shared secret for communication.
  * (all values are stored as copy)
  *
- * @param door Peer identity
- * @param key Shared secret of a room
+ * @param[in] door Peer identity
+ * @param[in] key Shared secret of a room
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_invite (const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key);
 
 /**
- * Creates and allocates a new text message containing a string representing text.
+ * Creates and allocates a new <i>text message containing a string representing text.
  * (all values are stored as copy)
  *
- * @param text Text
+ * @param[in] text Text
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
 create_message_text (const char *text);
 
+/**
+ * Creates and allocates a new delete message containing the <i>hash</i> of a message to delete after a specific <i>delay</i>.
+ * (all values are stored as copy)
+ *
+ * @param[in] hash Hash of message
+ * @param[in] delay Delay of deletion
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_delete (const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay);
+
 #endif //GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
diff --git a/src/messenger/gnunet-service-messenger_message_recv.c b/src/messenger/gnunet-service-messenger_message_recv.c
index aa28a36ea..b2a5052d2 100644
--- a/src/messenger/gnunet-service-messenger_message_recv.c
+++ b/src/messenger/gnunet-service-messenger_message_recv.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -24,137 +24,92 @@
  */
 
 #include "gnunet-service-messenger_message_recv.h"
-#include "gnunet-service-messenger_message_handle.h"
 
-void
-recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
-{
-  int conflict = GNUNET_CONTAINER_multishortmap_contains (room->members, &(message->body.info.unique_id));
-
-  if (GNUNET_NO == conflict)
-  {
-    struct GNUNET_MESSENGER_Message *sync_message = create_message_id (&(message->body.info.unique_id));
-    struct GNUNET_HashCode sync_hash;
+#include "gnunet-service-messenger_operation.h"
 
-    send_room_message_ext (room, room->host, sync_message, &sync_hash, tunnel);
-    destroy_message (sync_message);
-
-    switch_room_member_id (room, get_room_host_id (room), &(message->body.info.unique_id), NULL);
-
-    change_room_host_id (room, &(message->body.info.unique_id));
-  }
-
-  if (!tunnel->contact_id)
-    tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
-
-  GNUNET_memcpy(tunnel->contact_id, &(message->header.sender_id), sizeof(struct GNUNET_ShortHashCode));
-
-  struct GNUNET_ShortHashCode original_id;
-
-  if (GNUNET_YES == conflict)
-  {
-    GNUNET_memcpy(&original_id, get_room_host_id (room), sizeof(struct GNUNET_ShortHashCode));
+static void
+forward_about_members (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                       struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_CONTAINER_MultiHashMap *map)
+{
+  if (session->prev)
+    forward_about_members (room, tunnel, session->prev, map);
 
-    change_room_host_id (room, &(message->body.info.unique_id));
-  }
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
+  struct GNUNET_MESSENGER_ListMessage *element;
 
+  for (element = session->messages.head; element; element = element->next)
   {
-    struct GNUNET_MESSENGER_Message *join_message = create_message_join (room->host->ego);
-    struct GNUNET_HashCode join_hash;
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(map, &(element->hash)))
+      continue;
 
-    send_tunnel_message (tunnel, room->host, join_message, &join_hash);
-    destroy_message (join_message);
-  }
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(map, &(element->hash), NULL,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Forwarding of session message could be duplicated!\n");
 
-  if ((GNUNET_YES == conflict) && (0 != GNUNET_memcmp(&original_id, get_room_host_id (room))))
-  {
-    struct GNUNET_MESSENGER_Message *sync_message = create_message_id (&original_id);
-    struct GNUNET_HashCode sync_hash;
+    const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, &(element->hash));
 
-    send_tunnel_message (tunnel, room->host, sync_message, &sync_hash);
-    destroy_message (sync_message);
+    if (message)
+      forward_tunnel_message(tunnel, message, &(element->hash));
   }
 }
 
-struct GNUNET_MESSENGER_MemberInfoSpread
-{
-  struct GNUNET_MESSENGER_SrvRoom *room;
-  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
-};
-
 static int
-iterate_send_member_infos (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+iterate_forward_members (void *cls, const struct GNUNET_IDENTITY_PublicKey *public_key,
+                              struct GNUNET_MESSENGER_MemberSession *session)
 {
-  struct GNUNET_MESSENGER_MemberInfo *info = value;
-  struct GNUNET_MESSENGER_MemberInfoSpread *spread = cls;
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
-  struct GNUNET_MESSENGER_ListMessage *element = info->session_messages.head;
+  if (GNUNET_YES == is_member_session_completed(session))
+    return GNUNET_YES;
 
-  while (element)
-  {
-    const struct GNUNET_MESSENGER_Message *message = get_room_message (spread->room, spread->room->host,
-                                                                       &(element->hash), GNUNET_NO);
+  struct GNUNET_CONTAINER_MultiHashMap *map = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
 
-    if (message)
-      forward_tunnel_message (spread->tunnel, message, &(element->hash));
-
-    element = element->next;
-  }
+  forward_about_members (tunnel->room, tunnel, session, map);
 
+  GNUNET_CONTAINER_multihashmap_destroy(map);
   return GNUNET_YES;
 }
 
-void
-recv_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+int
+recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  const struct GNUNET_MESSENGER_Message *info_msg = get_room_message (room, room->host, &(message->header.previous),
-                                                                      GNUNET_NO);
+  const uint32_t version = get_tunnel_messenger_version(tunnel);
 
-  if ((info_msg) && (0 == GNUNET_memcmp(&(info_msg->header.sender_id), get_room_host_id (room)))
-      && (GNUNET_MESSENGER_KIND_INFO == info_msg->header.kind))
+  if (GNUNET_OK != update_tunnel_messenger_version(tunnel, message->body.info.messenger_version))
   {
-    struct GNUNET_MESSENGER_MemberInfoSpread spread;
+    disconnect_tunnel(tunnel);
+    return GNUNET_NO;
+  }
 
-    spread.room = room;
+  if (version == get_tunnel_messenger_version(tunnel))
+    return GNUNET_NO;
 
-    if ((tunnel) && (tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, &(message->header.sender_id))))
-      spread.tunnel = tunnel;
-    else
-      spread.tunnel = find_room_tunnel_to (room, &(message->header.sender_id));
+  if (room->host)
+  {
+    const struct GNUNET_MESSENGER_Ego *ego = get_handle_ego(room->host);
 
-    if (spread.tunnel)
-      GNUNET_CONTAINER_multishortmap_iterate (room->member_infos, iterate_send_member_infos, &spread);
+    send_tunnel_message (tunnel, room->host, create_message_info(ego));
   }
 
-  handle_message_join (room, tunnel, message, hash);
-}
+  struct GNUNET_PeerIdentity peer;
+  get_tunnel_peer_identity(tunnel, &peer);
 
-void
-recv_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
-{
-  handle_message_leave (room, tunnel, message, hash);
-}
+  if (GNUNET_YES != contains_list_tunnels(&(room->basement), &peer))
+  {
+    struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
 
-void
-recv_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
-{
-  handle_message_name (room, tunnel, message, hash);
-}
+    iterate_store_members(member_store, iterate_forward_members, tunnel);
+  }
 
-void
-recv_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                  struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
-{
-  handle_message_key (room, tunnel, message, hash);
+  check_room_peer_status(room, tunnel);
+
+  return GNUNET_NO;
 }
 
-void
+int
 recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   struct GNUNET_PeerIdentity peer;
   GNUNET_PEER_resolve (tunnel->peer, &peer);
@@ -164,41 +119,57 @@ recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGE
     if (!tunnel->peer_message)
       tunnel->peer_message = GNUNET_new(struct GNUNET_HashCode);
 
-    GNUNET_memcpy(tunnel->peer_message, hash, sizeof(struct GNUNET_HashCode));
-
-    if (!tunnel->contact_id)
-      tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
-
-    GNUNET_memcpy(tunnel->contact_id, &(message->header.sender_id), sizeof(struct GNUNET_ShortHashCode));
+    GNUNET_memcpy(tunnel->peer_message, &hash, sizeof(hash));
   }
 
-  handle_message_peer (room, tunnel, message, hash);
+  return GNUNET_YES;
 }
 
-void
-recv_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                 struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+static void
+callback_found_message (void *cls, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash)
 {
-  if ((tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, &(message->header.sender_id))))
-    GNUNET_memcpy(tunnel->contact_id, &(message->body.id.id), sizeof(struct GNUNET_ShortHashCode));
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = tunnel;
 
-  handle_message_id (room, tunnel, message, hash);
-}
-
-void
-recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
-{
-  handle_message_miss (room, tunnel, message, hash);
+  if (!message)
+  {
+    struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);
+
+    use_store_operation(
+        operation_store,
+        hash,
+        GNUNET_MESSENGER_OP_REQUEST,
+        GNUNET_MESSENGER_REQUEST_DELAY
+    );
+  }
+  else
+    forward_tunnel_message (tunnel, message, hash);
 }
 
-void
+/*
+ * Function returns GNUNET_NO to drop forwarding the request.
+ * It will only be forwarded if it can't be answered!
+ */
+int
 recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, room->host, &(message->body.request.hash),
-                                                                 GNUNET_NO);
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Request for message (%s)\n", GNUNET_h2s (hash));
+
+  if (!member)
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, hash);
+
+  if ((!session) || (GNUNET_YES != check_member_session_history(session, hash, GNUNET_NO)))
+    return GNUNET_NO;
+
+  if (GNUNET_NO == request_room_message(room, &(message->body.request.hash), session, callback_found_message, tunnel))
+    return GNUNET_YES;
 
-  if (msg)
-    forward_tunnel_message (tunnel, msg, &(message->body.request.hash));
+  return GNUNET_NO;
 }
diff --git a/src/messenger/gnunet-service-messenger_message_recv.h b/src/messenger/gnunet-service-messenger_message_recv.h
index 245612cb0..9cb36c466 100644
--- a/src/messenger/gnunet-service-messenger_message_recv.h
+++ b/src/messenger/gnunet-service-messenger_message_recv.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -29,6 +29,9 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 
+#include "gnunet-service-messenger_message_kind.h"
+
+#include "gnunet-service-messenger_member_session.h"
 #include "gnunet-service-messenger_tunnel.h"
 #include "messenger_api_message.h"
 
@@ -36,124 +39,43 @@
  * Handles a received info message to change the current member id to the one generated by
  * the host connected to. (all current tunnels will be informed about the id change)
  *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message INFO-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] tunnel Receiving connection
+ * @param[in] message INFO-Message
+ * @param[in] hash Hash of the message
+ * @return #GNUNET_NO to not forward the message
  */
-void
+int
 recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received join message to forward all member information to the new member if the message was
- * the direct reaction to a previous info message from this peer.
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message JOIN-Message
- * @param hash Hash of the message
- */
-void
-recv_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received leave message.
- * @see handle_message_leave()
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message LEAVE-Message
- * @param hash Hash of the message
- */
-void
-recv_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received name message.
- * @see handle_message_name()
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message NAME-Message
- * @param hash Hash of the message
- */
-void
-recv_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received key message.
- * @see handle_message_key()
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message KEY-Message
- * @param hash Hash of the message
- */
-void
-recv_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                  struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received peer message to link it to its origin tunnel if the peer identity matches.
  * (the peer message and the member id can potentially be linked to the tunnel)
  *
- * TODO: This handling will only check the one given tunnel!
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message PEER-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] tunnel Receiving connection
+ * @param[in] message PEER-Message
+ * @param[in] hash Hash of the message
+ * @return #GNUNET_YES to forward the message
  */
-void
+int
 recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received id message to change the tunnels linked member id if necessary.
- * (the tunnels linked member id will be changed if the sender id is matching)
- *
- * TODO: This handling will only check the one given tunnel!
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message ID-Message
- * @param hash Hash of the message
- */
-void
-recv_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                 struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a received miss message.
- * @see handle_message_miss()
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message MISS-Message
- * @param hash Hash of the message
- */
-void
-recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a received request message by checking for the requested message and forwarding it back
  * if the message was found.
  * (this can also cause this peer to send a new request instead of only forwarding the received one)
  *
- * TODO: Requests can cause exponentially more requests!
- *
- * @param room Room of the message
- * @param tunnel Receiving connection
- * @param message REQUEST-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] tunnel Receiving connection
+ * @param[in] message REQUEST-Message
+ * @param[in] hash Hash of the message
+ * @return #GNUNET_YES or #GNUNET_NO depending on required forwarding
  */
-void
+int
 recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 #endif //GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
diff --git a/src/messenger/gnunet-service-messenger_message_send.c b/src/messenger/gnunet-service-messenger_message_send.c
index 86cf9b888..a59a178cc 100644
--- a/src/messenger/gnunet-service-messenger_message_send.c
+++ b/src/messenger/gnunet-service-messenger_message_send.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -24,95 +24,45 @@
  */
 
 #include "gnunet-service-messenger_message_send.h"
-#include "gnunet-service-messenger_message_handle.h"
 
-void
-send_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
-{
-  if (!tunnel->contact_id)
-  {
-    tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
-
-    GNUNET_memcpy(tunnel->contact_id, &(message->body.info.unique_id), sizeof(struct GNUNET_ShortHashCode));
-  }
-  else
-  {
-    disconnect_tunnel (tunnel);
-  }
-}
+#include "gnunet-service-messenger_member.h"
+#include "gnunet-service-messenger_member_session.h"
+#include "gnunet-service-messenger_operation.h"
 
 void
 send_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
-{
-  handle_message_join (room, tunnel, message, hash);
-
-  if (room->peer_message)
-  {
-    const struct GNUNET_MESSENGER_Message *peer_message = get_room_message (room, handle, room->peer_message,
-                                                                            GNUNET_NO);
-
-    if ((peer_message) && (tunnel))
-    {
-      forward_tunnel_message (tunnel, peer_message, room->peer_message);
-    }
-  }
-}
-
-void
-send_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                    struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                    const struct GNUNET_HashCode *hash)
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  handle_message_leave (room, tunnel, message, hash);
-}
-
-void
-send_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
-{
-  handle_message_name (room, tunnel, message, hash);
-}
-
-void
-send_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                  struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                  const struct GNUNET_HashCode *hash)
-{
-  handle_message_key (room, tunnel, message, hash);
+  check_room_peer_status(room, NULL);
 }
 
 void
 send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   if (!room->peer_message)
-  {
     room->peer_message = GNUNET_new(struct GNUNET_HashCode);
-  }
 
   GNUNET_memcpy(room->peer_message, hash, sizeof(struct GNUNET_HashCode));
-
-  handle_message_peer (room, tunnel, message, hash);
 }
 
 void
 send_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                 struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                 const struct GNUNET_HashCode *hash)
+                 const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  handle_message_id (room, tunnel, message, hash);
+  change_handle_member_id (handle, get_room_key(room), &(message->body.id.id));
 }
 
 void
-send_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
+send_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  handle_message_miss (room, tunnel, message, hash);
+  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);
+
+  use_store_operation(
+      operation_store,
+      &(message->body.request.hash),
+      GNUNET_MESSENGER_OP_REQUEST,
+      GNUNET_MESSENGER_REQUEST_DELAY
+  );
 }
diff --git a/src/messenger/gnunet-service-messenger_message_send.h b/src/messenger/gnunet-service-messenger_message_send.h
index c1096205a..63320ab17 100644
--- a/src/messenger/gnunet-service-messenger_message_send.h
+++ b/src/messenger/gnunet-service-messenger_message_send.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -29,127 +29,61 @@
 #include "platform.h"
 #include "gnunet_crypto_lib.h"
 
+#include "gnunet-service-messenger_message_kind.h"
+
 #include "gnunet-service-messenger_tunnel.h"
 #include "messenger_api_message.h"
 
 /**
- * Handles a sent info message to setup a tunnels linked member id.
- * (if a tunnel has already got a member id linked to it, the connection will be closed)
- *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message INFO-Message
- * @param hash Hash of the message
- */
-void
-send_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash);
-
-/**
  * Handles a sent join message to ensure growth of the decentralized room structure.
  * (if the service provides a peer message for this room currently, it will be forwarded)
  *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message JOIN-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] handle Sending handle
+ * @param[in] message JOIN-Message
+ * @param[in] hash Hash of the message
  */
 void
 send_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a sent leave message.
- * @see handle_message_leave()
- *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message LEAVE-Message
- * @param hash Hash of the message
- */
-void
-send_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                    struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                    const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a sent name message.
- * @see handle_message_name()
- *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message NAME-Message
- * @param hash Hash of the message
- */
-void
-send_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash);
-
-/**
- * Handles a sent key message.
- * @see handle_message_key()
- *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message KEY-Message
- * @param hash Hash of the message
- */
-void
-send_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                  struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                  const struct GNUNET_HashCode *hash);
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
  * Handles a sent peer message to update the rooms peer message of this service.
  * (a set peer message indicates this service being a part of the decentralized room structure)
  *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message PEER-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] handle Sending handle
+ * @param[in] message PEER-Message
+ * @param[in] hash Hash of the message
  */
 void
 send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash);
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
- * Handles a sent id message.
- * @see handle_message_id()
+ * Handles a sent id message to update the handles member id in the room.
+ * (changing member id is useful to prevent collisions)
  *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message ID-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] handle Sending handle
+ * @param[in] message ID-Message
+ * @param[in] hash Hash of the message
  */
 void
 send_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                 struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                 const struct GNUNET_HashCode *hash);
+                 const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
- * Handles a sent miss message.
- * @see handle_message_miss()
+ * Handles a sent request message to trigger the request operation for this service.
+ * (the request operation will deactivate the possibility of spamming requests)
  *
- * @param room Room of the message
- * @param handle Sending handle
- * @param tunnel Sending connection (may be NULL)
- * @param message MISS-Message
- * @param hash Hash of the message
+ * @param[in/out] room Room of the message
+ * @param[in/out] handle Sending handle
+ * @param[in] message PEER-Message
+ * @param[in] hash Hash of the message
  */
 void
-send_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash);
+send_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 #endif //GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
diff --git a/src/messenger/gnunet-service-messenger_message_state.c b/src/messenger/gnunet-service-messenger_message_state.c
new file mode 100644
index 000000000..cdd2d9712
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_state.c
@@ -0,0 +1,109 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_state.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_state.h"
+
+void
+init_message_state (struct GNUNET_MESSENGER_MessageState *state)
+{
+  GNUNET_assert(state);
+
+  init_list_messages (&(state->last_messages));
+}
+
+void
+clear_message_state (struct GNUNET_MESSENGER_MessageState *state)
+{
+  GNUNET_assert(state);
+
+  clear_list_messages (&(state->last_messages));
+}
+
+void
+get_message_state_chain_hash (const struct GNUNET_MESSENGER_MessageState *state,
+                              struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((state) && (hash));
+
+  if (state->last_messages.head)
+    GNUNET_memcpy(hash, &(state->last_messages.head->hash), sizeof(*hash));
+  else
+    memset (hash, 0, sizeof(*hash));
+}
+
+const struct GNUNET_HashCode*
+get_message_state_merge_hash (const struct GNUNET_MESSENGER_MessageState *state)
+{
+  GNUNET_assert(state);
+
+  if (state->last_messages.head == state->last_messages.tail)
+    return NULL;
+
+  return &(state->last_messages.tail->hash);
+}
+
+void
+update_message_state (struct GNUNET_MESSENGER_MessageState *state, int requested,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((state) && (message) && (hash));
+
+  if ((GNUNET_YES == requested) ||
+      (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_REQUEST == message->header.kind))
+    return;
+
+  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
+    remove_from_list_messages(&(state->last_messages), &(message->body.merge.previous));
+  remove_from_list_messages(&(state->last_messages), &(message->header.previous));
+
+  add_to_list_messages (&(state->last_messages), hash);
+}
+
+void
+load_message_state (struct GNUNET_MESSENGER_MessageState *state, const char *path)
+{
+  GNUNET_assert((state) && (path));
+
+  char *last_messages_file;
+  GNUNET_asprintf (&last_messages_file, "%s%s", path, "last_messages.list");
+
+  load_list_messages(&(state->last_messages), last_messages_file);
+  GNUNET_free(last_messages_file);
+}
+
+void
+save_message_state (const struct GNUNET_MESSENGER_MessageState *state, const char *path)
+{
+  GNUNET_assert((state) && (path));
+
+  char *last_messages_file;
+  GNUNET_asprintf (&last_messages_file, "%s%s", path, "last_messages.list");
+
+  save_list_messages(&(state->last_messages), last_messages_file);
+  GNUNET_free(last_messages_file);
+}
+
+
diff --git a/src/messenger/gnunet-service-messenger_message_state.h b/src/messenger/gnunet-service-messenger_message_state.h
new file mode 100644
index 000000000..dc8671df4
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_state.h
@@ -0,0 +1,63 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_state.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_STATE_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_STATE_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+
+#include "messenger_api_message.h"
+#include "gnunet-service-messenger_list_messages.h"
+
+struct GNUNET_MESSENGER_MessageState
+{
+  struct GNUNET_MESSENGER_ListMessages last_messages;
+};
+
+void
+init_message_state (struct GNUNET_MESSENGER_MessageState *state);
+
+void
+clear_message_state (struct GNUNET_MESSENGER_MessageState *state);
+
+void
+get_message_state_chain_hash (const struct GNUNET_MESSENGER_MessageState *state,
+                              struct GNUNET_HashCode *hash);
+
+const struct GNUNET_HashCode*
+get_message_state_merge_hash (const struct GNUNET_MESSENGER_MessageState *state);
+
+void
+update_message_state (struct GNUNET_MESSENGER_MessageState *state, int requested,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+void
+load_message_state (struct GNUNET_MESSENGER_MessageState *state, const char *path);
+
+void
+save_message_state (const struct GNUNET_MESSENGER_MessageState *state, const char *path);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_STATE_H
diff --git a/src/messenger/gnunet-service-messenger_message_store.c b/src/messenger/gnunet-service-messenger_message_store.c
index 5933d6390..1984eba21 100644..100755
--- a/src/messenger/gnunet-service-messenger_message_store.c
+++ b/src/messenger/gnunet-service-messenger_message_store.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -29,10 +29,16 @@
 void
 init_message_store (struct GNUNET_MESSENGER_MessageStore *store)
 {
+  GNUNET_assert(store);
+
   store->storage_messages = NULL;
 
   store->entries = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
   store->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  store->links = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  store->rewrite_entries = GNUNET_NO;
+  store->write_links = GNUNET_NO;
 }
 
 static int
@@ -55,9 +61,21 @@ iterate_destroy_messages (void *cls, const struct GNUNET_HashCode *key, void *va
   return GNUNET_YES;
 }
 
+static int
+iterate_destroy_links (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_HashCode *previous = value;
+
+  GNUNET_free(previous);
+
+  return GNUNET_YES;
+}
+
 void
 clear_message_store (struct GNUNET_MESSENGER_MessageStore *store)
 {
+  GNUNET_assert(store);
+
   if (store->storage_messages)
   {
     GNUNET_DISK_file_close (store->storage_messages);
@@ -67,9 +85,11 @@ clear_message_store (struct GNUNET_MESSENGER_MessageStore *store)
 
   GNUNET_CONTAINER_multihashmap_iterate (store->entries, iterate_destroy_entries, NULL);
   GNUNET_CONTAINER_multihashmap_iterate (store->messages, iterate_destroy_messages, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_destroy_links, NULL);
 
   GNUNET_CONTAINER_multihashmap_destroy (store->entries);
   GNUNET_CONTAINER_multihashmap_destroy (store->messages);
+  GNUNET_CONTAINER_multihashmap_destroy (store->links);
 }
 
 struct GNUNET_MESSENGER_MessageEntryStorage
@@ -78,36 +98,15 @@ struct GNUNET_MESSENGER_MessageEntryStorage
   struct GNUNET_MESSENGER_MessageEntry entry;
 };
 
-void
-load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
+static void
+load_message_store_entries (struct GNUNET_MESSENGER_MessageStore *store, const char *filename)
 {
-  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
-
-  if (store->storage_messages)
-    GNUNET_DISK_file_close (store->storage_messages);
-
-  char *filename;
-  GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
-
-  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
-    store->storage_messages = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ, permission);
-  else
-    store->storage_messages = NULL;
-
-  GNUNET_free(filename);
-
-  if (!store->storage_messages)
-    return;
-
-  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
-
-  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-    goto free_filename;
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ);
 
   struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ, permission);
 
   if (!entries)
-    goto free_filename;
+    return;
 
   struct GNUNET_MESSENGER_MessageEntryStorage storage;
   struct GNUNET_MESSENGER_MessageEntry *entry;
@@ -120,9 +119,13 @@ load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *dir
     {
       GNUNET_memcpy(entry, &(storage.entry), sizeof(*entry));
 
-      if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->entries, &(storage.hash), entry,
-                                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+      if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->entries, &(storage.hash))) ||
+          (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->entries, &(storage.hash), entry,
+                                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+      {
+        store->rewrite_entries = GNUNET_YES;
         GNUNET_free(entry);
+      }
     }
     else
     {
@@ -134,22 +137,120 @@ load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *dir
   while (entry);
 
   GNUNET_DISK_file_close (entries);
+}
+
+struct GNUNET_MESSENGER_MessageLinkStorage
+{
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_MessageLink link;
+};
+
+static void
+load_message_store_links (struct GNUNET_MESSENGER_MessageStore *store, const char *filename)
+{
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ);
+
+  struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ, permission);
+
+  if (!entries)
+    return;
+
+  struct GNUNET_MESSENGER_MessageLinkStorage storage;
+  struct GNUNET_MESSENGER_MessageLink *link = NULL;
+
+  memset(&storage, 0, sizeof(storage));
+
+  do
+  {
+    if ((sizeof(storage.hash) != GNUNET_DISK_file_read (entries, &(storage.hash), sizeof(storage.hash))) ||
+        (sizeof(storage.link.multiple) != GNUNET_DISK_file_read (entries, &(storage.link.multiple), sizeof(storage.link.multiple))) ||
+        (sizeof(storage.link.first) != GNUNET_DISK_file_read (entries, &(storage.link.first), sizeof(storage.link.first))) ||
+        ((GNUNET_YES == storage.link.multiple) &&
+         (sizeof(storage.link.second) != GNUNET_DISK_file_read (entries, &(storage.link.second), sizeof(storage.link.second)))))
+      break;
+
+    link = GNUNET_new(struct GNUNET_MESSENGER_MessageLink);
+
+    GNUNET_memcpy(link, &(storage.link), sizeof(*link));
+
+    if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->links, &(storage.hash))) ||
+        (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->links, &(storage.hash), link,
+                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+      break;
+  }
+  while (link);
+
+  if (link)
+    GNUNET_free(link);
+
+  GNUNET_DISK_file_close (entries);
+}
+
+void
+load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
+{
+  GNUNET_assert((store) && (directory));
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  if (store->storage_messages)
+    GNUNET_DISK_file_close (store->storage_messages);
+
+  char *filename;
+  GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
+
+  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+    store->storage_messages = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READWRITE, permission);
+  else
+    store->storage_messages = NULL;
+
+  GNUNET_free(filename);
+
+  if (!store->storage_messages)
+    return;
+
+  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
+
+  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+    load_message_store_entries(store, filename);
+
+  GNUNET_free(filename);
+
+  GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
+
+  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+    load_message_store_links(store, filename);
 
-free_filename:
   GNUNET_free(filename);
 }
 
-struct GNUNET_MESSENGER_MessageSave
+struct GNUNET_MESSENGER_ClosureMessageSave
 {
   struct GNUNET_MESSENGER_MessageStore *store;
 
-  struct GNUNET_DISK_FileHandle *storage_entries;
+  struct GNUNET_DISK_FileHandle *storage;
 };
 
 static int
+iterate_save_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
+  struct GNUNET_MESSENGER_MessageEntry *entry = value;
+
+  struct GNUNET_MESSENGER_MessageEntryStorage storage;
+
+  GNUNET_memcpy(&(storage.hash), key, sizeof(storage.hash));
+  GNUNET_memcpy(&(storage.entry), entry, sizeof(*entry));
+
+  GNUNET_DISK_file_write (save->storage, &storage, sizeof(storage));
+
+  return GNUNET_YES;
+}
+
+static int
 iterate_save_messages (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
-  struct GNUNET_MESSENGER_MessageSave *save = cls;
+  struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
 
   if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (save->store->entries, key))
     return GNUNET_YES;
@@ -159,16 +260,16 @@ iterate_save_messages (void *cls, const struct GNUNET_HashCode *key, void *value
 
   GNUNET_memcpy(&(storage.hash), key, sizeof(storage.hash));
 
-  storage.entry.length = get_message_size (message);
+  storage.entry.length = get_message_size (message, GNUNET_YES);
   storage.entry.offset = GNUNET_DISK_file_seek (save->store->storage_messages, 0, GNUNET_DISK_SEEK_END);
 
-  if ((GNUNET_SYSERR == storage.entry.offset) ||
-      (sizeof(storage) != GNUNET_DISK_file_write (save->storage_entries, &storage, sizeof(storage))))
+  if ((GNUNET_SYSERR == storage.entry.offset) || (sizeof(storage)
+      != GNUNET_DISK_file_write (save->storage, &storage, sizeof(storage))))
     return GNUNET_YES;
 
   char *buffer = GNUNET_malloc(storage.entry.length);
 
-  encode_message (message, storage.entry.length, buffer);
+  encode_message (message, storage.entry.length, buffer, GNUNET_YES);
 
   GNUNET_DISK_file_write (save->store->storage_messages, buffer, storage.entry.length);
 
@@ -177,25 +278,75 @@ iterate_save_messages (void *cls, const struct GNUNET_HashCode *key, void *value
   return GNUNET_YES;
 }
 
+static int
+iterate_save_links (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
+  struct GNUNET_MESSENGER_MessageLink *link = value;
+
+  GNUNET_DISK_file_write (save->storage, key, sizeof(*key));
+  GNUNET_DISK_file_write (save->storage, &(link->multiple), sizeof(link->multiple));
+  GNUNET_DISK_file_write (save->storage, &(link->first), sizeof(link->first));
+
+  if (GNUNET_YES == link->multiple)
+    GNUNET_DISK_file_write (save->storage, &(link->second), sizeof(link->second));
+
+  return GNUNET_YES;
+}
+
 void
 save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
 {
-  struct GNUNET_MESSENGER_MessageSave save;
+  GNUNET_assert((store) && (directory));
+
+  struct GNUNET_MESSENGER_ClosureMessageSave save;
 
   enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
 
   char *filename;
+
+  if (GNUNET_YES != store->write_links)
+    goto save_entries;
+
+  GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
+
+  save.store = store;
+  save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
+
+  GNUNET_free(filename);
+
+  if (!save.storage)
+    goto save_entries;
+
+  if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_SET))
+    goto close_links;
+
+  GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_save_links, &save);
+  store->write_links = GNUNET_NO;
+
+close_links:
+  GNUNET_DISK_file_close (save.storage);
+
+save_entries:
   GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
 
   save.store = store;
-  save.storage_entries = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
+  save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
 
   GNUNET_free(filename);
 
-  if (!save.storage_entries)
+  if (!save.storage)
     return;
 
-  if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage_entries, 0, GNUNET_DISK_SEEK_END))
+  if (GNUNET_YES == store->rewrite_entries)
+  {
+    if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_SET))
+      goto close_entries;
+
+    GNUNET_CONTAINER_multihashmap_iterate (store->entries, iterate_save_entries, &save);
+    store->rewrite_entries = GNUNET_NO;
+  }
+  else if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_END))
     goto close_entries;
 
   if (store->storage_messages)
@@ -213,16 +364,18 @@ save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *dir
     GNUNET_CONTAINER_multihashmap_iterate (store->messages, iterate_save_messages, &save);
 
     GNUNET_DISK_file_sync (store->storage_messages);
-    GNUNET_DISK_file_sync (save.storage_entries);
+    GNUNET_DISK_file_sync (save.storage);
   }
 
 close_entries:
-  GNUNET_DISK_file_close (save.storage_entries);
+  GNUNET_DISK_file_close (save.storage);
 }
 
 int
-contains_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
+contains_store_message (const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((store) && (hash));
+
   if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->messages, hash))
     return GNUNET_YES;
 
@@ -232,6 +385,8 @@ contains_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struc
 const struct GNUNET_MESSENGER_Message*
 get_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((store) && (hash));
+
   struct GNUNET_MESSENGER_Message *message = GNUNET_CONTAINER_multihashmap_get (store->messages, hash);
 
   if (message)
@@ -250,33 +405,145 @@ get_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNU
 
   char *buffer = GNUNET_malloc(entry->length);
 
-  if (GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length) != entry->length)
-    goto free_buffer;
+  if (!buffer)
+    return NULL;
 
+  if ((GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length) != entry->length) ||
+      (entry->length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN)))
+    goto free_buffer;
 
   message = create_message (GNUNET_MESSENGER_KIND_UNKNOWN);
 
-  if ((GNUNET_YES != decode_message (message, entry->length, buffer)) || (GNUNET_OK
-      != GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  const int decoding = decode_message (message, entry->length, buffer, GNUNET_YES, NULL);
+
+  struct GNUNET_HashCode check;
+  hash_message (message, entry->length, buffer, &check);
+
+  if ((GNUNET_YES != decoding) || (GNUNET_CRYPTO_hash_cmp (hash, &check) != 0))
   {
-    destroy_message (message);
+    if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry))
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Corrupted entry could not be removed from store: %s\n",
+                 GNUNET_h2s(hash));
 
-    message = NULL;
+    store->rewrite_entries = GNUNET_YES;
 
-    GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry);
+    goto free_message;
   }
 
+  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    goto free_buffer;
+
+free_message: destroy_message (message);
+  message = NULL;
+
 free_buffer:
   GNUNET_free(buffer);
 
   return message;
 }
 
+const struct GNUNET_MESSENGER_MessageLink*
+get_store_message_link (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
+                        int deleted_only)
+{
+  if (deleted_only)
+    goto get_link;
+
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(store, hash);
+
+  if (!message)
+    goto get_link;
+
+  static struct GNUNET_MESSENGER_MessageLink link;
+
+  GNUNET_memcpy(&(link.first), &(message->header.previous), sizeof(link.first));
+
+  link.multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind? GNUNET_YES : GNUNET_NO;
+
+  if (GNUNET_YES == link.multiple)
+    GNUNET_memcpy(&(link.second), &(message->body.merge.previous), sizeof(link.second));
+  else
+    GNUNET_memcpy(&(link.second), &(message->header.previous), sizeof(link.second));
+
+  return &link;
+
+get_link:
+  return GNUNET_CONTAINER_multihashmap_get (store->links, hash);
+}
+
 int
 put_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
                    struct GNUNET_MESSENGER_Message *message)
 {
+  GNUNET_assert((store) && (hash) && (message));
+
   return GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 }
+
+static void
+add_link (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
+          const struct GNUNET_MESSENGER_Message *message)
+{
+  struct GNUNET_MESSENGER_MessageLink *link = GNUNET_new(struct GNUNET_MESSENGER_MessageLink);
+
+  GNUNET_memcpy(&(link->first), &(message->header.previous), sizeof(link->first));
+
+  link->multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind? GNUNET_YES : GNUNET_NO;
+
+  if (GNUNET_YES == link->multiple)
+    GNUNET_memcpy(&(link->second), &(message->body.merge.previous), sizeof(link->second));
+  else
+    GNUNET_memcpy(&(link->second), &(message->header.previous), sizeof(link->second));
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(store->links, hash, link,
+                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    GNUNET_free(link);
+}
+
+int
+delete_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((store) && (hash));
+
+  const struct GNUNET_MESSENGER_MessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
+
+  if (!entry)
+    goto clear_memory;
+
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(store, hash);
+
+  if (message)
+    add_link (store, hash, message);
+
+  if (!store->storage_messages)
+    goto clear_entry;
+
+  if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages, entry->offset, GNUNET_DISK_SEEK_SET))
+    return GNUNET_SYSERR;
+
+  char *clear_buffer = GNUNET_malloc(entry->length);
+
+  if (!clear_buffer)
+    return GNUNET_SYSERR;
+
+  GNUNET_CRYPTO_zero_keys (clear_buffer, entry->length);
+
+  if ((entry->length != GNUNET_DISK_file_write (store->storage_messages, clear_buffer, entry->length)) || (GNUNET_OK
+      != GNUNET_DISK_file_sync (store->storage_messages)))
+  {
+    GNUNET_free(clear_buffer);
+    return GNUNET_SYSERR;
+  }
+
+  GNUNET_free(clear_buffer);
+
+clear_entry:
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry))
+    store->rewrite_entries = GNUNET_YES;
+
+clear_memory:
+  GNUNET_CONTAINER_multihashmap_remove_all (store->messages, hash);
+  return GNUNET_OK;
+}
diff --git a/src/messenger/gnunet-service-messenger_message_store.h b/src/messenger/gnunet-service-messenger_message_store.h
index e58459b21..87305826a 100644
--- a/src/messenger/gnunet-service-messenger_message_store.h
+++ b/src/messenger/gnunet-service-messenger_message_store.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -36,85 +36,127 @@ struct GNUNET_MESSENGER_MessageEntry
   uint16_t length;
 };
 
+struct GNUNET_MESSENGER_Message;
+
+struct GNUNET_MESSENGER_MessageLink
+{
+  uint8_t multiple;
+
+  struct GNUNET_HashCode first;
+  struct GNUNET_HashCode second;
+};
+
 struct GNUNET_MESSENGER_MessageStore
 {
   struct GNUNET_DISK_FileHandle *storage_messages;
 
   struct GNUNET_CONTAINER_MultiHashMap *entries;
   struct GNUNET_CONTAINER_MultiHashMap *messages;
+  struct GNUNET_CONTAINER_MultiHashMap *links;
+
+  int rewrite_entries;
+  int write_links;
 };
 
 /**
- * Initializes a message store as fully empty.
+ * Initializes a message <i>store</i> as fully empty.
  *
- * @param store Message store
+ * @param[out] store Message store
  */
 void
 init_message_store (struct GNUNET_MESSENGER_MessageStore *store);
 
 /**
- * Clears a message store, wipes its content and deallocates its memory.
+ * Clears a message <i>store</i>, wipes its content and deallocates its memory.
  *
- * @param store Message store
+ * @param[in/out] store Message store
  */
 void
 clear_message_store (struct GNUNET_MESSENGER_MessageStore *store);
 
 /**
- * Loads messages from a directory into a message store.
+ * Loads messages from a <i>directory</i> into a message <i>store</i>.
  *
- * @param store Message store
- * @param directory Path to a directory
+ * @param[out] store Message store
+ * @param[in] directory Path to a directory
  */
 void
 load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory);
 
 /**
- * Saves messages from a message store into a directory.
+ * Saves messages from a message <i>store</i> into a <i>directory</i>.
  *
- * @param store Message store
- * @param directory Path to a directory
+ * @param[in] store Message store
+ * @param[in] directory Path to a directory
  */
 void
 save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory);
 
 /**
- * Checks if a message matching a given <i>hash</i> is stored in a message store. The function returns
- * GNUNET_YES if a match is found, GNUNET_NO otherwise.
+ * Checks if a message matching a given <i>hash</i> is stored in a message <i>store</i>.
+ * The function returns #GNUNET_YES if a match is found, #GNUNET_NO otherwise.
  *
  * The message has not to be loaded from disk into memory for this check!
  *
- * @param store Message store
- * @param hash Hash of message
- * @return GNUNET_YES on match, otherwise GNUNET_NO
+ * @param[in] store Message store
+ * @param[in] hash Hash of message
+ * @return #GNUNET_YES on match, otherwise #GNUNET_NO
  */
 int
-contains_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash);
+contains_store_message (const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash);
 
 /**
- * Returns the message from a message store matching a given <i>hash</i>. If no matching message is found,
- * NULL gets returned.
+ * Returns the message from a message <i>store</i> matching a given <i>hash</i>. If no matching
+ * message is found, NULL gets returned.
  *
  * This function requires the message to be loaded into memory!
  * @see contains_store_message()
  *
- * @param store Message store
- * @param hash Hash of message
+ * @param[in/out] store Message store
+ * @param[in] hash Hash of message
  * @return Message or NULL
  */
 const struct GNUNET_MESSENGER_Message*
 get_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash);
 
 /**
+ * Returns the message link from a message <i>store</i> matching a given <i>hash</i>. If the
+ * flag is set to #GNUNET_YES, only links from deleted messages will be returned or NULL.
+ *
+ * Otherwise message links will also returned for messages found in the store under the given
+ * hash. The link which will be returned copies link information from the message for
+ * temporary usage.
+ *
+ * @param[in/out] store Message store
+ * @param[in] hash Hash of message
+ * @param[in] deleted_only Flag
+ * @return Message link or NULL
+ */
+const struct GNUNET_MESSENGER_MessageLink*
+get_store_message_link (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
+                        int deleted_only);
+
+/**
  * Stores a message into the message store. The result indicates if the operation was successful.
  *
- * @param store Message store
- * @param hash Hash of message
- * @param message Message
- * @return GNUNET_OK on success, otherwise GNUNET_NO
+ * @param[in/out] store Message store
+ * @param[in] hash Hash of message
+ * @param[in/out] message Message
+ * @return #GNUNET_OK on success, otherwise #GNUNET_NO
  */
 int
 put_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
                    struct GNUNET_MESSENGER_Message *message);
 
+/**
+ * Deletes a message in the message store. It will be removed from disk space and memory. The result
+ * indicates if the operation was successful.
+ *
+ * @param[in/out] store Message store
+ * @param[in] hash Hash of message
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+int
+delete_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash);
+
 #endif //GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_operation.c b/src/messenger/gnunet-service-messenger_operation.c
new file mode 100644
index 000000000..d0c378699
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_operation.c
@@ -0,0 +1,214 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_operation.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_operation.h"
+
+#include "gnunet-service-messenger_operation_store.h"
+
+struct GNUNET_MESSENGER_Operation*
+create_operation (const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert(hash);
+
+  struct GNUNET_MESSENGER_Operation *op = GNUNET_new(struct GNUNET_MESSENGER_Operation);
+
+  op->type = GNUNET_MESSENGER_OP_UNKNOWN;
+  GNUNET_memcpy(&(op->hash), hash, sizeof(*hash));
+  op->timestamp = GNUNET_TIME_absolute_get_zero_();
+  op->store = NULL;
+  op->task = NULL;
+
+  return op;
+}
+
+void
+destroy_operation (struct GNUNET_MESSENGER_Operation *op)
+{
+  GNUNET_assert(op);
+
+  if (op->task)
+    GNUNET_SCHEDULER_cancel(op->task);
+
+  GNUNET_free(op);
+}
+
+static void
+callback_operation (void *cls);
+
+struct GNUNET_MESSENGER_Operation*
+load_operation (struct GNUNET_MESSENGER_OperationStore *store, const char *path)
+{
+  GNUNET_assert((store) && (path));
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+  struct GNUNET_MESSENGER_Operation* op = NULL;
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_parse(cfg, path))
+    goto destroy_config;
+
+  struct GNUNET_HashCode hash;
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation", "hash", &hash, sizeof(hash)))
+    goto destroy_config;
+
+  op = create_operation(&hash);
+
+  unsigned long long type_number;
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, "operation", "type", &type_number))
+    switch (type_number)
+    {
+    case GNUNET_MESSENGER_OP_REQUEST:
+      op->type = GNUNET_MESSENGER_OP_REQUEST;
+      break;
+    case GNUNET_MESSENGER_OP_DELETE:
+      op->type = GNUNET_MESSENGER_OP_DELETE;
+      break;
+    case GNUNET_MESSENGER_OP_MERGE:
+      op->type = GNUNET_MESSENGER_OP_MERGE;
+      break;
+    default:
+      break;
+    }
+
+  if ((GNUNET_MESSENGER_OP_UNKNOWN == op->type) ||
+      (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation", "timestamp", &(op->timestamp), sizeof(op->timestamp))))
+  {
+    destroy_operation(op);
+    op = NULL;
+    goto destroy_config;
+  }
+
+  const struct GNUNET_TIME_Relative delay = GNUNET_TIME_absolute_get_remaining(op->timestamp);
+
+  op->task = GNUNET_SCHEDULER_add_delayed_with_priority(
+      delay,
+      GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+      callback_operation,
+      op
+  );
+
+  op->store = store;
+
+destroy_config:
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+  return op;
+}
+
+void
+save_operation (const struct GNUNET_MESSENGER_Operation *op, const char *path)
+{
+  GNUNET_assert((path) && (op));
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  char *hash_data;
+  hash_data = GNUNET_STRINGS_data_to_string_alloc (&(op->hash), sizeof(op->hash));
+
+  if (hash_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "hash", hash_data);
+
+    GNUNET_free(hash_data);
+  }
+
+  GNUNET_CONFIGURATION_set_value_number(cfg, "operation", "type", op->type);
+
+  char *timestamp_data;
+  timestamp_data = GNUNET_STRINGS_data_to_string_alloc (&(op->timestamp), sizeof(op->timestamp));
+
+  if (timestamp_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "timestamp", timestamp_data);
+
+    GNUNET_free(timestamp_data);
+  }
+
+  GNUNET_CONFIGURATION_write (cfg, path);
+  GNUNET_CONFIGURATION_destroy (cfg);
+}
+
+extern void
+callback_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                          enum GNUNET_MESSENGER_OperationType type,
+                          const struct GNUNET_HashCode *hash);
+
+static void
+callback_operation (void *cls)
+{
+  struct GNUNET_MESSENGER_Operation *op = cls;
+
+  op->task = NULL;
+
+  callback_store_operation (op->store, op->type, &(op->hash));
+}
+
+int
+start_operation (struct GNUNET_MESSENGER_Operation *op,
+                 enum GNUNET_MESSENGER_OperationType type,
+                 struct GNUNET_MESSENGER_OperationStore *store,
+                 struct GNUNET_TIME_Relative delay)
+{
+  GNUNET_assert((op) && (store));
+
+  if (op->task)
+    return GNUNET_SYSERR;
+
+  const struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_add(
+      GNUNET_TIME_absolute_get(),
+      delay
+  );
+
+  op->task = GNUNET_SCHEDULER_add_delayed_with_priority(
+      delay,
+      GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+      callback_operation,
+      op
+  );
+
+  op->type = type;
+  op->timestamp = timestamp;
+  op->store = store;
+
+  return GNUNET_OK;
+}
+
+int
+stop_operation (struct GNUNET_MESSENGER_Operation *op)
+{
+  GNUNET_assert(op);
+
+  if (!op->task)
+    return GNUNET_SYSERR;
+
+  GNUNET_SCHEDULER_cancel(op->task);
+  op->task = NULL;
+
+  op->type = GNUNET_MESSENGER_OP_UNKNOWN;
+  op->timestamp = GNUNET_TIME_absolute_get_zero_();
+  op->store = NULL;
+
+  return GNUNET_OK;
+}
diff --git a/src/messenger/gnunet-service-messenger_operation.h b/src/messenger/gnunet-service-messenger_operation.h
new file mode 100644
index 000000000..7757b8e88
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_operation.h
@@ -0,0 +1,129 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_operation.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_OPERATION_H
+#define GNUNET_SERVICE_MESSENGER_OPERATION_H
+
+#include "platform.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_strings_lib.h"
+#include "gnunet_time_lib.h"
+
+enum GNUNET_MESSENGER_OperationType
+{
+  GNUNET_MESSENGER_OP_REQUEST = 1,
+  GNUNET_MESSENGER_OP_DELETE = 2,
+  GNUNET_MESSENGER_OP_MERGE = 3,
+
+  GNUNET_MESSENGER_OP_UNKNOWN = 0
+};
+
+struct GNUNET_MESSENGER_OperationStore;
+
+struct GNUNET_MESSENGER_Operation
+{
+  enum GNUNET_MESSENGER_OperationType type;
+
+  struct GNUNET_HashCode hash;
+  struct GNUNET_TIME_Absolute timestamp;
+
+  struct GNUNET_MESSENGER_OperationStore *store;
+  struct GNUNET_SCHEDULER_Task* task;
+};
+
+/**
+ * Creates and allocates a new operation under a given <i>hash</i>.
+ *
+ * @param[in] hash Hash of message
+ */
+struct GNUNET_MESSENGER_Operation*
+create_operation (const struct GNUNET_HashCode *hash);
+
+/**
+ * Destroys an operation and frees its memory fully.
+ *
+ * @param[in/out] op Operation
+ */
+void
+destroy_operation (struct GNUNET_MESSENGER_Operation *op);
+
+/**
+ * Loads data from a configuration file at a selected <i>path</i> into
+ * a new allocated and created operation for a specific operation
+ * <i>store</i> if the required information could be read successfully.
+ *
+ * The method will return the new operation and it will be started
+ * automatically to match its timestamp of execution.
+ *
+ * If the method fails to restore any valid operation from the file,
+ * NULL gets returned instead.
+ *
+ * @param[in/out] store Operation store
+ * @param[in] path Path of a configuration file
+ */
+struct GNUNET_MESSENGER_Operation*
+load_operation (struct GNUNET_MESSENGER_OperationStore *store, const char *path);
+
+/**
+ * Saves data from an <i>operation</i> into a configuration file at a
+ * selected <i>path</i> which can be load to restore the operation
+ * completely and continue its process.
+ *
+ * @param[in] op Operation
+ * @param[in] path Path of a configuration file
+ */
+void
+save_operation (const struct GNUNET_MESSENGER_Operation *op, const char *path);
+
+/**
+ * Starts an inactive operation with a given <i>delay</i> in a
+ * specific operation <i>store</i>. The method will replace the
+ * operations type to process it correctly. An opeation can't be
+ * started twice, it has to be stopped or fully processed first.
+ *
+ * @param[in/out] op Operation
+ * @param[in] type Type of operation
+ * @param[in/out] store Operation store
+ * @param[in] delay Delay
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+int
+start_operation (struct GNUNET_MESSENGER_Operation *op,
+                 enum GNUNET_MESSENGER_OperationType type,
+                 struct GNUNET_MESSENGER_OperationStore *store,
+                 struct GNUNET_TIME_Relative delay);
+
+/**
+ * Stops an active operation and resets its type to be
+ * #GNUNET_MESSENGER_OP_UNKNOWN.
+ *
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+int
+stop_operation (struct GNUNET_MESSENGER_Operation *op);
+
+#endif //GNUNET_SERVICE_MESSENGER_OPERATION_H
diff --git a/src/messenger/gnunet-service-messenger_operation_store.c b/src/messenger/gnunet-service-messenger_operation_store.c
new file mode 100755
index 000000000..a32fbad2c
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_operation_store.c
@@ -0,0 +1,226 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_operation_store.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_operation_store.h"
+
+#include "gnunet-service-messenger_operation.h"
+#include "gnunet-service-messenger_room.h"
+
+void
+init_operation_store (struct GNUNET_MESSENGER_OperationStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert((store) && (room));
+
+  store->room = room;
+  store->operations = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
+}
+
+static int
+iterate_destroy_operations (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Operation *op = value;
+
+  destroy_operation(op);
+
+  return GNUNET_YES;
+}
+
+void
+clear_operation_store (struct GNUNET_MESSENGER_OperationStore *store)
+{
+  GNUNET_assert(store);
+
+  GNUNET_CONTAINER_multihashmap_iterate (store->operations, iterate_destroy_operations, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy(store->operations);
+}
+
+static int
+callback_scan_for_operations (void *cls, const char *filename)
+{
+  struct GNUNET_MESSENGER_OperationStore *store = cls;
+
+  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+  {
+    char *path;
+
+    GNUNET_asprintf (&path, "%s%c", filename, DIR_SEPARATOR);
+
+    struct GNUNET_MESSENGER_Operation *op = load_operation(store, path);
+
+    if ((op) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
+        store->operations,
+        &(op->hash), op,
+        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    {
+      destroy_operation(op);
+    }
+
+    GNUNET_free(path);
+  }
+
+  return GNUNET_OK;
+}
+
+void
+load_operation_store (struct GNUNET_MESSENGER_OperationStore *store,
+                      const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  if (GNUNET_OK == GNUNET_DISK_directory_test (directory, GNUNET_YES))
+    GNUNET_DISK_directory_scan (directory, callback_scan_for_operations, store);
+}
+
+static int
+iterate_save_operations (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  const char *save_dir = cls;
+
+  struct GNUNET_MESSENGER_Operation *op = value;
+
+  if (!op)
+    return GNUNET_YES;
+
+  char *op_dir;
+  GNUNET_asprintf (&op_dir, "%s%s.cfg", save_dir, GNUNET_h2s(key));
+  save_operation(op, op_dir);
+
+  GNUNET_free(op_dir);
+  return GNUNET_YES;
+}
+
+void
+save_operation_store (const struct GNUNET_MESSENGER_OperationStore *store,
+                      const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  char* save_dir;
+  GNUNET_asprintf (&save_dir, "%s%s%c", directory, "operations", DIR_SEPARATOR);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+    GNUNET_CONTAINER_multihashmap_iterate (store->operations, iterate_save_operations, save_dir);
+
+  GNUNET_free(save_dir);
+}
+
+enum GNUNET_MESSENGER_OperationType
+get_store_operation_type (const struct GNUNET_MESSENGER_OperationStore *store,
+                          const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((store) && (hash));
+
+  struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+
+  if (!op)
+    return GNUNET_MESSENGER_OP_UNKNOWN;
+
+  return op->type;
+}
+
+int
+use_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                     const struct GNUNET_HashCode *hash,
+                     enum GNUNET_MESSENGER_OperationType type,
+                     struct GNUNET_TIME_Relative delay)
+{
+  GNUNET_assert((store) && (hash));
+
+  struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+
+  if (op)
+    goto use_op;
+
+  op = create_operation(hash);
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(store->operations, hash, op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    destroy_operation(op);
+
+    return GNUNET_SYSERR;
+  }
+
+use_op:
+  if ((op->type != GNUNET_MESSENGER_OP_UNKNOWN) &&
+      (type == GNUNET_MESSENGER_OP_DELETE))
+    stop_operation (op);
+
+  return start_operation(op, type, store, delay);
+}
+
+void
+cancel_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                        const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((store) && (hash));
+
+  struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+
+  if (!op)
+    return;
+
+  stop_operation(op);
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(store->operations, hash, op))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Canceled operation could not be removed: %s\n",
+               GNUNET_h2s(hash));
+
+  destroy_operation(op);
+}
+
+extern void
+callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash);
+
+extern void
+callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash);
+
+void
+callback_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                          enum GNUNET_MESSENGER_OperationType type,
+                          const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((store) && (hash));
+
+  struct GNUNET_HashCode op_hash;
+  GNUNET_memcpy(&op_hash, hash, sizeof(op_hash));
+  cancel_store_operation (store, &op_hash);
+
+  struct GNUNET_MESSENGER_SrvRoom *room = store->room;
+
+  switch (type)
+  {
+  case GNUNET_MESSENGER_OP_REQUEST:
+    break;
+  case GNUNET_MESSENGER_OP_DELETE:
+    callback_room_deletion (room, &op_hash);
+    break;
+  case GNUNET_MESSENGER_OP_MERGE:
+    callback_room_merge (room, &op_hash);
+    break;
+  default:
+    break;
+  }
+}
diff --git a/src/messenger/gnunet-service-messenger_operation_store.h b/src/messenger/gnunet-service-messenger_operation_store.h
new file mode 100644
index 000000000..2fd604340
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_operation_store.h
@@ -0,0 +1,131 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_operation_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_OPERATION_STORE_H
+#define GNUNET_SERVICE_MESSENGER_OPERATION_STORE_H
+
+#include "platform.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+struct GNUNET_MESSENGER_SrvRoom;
+
+struct GNUNET_MESSENGER_OperationStore
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+
+  struct GNUNET_CONTAINER_MultiHashMap *operations;
+};
+
+/**
+ * Initializes an operation <i>store</i> as fully empty with a given <i>room</i>.
+ *
+ * @param[out] store Operation store
+ * @param[in/out] room Room
+ */
+void
+init_operation_store (struct GNUNET_MESSENGER_OperationStore *store, struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Clears an operation <i>store</i>, stops all operations and deallocates its memory.
+ *
+ * @param[in/out] store Operation store
+ */
+void
+clear_operation_store (struct GNUNET_MESSENGER_OperationStore *store);
+
+/**
+ * Loads operations from a <i>directory</i> into an operation <i>store</i>.
+ *
+ * @param[out] store Operation store
+ * @param[in] directory Path to a directory
+ */
+void
+load_operation_store (struct GNUNET_MESSENGER_OperationStore *store,
+                      const char *directory);
+
+/**
+ * Saves operations from an operation <i>store</i> into a <i>directory</i>.
+ *
+ * @param[in] store Operation store
+ * @param[in] directory Path to a directory
+ */
+void
+save_operation_store (const struct GNUNET_MESSENGER_OperationStore *store,
+                      const char *directory);
+
+/**
+ * Retruns the type of the active operation under a given <i>hash</i> in
+ * a specific operation <i>store</i>. If there is no active operation under
+ * the given <i>hash</i>, #GNUNET_MESSENGER_OP_UNKNOWN gets returned instead.
+ *
+ * @param[in] store Operation store
+ * @param[in] hash Hash of message
+ * @return Type of operation or #GNUNET_MESSENGER_OP_UNKNOWN
+ */
+enum GNUNET_MESSENGER_OperationType
+get_store_operation_type (const struct GNUNET_MESSENGER_OperationStore *store,
+                          const struct GNUNET_HashCode *hash);
+
+/**
+ * Tries to use an operation under a given <i>hash</i> in a specific
+ * operation <i>store</i>. The operation will use the selected <i>type</i>
+ * if successful. The operation will be delayed by a given <i>delay</i>.
+ *
+ * If the selected type is #GNUNET_MESSENGER_OP_DELETE any active operation
+ * under the given hash will be stopped and replaced.
+ *
+ * If the new operation could be started successfully the method returns
+ * #GNUNET_OK, otherwise #GNUNET_SYSERR.
+ *
+ * @param[in/out] store Operation store
+ * @param[in] hash Hash of message
+ * @param[in] type Operation type
+ * @param[in] delay Delay
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+int
+use_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                     const struct GNUNET_HashCode *hash,
+                     enum GNUNET_MESSENGER_OperationType type,
+                     struct GNUNET_TIME_Relative delay);
+
+/**
+ * Stops any active operation under a given <i>hash</i> in a specific
+ * operation <i>store</i>.
+ *
+ * Beware that calling this method will also implicitly free the memory
+ * of any active operation under the given hash!
+ *
+ * @param[in/out] store Operation store
+ * @param[in] hash Hash of message
+ */
+void
+cancel_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
+                        const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_OPERATION_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_room.c b/src/messenger/gnunet-service-messenger_room.c
index 7383e1d20..e8fe5b1f3 100644
--- a/src/messenger/gnunet-service-messenger_room.c
+++ b/src/messenger/gnunet-service-messenger_room.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,10 +25,19 @@
 
 #include "gnunet-service-messenger_room.h"
 
+#include "gnunet-service-messenger_member.h"
+#include "gnunet-service-messenger_member_session.h"
+
 #include "gnunet-service-messenger_message_kind.h"
+#include "gnunet-service-messenger_message_handle.h"
+#include "gnunet-service-messenger_message_send.h"
 
+#include "gnunet-service-messenger_operation.h"
+
+#include "gnunet-service-messenger.h"
 #include "gnunet-service-messenger_service.h"
-#include "gnunet-service-messenger_util.h"
+#include "gnunet-service-messenger_tunnel.h"
+#include "messenger_api_util.h"
 
 static void
 idle_request_room_messages (void *cls);
@@ -47,24 +56,21 @@ create_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_Hash
   GNUNET_memcpy(&(room->key), key, sizeof(struct GNUNET_HashCode));
 
   room->tunnels = GNUNET_CONTAINER_multipeermap_create (8, GNUNET_NO);
-  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
-  room->member_infos = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
 
-  init_message_store (&(room->store));
-  room->requested = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  init_member_store(get_room_member_store(room), room);
+  init_message_store (get_room_message_store(room));
+  init_operation_store(get_room_operation_store(room), room);
 
   init_list_tunnels (&(room->basement));
-  init_list_messages (&(room->last_messages));
+  init_message_state(&(room->state));
 
   room->peer_message = NULL;
 
   init_list_messages (&(room->handling));
   room->idle = NULL;
 
-  room->strict_access = GNUNET_NO;
-
   if (room->service->dir)
-    load_service_room_and_messages (room->service, room);
+    load_room (room);
 
   room->idle = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
 
@@ -79,34 +85,8 @@ iterate_destroy_tunnels (void *cls, const struct GNUNET_PeerIdentity *key, void
   return GNUNET_YES;
 }
 
-static int
-iterate_clear_members (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
-{
-  struct GNUNET_MESSENGER_SrvContact *contact = value;
-
-  if (GNUNET_YES == decrease_contact_rc (contact))
-  {
-    struct GNUNET_MESSENGER_SrvRoom *room = cls;
-
-    const struct GNUNET_HashCode *id = get_contact_id_from_key (contact);
-
-    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->service->contacts, id, contact))
-      destroy_contact (contact);
-  }
-
-  return GNUNET_YES;
-}
-
-static int
-iterate_destroy_member_infos (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
-{
-  struct GNUNET_MESSENGER_MemberInfo *info = value;
-
-  clear_list_messages (&(info->session_messages));
-
-  GNUNET_free(info);
-  return GNUNET_YES;
-}
+static void
+handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room);
 
 void
 destroy_room (struct GNUNET_MESSENGER_SrvRoom *room)
@@ -123,29 +103,21 @@ destroy_room (struct GNUNET_MESSENGER_SrvRoom *room)
   if (room->port)
     GNUNET_CADET_close_port (room->port);
 
-  merge_room_last_messages (room, room->host);
-
-  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_destroy_tunnels,
-  NULL);
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_destroy_tunnels, NULL);
 
   handle_room_messages (room);
 
   if (room->service->dir)
-    save_service_room_and_messages (room->service, room);
-
-  GNUNET_CONTAINER_multishortmap_iterate (room->members, iterate_clear_members, room);
-  GNUNET_CONTAINER_multishortmap_iterate (room->member_infos, iterate_destroy_member_infos, NULL);
+    save_room (room);
 
-  clear_message_store (&(room->store));
-
-  GNUNET_CONTAINER_multihashmap_destroy (room->requested);
+  clear_member_store (get_room_member_store(room));
+  clear_message_store (get_room_message_store(room));
+  clear_operation_store(get_room_operation_store(room));
 
   GNUNET_CONTAINER_multipeermap_destroy (room->tunnels);
-  GNUNET_CONTAINER_multishortmap_destroy (room->members);
-  GNUNET_CONTAINER_multishortmap_destroy (room->member_infos);
 
   clear_list_tunnels (&(room->basement));
-  clear_list_messages (&(room->last_messages));
+  clear_message_state(&(room->state));
 
   if (room->peer_message)
     GNUNET_free(room->peer_message);
@@ -153,103 +125,38 @@ destroy_room (struct GNUNET_MESSENGER_SrvRoom *room)
   GNUNET_free(room);
 }
 
-struct GNUNET_MESSENGER_SrvContact*
-get_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id)
+struct GNUNET_MESSENGER_MemberStore*
+get_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room)
 {
-  GNUNET_assert((room) && (room->members));
-
-  return GNUNET_CONTAINER_multishortmap_get (room->members, id);
-}
-
-void
-add_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id,
-                  const struct GNUNET_IDENTITY_PublicKey *pubkey)
-{
-  struct GNUNET_MESSENGER_SrvContact *contact = get_service_contact_by_pubkey (room->service, pubkey);
-
-  if (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (room->members, id, contact,
-                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    increase_contact_rc (contact);
-}
-
-struct GNUNET_MESSENGER_MemberInfo*
-get_room_member_info (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id)
-{
-  GNUNET_assert((room) && (room->member_infos));
-
-  return GNUNET_CONTAINER_multishortmap_get (room->member_infos, id);
-}
-
-struct GNUNET_ShortHashCode*
-generate_room_member_id (const struct GNUNET_MESSENGER_SrvRoom *room)
-{
-  struct GNUNET_ShortHashCode *unique_id = GNUNET_new(struct GNUNET_ShortHashCode);
-
   GNUNET_assert(room);
 
-  if (GNUNET_YES == generate_free_member_id (unique_id, room->members))
-    return unique_id;
-  else
-  {
-    GNUNET_free(unique_id);
-    return NULL;
-  }
+  return &(room->member_store);
 }
 
-const struct GNUNET_ShortHashCode*
-get_room_host_id (const struct GNUNET_MESSENGER_SrvRoom *room)
+struct GNUNET_MESSENGER_MessageStore*
+get_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room)
 {
   GNUNET_assert(room);
 
-  return get_handle_member_id (room->host, &(room->key));
+  return &(room->message_store);
 }
 
-void
-change_room_host_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *unique_id)
+struct GNUNET_MESSENGER_OperationStore*
+get_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
 {
   GNUNET_assert(room);
 
-  change_handle_member_id (room->host, &(room->key), unique_id);
+  return &(room->operation_store);
 }
 
 static int
 send_room_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
                 struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 {
-  if (!handle)
+  if ((!handle) || (!is_tunnel_connected (tunnel)))
     return GNUNET_NO;
 
-  merge_room_last_messages (room, handle);
-
-  if (!is_tunnel_connected (tunnel))
-    return GNUNET_NO;
-
-  struct GNUNET_MESSENGER_Message *message = create_message_info (get_handle_ego(handle), room->members);
-
-  if (!message)
-    return GNUNET_NO;
-
-  if ((tunnel->peer_message) && (tunnel->contact_id))
-  {
-    GNUNET_memcpy(&(message->body.info.unique_id), &(tunnel->contact_id), sizeof(struct GNUNET_ShortHashCode));
-    GNUNET_free(tunnel->contact_id);
-
-    tunnel->contact_id = NULL;
-  }
-
-  struct GNUNET_HashCode hash;
-
-  send_tunnel_message (tunnel, handle, message, &hash);
-  destroy_message (message);
-
-  if (tunnel->contact_id)
-  {
-    GNUNET_free(tunnel->contact_id);
-
-    tunnel->contact_id = NULL;
-  }
-
-  return GNUNET_YES;
+  return send_tunnel_message (tunnel, handle, create_message_info (get_handle_ego (handle)));
 }
 
 static void*
@@ -257,63 +164,51 @@ callback_room_connect (void *cls, struct GNUNET_CADET_Channel *channel, const st
 {
   struct GNUNET_MESSENGER_SrvRoom *room = cls;
 
-  struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, source);
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = create_tunnel (room, source);
 
-  if (tunnel)
+  if ((tunnel) &&
+      (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, source, tunnel,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
   {
-    if (GNUNET_YES == bind_tunnel (tunnel, channel))
-    {
-      if (GNUNET_YES == send_room_info (room, room->host, tunnel))
-        return tunnel;
-      else
-      {
-        disconnect_tunnel (tunnel);
-        return NULL;
-      }
-    }
-    else
-    {
-      delayed_disconnect_channel (channel);
-      return NULL;
-    }
+    destroy_tunnel (tunnel);
+    tunnel = NULL;
   }
-  else
+
+  if (!tunnel)
   {
-    tunnel = create_tunnel (room, source);
+    delayed_disconnect_channel (channel);
+    return NULL;
+  }
 
-    if ((GNUNET_YES == bind_tunnel (tunnel, channel)) && (GNUNET_OK
-        == GNUNET_CONTAINER_multipeermap_put (room->tunnels, source, tunnel,
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
-    {
-      if (GNUNET_YES == send_room_info (room, room->host, tunnel))
-        return tunnel;
-      else
-      {
-        GNUNET_CONTAINER_multipeermap_remove (room->tunnels, source, tunnel);
+  bind_tunnel(tunnel, channel);
 
-        disconnect_tunnel (tunnel);
-        destroy_tunnel (tunnel);
-        return NULL;
-      }
-    }
-    else
-    {
-      tunnel->channel = NULL;
-      destroy_tunnel (tunnel);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "New tunnel in room (%s) established to peer: %s\n",
+             GNUNET_h2s(get_room_key(room)), GNUNET_i2s (source));
 
-      delayed_disconnect_channel (channel);
-      return NULL;
-    }
-  }
+  if (GNUNET_YES == send_room_info (room, room->host, tunnel))
+    return tunnel;
+
+  disconnect_tunnel (tunnel);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (room->tunnels, source, tunnel))
+    destroy_tunnel (tunnel);
+
+  return NULL;
 }
 
 static int
 join_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-           const struct GNUNET_ShortHashCode *member_id)
+           struct GNUNET_MESSENGER_Member *member)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s(get_room_key(room)), GNUNET_sh2s(member_id));
+  GNUNET_assert((room) && (handle) && (member));
 
-  struct GNUNET_MESSENGER_Message *message = create_message_join (get_handle_ego(handle));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (get_room_key (room)),
+             GNUNET_sh2s (get_member_id(member)));
+
+  if (GNUNET_OK != change_handle_member_id (handle, get_room_key(room), get_member_id(member)))
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_join (get_handle_ego (handle));
 
   if (!message)
   {
@@ -322,48 +217,97 @@ join_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHan
     return GNUNET_NO;
   }
 
-  struct GNUNET_HashCode hash;
+  return send_room_message (room, handle, message);
+}
 
-  send_room_message (room, handle, message, &hash);
-  destroy_message (message);
+struct GNUNET_MESSENGER_MemberNotify
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_MemberSession *session;
+};
 
-  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_new(struct GNUNET_MESSENGER_MemberInfo);
+static void
+notify_about_members (struct GNUNET_MESSENGER_MemberNotify *notify, struct GNUNET_MESSENGER_MemberSession *session,
+                      struct GNUNET_CONTAINER_MultiHashMap *map, int check_permission)
+{
+  if (session->prev)
+    notify_about_members (notify, session->prev, map, GNUNET_YES);
 
-  info->access = GNUNET_MESSENGER_MEMBER_ALLOWED;
-  init_list_messages (&(info->session_messages));
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(notify->room);
+  struct GNUNET_MESSENGER_ListMessage *element;
 
-  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_put (room->member_infos, member_id, info,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  for (element = session->messages.head; element; element = element->next)
   {
-    change_handle_member_id (handle, &(room->key), member_id);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(map, &(element->hash)))
+      continue;
 
-    add_to_list_messages (&(info->session_messages), &hash);
-    return GNUNET_YES;
-  }
-  else
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Your member information could not be registered!\n");
+    if ((GNUNET_YES == check_permission) &&
+        (GNUNET_YES != check_member_session_history(notify->session, &(element->hash), GNUNET_NO)))
+      continue;
 
-    GNUNET_free(info);
-    return GNUNET_NO;
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(map, &(element->hash), NULL,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notification of session message could be duplicated!\n");
+
+    const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, &(element->hash));
+
+    if (message)
+      notify_handle_message (notify->handle, get_room_key(notify->room), session, message, &(element->hash));
   }
 }
 
 static int
+iterate_notify_about_members (void *cls, const struct GNUNET_IDENTITY_PublicKey *public_key,
+                              struct GNUNET_MESSENGER_MemberSession *session)
+{
+  struct GNUNET_MESSENGER_MemberNotify *notify = cls;
+
+  if ((notify->session == session) || (GNUNET_YES == is_member_session_completed(session)))
+    return GNUNET_YES;
+
+  struct GNUNET_CONTAINER_MultiHashMap *map = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
+
+  notify_about_members (notify, session, map, GNUNET_NO);
+
+  GNUNET_CONTAINER_multihashmap_destroy(map);
+  return GNUNET_YES;
+}
+
+static int
 join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, &(room->key));
+  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, get_room_key(room));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = add_store_member(member_store, member_id);
+
+  if (GNUNET_NO == join_room (room, handle, member))
+    return GNUNET_NO;
 
-  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, member_id);
+  const struct GNUNET_MESSENGER_Ego *ego = get_handle_ego(handle);
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member, &(ego->pub));
 
-  if ((!info) && (GNUNET_NO == join_room (room, handle, member_id)))
+  if (!session)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "A valid session is required to join a room!\n");
     return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_MemberNotify notify;
+
+  notify.room = room;
+  notify.handle = handle;
+  notify.session = session;
+
+  iterate_store_members(get_room_member_store(room), iterate_notify_about_members, &notify);
 
   return GNUNET_YES;
 }
 
 extern int
 check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header);
+
 extern void
 handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header);
 
@@ -373,24 +317,39 @@ callback_tunnel_disconnect (void *cls, const struct GNUNET_CADET_Channel *channe
 int
 open_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert((room) && (handle));
+
   if (room->port)
     return join_room_locally (room, handle);
 
   struct GNUNET_CADET_Handle *cadet = get_room_cadet (room);
-  struct GNUNET_HashCode *key = get_room_key (room);
+  const struct GNUNET_HashCode *key = get_room_key (room);
 
   struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
                                                                        struct GNUNET_MessageHeader, NULL),
                                                  GNUNET_MQ_handler_end() };
 
-  room->port = GNUNET_CADET_open_port (cadet, key, callback_room_connect, room, NULL,
-                                       callback_tunnel_disconnect, handlers);
+  room->port = GNUNET_CADET_open_port (cadet, key, callback_room_connect, room, NULL, callback_tunnel_disconnect,
+                                       handlers);
+
+  if (room->port)
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Port of room (%s) was opened!\n",
+               GNUNET_h2s(get_room_key(room)));
+  else
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Port of room (%s) could not be opened!\n",
+               GNUNET_h2s(get_room_key(room)));
+
+  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, get_room_key(room));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member(member_store, member_id);
 
-  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, &(room->key));
+  if (member)
+    goto exit_open_room;
 
-  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, member_id);
+  member = add_store_member(member_store, member_id);
 
-  if ((!info) && (GNUNET_NO == join_room (room, handle, member_id)) && (room->port))
+  if ((GNUNET_NO == join_room (room, handle, member)) && (room->port))
   {
     GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not join the room, therefore it keeps closed!\n");
 
@@ -400,111 +359,62 @@ open_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHan
     return GNUNET_NO;
   }
 
-  struct GNUNET_MESSENGER_Message *message = create_message_peer (room->service);
-
-  if (message)
-  {
-    struct GNUNET_HashCode hash;
-
-    send_room_message (room, handle, message, &hash);
-    destroy_message (message);
-  }
-
-  return (room->port ? GNUNET_YES : GNUNET_NO);
+exit_open_room:
+  return (room->port ? send_room_message (room, handle, create_message_peer (room->service)) : GNUNET_NO);
 }
 
 int
-entry_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+enter_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
                const struct GNUNET_PeerIdentity *door)
 {
-  if (room->peer_message)
-  {
-    const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, handle, room->peer_message, GNUNET_NO);
+  GNUNET_assert((room) && (handle) && (door));
 
-    if (0 == GNUNET_memcmp(&(msg->body.peer.peer), door))
-      return join_room_locally (room, handle);
-  }
+  struct GNUNET_PeerIdentity peer;
+
+  if ((GNUNET_OK == get_service_peer_identity (room->service, &peer)) &&
+      (0 == GNUNET_memcmp(&peer, door)))
+    return join_room_locally (room, handle);
 
   struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, door);
 
-  if (tunnel)
+  if (!tunnel)
   {
-    switch (connect_tunnel (tunnel))
+    tunnel = create_tunnel (room, door);
+
+    if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, door, tunnel,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
     {
-    case GNUNET_YES:
-      return GNUNET_YES;
-    case GNUNET_NO:
-      return join_room_locally (room, handle);
-    default:
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not connect to that door!\n");
+      destroy_tunnel (tunnel);
       return GNUNET_NO;
     }
   }
 
-  tunnel = create_tunnel (room, door);
-
-  if ((GNUNET_YES == connect_tunnel (tunnel)) &&
-      (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (room->tunnels, door, tunnel,
-                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
-    return GNUNET_YES;
-  else
+  if (GNUNET_SYSERR == connect_tunnel (tunnel))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not connect to that door!\n");
-
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connection failure during entrance!\n");
+    GNUNET_CONTAINER_multipeermap_remove (room->tunnels, door, tunnel);
     destroy_tunnel (tunnel);
     return GNUNET_NO;
   }
-}
-
-struct GNUNET_MESSENGER_SrvTunnelFinder
-{
-  const struct GNUNET_ShortHashCode *needle;
-  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
-};
-
-static int
-iterate_find_tunnel (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
-{
-  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
-  struct GNUNET_MESSENGER_SrvTunnelFinder *finder = cls;
-
-  if ((tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, finder->needle)))
-  {
-    finder->tunnel = tunnel;
-    return GNUNET_NO;
-  }
-
-  return GNUNET_YES;
-}
-
-struct GNUNET_MESSENGER_SrvTunnel*
-find_room_tunnel_to (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *contact_id)
-{
-  struct GNUNET_MESSENGER_SrvTunnelFinder finder;
-
-  finder.needle = contact_id;
-  finder.tunnel = NULL;
-
-  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_find_tunnel, &finder);
 
-  return finder.tunnel;
+  return join_room_locally (room, handle);
 }
 
 struct GNUNET_MQ_Envelope*
-pack_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+pack_room_message (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle,
                    struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, int mode)
 {
+  GNUNET_assert((room) && (handle) && (message) && (hash));
+
   message->header.timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
 
-  const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, &(room->key));
+  const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, get_room_key(room));
 
   GNUNET_assert(id);
 
   GNUNET_memcpy(&(message->header.sender_id), id, sizeof(struct GNUNET_ShortHashCode));
-
-  if (room->last_messages.head)
-    GNUNET_memcpy(&(message->header.previous), &(room->last_messages.head->hash), sizeof(struct GNUNET_HashCode));
-  else
-    memset (&(message->header.previous), 0, sizeof(struct GNUNET_HashCode));
+  get_message_state_chain_hash (&(room->state), &(message->header.previous));
 
   return pack_message (message, hash, get_handle_ego (handle), mode);
 }
@@ -524,7 +434,8 @@ iterate_send_room_message (void *cls, const struct GNUNET_PeerIdentity *key, voi
 {
   struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
 
-  if ((!is_tunnel_connected (tunnel)) || (!tunnel->contact_id))
+  if ((!is_tunnel_connected (tunnel)) ||
+      (get_tunnel_messenger_version(tunnel) < GNUNET_MESSENGER_VERSION))
     return GNUNET_YES;
 
   struct GNUNET_MESSENGER_ClosureSendRoom *closure = cls;
@@ -540,80 +451,91 @@ iterate_send_room_message (void *cls, const struct GNUNET_PeerIdentity *key, voi
     GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
     if (env)
-    {
-      closure->message = copy_message (closure->message);
       closure->packed = GNUNET_YES;
-    }
   }
   else
-  {
-    env = pack_message (closure->message, NULL, NULL,
-    GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
-  }
+    env = pack_message (closure->message, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
   if (env)
-    send_tunnel_envelope (tunnel, closure->handle, env, closure->message, closure->hash);
+    send_tunnel_envelope (tunnel, env, closure->hash);
 
   return GNUNET_YES;
 }
 
-void
-callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+int
+update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 void
+callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                              const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+int
 send_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
+                   struct GNUNET_MESSENGER_Message *message)
 {
-  struct GNUNET_MESSENGER_ClosureSendRoom closure;
+  GNUNET_assert((room) && (handle));
 
-  closure.room = room;
-  closure.handle = handle;
-  closure.exclude = NULL;
-  closure.message = message;
-  closure.hash = hash;
-  closure.packed = GNUNET_NO;
-
-  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_send_room_message, &closure);
+  if (!message)
+    return GNUNET_NO;
 
-  if ((GNUNET_NO == closure.packed) && (closure.message == message))
-  {
-    pack_room_message (room, handle, message, hash,
-    GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+  if (GNUNET_YES == is_message_session_bound(message))
+    merge_room_last_messages(room, handle);
 
-    callback_room_sent (room, handle, NULL, copy_message (message), hash);
-  }
-}
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Sending message from handle with member id: %s\n",
+             GNUNET_sh2s(get_handle_member_id(handle, get_room_key(room))));
 
-void
-send_room_message_ext (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                       struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
-                       struct GNUNET_MESSENGER_SrvTunnel *tunnel)
-{
+  struct GNUNET_HashCode hash;
   struct GNUNET_MESSENGER_ClosureSendRoom closure;
 
   closure.room = room;
   closure.handle = handle;
-  closure.exclude = tunnel;
+  closure.exclude = NULL;
   closure.message = message;
-  closure.hash = hash;
+  closure.hash = &hash;
   closure.packed = GNUNET_NO;
 
   GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_send_room_message, &closure);
 
-  if ((GNUNET_NO == closure.packed) && (closure.message == message))
-  {
-    pack_room_message (room, handle, message, hash,
-    GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+  if (GNUNET_NO == closure.packed)
+    pack_room_message (room, handle, message, &hash, GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+
+  const int new_message = update_room_message (room, message, &hash);
+
+  if (GNUNET_YES != new_message)
+    return GNUNET_SYSERR;
 
-    callback_room_sent (room, handle, NULL, copy_message (message), hash);
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    send_message_join (room, handle, message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    send_message_peer (room, handle, message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    send_message_id (room, handle, message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    send_message_request (room, handle, message, &hash);
+    break;
+  default:
+    break;
   }
+
+  callback_room_handle_message (room, handle, message, &hash);
+  return GNUNET_YES;
 }
 
 void
 forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((room) && (tunnel));
+
+  if (!message)
+    return;
+
   struct GNUNET_MESSENGER_ClosureSendRoom closure;
   struct GNUNET_HashCode message_hash;
 
@@ -622,7 +544,7 @@ forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSE
   closure.room = room;
   closure.handle = NULL;
   closure.exclude = tunnel;
-  closure.message = copy_message (message);
+  closure.message = message;
   closure.hash = &message_hash;
   closure.packed = GNUNET_YES;
 
@@ -630,76 +552,196 @@ forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSE
 }
 
 void
+check_room_peer_status (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  if (!room->peer_message)
+    return;
+
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
+
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, room->peer_message);
+
+  if (!message)
+  {
+    GNUNET_free(room->peer_message);
+    room->peer_message = NULL;
+    return;
+  }
+
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
+
+  if (!member)
+    goto resend_peer_message;
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, room->peer_message);
+
+  if (GNUNET_YES == is_member_session_closed(session))
+    goto resend_peer_message;
+
+  if (tunnel)
+    forward_tunnel_message(tunnel, message, room->peer_message);
+
+  return;
+
+resend_peer_message:
+  if (room->host)
+    send_room_message (room, room->host, create_message_peer (room->service));
+}
+
+void
 merge_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert(room);
+
   if (!handle)
     return;
 
-  if (!room->last_messages.head)
+  const struct GNUNET_HashCode *hash;
+
+merge_next:
+  hash = get_message_state_merge_hash (&(room->state));
+
+  if (!hash)
     return;
 
-  while (room->last_messages.head != room->last_messages.tail)
+  send_room_message (room, handle, create_message_merge (hash));
+  goto merge_next;
+}
+
+void
+callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
+{
+  if (GNUNET_OK != delete_store_message (get_room_message_store(room), hash))
   {
-    struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.tail;
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Deletion of message failed! (%s)\n", GNUNET_h2s(hash));
+    return;
+  }
+}
 
-    struct GNUNET_MESSENGER_Message *message = create_message_merge (&(element->hash));
+void
+callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
+{
+  if (!room->host)
+    return;
 
-    if (message)
-    {
-      struct GNUNET_HashCode hash;
+  send_room_message (room, room->host, create_message_merge (hash));
+}
 
-      send_room_message (room, handle, message, &hash);
-      destroy_message (message);
-    }
+int
+delete_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
+{
+  GNUNET_assert((room) && (session) && (hash));
 
-    if (element->prev)
-      GNUNET_CONTAINER_DLL_remove(room->last_messages.head, room->last_messages.tail, element);
+  const struct GNUNET_TIME_Relative forever = GNUNET_TIME_relative_get_forever_ ();
+
+  if (0 == GNUNET_memcmp(&forever, &delay))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Deletion is delayed forever: operation is impossible!\n");
+    return GNUNET_SYSERR;
   }
+
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
+
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, hash);
+
+  if (!message)
+    return GNUNET_YES;
+
+  if (GNUNET_YES != check_member_session_history(session, hash, GNUNET_YES))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unpermitted request for deletion by member (%s) of message (%s)!\n",
+               GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
+
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);
+
+  if (GNUNET_OK != use_store_operation(operation_store, hash, GNUNET_MESSENGER_OP_DELETE, delay))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Deletion has failed: operation denied!\n");
+    return GNUNET_SYSERR;
+  }
+
+  return GNUNET_YES;
 }
 
 struct GNUNET_CADET_Handle*
 get_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
 {
+  GNUNET_assert(room);
+
   return room->service->cadet;
 }
 
-struct GNUNET_HashCode*
-get_room_key (struct GNUNET_MESSENGER_SrvRoom *room)
+const struct GNUNET_HashCode*
+get_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
 {
+  GNUNET_assert(room);
+
   return &(room->key);
 }
 
 const struct GNUNET_MESSENGER_SrvTunnel*
-get_room_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer)
+get_room_tunnel (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer)
 {
+  GNUNET_assert((room) && (peer));
+
   return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
 }
 
-const struct GNUNET_MESSENGER_Message*
-get_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                  const struct GNUNET_HashCode *hash, int request)
+static int
+request_room_message_step (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash,
+                           const struct GNUNET_MESSENGER_MemberSession *session,
+                           GNUNET_MESSENGER_MessageRequestCallback callback, void* cls)
 {
-  const struct GNUNET_MESSENGER_Message *message = get_store_message (&(room->store), hash);
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
 
-  if ((message) || (!handle) || (GNUNET_YES != request)
-      || (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->requested, hash)))
-    return message;
+  const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link(
+      message_store, hash, GNUNET_YES
+  );
 
-  struct GNUNET_MESSENGER_Message *request_msg = create_message_request (hash);
+  if (!link)
+    goto forward;
 
-  if (request_msg)
-  {
-    if (GNUNET_CONTAINER_multihashmap_put (room->requested, hash, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST) == GNUNET_OK)
-    {
-      struct GNUNET_HashCode request_hash;
+  int result = request_room_message_step(room, &(link->first), session, callback, cls);
 
-      send_room_message (room, handle, request_msg, &request_hash);
-    }
+  if ((GNUNET_YES == link->multiple) &&
+      (GNUNET_YES == request_room_message_step(room, &(link->second), session, callback, cls)))
+    return GNUNET_YES;
+  else
+    return result;
 
-    destroy_message (request_msg);
-  }
+forward:
+  if (GNUNET_YES != check_member_session_history(session, hash, GNUNET_NO))
+    return GNUNET_YES;
 
-  return message;
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, hash);
+
+  if (!message)
+    return GNUNET_NO;
+
+  if (callback)
+    callback (cls, room, message, hash);
+
+  return GNUNET_YES;
+}
+
+int
+request_room_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash,
+                      const struct GNUNET_MESSENGER_MemberSession *session,
+                      GNUNET_MESSENGER_MessageRequestCallback callback, void* cls)
+{
+  GNUNET_assert((room) && (hash));
+
+  int result = request_room_message_step (room, hash, session, callback, cls);
+
+  if ((GNUNET_NO == result) && (callback))
+    callback (cls, room, NULL, hash);
+
+  return result;
 }
 
 void
@@ -711,21 +753,14 @@ callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room, void *cls)
     return;
 
   struct GNUNET_PeerIdentity identity;
+  get_tunnel_peer_identity(tunnel, &identity);
 
-  GNUNET_PEER_resolve (tunnel->peer, &identity);
+  if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels, &identity, tunnel)) ||
+      (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(room->tunnels, &identity)))
+    return;
 
   if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
-  {
-    struct GNUNET_MESSENGER_Message *message = create_message_miss (&identity);
-
-    if (message)
-    {
-      struct GNUNET_HashCode hash;
-
-      send_room_message (room, room->host, message, &hash);
-      destroy_message (message);
-    }
-  }
+    send_room_message (room, room->host, create_message_miss (&identity));
 }
 
 int
@@ -733,49 +768,32 @@ callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room, void *cls,
                               struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
 {
   if (GNUNET_MESSENGER_KIND_UNKNOWN == message->header.kind)
-    return GNUNET_SYSERR;
-
-  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
-                                                                                    &(message->header.sender_id));
-
-  if (!contact)
   {
-    if (GNUNET_MESSENGER_KIND_INFO == message->header.kind)
-      contact = get_service_contact_by_pubkey (room->service, &(message->body.info.host_key));
-    else if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
-      contact = get_service_contact_by_pubkey (room->service, &(message->body.join.key));
-  }
-
-  if ((!contact) || (GNUNET_SYSERR == verify_message (message, hash, get_contact_key (contact))))
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Message error: Kind is unknown! (%d)\n", message->header.kind);
     return GNUNET_SYSERR;
-
-  if (GNUNET_YES == room->strict_access)
-  {
-    struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos,
-                                                                                   &(message->header.sender_id));
-
-    if ((info) && (GNUNET_MESSENGER_MEMBER_BLOCKED == info->access))
-      return GNUNET_SYSERR;
   }
 
-  if (GNUNET_YES == contains_store_message (&(room->store), hash))
-    return GNUNET_NO;
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
 
-  return GNUNET_YES;
-}
+  const struct GNUNET_MESSENGER_Message *previous = get_store_message(message_store, &(message->header.previous));
 
-static void
-search_room_for_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
-{
-  const struct GNUNET_MESSENGER_Message *message = get_room_message (room, room->host, hash, GNUNET_YES);
+  if (!previous)
+    goto skip_time_comparison;
 
-  if (!message)
-    return;
+  struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_ntoh(message->header.timestamp);
+  struct GNUNET_TIME_Absolute last = GNUNET_TIME_absolute_ntoh(previous->header.timestamp);
 
-  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
-    search_room_for_message (room, &(message->body.merge.previous));
+  if (GNUNET_TIME_relative_get_zero_().rel_value_us != GNUNET_TIME_absolute_get_difference(timestamp, last).rel_value_us)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Message error: Timestamp does not check out!\n");
+    return GNUNET_SYSERR;
+  }
+
+skip_time_comparison:
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
+             GNUNET_MESSENGER_name_of_kind(message->header.kind));
 
-  search_room_for_message (room, &(message->header.previous));
+  return GNUNET_OK;
 }
 
 static void
@@ -785,102 +803,76 @@ idle_request_room_messages (void *cls)
 
   room->idle = NULL;
 
-  struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.head;
-
-  while (element)
-  {
-    search_room_for_message (room, &(element->hash));
-
-    element = element->next;
-  }
-
-  merge_room_last_messages (room, room->host);
-
-  room->idle = GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_second_ (),
-                                                           GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages,
-                                                           cls);
+  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);
+  const struct GNUNET_HashCode *hash = get_message_state_merge_hash(&(room->state));
+
+  if ((hash) &&
+      (GNUNET_MESSENGER_OP_UNKNOWN == get_store_operation_type(operation_store, hash)))
+    use_store_operation(
+        operation_store,
+        hash,
+        GNUNET_MESSENGER_OP_MERGE,
+        GNUNET_MESSENGER_MERGE_DELAY
+    );
+
+  room->idle = GNUNET_SCHEDULER_add_delayed_with_priority (
+      GNUNET_MESSENGER_IDLE_DELAY,
+      GNUNET_SCHEDULER_PRIORITY_IDLE,
+      idle_request_room_messages,
+      cls
+  );
 }
 
 void
-update_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message,
-                           const struct GNUNET_HashCode *hash)
+solve_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_IDENTITY_PublicKey *public_key,
+                              const struct GNUNET_ShortHashCode *member_id, struct GNUNET_TIME_Absolute timestamp)
 {
-  struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.head;
-  struct GNUNET_MESSENGER_ListMessage *merging = NULL;
-
-  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
-  {
-    merging = room->last_messages.head;
-
-    while (merging)
-    {
-      if (0 == GNUNET_CRYPTO_hash_cmp (&(merging->hash), &(message->body.merge.previous)))
-        break;
+  GNUNET_assert ((room) && (public_key) && (member_id));
 
-      merging = merging->next;
-    }
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member(member_store, member_id);
 
-    if (merging)
-      element = merging->next;
-  }
-
-  while (element)
-  {
-    if (0 == GNUNET_CRYPTO_hash_cmp (&(element->hash), &(message->header.previous)))
-      break;
-
-    element = element->next;
-  }
+  if ((!member) || (1 >= GNUNET_CONTAINER_multihashmap_size(member->sessions)))
+    return;
 
-  if ((merging) && (!element))
-  {
-    element = merging;
-    merging = NULL;
-  }
+  struct GNUNET_MESSENGER_ListHandles *handles = &(room->service->handles);
+  struct GNUNET_MESSENGER_ListHandle* element;
 
-  if (element)
+  for (element = handles->head; element; element = element->next)
   {
-    GNUNET_memcpy(&(element->hash), hash, sizeof(struct GNUNET_HashCode));
+    if (0 != GNUNET_memcmp(member_id, get_handle_member_id(element->handle, get_room_key(room))))
+      continue;
 
-    if (merging)
-      GNUNET_CONTAINER_DLL_remove(room->last_messages.head, room->last_messages.tail, merging);
-  }
-  else
-    add_to_list_messages (&(room->last_messages), hash);
+    if (0 == GNUNET_memcmp(public_key, &(get_handle_ego(element->handle)->pub)))
+      continue;
 
-  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (room->requested, hash))
-    GNUNET_CONTAINER_multihashmap_remove_all (room->requested, hash);
-}
+    struct GNUNET_MESSENGER_MemberSession *session = get_member_session(member, &(get_handle_ego(element->handle)->pub));
 
-void
-switch_room_member_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *old_id,
-                       const struct GNUNET_ShortHashCode *new_id, const struct GNUNET_HashCode *hash)
-{
-  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multishortmap_get (room->members, old_id);
+    if (!session)
+      continue;
 
-  if ((contact) && (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (room->members, old_id, contact)))
-    GNUNET_CONTAINER_multishortmap_put (room->members, new_id, contact,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    struct GNUNET_TIME_Absolute start = get_member_session_start(session);
 
-  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, old_id);
+    if (GNUNET_TIME_relative_get_zero_().rel_value_us != GNUNET_TIME_absolute_get_difference(start, timestamp).rel_value_us)
+      continue;
 
-  if ((!info) || (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->member_infos, old_id, contact))
-      || (GNUNET_YES != GNUNET_CONTAINER_multishortmap_put (room->member_infos, new_id, contact,
-                                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
-    return;
+    struct GNUNET_ShortHashCode random_id;
+    generate_free_member_id (&random_id, member_store->members);
 
-  if (hash)
-    add_to_list_messages (&(info->session_messages), hash);
+    send_room_message(room, element->handle, create_message_id(&random_id));
+  }
 }
 
 void
 rebuild_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
 {
+  GNUNET_assert(room);
+
   struct GNUNET_PeerIdentity peer;
   size_t src;
 
-  if ((GNUNET_OK != get_service_peer_identity (room->service, &peer)) || (!find_list_tunnels (&(room->basement), &peer,
-                                                                                              &src)))
+  if ((GNUNET_OK != get_service_peer_identity (room->service, &peer)) ||
+      (!find_list_tunnels (&(room->basement), &peer, &src)))
     return;
 
   size_t count = count_of_tunnels (&(room->basement));
@@ -918,38 +910,167 @@ rebuild_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
   }
 }
 
-void
+static void
 handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
 {
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+
   while (room->handling.head)
   {
     struct GNUNET_MESSENGER_ListMessage *element = room->handling.head;
 
-    const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, room->host, &(element->hash), GNUNET_NO);
+    const struct GNUNET_MESSENGER_Message *message = get_store_message (message_store, &(element->hash));
+
+    if (!message)
+      goto finish_handling;
 
-    if (msg)
-      handle_service_message (room->service, room, msg, &(element->hash));
+    struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
 
+    if (!member)
+      goto finish_handling;
+
+    struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, &(element->hash));
+
+    if (session)
+      handle_service_message (room->service, room, session, message, &(element->hash));
+
+finish_handling:
     GNUNET_CONTAINER_DLL_remove(room->handling.head, room->handling.tail, element);
     GNUNET_free(element);
   }
 }
 
-#include "gnunet-service-messenger_message_recv.h"
+int
+update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((room) && (message) && (hash));
+
+  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);
+
+  const int requested = (GNUNET_MESSENGER_OP_REQUEST == get_store_operation_type(operation_store, hash)?
+      GNUNET_YES : GNUNET_NO
+  );
+
+  if (GNUNET_YES == requested)
+    cancel_store_operation(operation_store, hash);
+
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);
+
+  const struct GNUNET_MESSENGER_Message *old_message = get_store_message (message_store, hash);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n", GNUNET_h2s (get_room_key(room)));
+
+  if ((old_message) || (GNUNET_OK != put_store_message (message_store, hash, message)))
+  {
+    if (old_message != message)
+      destroy_message(message);
+
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
+    return GNUNET_NO;
+  }
+
+  update_message_state(&(room->state), requested, message, hash);
+
+  if ((GNUNET_YES == requested) ||
+      (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_REQUEST == message->header.kind))
+    return GNUNET_YES;
+
+  if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
+      (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type(operation_store, &(message->body.merge.previous))))
+    cancel_store_operation(operation_store, &(message->body.merge.previous));
+
+  if (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type(operation_store, &(message->header.previous)))
+    cancel_store_operation(operation_store, &(message->header.previous));
+
+  return GNUNET_YES;
+}
+
+struct GNUNET_MESSENGER_MemberSessionCompletion
+{
+  struct GNUNET_MESSENGER_MemberSessionCompletion *prev;
+  struct GNUNET_MESSENGER_MemberSessionCompletion *next;
+
+  struct GNUNET_MESSENGER_MemberSession *session;
+};
+
+struct GNUNET_MESSENGER_MemberUpdate
+{
+  const struct GNUNET_MESSENGER_Message *message;
+  const struct GNUNET_HashCode *hash;
+
+  struct GNUNET_MESSENGER_MemberSessionCompletion *head;
+  struct GNUNET_MESSENGER_MemberSessionCompletion *tail;
+};
+
+static int
+iterate_update_member_sessions (void *cls, const struct GNUNET_IDENTITY_PublicKey *public_key,
+                                struct GNUNET_MESSENGER_MemberSession *session)
+{
+  struct GNUNET_MESSENGER_MemberUpdate *update = cls;
+
+  update_member_session_history(session, update->message, update->hash);
+
+  if (GNUNET_YES == is_member_session_completed(session))
+  {
+    struct GNUNET_MESSENGER_MemberSessionCompletion *element = GNUNET_new(
+        struct GNUNET_MESSENGER_MemberSessionCompletion
+    );
+
+    element->session = session;
+
+    GNUNET_CONTAINER_DLL_insert_tail(update->head, update->tail, element);
+  }
+
+  return GNUNET_YES;
+}
+
+static void
+remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session);
 
 void
-callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message,
-                    const struct GNUNET_HashCode *hash)
+callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                              const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n", GNUNET_h2s (hash));
 
-  if (GNUNET_OK != put_store_message (&(room->store), hash, message))
+  if (!member)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message handling dropped: Member is missing!\n");
     return;
+  }
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, hash);
+
+  if (!session)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message handling dropped: Session is missing!\n");
+    return;
+  }
 
-  update_room_last_messages (room, message, hash);
+  struct GNUNET_MESSENGER_MemberUpdate update;
+  update.message = message;
+  update.hash = hash;
 
-  if (GNUNET_MESSENGER_KIND_INFO != message->header.kind)
-    forward_room_message (room, tunnel, message, hash);
+  update.head = NULL;
+  update.tail = NULL;
+
+  iterate_store_members(member_store, iterate_update_member_sessions, &update);
+
+  while (update.head)
+  {
+    struct GNUNET_MESSENGER_MemberSessionCompletion *element = update.head;
+
+    remove_room_member_session (room, element->session);
+
+    GNUNET_CONTAINER_DLL_remove(update.head, update.tail, element);
+    GNUNET_free (element);
+  }
 
   const int start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
 
@@ -957,32 +1078,29 @@ callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNU
 
   switch (message->header.kind)
   {
-  case GNUNET_MESSENGER_KIND_INFO:
-    recv_message_info (room, tunnel, message, hash);
-    break;
   case GNUNET_MESSENGER_KIND_JOIN:
-    recv_message_join (room, tunnel, message, hash);
+    handle_message_join (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_LEAVE:
-    recv_message_leave (room, tunnel, message, hash);
+    handle_message_leave (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_NAME:
-    recv_message_name (room, tunnel, message, hash);
+    handle_message_name (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_KEY:
-    recv_message_key (room, tunnel, message, hash);
+    handle_message_key (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_PEER:
-    recv_message_peer (room, tunnel, message, hash);
+    handle_message_peer (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_ID:
-    recv_message_id (room, tunnel, message, hash);
+    handle_message_id (room, session, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_MISS:
-    recv_message_miss (room, tunnel, message, hash);
+    handle_message_miss (room, session, message, hash);
     break;
-  case GNUNET_MESSENGER_KIND_REQUEST:
-    recv_message_request (room, tunnel, message, hash);
+  case GNUNET_MESSENGER_KIND_DELETE:
+    handle_message_delete (room, session, message, hash);
     break;
   default:
     break;
@@ -992,60 +1110,98 @@ callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNU
     handle_room_messages (room);
 }
 
-#include "gnunet-service-messenger_message_send.h"
+static void
+get_room_data_subdir (struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
+{
+  GNUNET_assert((room) && (dir));
+
+  GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (get_room_key(room)), DIR_SEPARATOR);
+}
 
 void
-callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+load_room (struct GNUNET_MESSENGER_SrvRoom *room)
 {
-  const struct GNUNET_MESSENGER_Message *old_message = get_room_message (room, handle, hash, GNUNET_NO);
+  GNUNET_assert(room);
+
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
 
-  if ((old_message) || (GNUNET_OK != put_store_message (&(room->store), hash, message)))
+  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
   {
-    if (old_message != message)
-      GNUNET_free(message);
+    load_member_store (get_room_member_store(room), room_dir);
+    load_message_store (get_room_message_store(room), room_dir);
+    load_operation_store(get_room_operation_store(room), room_dir);
+
+    char *basement_file;
+    GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
+
+    load_list_tunnels(&(room->basement), basement_file);
+    GNUNET_free(basement_file);
+
+    char *last_messages_file;
+    GNUNET_asprintf (&last_messages_file, "%s%s", room_dir, "last_messages.list");
+
+    load_message_state(&(room->state), room_dir);
   }
-  else
-  {
-    struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls; // may be NULL
 
-    update_room_last_messages (room, message, hash);
+  GNUNET_free(room_dir);
+}
 
-    const int start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
+void
+save_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert(room);
 
-    add_to_list_messages (&(room->handling), hash);
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
 
-    switch (message->header.kind)
-    {
-    case GNUNET_MESSENGER_KIND_INFO:
-      send_message_info (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_JOIN:
-      send_message_join (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_LEAVE:
-      send_message_leave (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_NAME:
-      send_message_name (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_KEY:
-      send_message_key (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_PEER:
-      send_message_peer (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_ID:
-      send_message_id (room, handle, tunnel, message, hash);
-      break;
-    case GNUNET_MESSENGER_KIND_MISS:
-      send_message_miss (room, handle, tunnel, message, hash);
-      break;
-    default:
-      break;
-    }
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (room_dir)))
+  {
+    save_member_store(get_room_member_store(room), room_dir);
+    save_message_store (get_room_message_store(room), room_dir);
+    save_operation_store(get_room_operation_store(room), room_dir);
+
+    char *basement_file;
+    GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
 
-    if (GNUNET_YES == start_handle)
-      handle_room_messages (room);
+    save_list_tunnels(&(room->basement), basement_file);
+    GNUNET_free(basement_file);
+
+    save_message_state(&(room->state), room_dir);
   }
+
+  GNUNET_free(room_dir);
+}
+
+static void
+remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session)
+{
+  GNUNET_assert ((room) && (session));
+
+  remove_member_session (session->member, session);
+
+  const struct GNUNET_IDENTITY_PublicKey *public_key = get_member_session_public_key(session);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
+
+  char* session_dir;
+  GNUNET_asprintf (
+      &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
+      "members", DIR_SEPARATOR,
+      GNUNET_sh2s(get_member_session_id(session)), DIR_SEPARATOR,
+      "sessions", DIR_SEPARATOR,
+      GNUNET_h2s(&hash), DIR_SEPARATOR
+  );
+
+  GNUNET_free (room_dir);
+
+  GNUNET_DISK_directory_remove(session_dir);
+  GNUNET_free (session_dir);
+
+  destroy_member_session(session);
 }
diff --git a/src/messenger/gnunet-service-messenger_room.h b/src/messenger/gnunet-service-messenger_room.h
index 36c9e8cf5..b6a0f1064 100644
--- a/src/messenger/gnunet-service-messenger_room.h
+++ b/src/messenger/gnunet-service-messenger_room.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -33,33 +33,30 @@
 #include "gnunet_identity_service.h"
 #include "gnunet_mq_lib.h"
 
-#include "gnunet-service-messenger_contact.h"
-
 #include "gnunet_messenger_service.h"
 #include "gnunet-service-messenger_basement.h"
 #include "gnunet-service-messenger_handle.h"
-#include "gnunet-service-messenger_tunnel.h"
-
+#include "gnunet-service-messenger_message_state.h"
 #include "gnunet-service-messenger_list_messages.h"
+
 #include "messenger_api_list_tunnels.h"
 
+#include "gnunet-service-messenger_member_store.h"
 #include "gnunet-service-messenger_message_store.h"
+#include "gnunet-service-messenger_operation_store.h"
 #include "messenger_api_ego.h"
 
-enum GNUNET_MESSENGER_MemberAccess
-{
-  GNUNET_MESSENGER_MEMBER_ALLOWED = 1,
-  GNUNET_MESSENGER_MEMBER_BLOCKED = 1,
+#define GNUNET_MESSENGER_IDLE_DELAY GNUNET_TIME_relative_multiply \
+  (GNUNET_TIME_relative_get_second_ (), 5)
 
-  GNUNET_MESSENGER_MEMBER_UNKNOWN = 0
-};
+#define GNUNET_MESSENGER_REQUEST_DELAY GNUNET_TIME_relative_multiply \
+  (GNUNET_TIME_relative_get_minute_ (), 5)
 
-struct GNUNET_MESSENGER_MemberInfo
-{
-  enum GNUNET_MESSENGER_MemberAccess access;
+#define GNUNET_MESSENGER_MERGE_DELAY GNUNET_TIME_relative_multiply \
+  (GNUNET_TIME_relative_get_second_ (), 30)
 
-  struct GNUNET_MESSENGER_ListMessages session_messages;
-};
+struct GNUNET_MESSENGER_SrvTunnel;
+struct GNUNET_MESSENGER_MemberSession;
 
 struct GNUNET_MESSENGER_SrvRoom
 {
@@ -70,28 +67,25 @@ struct GNUNET_MESSENGER_SrvRoom
   struct GNUNET_HashCode key;
 
   struct GNUNET_CONTAINER_MultiPeerMap *tunnels;
-  struct GNUNET_CONTAINER_MultiShortmap *members;
-  struct GNUNET_CONTAINER_MultiShortmap *member_infos;
 
-  struct GNUNET_MESSENGER_MessageStore store;
-  struct GNUNET_CONTAINER_MultiHashMap *requested;
+  struct GNUNET_MESSENGER_MemberStore member_store;
+  struct GNUNET_MESSENGER_MessageStore message_store;
+  struct GNUNET_MESSENGER_OperationStore operation_store;
 
   struct GNUNET_MESSENGER_ListTunnels basement;
-  struct GNUNET_MESSENGER_ListMessages last_messages;
+  struct GNUNET_MESSENGER_MessageState state;
 
   struct GNUNET_HashCode *peer_message;
 
   struct GNUNET_MESSENGER_ListMessages handling;
   struct GNUNET_SCHEDULER_Task *idle;
-
-  int strict_access;
 };
 
 /**
  * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i>.
  *
- * @param handle Handle
- * @param key Key of room
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
  * @return New room
  */
 struct GNUNET_MESSENGER_SrvRoom*
@@ -100,71 +94,37 @@ create_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_Hash
 /**
  * Destroys a room and frees its memory fully.
  *
- * @param room Room
+ * @param[in/out] room Room
  */
 void
 destroy_room (struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
- * Returns the contact of a member in a <i>room</i> identified by a given <i>id</i>. If the <i>room</i>
- * does not contain a member with the given <i>id</i>, NULL gets returned.
- *
- * @param room Room
- * @param id Member id
- * @return Contact or NULL
- */
-struct GNUNET_MESSENGER_SrvContact*
-get_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id);
-
-/**
- * Adds a contact from the service to a <i>room</i> under a specific <i>id</i> with a given public key.
- *
- * @param room Room
- * @param id Member id
- * @param pubkey Public key of EGO
- */
-void
-add_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id,
-                  const struct GNUNET_IDENTITY_PublicKey *pubkey);
-
-/**
- * Returns the member information of a member in a <i>room</i> identified by a given <i>id</i>. If the <i>room</i>
- * does not contain a member with the given <i>id</i>, NULL gets returned.
+ * Returns the used member store of a given <i>room</i>.
  *
- * @param room Room
- * @param id Member id
- * @return Member information or NULL
+ * @param[in/out] room Room
+ * @return Member store
  */
-struct GNUNET_MESSENGER_MemberInfo*
-get_room_member_info (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id);
+struct GNUNET_MESSENGER_MemberStore*
+get_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
- * Tries to generate and allocate a new unique member id checking all current members for possible
- * duplicates. If the function fails, NULL gets returned.
+ * Returns the used message store of a given <i>room</i>.
  *
- * @param room Room
- * @return New member id or NULL
+ * @param[in/out] room Room
+ * @return Message store
  */
-struct GNUNET_ShortHashCode*
-generate_room_member_id (const struct GNUNET_MESSENGER_SrvRoom *room);
+struct GNUNET_MESSENGER_MessageStore*
+get_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
- * Returns the member id of the member representing the handle currently hosting this <i>room</i>.
+ * Returns the used operation store of a given <i>room</i>.
  *
- * @param room Room
- * @return Host member id or NULL
+ * @param[in/out] room Room
+ * @return Operation store
  */
-const struct GNUNET_ShortHashCode*
-get_room_host_id (const struct GNUNET_MESSENGER_SrvRoom *room);
-
-/**
- * Changes the member id of the member representing the handle currently hosting this <i>room</i>.
- *
- * @param room Room
- * @param unique_id Unique member id
- */
-void
-change_room_host_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *unique_id);
+struct GNUNET_MESSENGER_OperationStore*
+get_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
  * Tries to open a <i>room</i> for a given <i>handle</i>. If the room has already been opened, the handle
@@ -172,11 +132,11 @@ change_room_host_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_
  *
  * Calling this method should result in joining a room and sending a peer message as well for this peer.
  *
- * If the function returns GNUNET_YES the port for this room is guranteed to be open for incoming connections.
+ * If the function returns #GNUNET_YES the port for this room is guranteed to be open for incoming connections.
  *
- * @param room Room
- * @param handle Handle
- * @return GNUNET_YES on success, GNUNET_NO on failure.
+ * @param[in/out] room Room
+ * @param[in/out] handle Handle
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
  */
 int
 open_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle);
@@ -186,45 +146,34 @@ open_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHan
  * a peer identity of a hosting peer. During the connection the handle will join the room as a member, waiting for
  * an info message from the selected host.
  *
- * @param room Room
- * @param handle Handle
- * @param door Peer identity
- * @return GNUNET_YES on success, GNUNET_NO on failure.
+ * @param[in/out] room Room
+ * @param[in/out] handle Handle
+ * @param[in] door Peer identity
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
  */
 int
-entry_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+enter_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
                const struct GNUNET_PeerIdentity *door);
 
 /**
- * Returns a tunnel granting a direct connection to a specific member in a <i>room</i>. The member gets identified
- * by an <i>id</i>. If no tunnel has been linked to the selected id, NULL gets returned.
- *
- * @param room Room
- * @param contact_id Member id
- * @return Tunnel to the member or NULL
- */
-struct GNUNET_MESSENGER_SrvTunnel*
-find_room_tunnel_to (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *contact_id);
-
-/**
  * Packs a <i>message</i> depending on the selected <i>mode</i> into a newly allocated envelope. It will set the
  * timestamp of the message, the sender id and the previous messages hash automatically before packing. The message
  * will be signed by the handles EGO.
  *
  * If the optional <i>hash</i> parameter is a valid pointer, its value will be overriden by the signed messages hash.
  *
- * If <i>mode</i> is set to GNUNET_MESSENGER_PACK_MODE_ENVELOPE, the function returns a valid envelope to send
+ * If <i>mode</i> is set to #GNUNET_MESSENGER_PACK_MODE_ENVELOPE, the function returns a valid envelope to send
  * through a message queue, otherwise NULL.
  *
- * @param room Room
- * @param handle Handle
- * @param message Message
+ * @param[in] room Room
+ * @param[in] handle Handle
+ * @param[in/out] message Message
  * @param[out] hash Hash of message
- * @param mode Packing mode
+ * @param[in] mode Packing mode
  * @return New envelope or NULL
  */
 struct GNUNET_MQ_Envelope*
-pack_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+pack_room_message (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle,
                    struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, int mode);
 
 /**
@@ -234,59 +183,69 @@ pack_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGE
  * The function handles packing the message automatically and will call linked message-events locally even if
  * the message won't be sent to another peer.
  *
- * @param room Room
- * @param handle Handle
- * @param message Message
- * @param[out] hash Hash of message
+ * The function returns #GNUNET_YES on success, #GNUNET_NO if message is null and
+ * #GNUNET_SYSERR if the message was known already.
+ *
+ * @param[in/out] room Room
+ * @param[in/out] handle Handle
+ * @param[in/out] message Message
+ * @return #GNUNET_YES on success, #GNUNET_NO or #GNUNET_SYSERR otherwise.
  */
-void
+int
 send_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash);
+                   struct GNUNET_MESSENGER_Message *message);
 
 /**
- * Sends a <i>message</i> from a given <i>handle</i> into a <i>room</i> excluding one specific <i>tunnel</i>.
- * The <i>hash</i> parameter will be updated with the hash-value resulting from the sent message.
- *
- * The function handles packing the message automatically and will call linked message-events locally even if
- * the message won't be sent to another peer.
+ * Forwards a <i>message</i> with a given <i>hash</i> to a specific <i>tunnel</i> inside of a <i>room</i>.
  *
- * @param room Room
- * @param handle Handle
- * @param message Message
- * @param[out] hash Hash of message
- * @param tunnel Tunnel
+ * @param[in/out] room Room
+ * @param[in/out] tunnel Tunnel
+ * @param[in/out] message Message
+ * @param[in] hash Hash of message
  */
 void
-send_room_message_ext (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                       struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
-                       struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 /**
- * Forwards a <i>message</i> with a given <i>hash</i> to a specific <i>tunnel</i> inside of a <i>room</i>.
+ * Checks the current state of opening a given <i>room</i> from this peer and re-publishes it
+ * if necessary to a selected <i>tunnel</i> or to all connected tunnels if necessary or if the
+ * selected tunnel is NULL.
  *
- * @param room Room
- * @param tunnel Tunnel
- * @param message Message
- * @param hash Hash of message
+ * @param[in/out] room Room
+ * @param[in/out] tunnel Tunnel
  */
 void
-forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
-                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+check_room_peer_status (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel);
 
 /**
  * Reduces all current forks inside of the message history of a <i>room</i> to one remaining last message
  * by merging them down. All merge messages will be sent from a given <i>handle</i>.
  *
- * @param room Room
- * @param handle Handle
+ * @param[in/out] room Room
+ * @param[in/out] handle Handle
  */
 void
 merge_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
+ * Deletes a message from the <i>room</i> with a given <i>hash</i> in a specific <i>delay</i> if
+ * the provided member by its session is permitted to do so.
+ *
+ * @param[in/out] room Room
+ * @param[in/out] session Member session
+ * @param[in] hash Hash of message
+ * @param[in] delay Delay of deletion
+ * @return #GNUNET_YES on success, #GNUNET_NO if permission gets denied, #GNUNET_SYSERR on operation failure
+ */
+int
+delete_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session,
+                     const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay);
+
+/**
  * Returns the CADET handle from a rooms service.
  *
- * @param room Room
+ * @param[in/out] room Room
  * @return CADET handle
  */
 struct GNUNET_CADET_Handle*
@@ -295,84 +254,95 @@ get_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room);
 /**
  * Returns the shared secret you need to access a <i>room</i>.
  *
- * @param room Room
+ * @param[in] room Room
  * @return Shared secret
  */
-struct GNUNET_HashCode*
-get_room_key (struct GNUNET_MESSENGER_SrvRoom *room);
+const struct GNUNET_HashCode*
+get_room_key (const struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
  * Returns a tunnel inside of a <i>room</i> leading towards a given <i>peer</i> if such a tunnel exists,
  * otherwise NULL.
  *
- * @param room Room
- * @param peer Peer identity
+ * @param[in] room Room
+ * @param[in] peer Peer identity
  * @return Tunnel or NULL
  */
 const struct GNUNET_MESSENGER_SrvTunnel*
-get_room_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer);
+get_room_tunnel (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer);
 
 /**
- * Returns a message from a <i>room</i> identified by a given <i>hash</i>. If no matching message is
- * found and <i>request</i> is set to GNUNET_YES, the <i>handle</i> will request the missing message
- * automatically.
- *
- * The function uses the optimized check for a message via its hash from the message store.
- * @see contains_store_message()
+ * Method called whenever a <i>message</i> is found during a request in a <i>room</i>.
  *
- * If a message is missing independent of the following request, NULL gets returned instead of the
- * matching message.
- *
- * @param room Room
- * @param handle Handle
- * @param hash Hash of message
- * @param request Flag to request a message
- * @return Message or NULL
+ * @param[in/out] cls Closure from #request_room_message
+ * @param[in/out] room Room
+ * @param[in] message Message or NULL
+ * @param[in] hash Hash of message
  */
-const struct GNUNET_MESSENGER_Message*
-get_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
-                  const struct GNUNET_HashCode *hash, int request);
+typedef void (GNUNET_MESSENGER_MessageRequestCallback) (
+    void *cls, struct GNUNET_MESSENGER_SrvRoom *room,
+    const struct GNUNET_MESSENGER_Message *message,
+    const struct GNUNET_HashCode *hash
+);
 
 /**
- * Updates the last messages of a <i>room</i> by replacing them if the previous hash of a given <i>message</i>
- * matches with one of the latest messages.
- *
- * @param room Room
- * @param message Message
- * @param hash Hash of message
+ * Requests a message from a <i>room</i> identified by a given <i>hash</i>. If the message is found,
+ * the selected <i>callback</i> will be called with it and the provided closure. If no matching message
+ * is found but it wasn't deleted the selected callback will be called with #NULL as message instead.
+ * In case of deletion the next available previous message will be used to call the callback.
+ *
+ * It is also possible that the given callback will not be called if the requesting session is not
+ * permitted!
+ *
+ * @param[in/out] room Room
+ * @param[in] hash Hash of message
+ * @param[in] callback Callback to process result
+ * @param[in] cls Closure for the <i>callback</i>
+ * @return #GNUNET_YES if the request could be processed, otherwise #GNUNET_NO
  */
-void
-update_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message,
-                           const struct GNUNET_HashCode *hash);
+int
+request_room_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash,
+                      const struct GNUNET_MESSENGER_MemberSession *session,
+                      GNUNET_MESSENGER_MessageRequestCallback callback, void* cls);
 
 /**
- * Changes an id of a current member from an old id to a new one and adds optionally the <i>hash</i> of an
- * id message to the members information.
+ * Checks for potential collisions with member ids and solves them changing active handles ids if they
+ * use an already used member id (comparing public key and timestamp).
  *
- * @param room Room
- * @param old_id Old member id
- * @param new_id New member id
- * @param hash Hash of id message
+ * @param[in/out] room Room
+ * @param[in] public_key Public key of EGO
+ * @param[in] member_id Member ID
+ * @param[in] timestamp Timestamp
  */
 void
-switch_room_member_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *old_id,
-                       const struct GNUNET_ShortHashCode *new_id, const struct GNUNET_HashCode *hash);
+solve_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_IDENTITY_PublicKey *public_key,
+                              const struct GNUNET_ShortHashCode *member_id, struct GNUNET_TIME_Absolute timestamp);
 
 /**
  * Rebuilds the decentralized structure for a <i>room</i> by ensuring all required connections are made
  * depending on the amount of peers and this peers index in the list of them.
  *
- * @param room Room
+ * @param[in/out] room Room
  */
 void
 rebuild_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room);
 
 /**
- * Handles all queued up messages of a room to handle in correct order.
+ * Loads the local configuration for a given <i>room</i> of a service which contains the last messages hash
+ * and the ruleset for general access of new members.
+ *
+ * @param[out] room Room
+ */
+void
+load_room (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Saves the configuration for a given <i>room</i> of a service which contains the last messages hash
+ * and the ruleset for general access of new members locally.
  *
- * @param room Room
+ * @param[in] room Room
  */
 void
-handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room);
+save_room (struct GNUNET_MESSENGER_SrvRoom *room);
 
 #endif //GNUNET_SERVICE_MESSENGER_ROOM_H
diff --git a/src/messenger/gnunet-service-messenger_service.c b/src/messenger/gnunet-service-messenger_service.c
index 963314fd8..8c63e9bf4 100644
--- a/src/messenger/gnunet-service-messenger_service.c
+++ b/src/messenger/gnunet-service-messenger_service.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -24,11 +24,8 @@
  */
 
 #include "gnunet-service-messenger_service.h"
-
 #include "gnunet-service-messenger_message_kind.h"
-
 #include "gnunet-service-messenger.h"
-#include "gnunet-service-messenger_util.h"
 
 static void
 callback_shutdown_service (void *cls)
@@ -43,23 +40,11 @@ callback_shutdown_service (void *cls)
   }
 }
 
-static void
-callback_update_ego (void *cls,
-                     struct GNUNET_IDENTITY_Ego *ego,
-                     void **ctx,
-                     const char *identifier)
-{
-  if ((!ego) || (!identifier))
-    return;
-
-  struct GNUNET_MESSENGER_Service *service = cls;
-
-  update_service_ego(service, identifier, GNUNET_IDENTITY_ego_get_private_key(ego));
-}
-
 struct GNUNET_MESSENGER_Service*
 create_service (const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service_handle)
 {
+  GNUNET_assert((config) && (service_handle));
+
   struct GNUNET_MESSENGER_Service *service = GNUNET_new(struct GNUNET_MESSENGER_Service);
 
   service->config = config;
@@ -90,24 +75,16 @@ create_service (const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_
   }
 
   service->cadet = GNUNET_CADET_connect (service->config);
-  service->identity = GNUNET_IDENTITY_connect (service->config, &callback_update_ego, service);
 
-  service->egos = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  init_ego_store(get_service_ego_store(service), service->config);
 
   init_list_handles (&(service->handles));
 
-  service->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
   service->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
-  return service;
-}
+  init_contact_store(get_service_contact_store(service));
 
-static int
-iterate_destroy_egos (void *cls, const struct GNUNET_HashCode *key, void *value)
-{
-  struct GNUNET_MESSENGER_Ego *ego = value;
-  GNUNET_free(ego);
-  return GNUNET_YES;
+  return service;
 }
 
 static int
@@ -118,17 +95,11 @@ iterate_destroy_rooms (void *cls, const struct GNUNET_HashCode *key, void *value
   return GNUNET_YES;
 }
 
-static int
-iterate_destroy_contacts (void *cls, const struct GNUNET_HashCode *key, void *value)
-{
-  struct GNUNET_MESSENGER_SrvContact *contact = value;
-  destroy_contact (contact);
-  return GNUNET_YES;
-}
-
 void
 destroy_service (struct GNUNET_MESSENGER_Service *service)
 {
+  GNUNET_assert(service);
+
   if (service->shutdown)
   {
     GNUNET_SCHEDULER_cancel (service->shutdown);
@@ -136,16 +107,13 @@ destroy_service (struct GNUNET_MESSENGER_Service *service)
     service->shutdown = NULL;
   }
 
-  GNUNET_CONTAINER_multihashmap_iterate (service->egos, iterate_destroy_egos, NULL);
-
+  clear_ego_store(get_service_ego_store(service));
   clear_list_handles (&(service->handles));
 
   GNUNET_CONTAINER_multihashmap_iterate (service->rooms, iterate_destroy_rooms, NULL);
-  GNUNET_CONTAINER_multihashmap_iterate (service->contacts, iterate_destroy_contacts, NULL);
-
-  GNUNET_CONTAINER_multihashmap_destroy (service->egos);
   GNUNET_CONTAINER_multihashmap_destroy (service->rooms);
-  GNUNET_CONTAINER_multihashmap_destroy (service->contacts);
+
+  clear_contact_store(get_service_contact_store(service));
 
   if (service->cadet)
   {
@@ -154,13 +122,6 @@ destroy_service (struct GNUNET_MESSENGER_Service *service)
     service->cadet = NULL;
   }
 
-  if (service->identity)
-  {
-    GNUNET_IDENTITY_disconnect (service->identity);
-
-    service->identity = NULL;
-  }
-
   if (service->dir)
   {
     GNUNET_free(service->dir);
@@ -173,44 +134,27 @@ destroy_service (struct GNUNET_MESSENGER_Service *service)
   GNUNET_free(service);
 }
 
-struct GNUNET_MESSENGER_Ego*
-lookup_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier)
+struct GNUNET_MESSENGER_EgoStore*
+get_service_ego_store (struct GNUNET_MESSENGER_Service *service)
 {
-  GNUNET_assert(identifier);
+  GNUNET_assert(service);
 
-  struct GNUNET_HashCode hash;
-
-  GNUNET_CRYPTO_hash(identifier, strlen(identifier), &hash);
-  return GNUNET_CONTAINER_multihashmap_get(service->egos, &hash);
+  return &(service->ego_store);
 }
 
-void
-update_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier,
-                    const struct GNUNET_IDENTITY_PrivateKey* key)
+struct GNUNET_MESSENGER_ContactStore*
+get_service_contact_store (struct GNUNET_MESSENGER_Service *service)
 {
-  GNUNET_assert((identifier) && (key));
-
-  struct GNUNET_HashCode hash;
-
-  GNUNET_CRYPTO_hash(identifier, strlen(identifier), &hash);
+  GNUNET_assert(service);
 
-  struct GNUNET_MESSENGER_Ego* ego = GNUNET_CONTAINER_multihashmap_get(service->egos, &hash);
-
-  if (!ego)
-  {
-    ego = GNUNET_new(struct GNUNET_MESSENGER_Ego);
-    GNUNET_CONTAINER_multihashmap_put(service->egos, &hash, ego, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-  }
-
-  GNUNET_memcpy(&(ego->priv), key, sizeof(*key));
-
-  if (GNUNET_OK != GNUNET_IDENTITY_key_get_public(key, &(ego->pub)))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating invalid ego key failed!\n");
+  return &(service->contact_store);
 }
 
 struct GNUNET_MESSENGER_SrvHandle*
 add_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
 {
+  GNUNET_assert((service) && (mq));
+
   struct GNUNET_MESSENGER_SrvHandle *handle = create_handle (service, mq);
 
   if (handle)
@@ -224,6 +168,8 @@ add_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_H
 void
 remove_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert((service) && (handle));
+
   if (!handle)
     return;
 
@@ -234,68 +180,16 @@ remove_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_M
 int
 get_service_peer_identity (const struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CRYPTO_get_peer_identity (service->config, peer);
-}
+  GNUNET_assert((service) && (peer));
 
-struct GNUNET_MESSENGER_SrvContact*
-get_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_IDENTITY_PublicKey *pubkey)
-{
-  struct GNUNET_HashCode hash;
-
-  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
-
-  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multihashmap_get (service->contacts, &hash);
-
-  if (contact)
-    return contact;
-
-  contact = create_contact (pubkey);
-
-  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->contacts, &hash, contact,
-                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    return contact;
-
-  destroy_contact (contact);
-  return NULL;
-}
-
-void
-swap_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvContact *contact,
-                                const struct GNUNET_IDENTITY_PublicKey *pubkey)
-{
-  const struct GNUNET_HashCode *hash = get_contact_id_from_key (contact);
-
-  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (service->contacts, hash, contact))
-  {
-    GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
-
-    hash = get_contact_id_from_key (contact);
-
-    GNUNET_CONTAINER_multihashmap_put (service->contacts, hash, contact,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-  }
-}
-
-struct GNUNET_ShortHashCode*
-generate_service_new_member_id (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
-{
-  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
-
-  if (room)
-  {
-    return generate_room_member_id (room);
-  }
-  else
-  {
-    struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
-    generate_free_member_id (random_id, NULL);
-    return random_id;
-  }
+  return GNUNET_CRYPTO_get_peer_identity (service->config, peer);
 }
 
 struct GNUNET_MESSENGER_SrvRoom*
-get_service_room (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
+get_service_room (const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((service) && (key));
+
   return GNUNET_CONTAINER_multihashmap_get (service->rooms, key);
 }
 
@@ -303,6 +197,8 @@ int
 open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
                    const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((service) && (handle) && (key));
+
   struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
 
   if (room)
@@ -310,8 +206,10 @@ open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSE
 
   room = create_room (handle, key);
 
-  if ((GNUNET_YES == open_room (room, handle)) && (GNUNET_OK
-      == GNUNET_CONTAINER_multihashmap_put (service->rooms, key, room, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  if ((GNUNET_YES == open_room (room, handle)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
+                                                       key, room,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
     return GNUNET_YES;
 
   destroy_room (room);
@@ -322,11 +220,13 @@ int
 entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
                     const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((service) && (handle) && (door) && (key));
+
   struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
 
   if (room)
   {
-    if (GNUNET_YES == entry_room_at (room, handle, door))
+    if (GNUNET_YES == enter_room_at (room, handle, door))
       return GNUNET_YES;
     else
       return GNUNET_NO;
@@ -334,8 +234,10 @@ entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESS
 
   room = create_room (handle, key);
 
-  if ((GNUNET_YES == entry_room_at (room, handle, door)) && (GNUNET_OK
-      == GNUNET_CONTAINER_multihashmap_put (service->rooms, key, room, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  if ((GNUNET_YES == enter_room_at (room, handle, door)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
+                                                       key, room,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
   {
     return GNUNET_YES;
   }
@@ -351,20 +253,14 @@ int
 close_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
                     const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((service) && (handle) && (key));
+
   struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
 
   if (!room)
     return GNUNET_NO;
 
-  struct GNUNET_MESSENGER_Message *message = create_message_leave ();
-
-  if (message)
-  {
-    struct GNUNET_HashCode hash;
-
-    send_room_message (room, handle, message, &hash);
-    destroy_message (message);
-  }
+  send_room_message (room, handle, create_message_leave ());
 
   const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, key);
 
@@ -393,124 +289,18 @@ close_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESS
   return GNUNET_YES;
 }
 
-static void
-get_room_data_subdir (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
-{
-  GNUNET_asprintf (dir, "%s%s%c%s%c", service->dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (&(room->key)), DIR_SEPARATOR);
-}
-
-void
-load_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room)
-{
-  char *room_dir;
-  get_room_data_subdir (service, room, &room_dir);
-
-  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
-  {
-    load_message_store (&room->store, room_dir);
-
-    char *config_file;
-    GNUNET_asprintf (&config_file, "%s%s", room_dir, "room.cfg");
-
-    struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
-
-    if ((GNUNET_YES == GNUNET_DISK_file_test (config_file)) && (GNUNET_OK
-        == GNUNET_CONFIGURATION_parse (cfg, config_file)))
-    {
-      unsigned long long access;
-
-      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "room", "access-rule", &access))
-        room->strict_access = (int) (access);
-
-      char *message_string;
-
-      if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "room", "last-message", &message_string)) && (message_string))
-      {
-        struct GNUNET_HashCode hash;
-
-        GNUNET_CRYPTO_hash_from_string(message_string, &hash);
-
-        const struct GNUNET_MESSENGER_Message *message = get_room_message (room, room->host, &hash, GNUNET_NO);
-
-        if (message)
-          update_room_last_messages (room, message, &hash);
-
-        GNUNET_free(message_string);
-      }
-    }
-
-    GNUNET_CONFIGURATION_destroy (cfg);
-
-    GNUNET_free(config_file);
-  }
-
-  GNUNET_free(room_dir);
-}
-
-void
-save_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room)
-{
-  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (service->rooms, &(room->key)))
-  {
-    return;
-  }
-
-  char *room_dir;
-  get_room_data_subdir (service, room, &room_dir);
-
-  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) || (GNUNET_OK
-      == GNUNET_DISK_directory_create (room_dir)))
-  {
-    save_message_store (&room->store, room_dir);
-
-    char *config_file;
-    GNUNET_asprintf (&config_file, "%s%s", room_dir, "room.cfg");
-
-    struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
-
-    GNUNET_CONFIGURATION_set_value_number (cfg, "room", "access-rule", room->strict_access);
-
-    if (room->last_messages.head)
-      GNUNET_CONFIGURATION_set_value_string (cfg, "room", "last-message",
-                                             GNUNET_h2s_full (&(room->last_messages.head->hash)));
-
-    GNUNET_CONFIGURATION_write (cfg, config_file);
-    GNUNET_CONFIGURATION_destroy (cfg);
-
-    GNUNET_free(config_file);
-  }
-
-  GNUNET_free(room_dir);
-}
-
 void
 handle_service_message (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_MemberSession *session,
                         const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
+  GNUNET_assert((service) && (room) && (session) && (message) && (hash));
 
-  const uint16_t length = get_message_size (message);
+  struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
 
   while (element)
   {
-    struct GNUNET_MESSENGER_SrvHandle *handle = (struct GNUNET_MESSENGER_SrvHandle*) element->handle;
-
-    if ((handle->mq) && (get_handle_member_id (handle, &(room->key))))
-    {
-      struct GNUNET_MESSENGER_RecvMessage *msg;
-      struct GNUNET_MQ_Envelope *env;
-
-      env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
-
-      GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
-      GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
-
-      char *buffer = ((char*) msg) + sizeof(*msg);
-      encode_message (message, length, buffer);
-
-      GNUNET_MQ_send (handle->mq, env);
-    }
-
+    notify_handle_message (element->handle, get_room_key(room), session, message, hash);
     element = element->next;
   }
 }
diff --git a/src/messenger/gnunet-service-messenger_service.h b/src/messenger/gnunet-service-messenger_service.h
index 246c74771..aa43fa457 100644
--- a/src/messenger/gnunet-service-messenger_service.h
+++ b/src/messenger/gnunet-service-messenger_service.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -33,13 +33,14 @@
 #include "gnunet_disk_lib.h"
 #include "gnunet_identity_service.h"
 
-#include "messenger_api_ego.h"
-
+#include "gnunet-service-messenger_ego_store.h"
 #include "gnunet-service-messenger_list_handles.h"
 
-#include "gnunet-service-messenger_contact.h"
+#include "messenger_api_contact_store.h"
 #include "gnunet-service-messenger_room.h"
 
+#include "gnunet-service-messenger_member_session.h"
+
 struct GNUNET_MESSENGER_Service
 {
   const struct GNUNET_CONFIGURATION_Handle *config;
@@ -50,21 +51,20 @@ struct GNUNET_MESSENGER_Service
   char *dir;
 
   struct GNUNET_CADET_Handle *cadet;
-  struct GNUNET_IDENTITY_Handle *identity;
 
-  struct GNUNET_CONTAINER_MultiHashMap *egos;
+  struct GNUNET_MESSENGER_EgoStore ego_store;
+  struct GNUNET_MESSENGER_ContactStore contact_store;
 
   struct GNUNET_MESSENGER_ListHandles handles;
 
-  struct GNUNET_CONTAINER_MultiHashMap *contacts;
   struct GNUNET_CONTAINER_MultiHashMap *rooms;
 };
 
 /**
  * Creates and allocates a new service using a given <i>config</i> and a GNUnet service handle.
  *
- * @param config Configuration
- * @param service_handle GNUnet service handle
+ * @param[in] config Configuration
+ * @param[in/out] service_handle GNUnet service handle
  * @return New service
  */
 struct GNUNET_MESSENGER_Service*
@@ -73,39 +73,34 @@ create_service (const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_
 /**
  * Destroys a <i>service</i> and frees its memory fully.
  *
- * @param service Service
+ * @param[in/out] service Service
  */
 void
 destroy_service (struct GNUNET_MESSENGER_Service *service);
 
 /**
- * Lookups an EGO which was registered to a <i>service</i> under
- * a specific <i>identifier</i>.
+ * Returns the used EGO-store of a given <i>service</i>.
  *
- * @param service Service
- * @param identifier Identifier string
- * @return EGO or NULL
+ * @param[in/out] service Service
+ * @return EGO-store
  */
-struct GNUNET_MESSENGER_Ego*
-lookup_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier);
+struct GNUNET_MESSENGER_EgoStore*
+get_service_ego_store (struct GNUNET_MESSENGER_Service *service);
 
 /**
- * Updates the registration of an EGO to a <i>service</i> under
- * a specific <i>identifier</i> with a new <i>key</i>.
+ * Returns the used contact store of a given <i>service</i>.
  *
- * @param service Service
- * @param identifier Identifier string
- * @param key Private EGO key
+ * @param[in/out] service Service
+ * @return Contact store
  */
-void
-update_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier,
-                    const struct GNUNET_IDENTITY_PrivateKey* key);
+struct GNUNET_MESSENGER_ContactStore*
+get_service_contact_store (struct GNUNET_MESSENGER_Service *service);
 
 /**
  * Creates and adds a new handle to a <i>service</i> using a given message queue.
  *
- * @param service Service
- * @param mq Message queue
+ * @param[in/out] service Service
+ * @param[in/out] mq Message queue
  * @return New handle
  */
 struct GNUNET_MESSENGER_SrvHandle*
@@ -114,77 +109,42 @@ add_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_H
 /**
  * Removes a <i>handle</i> from a <i>service</i> and destroys it.
  *
- * @param service Service
- * @param handle Handle
+ * @param[in/out] service Service
+ * @param[in/out] handle Handle
  */
 void
 remove_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle);
 
 /**
  * Tries to write the peer identity of the peer running a <i>service</i> on to the <i>peer</i>
- * parameter. The functions returns GNUNET_OK on success, otherwise GNUNET_SYSERR.
+ * parameter. The functions returns #GNUNET_OK on success, otherwise #GNUNET_SYSERR.
  *
- * @param service Service
+ * @param[in] service Service
  * @param[out] peer Peer identity
- * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
  */
 int
 get_service_peer_identity (const struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer);
 
 /**
- * Returns a contact of a <i>service</i> identified by a given public key. If no matching contact exists,
- * it will tried to create one with the specific public key. If the function still fails to do so,
- * NULL gets returned.
- *
- * @param service Service
- * @param pubkey Public key of EGO
- * @return Contact
- */
-struct GNUNET_MESSENGER_SrvContact*
-get_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_IDENTITY_PublicKey *pubkey);
-
-/**
- * Changes the public key for a <i>contact</i> known to a <i>service</i> to a specific public key and
- * updates local map entries to access the contact by its updated key.
- *
- * @param service Service
- * @param contact Contact
- * @param pubkey Public key of EGO
- */
-void
-swap_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvContact *contact,
-                                const struct GNUNET_IDENTITY_PublicKey *pubkey);
-
-/**
- * Tries to generate and allocate a new unique member id for a given room of a service identified by its <i>key</i>.
- * If the generation fails caused by too many tries of duplicates, it returns NULL.
- *
- * @param service Service
- * @param key Key of room
- * @return Newly generated member id or NULL
- */
-struct GNUNET_ShortHashCode*
-generate_service_new_member_id (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key);
-
-/**
  * Returns the room identified by a given <i>key</i> for a <i>service</i>. If the service doesn't know any room
  * using the given key, NULL gets returned.
  *
- * @param service Service
- * @param key Key of room
+ * @param[in] service Service
+ * @param[in] key Key of room
  * @return Room or NULL
  */
 struct GNUNET_MESSENGER_SrvRoom*
-get_service_room (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key);
+get_service_room (const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key);
 
 /**
  * Tries to open a room using a given <i>key</i> for a <i>service</i> by a specific <i>handle</i>. The room will be
- * created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.
+ * created if necessary. If the function is successful, it returns #GNUNET_YES, otherwise #GNUNET_NO.
  *
- * @param service Service
- * @param handle Handle
- * @param key Key of room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] service Service
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
@@ -192,16 +152,16 @@ open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSE
 
 /**
  * Tries to enter a room using a given <i>key</i> for a <i>service</i> by a specific <i>handle</i>. The room will
- * be created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.
+ * be created if necessary. If the function is successful, it returns #GNUNET_YES, otherwise #GNUNET_NO.
  *
  * The room will be entered through the peer identitied by the peer identity provided as <i>door</i> parameter and
  * a new connection will be made.
  *
- * @param service Service
- * @param handle Handle
- * @param door Peer identity
- * @param key Key of room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] service Service
+ * @param[in/out] handle Handle
+ * @param[in] door Peer identity
+ * @param[in] key Key of room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
@@ -209,51 +169,33 @@ entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESS
 
 /**
  * Tries to close a room using a given <i>key</i> for a <i>service</i> by a specific <i>handle</i>. The room will
- * be created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.
+ * be created if necessary. If the function is successful, it returns #GNUNET_YES, otherwise #GNUNET_NO.
  *
  * If the specific handle is currently the host of the room for this service, a new handle which is a member will
  * take its place. Otherwise the room will be destroyed for this service.
  *
- * @param service Service
- * @param handle Handle
- * @param key Key of room
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] service Service
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 close_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
                     const struct GNUNET_HashCode *key);
 
 /**
- * Loads the local configuration for a given <i>room</i> of a <i>service</i> which contains the last messages hash
- * and the ruleset for general access of new members.
- *
- * @param service Service
- * @param room Room
- */
-void
-load_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room);
-
-/**
- * Saves the configuration for a given <i>room</i> of a <i>service</i> which contains the last messages hash
- * and the ruleset for general access of new members locally.
- *
- * @param service Service
- * @param room Room
- */
-void
-save_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room);
-
-/**
  * Sends a received or sent <i>message</i> with a given <i>hash</i> to each handle of a <i>service</i> which
  * is currently member of a specific <i>room</i> for handling it in the client API.
  *
- * @param service Service
- * @param room Room
- * @param message Message
- * @param hash Hash of message
+ * @param[in/out] service Service
+ * @param[in/out] room Room
+ * @param[in] session Member session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
  */
 void
 handle_service_message (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_MemberSession *session,
                         const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
 
 #endif //GNUNET_SERVICE_MESSENGER_SERVICE_H
diff --git a/src/messenger/gnunet-service-messenger_tunnel.c b/src/messenger/gnunet-service-messenger_tunnel.c
index df9e5c4c7..80d8dfa5e 100644
--- a/src/messenger/gnunet-service-messenger_tunnel.c
+++ b/src/messenger/gnunet-service-messenger_tunnel.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -26,7 +26,11 @@
 #include "gnunet-service-messenger_tunnel.h"
 
 #include "gnunet-service-messenger_handle.h"
-#include "gnunet-service-messenger_util.h"
+#include "gnunet-service-messenger_message_recv.h"
+#include "gnunet-service-messenger_message_store.h"
+#include "gnunet-service-messenger_operation_store.h"
+#include "gnunet-service-messenger_operation.h"
+#include "messenger_api_util.h"
 
 struct GNUNET_MESSENGER_SrvTunnel*
 create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *door)
@@ -39,10 +43,12 @@ create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerId
   tunnel->channel = NULL;
 
   tunnel->peer = GNUNET_PEER_intern (door);
-  tunnel->contact_id = NULL;
+
+  tunnel->messenger_version = 0;
 
   tunnel->peer_message = NULL;
-  tunnel->last_message = NULL;
+
+  init_message_state(&(tunnel->state));
 
   return tunnel;
 }
@@ -57,34 +63,23 @@ destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 
   GNUNET_PEER_change_rc (tunnel->peer, -1);
 
-  if (tunnel->contact_id)
-    GNUNET_free(tunnel->contact_id);
-
   if (tunnel->peer_message)
     GNUNET_free(tunnel->peer_message);
 
-  if (tunnel->last_message)
-    GNUNET_free(tunnel->last_message);
+  clear_message_state(&(tunnel->state));
 
   GNUNET_free(tunnel);
 }
 
-int
+void
 bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel)
 {
   GNUNET_assert(tunnel);
 
   if (tunnel->channel)
-  {
-    if (tunnel->contact_id)
-      return GNUNET_NO;
-
     delayed_disconnect_channel (tunnel->channel);
-  }
 
   tunnel->channel = channel;
-
-  return GNUNET_YES;
 }
 
 extern void
@@ -113,52 +108,57 @@ check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
   struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
   if (!tunnel)
-    return GNUNET_NO;
+    return GNUNET_SYSERR;
 
   const uint16_t length = ntohs (header->size) - sizeof(*header);
   const char *buffer = (const char*) &header[1];
 
   struct GNUNET_MESSENGER_Message message;
 
-  if (length < sizeof(message.header))
-    return GNUNET_NO;
-
-  if (GNUNET_YES != decode_message (&message, length, buffer))
-    return GNUNET_NO;
-
-  struct GNUNET_HashCode hash;
-  hash_message (length, buffer, &hash);
+  if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Message too short! (%d)\n", length);
+    return GNUNET_SYSERR;
+  }
 
-  int result = callback_verify_room_message (tunnel->room, cls, &message, &hash);
+  uint16_t padding = 0;
 
-  if (GNUNET_MESSENGER_KIND_PEER == message.header.kind)
+  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, &padding))
   {
-    struct GNUNET_PeerIdentity identity;
-
-    GNUNET_PEER_resolve (tunnel->peer, &identity);
-
-    if (0 == GNUNET_memcmp(&(message.body.peer.peer), &(identity)))
-    {
-      if (tunnel->contact_id)
-      {
-        if (0 != GNUNET_memcmp(tunnel->contact_id, &(message.header.sender_id)))
-          result = GNUNET_SYSERR;
-      }
-      else
-      {
-        tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
-
-        GNUNET_memcpy(tunnel->contact_id, &(message.header.sender_id), sizeof(struct GNUNET_ShortHashCode));
-      }
-    }
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
+    return GNUNET_SYSERR;
   }
 
-  return (result == GNUNET_YES ? GNUNET_OK : GNUNET_NO);
+  struct GNUNET_HashCode hash;
+  hash_message (&message, length - padding, buffer, &hash);
+
+  return callback_verify_room_message (tunnel->room, cls, &message, &hash);
 }
 
+extern int
+update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
 extern void
-callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message,
-                    const struct GNUNET_HashCode *hash);
+callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                              const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+static void
+update_tunnel_last_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(tunnel->room);
+
+  const int requested = (GNUNET_MESSENGER_OP_REQUEST == get_store_operation_type(operation_store, hash)?
+      GNUNET_YES : GNUNET_NO
+  );
+
+  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(tunnel->room);
+
+  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, hash);
+
+  if (message)
+    update_message_state(&(tunnel->state), requested, message, hash);
+}
 
 void
 handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
@@ -171,19 +171,50 @@ handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
   struct GNUNET_MESSENGER_Message message;
   struct GNUNET_HashCode hash;
 
-  decode_message (&message, length, buffer);
-  hash_message (length, buffer, &hash);
+  uint16_t padding = 0;
 
-  if (tunnel)
-  {
-    if (!tunnel->last_message)
-      tunnel->last_message = GNUNET_new(struct GNUNET_HashCode);
+  decode_message (&message, length, buffer, GNUNET_YES, &padding);
+  hash_message (&message, length - padding, buffer, &hash);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
+             GNUNET_MESSENGER_name_of_kind(message.header.kind));
+
+  if (!tunnel)
+    return;
+
+  const int new_message = update_room_message (
+      tunnel->room, copy_message (&message), &hash
+  );
+
+  if (GNUNET_YES != new_message)
+    goto receive_done;
 
-    GNUNET_memcpy(tunnel->last_message, &hash, sizeof(struct GNUNET_HashCode));
+  update_tunnel_last_message (tunnel, &hash);
 
-    callback_room_recv (tunnel->room, cls, copy_message (&message), &hash);
+  int forward_message = GNUNET_YES;
+
+  switch (message.header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    forward_message = recv_message_info (tunnel->room, tunnel, &message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    forward_message = recv_message_peer (tunnel->room, tunnel, &message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    forward_message = recv_message_request (tunnel->room, tunnel, &message, &hash);
+    break;
+  default:
+    break;
   }
 
+  if (GNUNET_YES == forward_message)
+  {
+    forward_room_message (tunnel->room, tunnel, &message, &hash);
+    callback_room_handle_message (tunnel->room, NULL, &message, &hash);
+  }
+
+receive_done:
   GNUNET_CADET_receive_done (tunnel->channel);
 }
 
@@ -198,7 +229,7 @@ connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
   const struct GNUNET_PeerIdentity *door = GNUNET_PEER_resolve2 (tunnel->peer);
 
   struct GNUNET_CADET_Handle *cadet = get_room_cadet (tunnel->room);
-  struct GNUNET_HashCode *key = get_room_key (tunnel->room);
+  const struct GNUNET_HashCode *key = get_room_key (tunnel->room);
 
   struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
                                                                        struct GNUNET_MessageHeader, NULL),
@@ -212,6 +243,8 @@ connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 void
 disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 {
+  GNUNET_assert(tunnel);
+
   if (tunnel->channel)
   {
     delayed_disconnect_channel (tunnel->channel);
@@ -223,6 +256,8 @@ disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 int
 is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 {
+  GNUNET_assert(tunnel);
+
   return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
 }
 
@@ -232,30 +267,23 @@ struct GNUNET_MESSENGER_MessageSent
   struct GNUNET_HashCode hash;
 };
 
-extern void
-callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
-                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
-
 static void
 callback_tunnel_sent (void *cls)
 {
   struct GNUNET_MESSENGER_MessageSent *sent = cls;
 
   if (sent->tunnel)
-  {
-    if (!sent->tunnel->last_message)
-      sent->tunnel->last_message = GNUNET_new(struct GNUNET_HashCode);
-
-    GNUNET_memcpy(sent->tunnel->last_message, &(sent->hash), sizeof(struct GNUNET_HashCode));
-  }
+    update_tunnel_last_message (sent->tunnel, &(sent->hash));
 
   GNUNET_free(sent);
 }
 
 void
-send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MQ_Envelope *env,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env,
+                      const struct GNUNET_HashCode *hash)
 {
+  GNUNET_assert((tunnel) && (env) && (hash));
+
   struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (tunnel->channel);
 
   struct GNUNET_MESSENGER_MessageSent *sent = GNUNET_new(struct GNUNET_MESSENGER_MessageSent);
@@ -266,35 +294,88 @@ send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, s
 
   GNUNET_MQ_notify_sent (env, callback_tunnel_sent, sent);
   GNUNET_MQ_send (mq, env);
-
-  callback_room_sent (tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle, tunnel, message, hash);
 }
 
-void
-send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message,
-                     struct GNUNET_HashCode *hash)
+int
+send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message)
 {
-  struct GNUNET_MQ_Envelope *env = pack_room_message (tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
-                                                      message, hash,
-                                                      GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+  GNUNET_assert((tunnel) && (handle));
+
+  if (!message)
+    return GNUNET_NO;
+
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MQ_Envelope *env = pack_room_message (
+      tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
+      message, &hash, GNUNET_MESSENGER_PACK_MODE_ENVELOPE
+  );
+
+  destroy_message(message);
+
+  if (!env)
+    return GNUNET_NO;
 
-  if (env)
-    send_tunnel_envelope (tunnel, handle, env, copy_message (message), hash);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
+             GNUNET_h2s(&hash));
+
+  send_tunnel_envelope (tunnel, env, &hash);
+  return GNUNET_YES;
 }
 
 void
 forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message,
                         const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_Message *clone = copy_message (message);
-  struct GNUNET_MQ_Envelope *env = pack_message (clone, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+  GNUNET_assert((tunnel) && (message) && (hash));
+
+  struct GNUNET_MESSENGER_Message *copy = copy_message(message);
+  struct GNUNET_MQ_Envelope *env = pack_message (copy, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+
+  destroy_message(copy);
+
+  if (!env)
+    return;
 
-  if (env)
-    send_tunnel_envelope (tunnel, NULL, env, clone, hash);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
+             GNUNET_h2s(hash));
+
+  send_tunnel_envelope (tunnel, env, hash);
 }
 
 const struct GNUNET_HashCode*
 get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 {
+  GNUNET_assert(tunnel);
+
   return tunnel->peer_message;
 }
+
+void
+get_tunnel_peer_identity (const struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_PeerIdentity *peer)
+{
+  GNUNET_assert(tunnel);
+
+  GNUNET_PEER_resolve(tunnel->peer, peer);
+}
+
+uint32_t
+get_tunnel_messenger_version (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  GNUNET_assert(tunnel);
+
+  return tunnel->messenger_version;
+}
+
+int
+update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel, uint32_t version)
+{
+  GNUNET_assert(tunnel);
+
+  if (version != GNUNET_MESSENGER_VERSION)
+    return GNUNET_SYSERR;
+
+  if (version > tunnel->messenger_version)
+    tunnel->messenger_version = version;
+
+  return GNUNET_OK;
+}
diff --git a/src/messenger/gnunet-service-messenger_tunnel.h b/src/messenger/gnunet-service-messenger_tunnel.h
index e6efb226d..96d98546d 100644
--- a/src/messenger/gnunet-service-messenger_tunnel.h
+++ b/src/messenger/gnunet-service-messenger_tunnel.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -32,6 +32,7 @@
 #include "gnunet_crypto_lib.h"
 
 #include "gnunet-service-messenger_room.h"
+#include "gnunet-service-messenger_message_state.h"
 
 struct GNUNET_MESSENGER_SrvTunnel
 {
@@ -39,17 +40,18 @@ struct GNUNET_MESSENGER_SrvTunnel
   struct GNUNET_CADET_Channel *channel;
 
   GNUNET_PEER_Id peer;
-  struct GNUNET_ShortHashCode *contact_id;
+
+  uint32_t messenger_version;
 
   struct GNUNET_HashCode *peer_message;
-  struct GNUNET_HashCode *last_message;
+  struct GNUNET_MESSENGER_MessageState state;
 };
 
 /**
- * Creates and allocates a tunnel of a <i>room</i> to a specific peer identity.
+ * Creates and allocates a tunnel of a <i>room</i> to a specific peer identity (called <i>door</i>).
  *
- * @param room Room
- * @param door Peer identity
+ * @param[in/out] room Room
+ * @param[in] door Peer identity
  * @return New tunnel
  */
 struct GNUNET_MESSENGER_SrvTunnel*
@@ -58,28 +60,27 @@ create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerId
 /**
  * Destroys a <i>tunnel</i> and frees its memory fully.
  *
- * @param tunnel
+ * @param[in/out] tunnel
  */
 void
 destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
 
 /**
- * Binds a CADET <i>channel</i> to a <i>tunnel</i> on returns GNUNET_YES only if
- * the bounds channel was replaced successfully, otherwise GNUNET_NO gets returned.
+ * Binds a CADET <i>channel</i> to a <i>tunnel</i> and replaces its channel
+ * the tunnel is currently bound to if necessary.
  *
- * @param tunnel Tunnel
- * @param channel CADET channel
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] tunnel Tunnel
+ * @param[in/out] channel CADET channel
  */
-int
+void
 bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel);
 
 /**
  * Tries to connect a <i>tunnel</i> by creating a new CADET channel and binding it.
- * The function returns GNUNET_YES on success, otherwise GNUNET_NO.
+ * The function returns #GNUNET_YES on success, otherwise #GNUNET_NO.
  *
- * @param tunnel Tunnel
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] tunnel Tunnel
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
@@ -88,7 +89,7 @@ connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
  * Disconnects and unbinds a channel from a <i>tunnel</i>. The actual disconnection
  * will be asynchronous.
  *
- * @param tunnel Tunnel
+ * @param[in/out] tunnel Tunnel
  */
 void
 disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
@@ -96,46 +97,43 @@ disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
 /**
  * Returns the status of a currently bound channel of a <i>tunnel</i>.
  *
- * @param tunnel Tunnel
- * @return GNUNET_YES or GNUNET_NO
+ * @param[in] tunnel Tunnel
+ * @return #GNUNET_YES or #GNUNET_NO
  */
 int
 is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel);
 
 /**
  * Sends an envelope containing a <i>message</i> with a given <i>hash</i> through
- * a <i>tunnel</i> by a given <i>handle</i>.
+ * a <i>tunnel</i>.
  *
- * @param tunnel Tunnel
- * @param handle Handle
- * @param env Envelope
- * @param message Message
- * @param hash Hash of message
+ * @param[in/out] tunnel Tunnel
+ * @param[in/out] env Envelope
+ * @param[in] hash Hash of message
  */
 void
-send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MQ_Envelope *env,
-                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env,
+                      const struct GNUNET_HashCode *hash);
 
 /**
  * Sends a <i>message</i> by packing it automatically into an envelope and passing it
  * through the <i>tunnel</i>. The used <i>handle</i> will sign the message and
  * the <i>hash</i> will be calculated and stored.
  *
- * @param tunnel Tunnel
- * @param handle Handle
- * @param[out] message Message
- * @param[out] hash Hash of message
+ * @param[in/out] tunnel Tunnel
+ * @param[in/out] handle Handle
+ * @param[in/out] message Message
+ * @return #GNUNET_YES on success, GNUNET_NO otherwise
  */
-void
-send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message,
-                     struct GNUNET_HashCode *hash);
+int
+send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message);
 
 /**
  * Forwards a given <i>message</i> with a known <i>hash</i> through a <i>tunnel</i>.
  *
- * @param tunnel Tunnel
- * @param message Message
- * @param hash Hash of message
+ * @param[in/out] tunnel Tunnel
+ * @param[in] message Message
+ * @param[in] hash Hash of message
  */
 void
 forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message,
@@ -146,10 +144,43 @@ forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct
  * and matching the tunnels peer identity. If no peer message has been linked to the tunnel
  * yet, NULL gets returned.
  *
- * @param tunnel Tunnel
+ * @param[in] tunnel Tunnel
  * @return Hash of peer message or NULL
  */
 const struct GNUNET_HashCode*
 get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel);
 
+/**
+ * Writes the peer identity of the peer connected via <i>tunnel</i> to this peer into
+ * the <i>peer</i> parameter.
+ *
+ * @param[in] tunnel Tunnel
+ * @param[out] peer Peer identity
+ */
+void
+get_tunnel_peer_identity (const struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Returns the current messenger version the peer connected via a given <i>tunnel</i>
+ * has reported to be using if it was compatible during updating.
+ *
+ * @see update_tunnel_messenger_version
+ *
+ * @param[in] tunnel Tunnel
+ * @return Version of messenger
+ */
+uint32_t
+get_tunnel_messenger_version (const struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Updates the messenger version of the <i>tunnel</i> to a given <i>version</i> if
+ * it is compatible to the running peer of the service. Depending on success it
+ * returns #GNUNET_OK or #GNUNET_SYSERR on failure.
+ *
+ * @param[in/out] tunnel Tunnel
+ * @param[in] version Version of messenger
+ */
+int
+update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel, uint32_t version);
+
 #endif //GNUNET_SERVICE_MESSENGER_TUNNEL_H
diff --git a/src/messenger/messenger_api.c b/src/messenger/messenger_api.c
index 6401b18d7..b42bb40cc 100644
--- a/src/messenger/messenger_api.c
+++ b/src/messenger/messenger_api.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -29,6 +29,7 @@
 
 #include "messenger_api_handle.h"
 #include "messenger_api_message.h"
+#include "messenger_api_util.h"
 
 const char*
 GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
@@ -61,6 +62,8 @@ GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
     return "TEXT";
   case GNUNET_MESSENGER_KIND_FILE:
     return "FILE";
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    return "PRIVATE";
   default:
     return "UNKNOWN";
   }
@@ -82,7 +85,25 @@ handle_get_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set name of handle: %s\n", name);
 
-  set_handle_name (handle, strlen(name) > 0? name : NULL);
+  set_handle_name (handle, strlen (name) > 0 ? name : NULL);
+}
+
+static int
+check_get_key (void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size);
+
+  if (full_length < sizeof(*msg))
+    return GNUNET_NO;
+
+  const uint16_t length = full_length - sizeof(*msg);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_IDENTITY_PublicKey pubkey;
+  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
+    return GNUNET_NO;
+
+  return GNUNET_OK;
 }
 
 static void
@@ -90,11 +111,18 @@ handle_get_key (void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
 {
   struct GNUNET_MESSENGER_Handle *handle = cls;
 
-  const struct GNUNET_IDENTITY_PublicKey *pubkey = &(msg->pubkey);
+  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_IDENTITY_PublicKey pubkey;
+  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
+    return;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set key of handle: %s\n", GNUNET_IDENTITY_public_key_to_string (pubkey));
+  char* str = GNUNET_IDENTITY_public_key_to_string (&pubkey);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set key of handle: %s\n", str);
+  GNUNET_free(str);
 
-  set_handle_key (handle, pubkey);
+  set_handle_key (handle, &pubkey);
 
   if (handle->identity_callback)
     handle->identity_callback (handle->identity_cls, handle);
@@ -161,20 +189,20 @@ handle_room_close (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 static int
 check_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
 {
-  const uint16_t full_length = ntohs (msg->header.size) - sizeof(msg->header);
+  const uint16_t full_length = ntohs (msg->header.size);
 
-  if (full_length < sizeof(msg->hash))
+  if (full_length < sizeof(*msg))
     return GNUNET_NO;
 
-  const uint16_t length = full_length - sizeof(msg->hash);
+  const uint16_t length = full_length - sizeof(*msg);
   const char *buffer = ((const char*) msg) + sizeof(*msg);
 
   struct GNUNET_MESSENGER_Message message;
 
-  if (length < sizeof(message.header))
+  if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN))
     return GNUNET_NO;
 
-  if (GNUNET_YES != decode_message (&message, length, buffer))
+  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
     return GNUNET_NO;
 
   return GNUNET_OK;
@@ -186,14 +214,18 @@ handle_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
   struct GNUNET_MESSENGER_Handle *handle = cls;
 
   const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *sender = &(msg->sender);
+  const struct GNUNET_HashCode *context = &(msg->context);
   const struct GNUNET_HashCode *hash = &(msg->hash);
-
-  const char *buffer = ((const char*) msg) + sizeof(*msg);
+  const enum GNUNET_MESSENGER_MessageFlags flags = (
+      (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
+  );
 
   const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
 
   struct GNUNET_MESSENGER_Message message;
-  decode_message (&message, length, buffer);
+  decode_message (&message, length, buffer, GNUNET_YES, NULL);
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n", GNUNET_MESSENGER_name_of_kind (message.header.kind));
 
@@ -201,13 +233,22 @@ handle_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
 
   if (room)
   {
-    handle_room_message (room, &message, hash);
+    struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store(handle);
+
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Raw contact from sender and context: (%s : %s)\n",
+               GNUNET_h2s(sender), GNUNET_h2s_full(context));
+
+    struct GNUNET_MESSENGER_Contact *contact = get_store_contact_raw(
+        store, context, sender
+    );
+
+    handle_room_message (room, contact, &message, hash);
 
     if (handle->msg_callback)
-      handle->msg_callback (handle->msg_cls, room, &message, hash);
+      handle->msg_callback (handle->msg_cls, room, contact, &message, hash, flags);
   }
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MESSENGER ERROR: Room not found\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Room not found\n");
 }
 
 static void
@@ -220,12 +261,12 @@ send_open_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_
   struct GNUNET_MQ_Envelope *env;
 
   env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
-  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
   GNUNET_MQ_send (handle->mq, env);
 }
 
 static void
-send_entry_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room,
+send_enter_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room,
                  const struct GNUNET_PeerIdentity *door)
 {
   struct GNUNET_MESSENGER_RoomMessage *msg;
@@ -233,7 +274,7 @@ send_entry_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER
 
   env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
   GNUNET_memcpy(&(msg->door), door, sizeof(*door));
-  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
   GNUNET_MQ_send (handle->mq, env);
 }
 
@@ -244,7 +285,7 @@ send_close_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER
   struct GNUNET_MQ_Envelope *env;
 
   env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
-  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
   GNUNET_MQ_send (handle->mq, env);
 }
 
@@ -265,7 +306,7 @@ iterate_reset_room (void *cls, const struct GNUNET_HashCode *key, void *value)
   {
     GNUNET_PEER_resolve (entry->peer, &door);
 
-    send_entry_room (handle, room, &door);
+    send_enter_room (handle, room, &door);
 
     entry = entry->next;
   }
@@ -303,7 +344,7 @@ callback_mq_error (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_MESSENGER_Handle *handle = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
 
   GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_close_room, handle);
 
@@ -319,36 +360,45 @@ callback_mq_error (void *cls, enum GNUNET_MQ_Error error)
 static void
 reconnect (struct GNUNET_MESSENGER_Handle *handle)
 {
-  const struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(
-      get_name, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME, struct GNUNET_MESSENGER_NameMessage, handle),
-                                                       GNUNET_MQ_hd_fixed_size(
-                                                           get_key, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY,
-                                                           struct GNUNET_MESSENGER_KeyMessage, handle),
-                                                       GNUNET_MQ_hd_fixed_size(
-                                                           member_id,
-                                                           GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
-                                                           struct GNUNET_MESSENGER_MemberMessage, handle),
-                                                       GNUNET_MQ_hd_fixed_size(room_open,
-                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
-                                                                               struct GNUNET_MESSENGER_RoomMessage,
-                                                                               handle),
-                                                       GNUNET_MQ_hd_fixed_size(room_entry,
-                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
-                                                                               struct GNUNET_MESSENGER_RoomMessage,
-                                                                               handle),
-                                                       GNUNET_MQ_hd_fixed_size(room_close,
-                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
-                                                                               struct GNUNET_MESSENGER_RoomMessage,
-                                                                               handle),
-                                                       GNUNET_MQ_hd_var_size(
-                                                           recv_message,
-                                                           GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
-                                                           struct GNUNET_MESSENGER_RecvMessage, handle),
-                                                       GNUNET_MQ_handler_end() };
-
-  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
-  GNUNET_MESSENGER_SERVICE_NAME,
-                                      handlers, &callback_mq_error, handle);
+  const struct GNUNET_MQ_MessageHandler handlers[] =
+  {
+   GNUNET_MQ_hd_var_size(
+        get_name, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME,
+        struct GNUNET_MESSENGER_NameMessage, handle
+   ),
+   GNUNET_MQ_hd_var_size(
+       get_key, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY,
+       struct GNUNET_MESSENGER_KeyMessage, handle
+   ),
+   GNUNET_MQ_hd_fixed_size(
+       member_id,
+       GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
+       struct GNUNET_MESSENGER_MemberMessage, handle
+   ),
+   GNUNET_MQ_hd_fixed_size(
+       room_open,
+       GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
+       struct GNUNET_MESSENGER_RoomMessage, handle
+   ),
+   GNUNET_MQ_hd_fixed_size(
+       room_entry,
+       GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
+       struct GNUNET_MESSENGER_RoomMessage, handle
+   ),
+   GNUNET_MQ_hd_fixed_size(
+       room_close,
+       GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
+       struct GNUNET_MESSENGER_RoomMessage, handle
+   ),
+   GNUNET_MQ_hd_var_size(
+       recv_message,
+       GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
+       struct GNUNET_MESSENGER_RecvMessage, handle
+   ),
+   GNUNET_MQ_handler_end()
+  };
+
+  handle->mq = GNUNET_CLIENT_connect (handle->cfg, GNUNET_MESSENGER_SERVICE_NAME, handlers, &callback_mq_error, handle);
 }
 
 struct GNUNET_MESSENGER_Handle*
@@ -389,7 +439,7 @@ GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const c
 int
 GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle)
 {
-  if ((!handle) || (!get_handle_name(handle)))
+  if ((!handle) || (!get_handle_name (handle)))
     return GNUNET_SYSERR;
 
   struct GNUNET_MESSENGER_UpdateMessage *msg;
@@ -448,18 +498,30 @@ GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *n
   return GNUNET_YES;
 }
 
+static const struct GNUNET_IDENTITY_PublicKey*
+get_non_anonymous_key (const struct GNUNET_IDENTITY_PublicKey* public_key)
+{
+  if (0 == GNUNET_memcmp(public_key, get_anonymous_public_key()))
+    return NULL;
+
+  return public_key;
+}
+
 const struct GNUNET_IDENTITY_PublicKey*
 GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
 {
   if (!handle)
     return NULL;
 
-  return get_handle_key (handle);
+  return get_non_anonymous_key (get_handle_key (handle));
 }
 
 struct GNUNET_MESSENGER_Room*
 GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 {
+  if ((!handle) || (!key))
+    return NULL;
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
   if (!room)
@@ -479,9 +541,12 @@ GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct
 }
 
 struct GNUNET_MESSENGER_Room*
-GNUNET_MESSENGER_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
+GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
                              const struct GNUNET_HashCode *key)
 {
+  if ((!handle) || (!door) || (!key))
+    return NULL;
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
   if (!room)
@@ -496,20 +561,26 @@ GNUNET_MESSENGER_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struc
     }
   }
 
-  send_entry_room (handle, room, door);
+  send_enter_room (handle, room, door);
   return room;
 }
 
 void
 GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
 {
+  if (!room)
+    return;
+
   send_close_room (room->handle, room);
 }
 
 struct GNUNET_MESSENGER_Contact*
-GNUNET_MESSENGER_get_member (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id)
+GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 {
-  return GNUNET_CONTAINER_multishortmap_get (room->members, id);
+  if ((!room) || (!hash))
+    return NULL;
+
+  return get_room_sender(room, hash);
 }
 
 const char*
@@ -527,23 +598,73 @@ GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact
   if (!contact)
     return NULL;
 
-  return get_contact_key (contact);
+  return get_non_anonymous_key (get_contact_key (contact));
 }
 
 void
-GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message)
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_MESSENGER_Contact *contact)
 {
-  const uint16_t length = get_message_size (message);
+  if ((!room) || (!message))
+    return;
+
+  switch (filter_message_sending (message))
+  {
+  case GNUNET_SYSERR:
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message aborted: This kind of message is reserved for the service!\n");
+    return;
+  case GNUNET_NO:
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: This kind of message could cause issues!\n");
+    return;
+  default:
+    break;
+  }
+
+  ssize_t key_length = 0;
+
+  if (contact)
+  {
+    const struct GNUNET_IDENTITY_PublicKey *public_key = get_non_anonymous_key (
+        get_contact_key(contact)
+    );
+
+    if (public_key)
+      key_length = GNUNET_IDENTITY_key_get_length(public_key);
+    else
+      key_length = -1;
+  }
+
+  if (key_length < 0)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: Invalid key!\n");
+    return;
+  }
+
+  const uint16_t msg_length = get_message_size (message, GNUNET_NO);
 
   struct GNUNET_MESSENGER_SendMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE);
+  const uint16_t length = (uint16_t) key_length + msg_length;
+
+  env = GNUNET_MQ_msg_extra(
+      msg, length,
+      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
+  );
 
-  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
+
+  msg->flags = (uint32_t) (
+      contact? GNUNET_MESSENGER_FLAG_PRIVATE : GNUNET_MESSENGER_FLAG_NONE
+  );
 
   char *buffer = ((char*) msg) + sizeof(*msg);
-  encode_message (message, length, buffer);
+  char *msg_buffer = buffer + key_length;
+
+  if (key_length > 0)
+    GNUNET_IDENTITY_write_key_to_buffer(get_contact_key(contact), buffer, key_length);
+
+  encode_message (message, msg_length, msg_buffer, GNUNET_NO);
 
   GNUNET_MQ_send (room->handle->mq, env);
 }
@@ -551,18 +672,31 @@ GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct
 const struct GNUNET_MESSENGER_Message*
 GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 {
+  if ((!room) || (!hash))
+    return NULL;
+
   const struct GNUNET_MESSENGER_Message *message = get_room_message (room, hash);
 
   if (!message)
   {
-    struct GNUNET_MESSENGER_RecvMessage *msg;
+    struct GNUNET_MESSENGER_GetMessage *msg;
     struct GNUNET_MQ_Envelope *env;
 
     env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
-    GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+    GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
     GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
     GNUNET_MQ_send (room->handle->mq, env);
   }
 
   return message;
 }
+
+int
+GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback,
+                                  void* cls)
+{
+  if (!room)
+    return GNUNET_SYSERR;
+
+  return iterate_room_members(room, callback, cls);
+}
diff --git a/src/messenger/messenger_api_contact.c b/src/messenger/messenger_api_contact.c
index 9a242aa00..04e1f60c1 100644
--- a/src/messenger/messenger_api_contact.c
+++ b/src/messenger/messenger_api_contact.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -28,9 +28,12 @@
 struct GNUNET_MESSENGER_Contact*
 create_contact (const struct GNUNET_IDENTITY_PublicKey *key)
 {
+  GNUNET_assert(key);
+
   struct GNUNET_MESSENGER_Contact *contact = GNUNET_new(struct GNUNET_MESSENGER_Contact);
 
   contact->name = NULL;
+  contact->rc = 0;
 
   GNUNET_memcpy(&(contact->public_key), key, sizeof(contact->public_key));
 
@@ -40,6 +43,8 @@ create_contact (const struct GNUNET_IDENTITY_PublicKey *key)
 void
 destroy_contact (struct GNUNET_MESSENGER_Contact *contact)
 {
+  GNUNET_assert(contact);
+
   if (contact->name)
     GNUNET_free(contact->name);
 
@@ -49,30 +54,55 @@ destroy_contact (struct GNUNET_MESSENGER_Contact *contact)
 const char*
 get_contact_name (const struct GNUNET_MESSENGER_Contact *contact)
 {
+  GNUNET_assert(contact);
+
   return contact->name;
 }
 
 void
 set_contact_name (struct GNUNET_MESSENGER_Contact *contact, const char *name)
 {
+  GNUNET_assert(contact);
+
   if (contact->name)
     GNUNET_free(contact->name);
 
-  contact->name = name? GNUNET_strdup(name) : NULL;
+  contact->name = name ? GNUNET_strdup(name) : NULL;
 }
 
 const struct GNUNET_IDENTITY_PublicKey*
 get_contact_key (const struct GNUNET_MESSENGER_Contact *contact)
 {
+  GNUNET_assert(contact);
+
   return &(contact->public_key);
 }
 
-const struct GNUNET_HashCode*
-get_contact_id_from_key (const struct GNUNET_MESSENGER_Contact *contact)
+void
+increase_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
 {
-  static struct GNUNET_HashCode id;
+  GNUNET_assert(contact);
+
+  contact->rc++;
+}
 
-  GNUNET_CRYPTO_hash (&(contact->public_key), sizeof(contact->public_key), &id);
+int
+decrease_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert(contact);
+
+  if (contact->rc > 0)
+    contact->rc--;
+
+  return contact->rc ? GNUNET_NO : GNUNET_YES;
+}
+
+void
+get_context_from_member (const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *id,
+                         struct GNUNET_HashCode *context)
+{
+  GNUNET_assert((key) && (id) && (context));
 
-  return &id;
+  GNUNET_CRYPTO_hash (id, sizeof(*id), context);
+  GNUNET_CRYPTO_hash_xor (key, context, context);
 }
diff --git a/src/messenger/messenger_api_contact.h b/src/messenger/messenger_api_contact.h
index 0673b9b85..e94d1fcd0 100644
--- a/src/messenger/messenger_api_contact.h
+++ b/src/messenger/messenger_api_contact.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -33,6 +33,7 @@
 struct GNUNET_MESSENGER_Contact
 {
   char *name;
+  size_t rc;
 
   struct GNUNET_IDENTITY_PublicKey public_key;
 };
@@ -40,7 +41,7 @@ struct GNUNET_MESSENGER_Contact
 /**
  * Creates and allocates a new contact with a given public <i>key</i> from an EGO.
  *
- * @param key Public key
+ * @param[in] key Public key
  * @return New contact
  */
 struct GNUNET_MESSENGER_Contact*
@@ -49,7 +50,7 @@ create_contact (const struct GNUNET_IDENTITY_PublicKey *key);
 /**
  * Destroys a contact and frees its memory fully.
  *
- * @param contact Contact
+ * @param[in/out] contact Contact
  */
 void
 destroy_contact (struct GNUNET_MESSENGER_Contact *contact);
@@ -57,7 +58,7 @@ destroy_contact (struct GNUNET_MESSENGER_Contact *contact);
 /**
  * Returns the current name of a given <i>contact</i> or NULL if no valid name was assigned yet.
  *
- * @param contact Contact
+ * @param[in] contact Contact
  * @return Name of the contact or NULL
  */
 const char*
@@ -66,8 +67,8 @@ get_contact_name (const struct GNUNET_MESSENGER_Contact *contact);
 /**
  * Changes the current name of a given <i>contact</i> by copying it from the parameter <i>name</i>.
  *
- * @param contact Contact
- * @param name Valid name (may not be NULL!)
+ * @param[in/out] contact Contact
+ * @param[in] name Name
  */
 void
 set_contact_name (struct GNUNET_MESSENGER_Contact *contact, const char *name);
@@ -75,19 +76,39 @@ set_contact_name (struct GNUNET_MESSENGER_Contact *contact, const char *name);
 /**
  * Returns the public key of a given <i>contact</i>.
  *
- * @param contact Contact
+ * @param[in] contact Contact
  * @return Public key of the contact
  */
 const struct GNUNET_IDENTITY_PublicKey*
 get_contact_key (const struct GNUNET_MESSENGER_Contact *contact);
 
 /**
- * Returns the resulting hashcode of the public key from a given <i>contact</i>.
+ * Increases the reference counter of a given <i>contact</i> which is zero as default.
  *
- * @param contact Contact
- * @return Hash of the contacts public key
+ * @param[in/out] contact Contact
  */
-const struct GNUNET_HashCode*
-get_contact_id_from_key (const struct GNUNET_MESSENGER_Contact *contact);
+void
+increase_contact_rc (struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Decreases the reference counter if possible (can not underflow!) of a given <i>contact</i>
+ * and returns #GNUNET_YES if the counter is equal to zero, otherwise #GNUNET_NO.
+ *
+ * @param[in/out] contact Contact
+ * @return #GNUNET_YES or #GNUNET_NO depending on the reference counter
+ */
+int
+decrease_contact_rc (struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Calculates the context <i>hash</i> of a member in a room and returns it.
+ *
+ * @param[in] key Key of room
+ * @param[in] id Member id
+ * @param[out] hash Member context
+ */
+void
+get_context_from_member (const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *id,
+                         struct GNUNET_HashCode *context);
 
 #endif //GNUNET_MESSENGER_API_CONTACT_H
diff --git a/src/messenger/messenger_api_contact_store.c b/src/messenger/messenger_api_contact_store.c
new file mode 100755
index 000000000..6a517c2e0
--- /dev/null
+++ b/src/messenger/messenger_api_contact_store.c
@@ -0,0 +1,185 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_contact_store.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_contact_store.h"
+
+#include "messenger_api_contact.h"
+#include "messenger_api_util.h"
+
+void
+init_contact_store (struct GNUNET_MESSENGER_ContactStore *store)
+{
+  GNUNET_assert (store);
+
+  store->anonymous = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  store->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+}
+
+static int
+iterate_destroy_contacts (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Contact *contact = value;
+  destroy_contact (contact);
+  return GNUNET_YES;
+}
+
+void
+clear_contact_store (struct GNUNET_MESSENGER_ContactStore *store)
+{
+  GNUNET_assert ((store) && (store->contacts));
+
+  GNUNET_CONTAINER_multihashmap_iterate (store->anonymous, iterate_destroy_contacts, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (store->contacts, iterate_destroy_contacts, NULL);
+
+  GNUNET_CONTAINER_multihashmap_destroy (store->anonymous);
+  GNUNET_CONTAINER_multihashmap_destroy (store->contacts);
+}
+
+static struct GNUNET_CONTAINER_MultiHashMap*
+select_store_contact_map (struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context,
+                          struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_IDENTITY_PublicKey *anonymous = get_anonymous_public_key ();
+
+  struct GNUNET_HashCode anonHash;
+  GNUNET_CRYPTO_hash (anonymous, sizeof(*anonymous), &anonHash);
+
+  if ((context) && (0 == GNUNET_CRYPTO_hash_cmp(hash, &anonHash)))
+  {
+    GNUNET_memcpy(hash, context, sizeof(*context));
+    return store->anonymous;
+  }
+  else
+    return store->contacts;
+}
+
+struct GNUNET_MESSENGER_Contact*
+get_store_contact_raw (struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context,
+                       const struct GNUNET_HashCode *key_hash)
+{
+  GNUNET_assert ((store) && (store->contacts) && (context) && (key_hash));
+
+  struct GNUNET_HashCode hash;
+  GNUNET_memcpy(&hash, key_hash, sizeof(*key_hash));
+
+  struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
+      store, context, &hash
+  );
+
+  return GNUNET_CONTAINER_multihashmap_get (map, &hash);
+}
+
+struct GNUNET_MESSENGER_Contact*
+get_store_contact (struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context,
+                   const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  GNUNET_assert ((store) && (store->contacts) && (context) && (pubkey));
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+  struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
+      store, context, &hash
+  );
+
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multihashmap_get (map, &hash);
+
+  if (contact)
+  {
+    if (0 != GNUNET_memcmp(pubkey, get_contact_key(contact)))
+    {
+      char* str = GNUNET_IDENTITY_public_key_to_string (get_contact_key(contact));
+      GNUNET_log (GNUNET_ERROR_TYPE_INVALID, "Contact in store uses wrong key: %s\n", str);
+      GNUNET_free (str);
+      return NULL;
+    }
+
+    return contact;
+  }
+
+  contact = create_contact (pubkey);
+
+  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (map, &hash, contact,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    return contact;
+
+  destroy_contact (contact);
+  return NULL;
+}
+
+void
+update_store_contact (struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact* contact,
+                      const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *next_context,
+                      const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  GNUNET_assert ((store) && (store->contacts) && (contact) && (pubkey));
+
+  const struct GNUNET_IDENTITY_PublicKey* oldkey = get_contact_key (contact);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (oldkey, sizeof(*oldkey), &hash);
+
+  struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
+      store, context, &hash
+  );
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (map, &hash, contact))
+  {
+    GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
+
+    GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+    map = select_store_contact_map (
+        store, next_context, &hash
+    );
+
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (map, &hash, contact,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating a contact failed: %s\n",
+                 GNUNET_h2s(&hash));
+  }
+}
+
+void
+remove_store_contact (struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact* contact,
+                      const struct GNUNET_HashCode *context)
+{
+  GNUNET_assert ((store) && (store->contacts) && (contact));
+
+  const struct GNUNET_IDENTITY_PublicKey* pubkey = get_contact_key(contact);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+  struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
+      store, context, &hash
+  );
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (map, &hash, contact))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Removing a contact failed: %s\n",
+               GNUNET_h2s(&hash));
+
+  destroy_contact (contact);
+}
diff --git a/src/messenger/messenger_api_contact_store.h b/src/messenger/messenger_api_contact_store.h
new file mode 100644
index 000000000..966f6d962
--- /dev/null
+++ b/src/messenger/messenger_api_contact_store.h
@@ -0,0 +1,122 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_contact_store.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_CONTACT_STORE_H
+#define GNUNET_MESSENGER_API_CONTACT_STORE_H
+
+#include "platform.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+
+struct GNUNET_MESSENGER_Contact;
+
+struct GNUNET_MESSENGER_ContactStore
+{
+  struct GNUNET_CONTAINER_MultiHashMap *anonymous;
+  struct GNUNET_CONTAINER_MultiHashMap *contacts;
+};
+
+/**
+ * Initializes a contact store as fully empty.
+ *
+ * @param[out] store Contact store
+ */
+void
+init_contact_store (struct GNUNET_MESSENGER_ContactStore *store);
+
+/**
+ * Clears a contact store, wipes its content and deallocates its memory.
+ *
+ * @param[in/out] store Contact store
+ */
+void
+clear_contact_store (struct GNUNET_MESSENGER_ContactStore *store);
+
+/**
+ * Returns a contact using the hash of a specific public key. In case the anonymous
+ * key gets used by the requested contact, it will use its provided member
+ * <i>context</i> to select the matching contact from the <i>store</i>.
+ *
+ * In case there is no contact stored which uses the given key or context,
+ * NULL gets returned.
+ *
+ * @param[in/out] store Contact store
+ * @param[in] context Member context
+ * @param[in] key_hash Hash of public key
+ */
+struct GNUNET_MESSENGER_Contact*
+get_store_contact_raw (struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context,
+                       const struct GNUNET_HashCode *key_hash);
+
+/**
+ * Returns a contact using a specific public key. In case the anonymous
+ * key gets used by the requested contact, it will use its provided member
+ * <i>context</i> to select the matching contact from the <i>store</i>.
+ *
+ * In case there is no contact stored which uses the given key or context,
+ * a new contact will be created automatically.
+ *
+ * The function returns NULL if an error occures during allocation
+ * or validation of the contacts key.
+ *
+ * @param[in/out] store Contact store
+ * @param[in] context Member context
+ * @param[in] pubkey Public key of EGO
+ */
+struct GNUNET_MESSENGER_Contact*
+get_store_contact (struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context,
+                   const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Moves a <i>contact</i> from the <i>store</i> to another location
+ * matching a given public key and member <i>context</i>.
+ *
+ * This function allows changes of keys or changes of member contexts!
+ *
+ * @param[in/out] store Contact store
+ * @param[in/out] contact Contact
+ * @param[in] context Member context
+ * @param[in] next_context Member context
+ * @param[in] pubkey Public key of EGO
+ */
+void
+update_store_contact (struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact* contact,
+                      const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *next_context,
+                      const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Removes a <i>contact</i> from the <i>store</i> which uses
+ * a given member <i>context</i>.
+ *
+ * @param[in/out] store Contact store
+ * @param[in/out] contact Contact
+ * @param[in] context Member context
+ */
+void
+remove_store_contact (struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact* contact,
+                      const struct GNUNET_HashCode *context);
+
+#endif //GNUNET_MESSENGER_API_CONTACT_STORE_H
diff --git a/src/messenger/messenger_api_ego.h b/src/messenger/messenger_api_ego.h
index c60eeac50..b52b895f2 100644
--- a/src/messenger/messenger_api_ego.h
+++ b/src/messenger/messenger_api_ego.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
diff --git a/src/messenger/messenger_api_handle.c b/src/messenger/messenger_api_handle.c
index 20ef77254..ab57f82cc 100644
--- a/src/messenger/messenger_api_handle.c
+++ b/src/messenger/messenger_api_handle.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,10 +25,14 @@
 
 #include "messenger_api_handle.h"
 
+#include "messenger_api_util.h"
+
 struct GNUNET_MESSENGER_Handle*
 create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_IdentityCallback identity_callback,
                void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
 {
+  GNUNET_assert(cfg);
+
   struct GNUNET_MESSENGER_Handle *handle = GNUNET_new(struct GNUNET_MESSENGER_Handle);
 
   handle->cfg = cfg;
@@ -47,7 +51,8 @@ create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_I
   handle->reconnect_task = NULL;
 
   handle->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
-  handle->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_contact_store(get_handle_contact_store(handle));
 
   return handle;
 }
@@ -62,19 +67,11 @@ iterate_destroy_room (void *cls, const struct GNUNET_HashCode *key, void *value)
   return GNUNET_YES;
 }
 
-static int
-iterate_destroy_contact (void *cls, const struct GNUNET_HashCode *key, void *value)
-{
-  struct GNUNET_MESSENGER_Contact *contact = value;
-
-  destroy_contact (contact);
-
-  return GNUNET_YES;
-}
-
 void
 destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
 {
+  GNUNET_assert(handle);
+
   if (handle->reconnect_task)
     GNUNET_SCHEDULER_cancel (handle->reconnect_task);
 
@@ -94,12 +91,7 @@ destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
     GNUNET_CONTAINER_multihashmap_destroy (handle->rooms);
   }
 
-  if (handle->contacts)
-  {
-    GNUNET_CONTAINER_multihashmap_iterate (handle->contacts, iterate_destroy_contact, NULL);
-
-    GNUNET_CONTAINER_multihashmap_destroy (handle->contacts);
-  }
+  clear_contact_store(get_handle_contact_store(handle));
 
   GNUNET_free(handle->name);
 }
@@ -107,21 +99,27 @@ destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
 void
 set_handle_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
 {
+  GNUNET_assert(handle);
+
   if (handle->name)
     GNUNET_free(handle->name);
 
-  handle->name = name? GNUNET_strdup(name) : NULL;
+  handle->name = name ? GNUNET_strdup(name) : NULL;
 }
 
 const char*
 get_handle_name (const struct GNUNET_MESSENGER_Handle *handle)
 {
+  GNUNET_assert(handle);
+
   return handle->name;
 }
 
 void
 set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey)
 {
+  GNUNET_assert(handle);
+
   if (!handle->pubkey)
     handle->pubkey = GNUNET_new(struct GNUNET_IDENTITY_PublicKey);
 
@@ -131,62 +129,43 @@ set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDEN
 const struct GNUNET_IDENTITY_PublicKey*
 get_handle_key (const struct GNUNET_MESSENGER_Handle *handle)
 {
-  if (!handle->pubkey)
-  {
-    struct GNUNET_IDENTITY_Ego *anonymous = GNUNET_IDENTITY_ego_get_anonymous ();
-    static struct GNUNET_IDENTITY_PublicKey pubkey;
+  GNUNET_assert(handle);
 
-    GNUNET_IDENTITY_ego_get_public_key (anonymous, &pubkey);
-
-    return &pubkey;
-  }
+  if (handle->pubkey)
+    return handle->pubkey;
 
-  return handle->pubkey;
+  return get_anonymous_public_key ();
 }
 
-struct GNUNET_MESSENGER_Contact*
-get_handle_contact_by_pubkey (const struct GNUNET_MESSENGER_Handle *handle,
-                              const struct GNUNET_IDENTITY_PublicKey *pubkey)
+struct GNUNET_MESSENGER_ContactStore*
+get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle)
 {
-  struct GNUNET_HashCode hash;
-
-  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
-
-  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multihashmap_get (handle->contacts, &hash);
-
-  if (contact)
-    return contact;
-
-  contact = create_contact (pubkey);
-
-  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (handle->contacts, &hash, contact,
-                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    return contact;
+  GNUNET_assert(handle);
 
-  destroy_contact (contact);
-  return NULL;
+  return &(handle->contact_store);
 }
 
-void
-swap_handle_contact_by_pubkey (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Contact *contact,
-                               const struct GNUNET_IDENTITY_PublicKey *pubkey)
+struct GNUNET_MESSENGER_Contact*
+get_handle_contact (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 {
-  const struct GNUNET_HashCode *hash = get_contact_id_from_key (contact);
+  GNUNET_assert((handle) && (key));
 
-  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (handle->contacts, hash, contact))
-  {
-    GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
+  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
-    hash = get_contact_id_from_key (contact);
+  if ((!room) || (!(room->contact_id)))
+    return NULL;
 
-    GNUNET_CONTAINER_multihashmap_put (handle->contacts, hash, contact,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-  }
+  struct GNUNET_HashCode context;
+  get_context_from_member (key, room->contact_id, &context);
+
+  return get_store_contact(get_handle_contact_store(handle), &context, get_handle_key(handle));
 }
 
 void
 open_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
   if (room)
@@ -197,6 +176,8 @@ void
 entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
                       const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (door) && (key));
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
   if (room)
@@ -206,6 +187,8 @@ entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNE
 void
 close_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
 
   if ((room) && (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (handle->rooms, key, room)))
diff --git a/src/messenger/messenger_api_handle.h b/src/messenger/messenger_api_handle.h
index d6cde0106..e6ca474f2 100644
--- a/src/messenger/messenger_api_handle.h
+++ b/src/messenger/messenger_api_handle.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -35,7 +35,7 @@
 
 #include "gnunet_messenger_service.h"
 
-#include "messenger_api_contact.h"
+#include "messenger_api_contact_store.h"
 #include "messenger_api_room.h"
 
 struct GNUNET_MESSENGER_Handle
@@ -56,17 +56,18 @@ struct GNUNET_MESSENGER_Handle
   struct GNUNET_TIME_Relative reconnect_time;
   struct GNUNET_SCHEDULER_Task *reconnect_task;
 
+  struct GNUNET_MESSENGER_ContactStore contact_store;
+
   struct GNUNET_CONTAINER_MultiHashMap *rooms;
-  struct GNUNET_CONTAINER_MultiHashMap *contacts;
 };
 
 /**
  * Creates and allocates a new handle using a given configuration and a custom message callback
  * with a given closure for the client API.
  *
- * @param cfg Configuration
- * @param msg_callback Message callback
- * @param msg_cls Closure
+ * @param[in] cfg Configuration
+ * @param[in] msg_callback Message callback
+ * @param[in/out] msg_cls Closure
  * @return New handle
  */
 struct GNUNET_MESSENGER_Handle*
@@ -76,7 +77,7 @@ create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_I
 /**
  * Destroys a <i>handle</i> and frees its memory fully from the client API.
  *
- * @param handle Handle
+ * @param[in/out] handle Handle
  */
 void
 destroy_handle (struct GNUNET_MESSENGER_Handle *handle);
@@ -84,8 +85,8 @@ destroy_handle (struct GNUNET_MESSENGER_Handle *handle);
 /**
  * Sets the name of a <i>handle</i> to a specific <i>name</i>.
  *
- * @param handle Handle
- * @param name New name
+ * @param[in/out] handle Handle
+ * @param[in] name New name
  */
 void
 set_handle_name (struct GNUNET_MESSENGER_Handle *handle, const char *name);
@@ -93,7 +94,7 @@ set_handle_name (struct GNUNET_MESSENGER_Handle *handle, const char *name);
 /**
  * Returns the current name of a given <i>handle</i> or NULL if no valid name was assigned yet.
  *
- * @param handle Handle
+ * @param[in] handle Handle
  * @return Name of the handle or NULL
  */
 const char*
@@ -102,8 +103,8 @@ get_handle_name (const struct GNUNET_MESSENGER_Handle *handle);
 /**
  * Sets the public key of a given <i>handle</i> to a specific public key.
  *
- * @param handle Handle
- * @param pubkey Public key
+ * @param[in/out] handle Handle
+ * @param[in] pubkey Public key
  */
 void
 set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey);
@@ -111,41 +112,37 @@ set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDEN
 /**
  * Returns the public key of a given <i>handle</i>.
  *
- * @param handle Handle
+ * @param[in] handle Handle
  * @return Public key of the handle
  */
 const struct GNUNET_IDENTITY_PublicKey*
 get_handle_key (const struct GNUNET_MESSENGER_Handle *handle);
 
 /**
- * Returns a contact known to a <i>handle</i> identified by a given public key. If not matching
- * contact is found, NULL gets returned.
+ * Returns the used contact store of a given <i>handle</i>.
  *
- * @param handle Handle
- * @param pubkey Public key of EGO
- * @return Contact or NULL
+ * @param[in/out] handle Handle
+ * @return Contact store
  */
-struct GNUNET_MESSENGER_Contact*
-get_handle_contact_by_pubkey (const struct GNUNET_MESSENGER_Handle *handle,
-                              const struct GNUNET_IDENTITY_PublicKey *pubkey);
+struct GNUNET_MESSENGER_ContactStore*
+get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle);
 
 /**
- * Changes the public key for a <i>contact</i> known to a <i>handle</i> to a specific public key and
- * updates local map entries to access the contact by its updated key.
+ * Returns the contact of a given <i>handle</i> in a room identified by a
+ * given <i>key</i>.
  *
- * @param handle Handle
- * @param contact Contact
- * @param pubkey Public key of EGO
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
+ * @return Contact
  */
-void
-swap_handle_contact_by_pubkey (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Contact *contact,
-                               const struct GNUNET_IDENTITY_PublicKey *pubkey);
+struct GNUNET_MESSENGER_Contact*
+get_handle_contact (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
 
 /**
  * Marks a room known to a <i>handle</i> identified by a given <i>key</i> as open.
  *
- * @param handle Handle
- * @param key Key of room
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
  */
 void
 open_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
@@ -154,9 +151,9 @@ open_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_Ha
  * Adds a tunnel for a room known to a <i>handle</i> identified by a given <i>key</i> to a
  * list of opened connections.
  *
- * @param handle Handle
- * @param door Peer identity
- * @param key Key of room
+ * @param[in/out] handle Handle
+ * @param[in] door Peer identity
+ * @param[in] key Key of room
  */
 void
 entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
@@ -165,8 +162,8 @@ entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNE
 /**
  * Destroys and so implicitly closes a room known to a <i>handle</i> identified by a given <i>key</i>.
  *
- * @param handle Handle
- * @param key Key of room
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
  */
 void
 close_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
diff --git a/src/messenger/messenger_api_list_tunnels.c b/src/messenger/messenger_api_list_tunnels.c
index 13d8c1906..990e36878 100644
--- a/src/messenger/messenger_api_list_tunnels.c
+++ b/src/messenger/messenger_api_list_tunnels.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -62,6 +62,8 @@ compare_list_tunnels (void *cls, struct GNUNET_MESSENGER_ListTunnel *element0,
 void
 add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer)
 {
+  GNUNET_assert((tunnels) && (peer));
+
   struct GNUNET_MESSENGER_ListTunnel *element = GNUNET_new(struct GNUNET_MESSENGER_ListTunnel);
 
   element->peer = GNUNET_PEER_intern (peer);
@@ -73,6 +75,8 @@ add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct
 struct GNUNET_MESSENGER_ListTunnel*
 find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, size_t *index)
 {
+  GNUNET_assert((tunnels) && (peer));
+
   struct GNUNET_MESSENGER_ListTunnel *element;
   struct GNUNET_PeerIdentity pid;
 
@@ -96,12 +100,16 @@ find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GN
 int
 contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer)
 {
+  GNUNET_assert((tunnels) && (peer));
+
   return find_list_tunnels (tunnels, peer, NULL) != NULL ? GNUNET_YES : GNUNET_NO;
 }
 
 struct GNUNET_MESSENGER_ListTunnel*
 remove_from_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element)
 {
+  GNUNET_assert((tunnels) && (element));
+
   struct GNUNET_MESSENGER_ListTunnel *next = element->next;
 
   GNUNET_CONTAINER_DLL_remove(tunnels->head, tunnels->tail, element);
@@ -110,3 +118,67 @@ remove_from_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, struct G
 
   return next;
 }
+
+void
+load_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
+{
+  GNUNET_assert((tunnels) && (path));
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (path))
+    return;
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_READ, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_PeerIdentity peer;
+  ssize_t len;
+
+  do {
+    len = GNUNET_DISK_file_read(handle, &peer, sizeof(peer));
+
+    if (len != sizeof(peer))
+      break;
+
+    add_to_list_tunnels(tunnels, &peer);
+  } while (len == sizeof(peer));
+
+  GNUNET_DISK_file_close(handle);
+}
+
+void
+save_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
+{
+  GNUNET_assert((tunnels) && (path));
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
+      path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+  );
+
+  if (!handle)
+    return;
+
+  GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_MESSENGER_ListTunnel *element;
+  struct GNUNET_PeerIdentity pid;
+
+  for (element = tunnels->head; element; element = element->next)
+  {
+    GNUNET_PEER_resolve (element->peer, &pid);
+
+    GNUNET_DISK_file_write(handle, &pid, sizeof(pid));
+  }
+
+  GNUNET_DISK_file_sync(handle);
+  GNUNET_DISK_file_close(handle);
+}
diff --git a/src/messenger/messenger_api_list_tunnels.h b/src/messenger/messenger_api_list_tunnels.h
index 0240fceb8..bd0a42e41 100644
--- a/src/messenger/messenger_api_list_tunnels.h
+++ b/src/messenger/messenger_api_list_tunnels.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -47,7 +47,7 @@ struct GNUNET_MESSENGER_ListTunnels
 /**
  * Initializes list of tunnels peer identities as empty list.
  *
- * @param tunnels List of peer identities
+ * @param[out] tunnels List of peer identities
  */
 void
 init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
@@ -55,7 +55,7 @@ init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
 /**
  * Clears the list of tunnels peer identities.
  *
- * @param tunnels List of peer identities
+ * @param[in/out] tunnels List of peer identities
  */
 void
 clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
@@ -63,8 +63,8 @@ clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
 /**
  * Adds a specific <i>peer</i> from a tunnel to the end of the list.
  *
- * @param tunnels List of peer identities
- * @param peer Peer identity of tunnel
+ * @param[in/out] tunnels List of peer identities
+ * @param[in] peer Peer identity of tunnel
  */
 void
 add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer);
@@ -79,8 +79,8 @@ add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct
  * the found element in the list. If no matching element is found, <i>index</i> will
  * contain the total amount of elements in the list.
  *
- * @param tunnels List of peer identities
- * @param peer Peer identity of tunnel
+ * @param[in/out] tunnels List of peer identities
+ * @param[in] peer Peer identity of tunnel
  * @param[out] index Index of found element (optional)
  * @return Element in the list with matching peer identity
  */
@@ -89,11 +89,11 @@ find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GN
 
 /**
  * Tests linearly if the list of tunnels peer identities contains a specific
- * <i>peer</i> identity and returns GNUNET_YES on success, otherwise GNUNET_NO.
+ * <i>peer</i> identity and returns #GNUNET_YES on success, otherwise #GNUNET_NO.
  *
- * @param tunnels List of peer identities
- * @param peer Peer identity of tunnel
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] tunnels List of peer identities
+ * @param[in] peer Peer identity of tunnel
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer);
@@ -102,11 +102,29 @@ contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struc
  * Removes a specific <i>element</i> from the list of tunnels peer identities and returns
  * the next element in the list.
  *
- * @param tunnels List of peer identities
- * @param element Element of the list
+ * @param[in/out] tunnels List of peer identities
+ * @param[in/out] element Element of the list
  * @return Next element in the list
  */
 struct GNUNET_MESSENGER_ListTunnel*
 remove_from_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element);
 
+/**
+ * Loads the list of tunnels peer identities from a file under a given <i>path</i>.
+ *
+ * @param[out] messages List of hashes
+ * @param[in] path Path of file
+ */
+void
+load_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path);
+
+/**
+ * Saves the list of tunnels peer identities to a file under a given <i>path</i>.
+ *
+ * @param[in] messages List of hashes
+ * @param[in] path Path of file
+ */
+void
+save_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path);
+
 #endif //GNUNET_MESSENGER_API_LIST_TUNNELS_H
diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c
index fdab60eef..d65b80576 100644..100755
--- a/src/messenger/messenger_api_message.c
+++ b/src/messenger/messenger_api_message.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -69,6 +69,8 @@ create_message (enum GNUNET_MESSENGER_MessageKind kind)
 struct GNUNET_MESSENGER_Message*
 copy_message (const struct GNUNET_MESSENGER_Message *message)
 {
+  GNUNET_assert(message);
+
   struct GNUNET_MESSENGER_Message *copy = GNUNET_new(struct GNUNET_MESSENGER_Message);
 
   GNUNET_memcpy(copy, message, sizeof(struct GNUNET_MESSENGER_Message));
@@ -125,11 +127,28 @@ destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, struct GNUNET_MESS
 void
 destroy_message (struct GNUNET_MESSENGER_Message *message)
 {
+  GNUNET_assert(message);
+
   destroy_message_body (message->header.kind, &(message->body));
 
   GNUNET_free(message);
 }
 
+int
+is_message_session_bound (const struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert(message);
+
+  if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_NAME == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_KEY == message->header.kind) ||
+      (GNUNET_MESSENGER_KIND_ID == message->header.kind))
+    return GNUNET_YES;
+  else
+    return GNUNET_NO;
+}
+
 static void
 fold_short_message (const struct GNUNET_MESSENGER_Message *message, struct GNUNET_MESSENGER_ShortMessage *shortened)
 {
@@ -158,18 +177,7 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
   switch (kind)
   {
   case GNUNET_MESSENGER_KIND_INFO:
-    length += member_size(struct GNUNET_MESSENGER_Message, body.info.host_key);
-    length += member_size(struct GNUNET_MESSENGER_Message, body.info.unique_id);
-    break;
-  case GNUNET_MESSENGER_KIND_JOIN:
-    length += member_size(struct GNUNET_MESSENGER_Message, body.join.key);
-    break;
-  case GNUNET_MESSENGER_KIND_LEAVE:
-    break;
-  case GNUNET_MESSENGER_KIND_NAME:
-    break;
-  case GNUNET_MESSENGER_KIND_KEY:
-    length += member_size(struct GNUNET_MESSENGER_Message, body.key.key);
+    length += member_size(struct GNUNET_MESSENGER_Message, body.info.messenger_version);
     break;
   case GNUNET_MESSENGER_KIND_PEER:
     length += member_size(struct GNUNET_MESSENGER_Message, body.peer.peer);
@@ -195,7 +203,7 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
   case GNUNET_MESSENGER_KIND_FILE:
     length += member_size(struct GNUNET_MESSENGER_Message, body.file.key);
     length += member_size(struct GNUNET_MESSENGER_Message, body.file.hash);
-    length += NAME_MAX;
+    length += member_size(struct GNUNET_MESSENGER_Message, body.file.name);
     break;
   case GNUNET_MESSENGER_KIND_PRIVATE:
     length += member_size(struct GNUNET_MESSENGER_Message, body.private.key);
@@ -207,16 +215,17 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
   return length;
 }
 
+typedef uint32_t kind_t;
+
 uint16_t
 get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
 {
   uint16_t length = 0;
 
-  length += member_size(struct GNUNET_MESSENGER_Message, header.signature);
   length += member_size(struct GNUNET_MESSENGER_Message, header.timestamp);
   length += member_size(struct GNUNET_MESSENGER_Message, header.sender_id);
   length += member_size(struct GNUNET_MESSENGER_Message, header.previous);
-  length += member_size(struct GNUNET_MESSENGER_Message, header.kind);
+  length += sizeof(kind_t);
 
   return length + get_message_body_kind_size (kind);
 }
@@ -228,8 +237,17 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUN
 
   switch (kind)
   {
+  case GNUNET_MESSENGER_KIND_INFO:
+    length += GNUNET_IDENTITY_key_get_length(&(body->info.host_key));
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    length += GNUNET_IDENTITY_key_get_length(&(body->join.key));
+    break;
   case GNUNET_MESSENGER_KIND_NAME:
-    length += (body->name.name? strlen (body->name.name) : 0);
+    length += (body->name.name ? strlen (body->name.name) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    length += GNUNET_IDENTITY_key_get_length(&(body->key.key));
     break;
   case GNUNET_MESSENGER_KIND_TEXT:
     length += strlen (body->text.text);
@@ -248,19 +266,76 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUN
 }
 
 uint16_t
-get_message_size (const struct GNUNET_MESSENGER_Message *message)
+get_message_size (const struct GNUNET_MESSENGER_Message *message,
+                  int include_signature)
 {
-  return get_message_kind_size (message->header.kind) + get_message_body_size (message->header.kind, &(message->body));
+  GNUNET_assert(message);
+
+  uint16_t length = 0;
+
+  if (GNUNET_YES == include_signature)
+    length += GNUNET_IDENTITY_signature_get_length(&(message->header.signature));
+
+  length += get_message_kind_size (message->header.kind);
+  length += get_message_body_size (message->header.kind, &(message->body));
+
+  return length;
 }
 
 static uint16_t
-get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message)
+get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, int include_body)
 {
+  const uint16_t minimum_size = sizeof(struct GNUNET_HashCode) + sizeof(kind_t);
+
   if (message)
-    return sizeof(message->kind) + get_message_body_kind_size (message->kind)
-           + get_message_body_size (message->kind, &(message->body));
+    return minimum_size + get_message_body_kind_size (message->kind)
+           + (include_body == GNUNET_YES? get_message_body_size (message->kind, &(message->body)) : 0);
   else
-    return sizeof(message->kind);
+    return minimum_size;
+}
+
+static uint16_t
+calc_usual_padding ()
+{
+  uint16_t padding = 0;
+  uint16_t kind_size;
+
+  for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) {
+    kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i);
+
+    if (kind_size > padding)
+      padding = kind_size;
+  }
+
+  return padding + GNUNET_MESSENGER_PADDING_MIN;
+}
+
+#define max(x, y) (x > y? x : y)
+
+static uint16_t
+calc_padded_length (uint16_t length)
+{
+  static uint16_t usual_padding = 0;
+
+  if (!usual_padding)
+    usual_padding = calc_usual_padding();
+
+  const uint16_t padded_length = max(
+      length + GNUNET_MESSENGER_PADDING_MIN,
+      usual_padding
+  );
+
+  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0)
+    return GNUNET_MESSENGER_PADDING_LEVEL0;
+
+  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL1)
+    return GNUNET_MESSENGER_PADDING_LEVEL1;
+
+  if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL2)
+    return GNUNET_MESSENGER_PADDING_LEVEL2;
+
+  return GNUNET_MESSENGER_MAX_MESSAGE_SIZE;
+
 }
 
 #define min(x, y) (x < y? x : y)
@@ -272,7 +347,27 @@ get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message)
 
 #define encode_step(dst, offset, src) do {         \
   encode_step_ext(dst, offset, src, sizeof(*src)); \
-} while(0)
+} while (0)
+
+#define encode_step_key(dst, offset, src, length) do {  \
+  ssize_t result = GNUNET_IDENTITY_write_key_to_buffer( \
+      src, dst + offset, length - offset                \
+  );                                                    \
+  if (result < 0)                                       \
+    GNUNET_break (0);                                   \
+  else                                                  \
+    offset += result;                                   \
+} while (0)
+
+#define encode_step_signature(dst, offset, src, length) do {  \
+  ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer( \
+      src, dst + offset, length - offset                      \
+  );                                                          \
+  if (result < 0)                                             \
+    GNUNET_break (0);                                         \
+  else                                                        \
+    offset += result;                                         \
+} while (0)
 
 static void
 encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody *body,
@@ -281,20 +376,18 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET
   switch (kind)
   {
   case GNUNET_MESSENGER_KIND_INFO:
-    encode_step(buffer, offset, &(body->info.host_key));
-    encode_step(buffer, offset, &(body->info.unique_id));
+    encode_step_key(buffer, offset, &(body->info.host_key), length);
+    encode_step(buffer, offset, &(body->info.messenger_version));
     break;
   case GNUNET_MESSENGER_KIND_JOIN:
-    encode_step(buffer, offset, &(body->join.key));
-    break;
-  case GNUNET_MESSENGER_KIND_LEAVE:
+    encode_step_key(buffer, offset, &(body->join.key), length);
     break;
   case GNUNET_MESSENGER_KIND_NAME:
     if (body->name.name)
       encode_step_ext(buffer, offset, body->name.name, min(length - offset, strlen(body->name.name)));
     break;
   case GNUNET_MESSENGER_KIND_KEY:
-    encode_step(buffer, offset, &(body->key.key));
+    encode_step_key(buffer, offset, &(body->key.key), length);
     break;
   case GNUNET_MESSENGER_KIND_PEER:
     encode_step(buffer, offset, &(body->peer.peer));
@@ -321,7 +414,7 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET
   case GNUNET_MESSENGER_KIND_FILE:
     encode_step(buffer, offset, &(body->file.key));
     encode_step(buffer, offset, &(body->file.hash));
-    encode_step_ext(buffer, offset, body->file.name, NAME_MAX);
+    encode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name));
     encode_step_ext(buffer, offset, body->file.uri, min(length - offset, strlen(body->file.uri)));
     break;
   case GNUNET_MESSENGER_KIND_PRIVATE:
@@ -331,18 +424,40 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET
   default:
     break;
   }
+
+  if (offset >= length)
+    return;
+
+  const uint16_t padding = length - offset;
+  const uint16_t used_padding = sizeof(padding) + sizeof(char);
+
+  GNUNET_assert(padding >= used_padding);
+
+  buffer[offset++] = '\0';
+
+  if (padding > used_padding)
+    GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset, padding - used_padding);
+
+  GNUNET_memcpy(buffer + length - sizeof(padding), &padding, sizeof(padding));
 }
 
 void
-encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer)
+encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
+                int include_signature)
 {
+  GNUNET_assert((message) && (buffer));
+
   uint16_t offset = 0;
 
-  encode_step(buffer, offset, &(message->header.signature));
+  if (GNUNET_YES == include_signature)
+    encode_step_signature(buffer, offset, &(message->header.signature), length);
+
+  const kind_t kind = (kind_t) message->header.kind;
+
   encode_step(buffer, offset, &(message->header.timestamp));
   encode_step(buffer, offset, &(message->header.sender_id));
   encode_step(buffer, offset, &(message->header.previous));
-  encode_step(buffer, offset, &(message->header.kind));
+  encode_step(buffer, offset, &kind);
 
   encode_message_body (message->header.kind, &(message->body), length, buffer, offset);
 }
@@ -350,11 +465,22 @@ encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length,
 static void
 encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, uint16_t length, char *buffer)
 {
-  uint16_t offset = 0;
+  struct GNUNET_HashCode hash;
+  uint16_t offset = sizeof(hash);
 
-  encode_step(buffer, offset, &(message->kind));
+  const kind_t kind = (kind_t) message->kind;
+
+  encode_step(buffer, offset, &kind);
 
   encode_message_body (message->kind, &(message->body), length, buffer, offset);
+
+  GNUNET_CRYPTO_hash(
+      buffer + sizeof(hash),
+      length - sizeof(hash),
+      &hash
+  );
+
+  GNUNET_memcpy(buffer, &hash, sizeof(hash));
 }
 
 #define decode_step_ext(src, offset, dst, size) do { \
@@ -372,29 +498,51 @@ encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, uint1
         decode_step_ext(src, offset, dst, size);                                                  \
 } while (0)
 
-static void
+#define decode_step_key(src, offset, dst, length) do {   \
+  ssize_t result = GNUNET_IDENTITY_read_key_from_buffer( \
+    dst, src + offset, length - offset                   \
+  );                                                     \
+  if (result < 0)                                        \
+    GNUNET_break(0);                                     \
+  else                                                   \
+    offset += result;                                    \
+} while (0)
+
+static uint16_t
 decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, struct GNUNET_MESSENGER_MessageBody *body,
                      uint16_t length, const char *buffer, uint16_t offset)
 {
+  uint16_t padding = 0;
+
+  GNUNET_memcpy(&padding, buffer + length - sizeof(padding), sizeof(padding));
+
+  if (padding > length - offset)
+    padding = 0;
+
+  const uint16_t end_zero = length - padding;
+
+  if ((padding) && (buffer[end_zero] != '\0'))
+    padding = 0;
+
+  length -= padding;
+
   switch (*kind)
   {
-  case GNUNET_MESSENGER_KIND_INFO:
-    decode_step(buffer, offset, &(body->info.host_key));
-    decode_step(buffer, offset, &(body->info.unique_id));
+  case GNUNET_MESSENGER_KIND_INFO: {
+    decode_step_key(buffer, offset, &(body->info.host_key), length);
+    decode_step(buffer, offset, &(body->info.messenger_version));
     break;
-  case GNUNET_MESSENGER_KIND_JOIN:
-    decode_step(buffer, offset, &(body->join.key));
-    break;
-  case GNUNET_MESSENGER_KIND_LEAVE:
+  } case GNUNET_MESSENGER_KIND_JOIN: {
+    decode_step_key(buffer, offset, &(body->join.key), length);
     break;
-  case GNUNET_MESSENGER_KIND_NAME:
+  } case GNUNET_MESSENGER_KIND_NAME:
     if (length - offset > 0)
       decode_step_malloc(buffer, offset, body->name.name, length - offset, 1);
     else
       body->name.name = NULL;
     break;
   case GNUNET_MESSENGER_KIND_KEY:
-    decode_step(buffer, offset, &(body->key.key));
+    decode_step_key(buffer, offset, &(body->key.key), length);
     break;
   case GNUNET_MESSENGER_KIND_PEER:
     decode_step(buffer, offset, &(body->peer.peer));
@@ -421,7 +569,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, struct GNUNET_MESS
   case GNUNET_MESSENGER_KIND_FILE:
     decode_step(buffer, offset, &(body->file.key));
     decode_step(buffer, offset, &(body->file.hash));
-    decode_step_ext(buffer, offset, body->file.name, NAME_MAX);
+    decode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name));
     decode_step_malloc(buffer, offset, body->file.uri, length - offset, 1);
     break;
   case GNUNET_MESSENGER_KIND_PRIVATE:
@@ -434,26 +582,51 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, struct GNUNET_MESS
     *kind = GNUNET_MESSENGER_KIND_UNKNOWN;
     break;
   }
+
+  return padding;
 }
 
 int
-decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer)
+decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer,
+                int include_signature, uint16_t *padding)
 {
+  GNUNET_assert((message) && (buffer) && (length >= get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN)));
+
   uint16_t offset = 0;
 
-  if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN))
+  if (GNUNET_YES == include_signature)
+  {
+    ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer(
+        &(message->header.signature), buffer, length - offset
+    );
+
+    if (result < 0)
+      return GNUNET_NO;
+    else
+      offset += result;
+  }
+
+  const uint16_t count = length - offset;
+
+  if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN))
     return GNUNET_NO;
 
-  decode_step(buffer, offset, &(message->header.signature));
+  kind_t kind;
+
   decode_step(buffer, offset, &(message->header.timestamp));
   decode_step(buffer, offset, &(message->header.sender_id));
   decode_step(buffer, offset, &(message->header.previous));
-  decode_step(buffer, offset, &(message->header.kind));
+  decode_step(buffer, offset, &kind);
 
-  if (length < get_message_kind_size (message->header.kind))
+  message->header.kind = (enum GNUNET_MESSENGER_MessageKind) kind;
+
+  if (count < get_message_kind_size (message->header.kind))
     return GNUNET_NO;
 
-  decode_message_body (&(message->header.kind), &(message->body), length, buffer, offset);
+  const uint16_t result = decode_message_body (&(message->header.kind), &(message->body), length, buffer, offset);
+
+  if (padding)
+    *padding = result;
 
   return GNUNET_YES;
 }
@@ -461,47 +634,80 @@ decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const
 static int
 decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, uint16_t length, const char *buffer)
 {
-  uint16_t offset = 0;
+  struct GNUNET_HashCode expected, hash;
+  uint16_t offset = sizeof(hash);
+
+  if (length < get_short_message_size (NULL, GNUNET_NO))
+    return GNUNET_NO;
+
+  GNUNET_memcpy(&hash, buffer, sizeof(hash));
+
+  GNUNET_CRYPTO_hash(
+      buffer + sizeof(hash),
+      length - sizeof(hash),
+      &expected
+  );
 
-  if (length < get_short_message_size (NULL))
+  if (0 != GNUNET_CRYPTO_hash_cmp(&hash, &expected))
     return GNUNET_NO;
 
-  decode_step(buffer, offset, &(message->kind));
+  kind_t kind;
 
-  if (length < get_short_message_size (message))
+  decode_step(buffer, offset, &kind);
+
+  message->kind = (enum GNUNET_MESSENGER_MessageKind) kind;
+
+  if (length < get_short_message_size (message, GNUNET_NO))
     return GNUNET_NO;
 
   decode_message_body (&(message->kind), &(message->body), length, buffer, offset);
 
+  if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind)
+    return GNUNET_NO;
+
   return GNUNET_YES;
 }
 
 void
-hash_message (uint16_t length, const char *buffer, struct GNUNET_HashCode *hash)
+hash_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer,
+              struct GNUNET_HashCode *hash)
 {
-  GNUNET_CRYPTO_hash (buffer + sizeof(struct GNUNET_CRYPTO_EcdsaSignature),
-                      length - sizeof(struct GNUNET_CRYPTO_EcdsaSignature), hash);
+  GNUNET_assert((message) && (buffer) && (hash));
+
+  const ssize_t offset = GNUNET_IDENTITY_signature_get_length(
+      &(message->header.signature)
+  );
+
+  GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash);
 }
 
 void
 sign_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
               const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_Ego *ego)
 {
+  GNUNET_assert((message) && (buffer) && (hash) && (ego));
+
   struct GNUNET_MESSENGER_MessageSignature signature;
 
   signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
   signature.purpose.size = htonl (sizeof(signature));
 
   GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
-
   GNUNET_IDENTITY_sign(&(ego->priv), &signature, &(message->header.signature));
-  GNUNET_memcpy(buffer, &(message->header.signature), sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
+
+  uint16_t offset = 0;
+  encode_step_signature(buffer, offset, &(message->header.signature), length);
 }
 
 int
 verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
                 const struct GNUNET_IDENTITY_PublicKey *key)
 {
+  GNUNET_assert((message) && (hash) && (key));
+
+  if (ntohl (key->type) != ntohl (message->header.signature.type))
+    return GNUNET_SYSERR;
+
   struct GNUNET_MESSENGER_MessageSignature signature;
 
   signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
@@ -516,26 +722,32 @@ verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNU
 int
 encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PublicKey *key)
 {
+  GNUNET_assert((message) && (key));
+
   struct GNUNET_MESSENGER_ShortMessage shortened;
 
   fold_short_message (message, &shortened);
 
-  const uint16_t length = get_short_message_size (&shortened);
+  const uint16_t length = get_short_message_size (&shortened, GNUNET_YES);
+  const uint16_t padded_length = calc_padded_length(length);
 
   message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
-  message->body.private.data = GNUNET_malloc(length);
+  message->body.private.data = GNUNET_malloc(padded_length);
+  message->body.private.length = padded_length;
 
-  encode_short_message (&shortened, length, message->body.private.data);
+  encode_short_message (&shortened, padded_length, message->body.private.data);
 
-  if (GNUNET_IDENTITY_encrypt (message->body.private.data, length, key, &(message->body.private.key),
-                               message->body.private.data)
-      == length)
+  if (padded_length == GNUNET_IDENTITY_encrypt (message->body.private.data, padded_length, key,
+                                                &(message->body.private.key),
+                                                message->body.private.data))
   {
     destroy_message_body (shortened.kind, &(shortened.body));
     return GNUNET_YES;
   }
   else
   {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
+
     unfold_short_message (&shortened, message);
     return GNUNET_NO;
   }
@@ -544,18 +756,28 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_I
 int
 decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key)
 {
-  if (message->body.private.length != GNUNET_IDENTITY_decrypt (message->body.private.data,
-                                                               message->body.private.length, key,
-                                                               &(message->body.private.key),
+  GNUNET_assert((message) && (key));
+
+  if (message->body.private.length != GNUNET_IDENTITY_decrypt (message->body.private.data, message->body.private.length,
+                                                               key, &(message->body.private.key),
                                                                message->body.private.data))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Decrypting message failed!\n");
+
     return GNUNET_NO;
+  }
 
   struct GNUNET_MESSENGER_ShortMessage shortened;
 
   if (GNUNET_YES != decode_short_message (&shortened, message->body.private.length, message->body.private.data))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Decoding decrypted message failed!\n");
+
     return GNUNET_NO;
+  }
 
   unfold_short_message (&shortened, message);
+
   return GNUNET_YES;
 }
 
@@ -563,18 +785,25 @@ struct GNUNET_MQ_Envelope*
 pack_message (struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
               const struct GNUNET_MESSENGER_Ego *ego, int mode)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packing message: %u\n", message->header.kind);
+  GNUNET_assert(message);
+
+  if (ego)
+    message->header.signature.type = ego->priv.type;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packing message kind=%u and sender: %s\n",
+             message->header.kind, GNUNET_sh2s(&(message->header.sender_id)));
 
   struct GNUNET_MessageHeader *header;
 
-  uint16_t length = get_message_size (message);
+  const uint16_t length = get_message_size (message, GNUNET_YES);
+  const uint16_t padded_length = calc_padded_length(length);
 
   struct GNUNET_MQ_Envelope *env;
   char *buffer;
 
   if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
   {
-    env = GNUNET_MQ_msg_extra(header, length, GNUNET_MESSAGE_TYPE_CADET_CLI);
+    env = GNUNET_MQ_msg_extra(header, padded_length, GNUNET_MESSAGE_TYPE_CADET_CLI);
 
     buffer = (char*) &(header[1]);
   }
@@ -582,14 +811,14 @@ pack_message (struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *
   {
     env = NULL;
 
-    buffer = GNUNET_malloc(length);
+    buffer = GNUNET_malloc(padded_length);
   }
 
-  encode_message (message, length, buffer);
+  encode_message (message, padded_length, buffer, GNUNET_YES);
 
   if (hash)
   {
-    hash_message (length, buffer, hash);
+    hash_message (message, length, buffer, hash);
 
     if (ego)
       sign_message (message, length, buffer, hash, ego);
@@ -600,3 +829,43 @@ pack_message (struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *
 
   return env;
 }
+
+int
+filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
+{
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    return GNUNET_SYSERR; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_JOIN:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_enter_room(...) instead!
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_close_room(...) instead!
+  case GNUNET_MESSENGER_KIND_NAME:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_KEY:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_update(...) instead!
+  case GNUNET_MESSENGER_KIND_PEER:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_open_room(...) instead!
+  case GNUNET_MESSENGER_KIND_ID:
+    return GNUNET_SYSERR; // Reserved for member id handling only!
+  case GNUNET_MESSENGER_KIND_MISS:
+    return GNUNET_SYSERR; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_MERGE:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_INVITE:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_FILE:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
+  case GNUNET_MESSENGER_KIND_DELETE:
+    return GNUNET_YES;
+  default:
+    return GNUNET_SYSERR;
+  }
+}
diff --git a/src/messenger/messenger_api_message.h b/src/messenger/messenger_api_message.h
index 0f0a97e9c..7ce30dc92 100644
--- a/src/messenger/messenger_api_message.h
+++ b/src/messenger/messenger_api_message.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -36,10 +36,17 @@
 
 #include "messenger_api_ego.h"
 
+#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE (GNUNET_MAX_MESSAGE_SIZE - GNUNET_MIN_MESSAGE_SIZE)
+
+#define GNUNET_MESSENGER_PADDING_MIN (sizeof(uint16_t) + sizeof(char))
+#define GNUNET_MESSENGER_PADDING_LEVEL0 (512)
+#define GNUNET_MESSENGER_PADDING_LEVEL1 (4096)
+#define GNUNET_MESSENGER_PADDING_LEVEL2 (32768)
+
 /**
  * Creates and allocates a new message with a specific <i>kind</i>.
  *
- * @param kind Kind of message
+ * @param[in] kind Kind of message
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
@@ -48,7 +55,7 @@ create_message (enum GNUNET_MESSENGER_MessageKind kind);
 /**
  * Creates and allocates a copy of a given <i>message</i>.
  *
- * @param message Message
+ * @param[in] message Message
  * @return New message
  */
 struct GNUNET_MESSENGER_Message*
@@ -57,15 +64,24 @@ copy_message (const struct GNUNET_MESSENGER_Message *message);
 /**
  * Destroys a message and frees its memory fully.
  *
- * @param message Message
+ * @param[in/out] message Message
  */
 void
 destroy_message (struct GNUNET_MESSENGER_Message *message);
 
 /**
+ * Returns if the message should be bound to a member session.
+ *
+ * @param[in] message Message
+ * @return #GNUNET_YES or #GNUNET_NO
+ */
+int
+is_message_session_bound (const struct GNUNET_MESSENGER_Message *message);
+
+/**
  * Returns the minimal size in bytes to encode a message of a specific <i>kind</i>.
  *
- * @param kind Kind of message
+ * @param[in] kind Kind of message
  * @return Minimal size to encode
  */
 uint16_t
@@ -74,57 +90,66 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind);
 /**
  * Returns the exact size in bytes to encode a given <i>message</i>.
  *
- * @param message Message
+ * @param[in] message Message
+ * @param[in] encode_signature Flag to include signature
  * @return Size to encode
  */
 uint16_t
-get_message_size (const struct GNUNET_MESSENGER_Message *message);
+get_message_size (const struct GNUNET_MESSENGER_Message *message,
+                  int include_signature);
 
 /**
  * Encodes a given <i>message</i> into a <i>buffer</i> of a maximal <i>length</i> in bytes.
  *
- * @param message Message
- * @param length Maximal length to encode
+ * @param[in] message Message
+ * @param[in] length Maximal length to encode
  * @param[out] buffer Buffer
+ * @param[in] encode_signature Flag to include signature
  */
 void
-encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer);
+encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
+                int include_signature);
 
 /**
  * Decodes a <i>message</i> from a given <i>buffer</i> of a maximal <i>length</i> in bytes.
  *
  * If the buffer is too small for a message of its decoded kind the function fails with
- * resulting GNUNET_NO after decoding only the messages header.
+ * resulting #GNUNET_NO after decoding only the messages header.
  *
- * On success the function returns GNUNET_YES.
+ * On success the function returns #GNUNET_YES.
  *
  * @param[out] message Message
- * @param length Maximal length to decode
- * @param buffer Buffer
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in] length Maximal length to decode
+ * @param[in] buffer Buffer
+ * @param[out] padding Padding
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
-decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer);
+decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer,
+                int include_signature, uint16_t *padding);
 
 /**
- * Calculates a <i>hash</i> of a given <i>buffer</i> of a <i>length</i> in bytes.
+ * Calculates a <i>hash</i> of a given <i>buffer</i> with a <i>length</i> in bytes
+ * from a <i>message</i>.
  *
- * @param length Length of buffer
- * @param buffer Buffer
+ * @param[in] message Message
+ * @param[in] length Length of buffer
+ * @param[in] buffer Buffer
  * @param[out] hash Hash
  */
 void
-hash_message (uint16_t length, const char *buffer, struct GNUNET_HashCode *hash);
+hash_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer,
+              struct GNUNET_HashCode *hash);
 
 /**
  * Signs the <i>hash</i> of a <i>message</i> with a given <i>ego</i> and writes the signature
  * into the <i>buffer</i> as well.
  *
- * @param[out] message Message
- * @param length Length of buffer
+ * @param[in/out] message Message
+ * @param[in] length Length of buffer
  * @param[out] buffer Buffer
- * @param hash Hash of message
- * @param ego EGO
+ * @param[in] hash Hash of message
+ * @param[in] ego EGO
  */
 void
 sign_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
@@ -132,13 +157,13 @@ sign_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *b
 
 /**
  * Verifies the signature of a given <i>message</i> and its <i>hash</i> with a specific
- * public key. The function returns GNUNET_OK if the signature was valid, otherwise
- * GNUNET_SYSERR.
+ * public key. The function returns #GNUNET_OK if the signature was valid, otherwise
+ * #GNUNET_SYSERR.
  *
- * @param message Message
- * @param hash Hash of message
- * @param key Public key of EGO
- * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @param[in] key Public key of EGO
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
  */
 int
 verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
@@ -147,23 +172,23 @@ verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNU
 /**
  * Encrypts a <i>message</i> using a given public <i>key</i> and replaces its body
  * and kind with the now private encrypted <i>message</i>. The function returns
- * GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.
+ * #GNUNET_YES if the operation succeeded, otherwise #GNUNET_NO.
  *
- * @param message Message
- * @param key Public key of EGO
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] message Message
+ * @param[in] key Public key of EGO
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PublicKey *key);
 
 /**
  * Decrypts a private <i>message</i> using a given private <i>key</i> and replaces its body
- * and kind with the inner encrypted message. The function returns GNUNET_YES if the
- * operation succeeded, otherwise GNUNET_NO.
+ * and kind with the inner encrypted message. The function returns #GNUNET_YES if the
+ * operation succeeded, otherwise #GNUNET_NO.
  *
- * @param message Message
- * @param key Private key of EGO
- * @return GNUNET_YES on success, otherwise GNUNET_NO
+ * @param[in/out] message Message
+ * @param[in] key Private key of EGO
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
  */
 int
 decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key);
@@ -173,18 +198,28 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_I
 
 /**
  * Encodes the <i>message</i> to pack it into a newly allocated envelope if <i>mode</i>
- * is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE. Independent of the mode the message
+ * is equal to #GNUNET_MESSENGER_PACK_MODE_ENVELOPE. Independent of the mode the message
  * will be hashed if <i>hash</i> is not NULL and it will be signed if the <i>ego</i> is
  * not NULL.
  *
  * @param[out] message Message
  * @param[out] hash Hash of message
- * @param ego EGO to sign
- * @param mode Mode of packing
+ * @param[in] ego EGO to sign
+ * @param[in] mode Mode of packing
  * @return Envelope or NULL
  */
 struct GNUNET_MQ_Envelope*
 pack_message (struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
               const struct GNUNET_MESSENGER_Ego *ego, int mode);
 
+/**
+ * Returns if a specific kind of message should be sent by a client. The function returns
+ * #GNUNET_YES or #GNUNET_NO for recommendations and #GNUNET_SYSERR for specific kinds
+ * of messages which should not be sent manually at all.
+ *
+ * @param[in] message Message
+ */
+int
+filter_message_sending (const struct GNUNET_MESSENGER_Message *message);
+
 #endif //GNUNET_MESSENGER_API_MESSAGE_H
diff --git a/src/messenger/messenger_api_room.c b/src/messenger/messenger_api_room.c
index 5fedf1a78..5b7edee60 100644..100755
--- a/src/messenger/messenger_api_room.c
+++ b/src/messenger/messenger_api_room.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -30,6 +30,8 @@
 struct GNUNET_MESSENGER_Room*
 create_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   struct GNUNET_MESSENGER_Room *room = GNUNET_new(struct GNUNET_MESSENGER_Room);
 
   room->handle = handle;
@@ -38,11 +40,10 @@ create_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCod
   room->opened = GNUNET_NO;
   room->contact_id = NULL;
 
-  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
-
   init_list_tunnels (&(room->entries));
 
   room->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
 
   return room;
 }
@@ -50,9 +51,10 @@ create_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCod
 static int
 iterate_destroy_message (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
-  struct GNUNET_MESSENGER_Message *message = value;
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = value;
 
-  destroy_message (message);
+  destroy_message (entry->message);
+  GNUNET_free(entry);
 
   return GNUNET_YES;
 }
@@ -60,8 +62,7 @@ iterate_destroy_message (void *cls, const struct GNUNET_HashCode *key, void *val
 void
 destroy_room (struct GNUNET_MESSENGER_Room *room)
 {
-  if (room->members)
-    GNUNET_CONTAINER_multishortmap_destroy (room->members);
+  GNUNET_assert(room);
 
   clear_list_tunnels (&(room->entries));
 
@@ -72,6 +73,9 @@ destroy_room (struct GNUNET_MESSENGER_Room *room)
     GNUNET_CONTAINER_multihashmap_destroy (room->messages);
   }
 
+  if (room->members)
+    GNUNET_CONTAINER_multishortmap_destroy (room->members);
+
   if (room->contact_id)
     GNUNET_free(room->contact_id);
 
@@ -81,65 +85,113 @@ destroy_room (struct GNUNET_MESSENGER_Room *room)
 const struct GNUNET_MESSENGER_Message*
 get_room_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 {
-  return GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
+  GNUNET_assert((room) && (hash));
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (
+      room->messages, hash
+  );
+
+  return (entry? entry->message : NULL);
 }
 
-static void
-handle_join_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                     const struct GNUNET_HashCode *hash)
+struct GNUNET_MESSENGER_Contact*
+get_room_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((room) && (hash));
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (
+      room->messages, hash
+  );
+
+  return (entry? entry->sender : NULL);
+}
+
+static struct GNUNET_MESSENGER_Contact*
+handle_join_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_Contact *contact = get_handle_contact_by_pubkey (room->handle, &(message->body.join.key));
+  if (!sender)
+  {
+    struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store(room->handle);
+    struct GNUNET_HashCode context;
+
+    get_context_from_member(&(room->key), &(message->header.sender_id), &context);
+
+    sender = get_store_contact(store, &context, &(message->body.join.key));
+  }
+
+  if ((GNUNET_YES != GNUNET_CONTAINER_multishortmap_contains_value(room->members, &(message->header.sender_id), sender)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put(room->members, &(message->header.sender_id), sender,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+    increase_contact_rc(sender);
 
-  if (contact)
-    GNUNET_CONTAINER_multishortmap_put (room->members, &(message->header.sender_id), contact,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  return sender;
 }
 
 static void
-handle_leave_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                      const struct GNUNET_HashCode *hash)
+handle_leave_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  GNUNET_CONTAINER_multishortmap_remove_all (room->members, &(message->header.sender_id));
+  if ((!sender) ||
+      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove(room->members, &(message->header.sender_id), sender)))
+    return;
+
+  struct GNUNET_HashCode context;
+  get_context_from_member(&(room->key), &(message->header.sender_id), &context);
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store(room->handle);
+
+  if (GNUNET_YES == decrease_contact_rc(sender))
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "A contact does not share any room with you anymore!\n");
 }
 
 static void
-handle_name_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                     const struct GNUNET_HashCode *hash)
+handle_name_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
-                                                                                 &(message->header.sender_id));
+  if (!sender)
+    return;
 
-  if (contact)
-    set_contact_name (contact, message->body.name.name);
+  set_contact_name (sender, message->body.name.name);
 }
 
 static void
-handle_key_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                    const struct GNUNET_HashCode *hash)
+handle_key_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                    const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
-                                                                                 &(message->header.sender_id));
+  if (!sender)
+    return;
 
-  if (contact)
-    swap_handle_contact_by_pubkey (room->handle, contact, &(message->body.key.key));
+  struct GNUNET_HashCode context;
+  get_context_from_member(&(room->key), &(message->header.sender_id), &context);
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store(room->handle);
+
+  update_store_contact(store, sender, &context, &context, &(message->body.key.key));
 }
 
 static void
-handle_id_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                   const struct GNUNET_HashCode *hash)
+handle_id_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                   const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
-  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
-                                                                                 &(message->header.sender_id));
+  if ((!sender) ||
+      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove(room->members, &(message->header.sender_id), sender)) ||
+      (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put(room->members, &(message->body.id.id), sender,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+    return;
+
+  struct GNUNET_HashCode context, next_context;
+  get_context_from_member(&(room->key), &(message->header.sender_id), &context);
+  get_context_from_member(&(room->key), &(message->body.id.id), &next_context);
 
-  if ((contact) && (GNUNET_OK
-      == GNUNET_CONTAINER_multishortmap_put (room->members, &(message->body.id.id), contact,
-                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
-    GNUNET_CONTAINER_multishortmap_remove (room->members, &(message->header.sender_id), contact);
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store(room->handle);
+
+  update_store_contact(store, sender, &context, &next_context, get_contact_key(sender));
 }
 
 static void
-handle_miss_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                     const struct GNUNET_HashCode *hash)
+handle_miss_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   if ((room->contact_id) && (0 == GNUNET_memcmp(&(message->header.sender_id), room->contact_id)))
   {
@@ -150,40 +202,106 @@ handle_miss_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MES
   }
 }
 
-void
-handle_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                     const struct GNUNET_HashCode *hash)
+static void
+handle_delete_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (
+      room->messages, &(message->body.delete.hash)
+  );
+
+  if ((entry) && ((entry->sender == sender) || (get_handle_contact (room->handle, &(room->key)) == sender)) &&
+      (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->messages, &(message->body.delete.hash), entry)))
+  {
+    destroy_message (entry->message);
+    GNUNET_free(entry);
+  }
+}
+
+struct GNUNET_MESSENGER_Contact*
+handle_room_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 {
   if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->messages, hash))
-    return;
+    return sender;
 
   switch (message->header.kind)
   {
   case GNUNET_MESSENGER_KIND_JOIN:
-    handle_join_message (room, message, hash);
+    sender = handle_join_message (room, sender, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_LEAVE:
-    handle_leave_message (room, message, hash);
+    handle_leave_message (room, sender, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_NAME:
-    handle_name_message (room, message, hash);
+    handle_name_message (room, sender, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_KEY:
-    handle_key_message (room, message, hash);
+    handle_key_message (room, sender, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_ID:
-    handle_id_message (room, message, hash);
+    handle_id_message (room, sender, message, hash);
     break;
   case GNUNET_MESSENGER_KIND_MISS:
-    handle_miss_message (room, message, hash);
+    handle_miss_message (room, sender, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    handle_delete_message (room, sender, message, hash);
     break;
   default:
     break;
   }
 
-  struct GNUNET_MESSENGER_Message *clone = copy_message (message);
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_new(struct GNUNET_MESSENGER_RoomMessageEntry);
+
+  if (!entry)
+    return sender;
 
-  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash, clone,
+  entry->sender = sender;
+  entry->message = copy_message (message);
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash, entry,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
-    destroy_message (clone);
+  {
+    destroy_message (entry->message);
+    GNUNET_free(entry);
+  }
+
+  return sender;
+}
+
+struct GNUNET_MESSENGER_MemberCall
+{
+  struct GNUNET_MESSENGER_Room *room;
+  GNUNET_MESSENGER_MemberCallback callback;
+  void *cls;
+};
+
+static int
+iterate_local_members (void* cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberCall *call = cls;
+  struct GNUNET_MESSENGER_Contact *contact = value;
+
+  return call->callback(call->cls, call->room, contact);
+}
+
+int
+iterate_room_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback,
+                      void* cls)
+{
+  GNUNET_assert(room);
+
+  if (!callback)
+    return GNUNET_CONTAINER_multishortmap_iterate(room->members, NULL, NULL);
+
+  struct GNUNET_MESSENGER_MemberCall call;
+
+  call.room = room;
+  call.callback = callback;
+  call.cls = cls;
+
+  GNUNET_assert(callback);
+
+  return GNUNET_CONTAINER_multishortmap_iterate(room->members, iterate_local_members, &call);
 }
diff --git a/src/messenger/messenger_api_room.h b/src/messenger/messenger_api_room.h
index 0038128d8..eb41cf740 100644..100755
--- a/src/messenger/messenger_api_room.h
+++ b/src/messenger/messenger_api_room.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -36,6 +36,11 @@
 #include "messenger_api_contact.h"
 #include "messenger_api_message.h"
 
+struct GNUNET_MESSENGER_RoomMessageEntry {
+  struct GNUNET_MESSENGER_Contact* sender;
+  struct GNUNET_MESSENGER_Message* message;
+};
+
 struct GNUNET_MESSENGER_Room
 {
   struct GNUNET_MESSENGER_Handle *handle;
@@ -45,17 +50,17 @@ struct GNUNET_MESSENGER_Room
 
   struct GNUNET_ShortHashCode *contact_id;
 
-  struct GNUNET_CONTAINER_MultiShortmap *members;
   struct GNUNET_MESSENGER_ListTunnels entries;
 
   struct GNUNET_CONTAINER_MultiHashMap *messages;
+  struct GNUNET_CONTAINER_MultiShortmap *members;
 };
 
 /**
  * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i> for the client API.
  *
- * @param handle Handle
- * @param key Key of room
+ * @param[in/out] handle Handle
+ * @param[in] key Key of room
  * @return New room
  */
 struct GNUNET_MESSENGER_Room*
@@ -64,7 +69,7 @@ create_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCod
 /**
  * Destroys a room and frees its memory fully from the client API.
  *
- * @param room Room
+ * @param[in/out] room Room
  */
 void
 destroy_room (struct GNUNET_MESSENGER_Room *room);
@@ -73,23 +78,52 @@ destroy_room (struct GNUNET_MESSENGER_Room *room);
  * Returns a message locally stored from a map for a given <i>hash</i> in a <i>room</i>. If no matching
  * message is found, NULL gets returned.
  *
- * @param room Room
- * @param hash Hash of message
+ * @param[in] room Room
+ * @param[in] hash Hash of message
  * @return Message or NULL
  */
 const struct GNUNET_MESSENGER_Message*
 get_room_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
 
 /**
+ * Returns a messages sender locally stored from a map for a given <i>hash</i> in a <i>room</i>. If no
+ * matching message is found, NULL gets returned.
+ *
+ * @param[in] room Room
+ * @param[in] hash Hash of message
+ * @return Contact of sender or NULL
+ */
+struct GNUNET_MESSENGER_Contact*
+get_room_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
+
+/**
  * Handles a <i>message</i> with a given <i>hash</i> in a <i>room</i> for the client API to update
  * members and its information. The function also stores the message in map locally for access afterwards.
  *
- * @param room Room
- * @param message Message
- * @param hash Hash of message
+ * The contact of the message's sender could be updated or even created. It may not be freed or destroyed though!
+ * (The contact may still be in use for old messages...)
+ *
+ * @param[in/out] room Room
+ * @param[in/out] sender Contact of sender
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @return Contact of sender
  */
-void
-handle_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                     const struct GNUNET_HashCode *hash);
+struct GNUNET_MESSENGER_Contact*
+handle_room_message (struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Iterates through all members of a given <i>room</i> to forward each of them to a selected
+ * <i>callback</i> with a custom closure.
+ *
+ * @param[in/out] room Room
+ * @param[in] callback Function called for each member
+ * @param[in/out] cls Closure
+ * @return Amount of members iterated
+ */
+int
+iterate_room_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback,
+                      void* cls);
 
 #endif //GNUNET_MESSENGER_API_ROOM_H
diff --git a/src/messenger/gnunet-service-messenger_util.c b/src/messenger/messenger_api_util.c
index 94fc9469d..68e15d789 100644
--- a/src/messenger/gnunet-service-messenger_util.c
+++ b/src/messenger/messenger_api_util.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -19,11 +19,11 @@
  */
 /**
  * @author Tobias Frisch
- * @file src/messenger/gnunet-service-messenger_util.c
- * @brief GNUnet MESSENGER service
+ * @file src/messenger/messenger_api_util.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
  */
 
-#include "gnunet-service-messenger_util.h"
+#include "messenger_api_util.h"
 
 static void
 callback_close_channel (void *cls)
@@ -37,13 +37,18 @@ callback_close_channel (void *cls)
 void
 delayed_disconnect_channel (struct GNUNET_CADET_Channel *channel)
 {
-  GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (), GNUNET_SCHEDULER_PRIORITY_URGENT,
+  GNUNET_assert(channel);
+
+  GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (),
+                                              GNUNET_SCHEDULER_PRIORITY_URGENT,
                                               callback_close_channel, channel);
 }
 
 int
 generate_free_member_id (struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
 {
+  GNUNET_assert(id);
+
   size_t counter = 1 + (members ? GNUNET_CONTAINER_multishortmap_size (members) : 0);
 
   do
@@ -62,3 +67,18 @@ generate_free_member_id (struct GNUNET_ShortHashCode *id, const struct GNUNET_CO
 
   return GNUNET_NO;
 }
+
+const struct GNUNET_IDENTITY_PublicKey*
+get_anonymous_public_key ()
+{
+  static struct GNUNET_IDENTITY_PublicKey public_key;
+  static struct GNUNET_IDENTITY_Ego* ego = NULL;
+
+  if (!ego)
+  {
+    ego = GNUNET_IDENTITY_ego_get_anonymous();
+    GNUNET_IDENTITY_ego_get_public_key(ego, &public_key);
+  }
+
+  return &public_key;
+}
diff --git a/src/messenger/gnunet-service-messenger_util.h b/src/messenger/messenger_api_util.h
index 20f8f0afe..c70a3601f 100644
--- a/src/messenger/gnunet-service-messenger_util.h
+++ b/src/messenger/messenger_api_util.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -19,8 +19,8 @@
  */
 /**
  * @author Tobias Frisch
- * @file src/messenger/gnunet-service-messenger_util.h
- * @brief GNUnet MESSENGER service
+ * @file src/messenger/messenger_api_util.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
  */
 
 #ifndef GNUNET_SERVICE_MESSENGER_UTIL_H
@@ -30,24 +30,35 @@
 #include "gnunet_cadet_service.h"
 #include "gnunet_container_lib.h"
 #include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_identity_service.h"
 
 /**
  * Starts an urgent task to close a CADET channel asynchronously.
  *
- * @param channel Channel
+ * @param[in/out] channel Channel
  */
 void
 delayed_disconnect_channel (struct GNUNET_CADET_Channel *channel);
 
 /**
- * Tries to generate an unused member id and store it into the <i>id</i> parameter. A map containing all currently
- * used member ids is used to check against.
+ * Tries to generate an unused member id and store it into the <i>id</i> parameter.
+ * A map containing all currently used member ids is used to check against.
  *
  * @param[out] id New member id
- * @param members Map of member ids
- * @return GNUNET_YES on success, GNUNET_NO on failure
+ * @param[in] members Map of member ids
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure
  */
 int
 generate_free_member_id (struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members);
 
+/**
+ * Returns the public identity key of #GNUNET_IDENTITY_ego_get_anonymous() without
+ * recalculating it every time.
+ *
+ * @return anonymous public key
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+get_anonymous_public_key ();
+
 #endif //GNUNET_SERVICE_MESSENGER_UTIL_H
diff --git a/src/messenger/test_messenger.c b/src/messenger/test_messenger.c
index b42dfe6d9..fb3e3e1bc 100644
--- a/src/messenger/test_messenger.c
+++ b/src/messenger/test_messenger.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -61,14 +61,13 @@ end (void *cls)
 
   if (messenger)
   {
-    GNUNET_MESSENGER_disconnect(messenger);
+    GNUNET_MESSENGER_disconnect (messenger);
     messenger = NULL;
   }
 
   status = 0;
 }
 
-
 static void
 end_badly (void *cls)
 {
@@ -83,7 +82,7 @@ end_operation (void *cls)
 {
   op_task = NULL;
 
-  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls? (const char*) cls : "unknown");
+  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const char*) cls : "unknown");
 
   if (die_task)
     GNUNET_SCHEDULER_cancel (die_task);
@@ -109,30 +108,25 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
     op_task = NULL;
   }
 
-  const char* name = GNUNET_MESSENGER_get_name(handle);
+  const char *name = GNUNET_MESSENGER_get_name (handle);
 
-  if (0 != strcmp(name, TESTER_NAME))
+  if (0 != strcmp (name, TESTER_NAME))
   {
     op_task = GNUNET_SCHEDULER_add_now (&end_operation, "name");
     return;
   }
 
-  struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous();
-  struct GNUNET_IDENTITY_PublicKey anonymous_key;
-
-  GNUNET_IDENTITY_ego_get_public_key(ego, &anonymous_key);
+  const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key (handle);
 
-  const struct GNUNET_IDENTITY_PublicKey* key = GNUNET_MESSENGER_get_key(handle);
-
-  if (((!identity_counter) && (0 != GNUNET_memcmp(key, (&anonymous_key)))) ||
-      ((identity_counter) && (0 == GNUNET_memcmp(key, (&anonymous_key)))))
+  if (((!identity_counter) && (key)) || ((identity_counter) && (!key)))
   {
     op_task = GNUNET_SCHEDULER_add_now (&end_operation, "key");
     return;
   }
 
-  if (identity_counter) {
-    GNUNET_MESSENGER_disconnect(handle);
+  if (identity_counter)
+  {
+    GNUNET_MESSENGER_disconnect (handle);
 
     op_task = NULL;
     messenger = NULL;
@@ -144,7 +138,7 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
     return;
   }
 
-  GNUNET_MESSENGER_update(messenger);
+  GNUNET_MESSENGER_update (messenger);
   identity_counter++;
 }
 
@@ -156,16 +150,14 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
  * @param peer Peer for testing
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_Peer *peer)
 {
   die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT, &end_badly, NULL);
 
   identity_counter = 0;
 
   op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation, "connect");
-  messenger = GNUNET_MESSENGER_connect(cfg, TESTER_NAME, &on_identity, NULL, NULL, NULL);
+  messenger = GNUNET_MESSENGER_connect (cfg, TESTER_NAME, &on_identity, NULL, NULL, NULL);
 }
 
 /**
@@ -176,11 +168,9 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char **argv)
+main (int argc, char **argv)
 {
-  if (0 != GNUNET_TESTING_peer_run("test-messenger",
-                                   "test_messenger_api.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-messenger", "test_messenger_api.conf", &run, NULL))
     return 1;
 
   return status;
diff --git a/src/messenger/test_messenger_adapt.c b/src/messenger/test_messenger_adapt.c
new file mode 100644
index 000000000..90e8ac28d
--- /dev/null
+++ b/src/messenger/test_messenger_adapt.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_adapt.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    5,    1,    2,    3,    6,    7,    8,    4 };
+  unsigned int stages [] = { 0x21, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x21 };
+
+  struct test_configuration cfg;
+  cfg.count = 8;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_adapt", &cfg);
+}
diff --git a/src/messenger/test_messenger_anonymous.c b/src/messenger/test_messenger_anonymous.c
index e2057acc4..a70121a30 100644
--- a/src/messenger/test_messenger_anonymous.c
+++ b/src/messenger/test_messenger_anonymous.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -59,14 +59,13 @@ end (void *cls)
 
   if (messenger)
   {
-    GNUNET_MESSENGER_disconnect(messenger);
+    GNUNET_MESSENGER_disconnect (messenger);
     messenger = NULL;
   }
 
   status = 0;
 }
 
-
 static void
 end_badly (void *cls)
 {
@@ -81,7 +80,7 @@ end_operation (void *cls)
 {
   op_task = NULL;
 
-  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls? (const char*) cls : "unknown");
+  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const char*) cls : "unknown");
 
   if (die_task)
     GNUNET_SCHEDULER_cancel (die_task);
@@ -105,7 +104,7 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
     op_task = NULL;
   }
 
-  const char* name = GNUNET_MESSENGER_get_name(handle);
+  const char *name = GNUNET_MESSENGER_get_name (handle);
 
   if (NULL != name)
   {
@@ -113,26 +112,21 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
     return;
   }
 
-  if (GNUNET_SYSERR != GNUNET_MESSENGER_update(handle))
+  if (GNUNET_SYSERR != GNUNET_MESSENGER_update (handle))
   {
     op_task = GNUNET_SCHEDULER_add_now (&end_operation, "update-fail");
     return;
   }
 
-  struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous();
-  struct GNUNET_IDENTITY_PublicKey anonymous_key;
-
-  GNUNET_IDENTITY_ego_get_public_key(ego, &anonymous_key);
-
-  const struct GNUNET_IDENTITY_PublicKey* key = GNUNET_MESSENGER_get_key(handle);
+  const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key (handle);
 
-  if (0 != GNUNET_memcmp(key, (&anonymous_key)))
+  if (key)
   {
     op_task = GNUNET_SCHEDULER_add_now (&end_operation, "key-anonymous");
     return;
   }
 
-  GNUNET_MESSENGER_disconnect(handle);
+  GNUNET_MESSENGER_disconnect (handle);
 
   messenger = NULL;
 
@@ -150,14 +144,12 @@ on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
  * @param peer Peer for testing
  */
 static void
-run (void *cls,
-     const struct GNUNET_CONFIGURATION_Handle *cfg,
-     struct GNUNET_TESTING_Peer *peer)
+run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_Peer *peer)
 {
   die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT, &end_badly, NULL);
 
   op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation, "connect");
-  messenger = GNUNET_MESSENGER_connect(cfg, NULL, &on_identity, NULL, NULL, NULL);
+  messenger = GNUNET_MESSENGER_connect (cfg, NULL, &on_identity, NULL, NULL, NULL);
 }
 
 /**
@@ -168,11 +160,9 @@ run (void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char **argv)
+main (int argc, char **argv)
 {
-  if (0 != GNUNET_TESTING_peer_run("test-messenger",
-                                   "test_messenger_api.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-messenger", "test_messenger_api.conf", &run, NULL))
     return 1;
 
   return status;
diff --git a/src/messenger/test_messenger_api.conf b/src/messenger/test_messenger_api.conf
index f5837392e..968f56f6d 100644
--- a/src/messenger/test_messenger_api.conf
+++ b/src/messenger/test_messenger_api.conf
@@ -1,11 +1,39 @@
 @INLINE@ ../../contrib/conf/gnunet/no_forcestart.conf
 @INLINE@ ../../contrib/conf/gnunet/no_autostart_above_core.conf
 
+[testbed]
+HOSTNAME = localhost
+OVERLAY_TOPOLOGY = CLIQUE
+
+[arm]
+GLOBAL_POSTFIX = -l $GNUNET_CACHE_HOME/{}-logs -L verbose
+
+[transport]
+IMMEDIATE_START = YES
+
+[core]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+USE_EPHEMERAL_KEYS = NO
+
 [PATHS]
 GNUNET_TEST_HOME = $GNUNET_TMP/test-messenger-api/
 
+[peerinfo]
+NO_IO = YES
+
 [cadet]
 START_ON_DEMAND = YES
+REFRESH_CONNECTION_TIME = 1 s
+ID_ANNOUNCE_TIME = 5 s
+CONNECT_TIMEOUT = 30 s
+DEFAULT_TTL = 16
+DHT_REPLICATION_LEVEL = 10
+MAX_TUNNELS = 10
+MAX_CONNECTIONS = 10
+MAX_MSGS_QUEUE = 20
+DISABLE_TRY_CONNECT = YES
+REKEY_PERIOD = 2 s
 
 [identity]
 START_ON_DEMAND = YES
@@ -14,4 +42,6 @@ START_ON_DEMAND = YES
 START_ON_DEMAND = YES
 
 [nat]
-ENABLE_UPNP = NO
\ No newline at end of file
+ENABLE_UPNP = NO
+RETURN_LOCAL_ADDRESSES = YES
+IMMEDIATE_START = NO
\ No newline at end of file
diff --git a/src/messenger/test_messenger_async_client.c b/src/messenger/test_messenger_async_client.c
new file mode 100644
index 000000000..1067b9a6d
--- /dev/null
+++ b/src/messenger/test_messenger_async_client.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_async_client.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    0,    1 };
+  unsigned int stages [] = { 0x10, 0x20 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_async_client", &cfg);
+}
diff --git a/src/messenger/test_messenger_async_p2p.c b/src/messenger/test_messenger_async_p2p.c
new file mode 100644
index 000000000..d827aae16
--- /dev/null
+++ b/src/messenger/test_messenger_async_p2p.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_async_p2p.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    2,    1 };
+  unsigned int stages [] = { 0x30, 0x30 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_async_p2p", &cfg);
+}
diff --git a/src/messenger/test_messenger_comm0.c b/src/messenger/test_messenger_comm0.c
deleted file mode 100644
index 631b5b2c9..000000000
--- a/src/messenger/test_messenger_comm0.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
-   This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
-
-   GNUnet is free software: you can redistribute it and/or modify it
-   under the terms of the GNU Affero General Public License as published
-   by the Free Software Foundation, either version 3 of the License,
-   or (at your option) any later version.
-
-   GNUnet is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-   SPDX-License-Identifier: AGPL3.0-or-later
- */
-/**
- * @file messenger/test_messenger_comm0.c
- * @author Tobias Frisch
- * @brief Test for the messenger service using cadet API.
- */
-#include <stdio.h>
-#include "platform.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_testbed_logger_service.h"
-#include "gnunet_testbed_service.h"
-#include "gnunet_testing_lib.h"
-#include "gnunet_messenger_service.h"
-
-/**
- * How long until we really give up on a particular testcase portion?
- */
-#define TOTAL_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
-                                                     60)
-
-/**
- * How long until we give up on any particular operation (and retry)?
- */
-#define BASE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
-
-static int status = 1;
-
-static struct GNUNET_SCHEDULER_Task *die_task = NULL;
-static struct GNUNET_SCHEDULER_Task *op_task = NULL;
-
-static void
-end (void *cls)
-{
-  die_task = NULL;
-
-  if (op_task)
-  {
-    GNUNET_SCHEDULER_cancel (op_task);
-    op_task = NULL;
-  }
-
-  GNUNET_SCHEDULER_shutdown ();
-  status = 0;
-}
-
-
-static void
-end_badly (void *cls)
-{
-  fprintf (stderr, "Testcase failed (timeout).\n");
-
-  end (NULL);
-  status = 1;
-}
-
-static void
-end_operation (void *cls)
-{
-  op_task = NULL;
-
-  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls? (const char*) cls : "unknown");
-
-  if (die_task)
-    GNUNET_SCHEDULER_cancel (die_task);
-
-  end (NULL);
-  status = 1;
-}
-
-static void
-end_error (void *cls)
-{
-  op_task = NULL;
-
-  fprintf (stderr, "Testcase failed (error: '%s').\n", cls? (const char*) cls : "unknown");
-  GNUNET_free(cls);
-
-  if (die_task)
-    GNUNET_SCHEDULER_cancel (die_task);
-
-  end (NULL);
-  status = 1;
-}
-
-/**
- * Function called whenever a message is received or sent.
- *
- * @param cls Closure
- * @param room Room
- * @param message Message
- * @param hash Hash of message
- */
-static void
-on_message (void *cls, const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-            const struct GNUNET_HashCode *hash)
-{
-  // TODO
-}
-
-/**
- * Function called when an identity is retrieved.
- *
- * @param cls Closure
- * @param handle Handle of messenger service
- */
-static void
-on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
-{
-  // TODO
-}
-
-static void
-on_peer (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
-         const struct GNUNET_TESTBED_PeerInformation *pinfo,
-         const char *emsg)
-{
-  if (emsg)
-  {
-    op_task = GNUNET_SCHEDULER_add_now (&end_error, GNUNET_strdup(emsg));
-    return;
-  }
-
-  if (pinfo->pit != GNUNET_TESTBED_PIT_CONFIGURATION)
-  {
-    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "config");
-    return;
-  }
-
-  struct GNUNET_MESSENGER_Handle *handle;
-  struct GNUNET_MESSENGER_Room *room;
-
-  fprintf (stderr, "MSG: connect\n");
-
-  handle = GNUNET_MESSENGER_connect(pinfo->result.cfg, "tester", &on_identity, NULL, &on_message, NULL);
-
-  struct GNUNET_HashCode hash;
-  GNUNET_CRYPTO_hash("test", 4, &hash);
-
-  fprintf (stderr, "MSG: open\n");
-
-  room = GNUNET_MESSENGER_open_room(handle, &hash);
-
-  fprintf (stderr, "MSG: close\n");
-
-  GNUNET_MESSENGER_close_room(room);
-
-  fprintf (stderr, "MSG: disconnect\n");
-
-  GNUNET_MESSENGER_disconnect(handle);
-
-  GNUNET_TESTBED_operation_done(op);
-
-}
-
-/**
- * Main function for a peer of the testcase.
- *
- * @param cls Closure
- * @param event Information about the event
- */
-static void
-run (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
-{
-  if (GNUNET_TESTBED_ET_PEER_START != event->type)
-  {
-    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "start");
-    return;
-  }
-
-  GNUNET_TESTBED_peer_get_information(event->details.peer_start.peer,
-                                      GNUNET_TESTBED_PIT_CONFIGURATION,
-                                      on_peer, event->details.peer_start.peer);
-
-  fprintf (stderr, "MSG: barrier\n");
-
-  GNUNET_TESTBED_barrier_wait("exit", NULL, NULL);
-
-  fprintf (stderr, "MSG: exit\n");
-}
-
-static void
-exit_status (void *cls, const char *name,
-             struct GNUNET_TESTBED_Barrier *barrier,
-             enum GNUNET_TESTBED_BarrierStatus status,
-             const char *emsg)
-{
-  if (emsg)
-  {
-    op_task = GNUNET_SCHEDULER_add_now (&end_error, GNUNET_strdup(emsg));
-    return;
-  }
-
-  if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status)
-  {
-    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "exit");
-    return;
-  }
-  else if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED == status)
-    GNUNET_SCHEDULER_add_now(&end, NULL);
-}
-
-static void
-init (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers,
-      struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded,
-      unsigned int links_failed)
-{
-  die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT, &end_badly, NULL);
-
-  struct GNUNET_TESTBED_Controller *controller;
-
-  controller = GNUNET_TESTBED_run_get_controller_handle(h);
-
-  GNUNET_TESTBED_barrier_init(controller, "exit", num_peers, exit_status, NULL);
-}
-
-/**
- * The main function.
- *
- * @param argc number of arguments from the command line
- * @param argv command line arguments
- * @return 0 ok, 1 on error
- */
-int
-main(int argc, char **argv)
-{
-  if (GNUNET_OK != GNUNET_TESTBED_test_run("test-messenger-comm0",
-                                           "test_messenger_api.conf",
-                                           2, 0,
-                                           &run, NULL,
-                                           &init, NULL))
-    return 1;
-
-  return status;
-}
diff --git a/src/messenger/test_messenger_growth.c b/src/messenger/test_messenger_growth.c
new file mode 100644
index 000000000..3781f3ee5
--- /dev/null
+++ b/src/messenger/test_messenger_growth.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_growth.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    0,    1,    1,    1,    1,    1,    1,    1 };
+  unsigned int stages [] = { 0x01, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21 };
+
+  struct test_configuration cfg;
+  cfg.count = 8;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_growth", &cfg);
+}
diff --git a/src/messenger/test_messenger_ring.c b/src/messenger/test_messenger_ring.c
new file mode 100644
index 000000000..07cfd0c47
--- /dev/null
+++ b/src/messenger/test_messenger_ring.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_ring.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    8,    1,    2,    3,    4,    5,    6,    7 };
+  unsigned int stages [] = { 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21 };
+
+  struct test_configuration cfg;
+  cfg.count = 8;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_ring", &cfg);
+}
diff --git a/src/messenger/test_messenger_server.c b/src/messenger/test_messenger_server.c
new file mode 100644
index 000000000..1cf2fcc27
--- /dev/null
+++ b/src/messenger/test_messenger_server.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_server.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    0,    1,    1,    1,    1,    1,    1,    1 };
+  unsigned int stages [] = { 0x01, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
+
+  struct test_configuration cfg;
+  cfg.count = 8;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_server", &cfg);
+}
diff --git a/src/messenger/test_messenger_sync_client.c b/src/messenger/test_messenger_sync_client.c
new file mode 100644
index 000000000..99f26b018
--- /dev/null
+++ b/src/messenger/test_messenger_sync_client.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_sync_client.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    0,    1 };
+  unsigned int stages [] = { 0x01, 0x20 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_sync_client", &cfg);
+}
diff --git a/src/messenger/test_messenger_sync_p2p.c b/src/messenger/test_messenger_sync_p2p.c
new file mode 100644
index 000000000..77ce280a1
--- /dev/null
+++ b/src/messenger/test_messenger_sync_p2p.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_sync_p2p.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    2,    1 };
+  unsigned int stages [] = { 0x21, 0x21 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_sync_p2p", &cfg);
+}
diff --git a/src/messenger/test_messenger_worst_client.c b/src/messenger/test_messenger_worst_client.c
new file mode 100644
index 000000000..63826631c
--- /dev/null
+++ b/src/messenger/test_messenger_worst_client.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_worst_client.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    0,    1 };
+  unsigned int stages [] = { 0x10, 0x02 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_worst_client", &cfg);
+}
diff --git a/src/messenger/test_messenger_worst_p2p.c b/src/messenger/test_messenger_worst_p2p.c
new file mode 100644
index 000000000..c89288eea
--- /dev/null
+++ b/src/messenger/test_messenger_worst_p2p.c
@@ -0,0 +1,47 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_worst_p2p.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include "testing_messenger_setup.h"
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  unsigned int doors  [] = {    2,    1 };
+  unsigned int stages [] = { 0x12, 0x12 };
+
+  struct test_configuration cfg;
+  cfg.count = 2;
+  cfg.doors = doors;
+  cfg.stages = stages;
+
+  return GNUNET_run_messenger_setup ("test_messenger_worst_p2p", &cfg);
+}
diff --git a/src/messenger/testing_messenger_barrier.c b/src/messenger/testing_messenger_barrier.c
new file mode 100644
index 000000000..618d255b7
--- /dev/null
+++ b/src/messenger/testing_messenger_barrier.c
@@ -0,0 +1,170 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/testing_messenger_barrier.c
+ * @author Tobias Frisch
+ * @brief Pseudo-barriers for simple event handling
+ */
+
+#include "testing_messenger_barrier.h"
+
+struct GNUNET_BarrierHandle
+{
+  unsigned int requirement;
+  GNUNET_BarrierStatusCallback cb;
+  void *cls;
+
+  struct GNUNET_BarrierWaitHandle *head;
+  struct GNUNET_BarrierWaitHandle *tail;
+
+  struct GNUNET_SCHEDULER_Task* task;
+};
+
+struct GNUNET_BarrierHandle*
+GNUNET_init_barrier (unsigned int requirement,
+                     GNUNET_BarrierStatusCallback cb,
+                     void *cb_cls)
+{
+  if (0 == requirement)
+    return NULL;
+
+  struct GNUNET_BarrierHandle *barrier = GNUNET_new(struct GNUNET_BarrierHandle);
+
+  if (!barrier)
+    return NULL;
+
+  barrier->requirement = requirement;
+  barrier->cb = cb;
+  barrier->cls = cb_cls;
+  barrier->head = NULL;
+  barrier->tail = NULL;
+  barrier->task = NULL;
+
+  return barrier;
+}
+
+static void
+exit_status (struct GNUNET_BarrierHandle *barrier, int status);
+
+static void
+cancel_barrier (void *cls)
+{
+  exit_status ((struct GNUNET_BarrierHandle*) cls, GNUNET_SYSERR);
+}
+
+static void
+complete_barrier (void *cls)
+{
+  exit_status ((struct GNUNET_BarrierHandle*) cls, GNUNET_OK);
+}
+
+void
+GNUNET_cancel_barrier (struct GNUNET_BarrierHandle *barrier)
+{
+  if ((!barrier) || (barrier->task))
+    return;
+
+  barrier->task = GNUNET_SCHEDULER_add_now(cancel_barrier, barrier);
+}
+
+struct GNUNET_BarrierWaitHandle
+{
+  GNUNET_BarrierWaitStatusCallback cb;
+  void *cls;
+
+  struct GNUNET_BarrierWaitHandle *prev;
+  struct GNUNET_BarrierWaitHandle *next;
+
+  struct GNUNET_BarrierHandle *barrier;
+};
+
+static void
+exit_status (struct GNUNET_BarrierHandle *barrier, int status)
+{
+  struct GNUNET_BarrierWaitHandle *waiting = barrier->head;
+  while (waiting)
+  {
+    struct GNUNET_BarrierWaitHandle *current = waiting;
+
+    if (current->cb)
+      current->cb(current->cls, current, status);
+
+    waiting = waiting->next;
+
+    GNUNET_CONTAINER_DLL_remove(barrier->head, barrier->tail, current);
+    GNUNET_free(current);
+  }
+
+  if (barrier->cb)
+    barrier->cb(barrier->cls, barrier, status);
+
+  GNUNET_free(barrier);
+}
+
+struct GNUNET_BarrierWaitHandle*
+GNUNET_wait_barrier (struct GNUNET_BarrierHandle *barrier,
+                     GNUNET_BarrierWaitStatusCallback cb,
+                     void *cb_cls)
+{
+  if ((!barrier) || (0 == barrier->requirement))
+    return NULL;
+
+  struct GNUNET_BarrierWaitHandle *waiting = GNUNET_new(struct GNUNET_BarrierWaitHandle);
+
+  if (!waiting)
+    return NULL;
+
+  waiting->cb = cb;
+  waiting->cls = cb_cls;
+  waiting->prev = NULL;
+  waiting->next = NULL;
+  waiting->barrier = barrier;
+
+  GNUNET_CONTAINER_DLL_insert_tail(barrier->head, barrier->tail, waiting);
+  barrier->requirement--;
+
+  if ((barrier->requirement == 0) && (!barrier->task))
+    barrier->task = GNUNET_SCHEDULER_add_now(complete_barrier, barrier);
+
+  return waiting;
+}
+
+void
+GNUNET_cancel_wait_barrier (struct GNUNET_BarrierWaitHandle *waiting)
+{
+  if (!waiting)
+    return;
+
+  struct GNUNET_BarrierHandle *barrier = waiting->barrier;
+
+  if (!barrier)
+    return;
+
+  if ((barrier->requirement == 0) && (barrier->task))
+  {
+    GNUNET_SCHEDULER_cancel(barrier->task);
+    barrier->task = NULL;
+  }
+
+  barrier->requirement++;
+  GNUNET_CONTAINER_DLL_remove(barrier->head, barrier->tail, waiting);
+
+  GNUNET_free(waiting);
+}
diff --git a/src/messenger/testing_messenger_barrier.h b/src/messenger/testing_messenger_barrier.h
new file mode 100644
index 000000000..3062a393a
--- /dev/null
+++ b/src/messenger/testing_messenger_barrier.h
@@ -0,0 +1,131 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/testing_messenger_barrier.h
+ * @author Tobias Frisch
+ * @brief Pseudo-barriers for simple event handling
+ */
+
+#ifndef GNUNET_TESTING_MESSENGER_BARRIER_H_
+#define GNUNET_TESTING_MESSENGER_BARRIER_H_
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+/**
+ * Handle for pseudo-barrier
+ */
+struct GNUNET_BarrierHandle;
+
+
+/**
+ * Functions of this type are to be given as callback argument to
+ * GNUNET_init_barrier(). The callback will be called when status
+ * information is available for the pseudo-barrier.
+ *
+ * @param cls the closure given to GNUNET_init_barrier()
+ * @param barrier the pseudo-barrier handle
+ * @param status status of the pseudo-barrier. The pseudo-barrier is removed
+ *          once it has been crossed or an error occurs while processing it.
+ *          Therefore it is invalid to call GNUNET_cancel_barrier() on a
+ *          crossed or errored pseudo-barrier.
+ */
+typedef void
+(*GNUNET_BarrierStatusCallback) (void *cls,
+                                 struct GNUNET_BarrierHandle *barrier,
+                                 int status);
+
+
+/**
+ * Initialise a pseudo-barrier and call the given callback when the required
+ * amount of peers (requirement) reach the pseudo-barrier OR upon error.
+ *
+ * @param requirement the amount of peers that is required to reach the
+ *   pseudo-barrier. Peers signal reaching a pseudo-barrier by calling
+ *   GNUNET_wait_barrier().
+ * @param cb the callback to call when the pseudo-barrier is reached or upon
+ *   error. Can be NULL.
+ * @param cls closure for the above callback
+ * @return pseudo-barrier handle; NULL upon error
+ */
+struct GNUNET_BarrierHandle*
+GNUNET_init_barrier (unsigned int requirement,
+                     GNUNET_BarrierStatusCallback cb,
+                     void *cb_cls);
+
+
+/**
+ * Cancel a pseudo-barrier.
+ *
+ * @param barrier the pseudo-barrier handle
+ */
+void
+GNUNET_cancel_barrier (struct GNUNET_BarrierHandle *barrier);
+
+
+/**
+ * Handle for pseudo-barrier wait
+ */
+struct GNUNET_BarrierWaitHandle;
+
+
+/**
+ * Functions of this type are to be given as acallback argument to
+ * GNUNET_wait_barrier(). The callback will be called when the pseudo-barrier
+ * corresponding given in GNUNET_wait_barrier() is crossed or cancelled.
+ *
+ * @param cls closure pointer given to GNUNET_wait_barrier()
+ * @param waiting the pseudo-barrier wait handle
+ * @param status #GNUNET_SYSERR in case of error while waiting for the
+ *   pseudo-barrier; #GNUNET_OK if the pseudo-barrier is crossed
+ */
+typedef void
+(*GNUNET_BarrierWaitStatusCallback) (void *cls,
+                                     struct GNUNET_BarrierWaitHandle *waiting,
+                                     int status);
+
+
+/**
+ * Wait for a pseudo-barrier to be crossed. This function should be called for
+ * the peers which have been started by the testbed.
+ *
+ * @param barrier the pseudo-barrier handle
+ * @param cb the pseudo-barrier wait callback
+ * @param cls the closure for the above callback
+ * @return pseudo-barrier wait handle which can be used to cancel the waiting
+ *   at anytime before the callback is called. NULL upon error.
+ */
+struct GNUNET_BarrierWaitHandle*
+GNUNET_wait_barrier (struct GNUNET_BarrierHandle *barrier,
+                     GNUNET_BarrierWaitStatusCallback cb,
+                     void *cb_cls);
+
+
+/**
+ * Cancel a pseudo-barrier wait handle. Should not be called in or after the
+ * callback given to GNUNET_wait_barrier() has been called.
+ *
+ * @param waiting the pseudo-barrier wait handle
+ */
+void
+GNUNET_cancel_wait_barrier (struct GNUNET_BarrierWaitHandle *waiting);
+
+
+#endif /* GNUNET_TESTING_MESSENGER_BARRIER_H_ */
diff --git a/src/messenger/testing_messenger_setup.c b/src/messenger/testing_messenger_setup.c
new file mode 100644
index 000000000..98241fa08
--- /dev/null
+++ b/src/messenger/testing_messenger_setup.c
@@ -0,0 +1,528 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/testing_messenger_barrier.c
+ * @author Tobias Frisch
+ * @brief A simple test-case setup for the messenger service
+ */
+
+#include "testing_messenger_setup.h"
+
+#include <stdio.h>
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testbed_logger_service.h"
+#include "gnunet_testbed_service.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_messenger_service.h"
+#include "testing_messenger_barrier.h"
+
+#define TEST_ROOM "test"
+#define TEST_NAME "tester"
+
+struct test_properties;
+
+struct test_peer {
+  struct test_properties *props;
+  unsigned int num;
+
+  struct GNUNET_SCHEDULER_Task *op_task;
+  struct GNUNET_TESTBED_Operation *op;
+
+  struct GNUNET_TESTBED_Peer *peer;
+  struct GNUNET_PeerIdentity peer_id;
+  struct GNUNET_BarrierWaitHandle *wait;
+
+  struct GNUNET_MESSENGER_Handle *handle;
+  struct GNUNET_MESSENGER_Room *room;
+
+  unsigned int peer_messages;
+
+  const char *message;
+};
+
+struct test_properties {
+  const struct test_configuration *cfg;
+
+  unsigned int num_hosts;
+
+  struct GNUNET_SCHEDULER_Task *die_task;
+  struct GNUNET_SCHEDULER_Task *end_task;
+
+  struct GNUNET_BarrierHandle *barrier;
+
+  struct test_peer *peers;
+  unsigned int num_peer;
+
+  int status;
+};
+
+static void
+shutdown_cb (void *cls)
+{
+  struct test_properties *properties = cls;
+
+
+  for (unsigned int i = 0; i < properties->num_peer; i++)
+  {
+    struct test_peer *peer = &properties->peers[i];
+
+    GNUNET_assert(peer != NULL);
+
+    if (peer->op_task)
+      GNUNET_SCHEDULER_cancel(peer->op_task);
+
+    peer->op_task = NULL;
+
+    if (peer->op)
+      GNUNET_TESTBED_operation_done (peer->op);
+
+    peer->op = NULL;
+
+    if (peer->wait)
+      GNUNET_cancel_wait_barrier(peer->wait);
+
+    peer->wait = NULL;
+
+    if (peer->room)
+      GNUNET_MESSENGER_close_room (peer->room);
+
+    peer->room = NULL;
+
+    if (peer->handle)
+      GNUNET_MESSENGER_disconnect (peer->handle);
+
+    peer->handle = NULL;
+  }
+
+  if (properties->die_task)
+    GNUNET_SCHEDULER_cancel(properties->die_task);
+
+  properties->die_task = NULL;
+  properties->end_task = NULL;
+
+  if (properties->barrier)
+    GNUNET_cancel_barrier(properties->barrier);
+
+  properties->barrier = NULL;
+}
+
+
+
+static void
+end_cb (void *cls)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  properties->die_task = NULL;
+
+  int status = 0;
+
+  for (unsigned int i = 0; i < properties->num_peer; i++)
+  {
+    struct test_peer *peer = &properties->peers[i];
+
+    GNUNET_assert(peer != NULL);
+
+    const int members = GNUNET_MESSENGER_iterate_members(peer->room, NULL, NULL);
+
+    GNUNET_assert (members >= 0);
+
+    if (peer->props->num_peer != (unsigned int) members)
+    {
+      fprintf (stderr, "Testcase failed (members: %d/%u).\n", members, peer->props->num_peer);
+      status = 1;
+      break;
+    }
+  }
+
+  GNUNET_SCHEDULER_shutdown ();
+
+  properties->status = status;
+}
+
+static void
+end_badly_cb (void *cls)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  fprintf (stderr, "Testcase failed (timeout).\n");
+
+  end_cb (properties);
+
+  properties->status = 1;
+}
+
+static void
+end_operation_cb (void *cls)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  peer->op_task = NULL;
+
+  fprintf (stderr, "Testcase failed (operation: '%s').\n", peer->message);
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+static void
+end_error_cb (void *cls)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  peer->op_task = NULL;
+
+  fprintf (stderr, "Testcase failed (error: '%s').\n", peer->message);
+  GNUNET_free (peer);
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+static void
+barrier2_wait_cb (void *cls, struct GNUNET_BarrierWaitHandle *waiting, int status)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  if (peer->wait == waiting)
+    peer->wait = NULL;
+}
+
+static void
+barrier_wait_cb (void *cls, struct GNUNET_BarrierWaitHandle *waiting, int status)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  if (peer->wait == waiting)
+    peer->wait = NULL;
+
+  if (0 != (peer->props->cfg->stages[peer->num - 1] & 0x02))
+  {
+    unsigned int door = peer->props->cfg->doors[peer->num - 1];
+
+    if (door == 0)
+      door = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, peer->props->cfg->count);
+    else
+      door = door - 1;
+
+    struct GNUNET_HashCode hash;
+    GNUNET_CRYPTO_hash (TEST_ROOM, sizeof(TEST_ROOM), &hash);
+
+    struct GNUNET_MESSENGER_Room *room;
+    room = GNUNET_MESSENGER_enter_room(peer->handle, &(peer->props->peers[door].peer_id), &hash);
+
+    if (peer->room)
+      GNUNET_assert(room == peer->room);
+    else
+      GNUNET_assert(room != NULL);
+
+    peer->room = room;
+  }
+}
+
+/**
+ * Function called whenever a message is received or sent.
+ *
+ * @param cls Closure
+ * @param room Room
+ * @param sender Sender
+ * @param message Message
+ * @param hash Hash of message
+ * @param flags Flags of message
+ */
+static void
+on_message (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender,
+            const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
+            enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  fprintf (stderr, "Peer: %s; [%s] Message: %s (%s)\n",
+           GNUNET_i2s(&(peer->peer_id)),
+           GNUNET_sh2s(&(message->header.sender_id)),
+           GNUNET_MESSENGER_name_of_kind(message->header.kind),
+           GNUNET_h2s(hash));
+
+  if (GNUNET_MESSENGER_KIND_PEER == message->header.kind)
+    peer->peer_messages++;
+
+  if (peer->props->num_hosts == peer->peer_messages)
+    peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier2_wait_cb, peer);
+  else if (peer->props->num_hosts < peer->peer_messages)
+  {
+    if (peer->wait)
+      GNUNET_cancel_wait_barrier(peer->wait);
+
+    peer->wait = NULL;
+
+    if (peer->op_task)
+      GNUNET_SCHEDULER_cancel(peer->op_task);
+
+    peer->message = "peer";
+    peer->op_task = GNUNET_SCHEDULER_add_now (&end_operation_cb, peer);
+  }
+}
+
+static void
+second_stage (void *cls)
+{
+  struct test_peer *peer = cls;
+
+  GNUNET_assert(peer != NULL);
+
+  peer->op_task = NULL;
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (TEST_ROOM, sizeof(TEST_ROOM), &hash);
+
+  if (0 != (peer->props->cfg->stages[peer->num - 1] & 0x10))
+  {
+    struct GNUNET_MESSENGER_Room *room;
+    room = GNUNET_MESSENGER_open_room (peer->handle, &hash);
+
+    if (peer->room)
+      GNUNET_assert(room == peer->room);
+    else
+      GNUNET_assert(room != NULL);
+
+    peer->room = room;
+  }
+
+  if (0 != (peer->props->cfg->stages[peer->num - 1] & 0x20))
+  {
+    unsigned int door = peer->props->cfg->doors[peer->num - 1];
+
+    if (door == 0)
+      door = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, peer->props->cfg->count);
+    else
+      door = door - 1;
+
+    struct GNUNET_MESSENGER_Room *room;
+    room = GNUNET_MESSENGER_enter_room(peer->handle, &(peer->props->peers[door].peer_id), &hash);
+
+    if (peer->room)
+      GNUNET_assert(room == peer->room);
+    else
+      GNUNET_assert(room != NULL);
+
+    peer->room = room;
+  }
+}
+
+static void
+on_peer (void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo,
+         const char *emsg)
+{
+  struct test_peer *peer = cb_cls;
+
+  GNUNET_assert(peer != NULL);
+
+  if (emsg)
+  {
+    peer->message = GNUNET_strdup(emsg);
+    peer->op_task = GNUNET_SCHEDULER_add_now (&end_error_cb, peer);
+    return;
+  }
+
+  if (!pinfo)
+  {
+    peer->message = "info";
+    peer->op_task = GNUNET_SCHEDULER_add_now (&end_operation_cb, peer);
+    return;
+  }
+
+  if (pinfo->pit != GNUNET_TESTBED_PIT_CONFIGURATION)
+  {
+    peer->message = "config";
+    peer->op_task = GNUNET_SCHEDULER_add_now (&end_operation_cb, peer);
+    return;
+  }
+
+  peer->handle = GNUNET_MESSENGER_connect (pinfo->result.cfg, TEST_NAME, NULL, NULL, &on_message, peer);
+
+  GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_get_peer_identity(
+      pinfo->result.cfg, &(peer->peer_id)
+  ));
+
+  if (0 != (peer->props->cfg->stages[peer->num - 1] & 0x01))
+  {
+    struct GNUNET_HashCode hash;
+    GNUNET_CRYPTO_hash (TEST_ROOM, sizeof(TEST_ROOM), &hash);
+
+    peer->room = GNUNET_MESSENGER_open_room (peer->handle, &hash);
+
+    GNUNET_assert(peer->room != NULL);
+  }
+  else
+    peer->room = NULL;
+
+  peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier_wait_cb, peer);
+}
+
+/**
+ * Main function for a peer of the testcase.
+ *
+ * @param cls Closure
+ * @param event Information about the event
+ */
+static void
+run (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  if (GNUNET_TESTBED_ET_PEER_START != event->type)
+  {
+    fprintf (stderr, "Testcase failed (operation: 'start').\n");
+
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  struct test_peer *peer = &(properties->peers[properties->num_peer++]);
+
+  peer->props = properties;
+  peer->num = properties->num_peer;
+
+  peer->peer = event->details.peer_start.peer;
+  peer->op = GNUNET_TESTBED_peer_get_information (peer->peer, GNUNET_TESTBED_PIT_CONFIGURATION, on_peer, peer);
+}
+
+static void
+barrier2_cb (void *cls, struct GNUNET_BarrierHandle *barrier, int status)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  if (properties->barrier == barrier)
+    properties->barrier = NULL;
+
+  if (GNUNET_SYSERR == status)
+  {
+    fprintf (stderr, "Testcase failed (operation: 'barrier2').\n");
+
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  else if (GNUNET_OK == status)
+  {
+    if (properties->die_task)
+      GNUNET_SCHEDULER_cancel(properties->die_task);
+
+    properties->die_task = GNUNET_SCHEDULER_add_delayed (
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, properties->cfg->count),
+        &end_cb, properties
+    );
+  }
+}
+
+static void
+barrier_cb (void *cls, struct GNUNET_BarrierHandle *barrier, int status)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  if (properties->barrier == barrier)
+    properties->barrier = NULL;
+  else if (!properties->barrier)
+    return;
+
+  if (properties->num_peer != properties->cfg->count)
+  {
+    fprintf (stderr, "Testcase failed (operation: 'process').\n");
+
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  if (GNUNET_SYSERR == status)
+  {
+    fprintf (stderr, "Testcase failed (operation: 'barrier').\n");
+
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  else if (GNUNET_OK == status)
+  {
+    properties->barrier = GNUNET_init_barrier (properties->num_peer, &barrier2_cb, properties);
+
+    for (unsigned int i = 0; i < properties->num_peer; i++)
+      properties->peers[i].op_task = GNUNET_SCHEDULER_add_now (&second_stage, &(properties->peers[i]));
+  }
+}
+
+static void
+init (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers,
+      unsigned int links_succeeded, unsigned int links_failed)
+{
+  struct test_properties *properties = cls;
+
+  GNUNET_assert(properties != NULL);
+
+  properties->end_task = GNUNET_SCHEDULER_add_shutdown(&shutdown_cb, properties);
+  properties->die_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, properties->cfg->count * 5),
+      &end_badly_cb, properties
+  );
+}
+
+int
+GNUNET_run_messenger_setup (const char* test_name, const struct test_configuration *cfg)
+{
+  struct test_properties properties;
+  memset(&properties, 0, sizeof(properties));
+
+  properties.cfg = cfg;
+  properties.peers = GNUNET_new_array(cfg->count, struct test_peer);
+
+  for (unsigned int i = 0; i < cfg->count; i++)
+    if (0 != (cfg->stages[i] & 0x11))
+      properties.num_hosts++;
+
+  properties.status = 1;
+  properties.barrier = GNUNET_init_barrier (cfg->count, &barrier_cb, &properties);
+
+  if (GNUNET_OK != GNUNET_TESTBED_test_run (test_name, "test_messenger_api.conf",
+                                            cfg->count,
+                                            (1LL << GNUNET_TESTBED_ET_PEER_START),
+                                            &run, &properties,
+                                            &init, &properties))
+    return 1;
+
+  GNUNET_free(properties.peers);
+
+  return properties.status;
+}
diff --git a/src/messenger/testing_messenger_setup.h b/src/messenger/testing_messenger_setup.h
new file mode 100644
index 000000000..5e6b5d461
--- /dev/null
+++ b/src/messenger/testing_messenger_setup.h
@@ -0,0 +1,39 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/testing_messenger_setup.h
+ * @author Tobias Frisch
+ * @brief A simple test-case setup for the messenger service
+ */
+
+#ifndef GNUNET_TESTING_MESSENGER_SETUP_H_
+#define GNUNET_TESTING_MESSENGER_SETUP_H_
+
+struct test_configuration
+{
+  unsigned int count;
+  unsigned int *doors;
+  unsigned int *stages;
+};
+
+int
+GNUNET_run_messenger_setup (const char* test_name, const struct test_configuration *cfg);
+
+#endif /* GNUNET_TESTING_MESSENGER_SETUP_H_ */
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index d6774b37b..79210939f 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -743,13 +743,14 @@ send_lookup_response (struct NamestoreClient *nc,
     nick->flags =
       (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
     merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
-    GNUNET_free (nick);
   }
   else
   {
     res_count = rd_count;
     res = (struct GNUNET_GNSRECORD_Data *) rd;
   }
+  if (NULL != nick)
+    GNUNET_free (nick);
 
   GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (res_count, res));
 
@@ -758,12 +759,16 @@ send_lookup_response (struct NamestoreClient *nc,
   rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, res);
   if (rd_ser_len < 0)
   {
+    if (rd != res)
+      GNUNET_free (res);
     GNUNET_break (0);
     GNUNET_SERVICE_client_drop (nc->client);
     return;
   }
   if (((size_t) rd_ser_len) >= UINT16_MAX - name_len - sizeof(*zir_msg))
   {
+    if (rd != res)
+      GNUNET_free (res);
     GNUNET_break (0);
     GNUNET_SERVICE_client_drop (nc->client);
     return;
@@ -920,12 +925,15 @@ refresh_block (struct NamestoreClient *nc,
     nick->flags =
       (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
     merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
-    GNUNET_free (nick);
   }
+  if (NULL != nick)
+    GNUNET_free (nick);
   if (0 == res_count)
   {
     if (NULL != nc)
       send_store_response (nc, GNUNET_OK, rid);
+    if (rd != res)
+      GNUNET_free (res);
     return;   /* no data, no need to update cache */
   }
   if (GNUNET_YES == disable_namecache)
@@ -936,6 +944,8 @@ refresh_block (struct NamestoreClient *nc,
                               GNUNET_NO);
     if (NULL != nc)
       send_store_response (nc, GNUNET_OK, rid);
+    if (rd != res)
+      GNUNET_free (res);
     return;
   }
   exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, res);
@@ -970,6 +980,8 @@ refresh_block (struct NamestoreClient *nc,
                                           &finish_cache_operation,
                                           cop);
   GNUNET_free (block);
+  if (rd != res)
+    GNUNET_free (res);
 }
 
 
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index c845b5019..2d5327e06 100644
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_api.c
@@ -690,6 +690,12 @@ handle_zone_to_name_response (void *cls,
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n");
   qe = find_qe (h, ntohl (msg->gns_header.r_id));
+  if (NULL == qe)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Response queue already gone...\n");
+    return;
+  }
   res = ntohs (msg->res);
   switch (res)
   {
diff --git a/src/namestore/plugin_rest_namestore.c b/src/namestore/plugin_rest_namestore.c
index edcbeb874..ae93e5eff 100644
--- a/src/namestore/plugin_rest_namestore.c
+++ b/src/namestore/plugin_rest_namestore.c
@@ -375,6 +375,8 @@ get_egoentry_namestore (struct RequestHandle *handle, char *name)
   if (NULL == name)
     return NULL;
   tmp = strtok (copy, "/");
+  if (NULL == tmp)
+    return NULL;
   for (ego_entry = ego_head; NULL != ego_entry;
        ego_entry = ego_entry->next)
   {
diff --git a/src/peerinfo-tool/plugin_rest_peerinfo.c b/src/peerinfo-tool/plugin_rest_peerinfo.c
index 4bbc7442e..f969a175b 100644
--- a/src/peerinfo-tool/plugin_rest_peerinfo.c
+++ b/src/peerinfo-tool/plugin_rest_peerinfo.c
@@ -379,7 +379,9 @@ peerinfo_list_finished (void *cls)
   result_str = json_dumps (handle->response, 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
-  MHD_add_response_header (resp, "Content-Type", "application/json");
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Content-Type",
+                                                    "application/json"));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free (result_str);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
diff --git a/src/peerstore/gnunet-service-peerstore.c b/src/peerstore/gnunet-service-peerstore.c
index c92e4d3f0..959d088f9 100644
--- a/src/peerstore/gnunet-service-peerstore.c
+++ b/src/peerstore/gnunet-service-peerstore.c
@@ -77,6 +77,8 @@ static unsigned int num_clients;
 static void
 do_shutdown ()
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutting down peerstore, bye.\n");
   if (NULL != db_lib_name)
   {
     GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, db));
@@ -105,6 +107,8 @@ do_shutdown ()
 static void
 shutdown_task (void *cls)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Priming PEERSTORE for shutdown.\n");
   in_shutdown = GNUNET_YES;
   if (0 == num_clients) /* Only when no connected clients. */
     do_shutdown ();
@@ -176,6 +180,8 @@ client_connect_cb (void *cls,
                    struct GNUNET_MQ_Handle *mq)
 {
   num_clients++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "A client connected (now %u)\n", num_clients);
   return client;
 }
 
@@ -195,7 +201,7 @@ client_disconnect_it (void *cls, const struct GNUNET_HashCode *key, void *value)
   {
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CONTAINER_multihashmap_remove (watchers, key, value));
-    num_clients++;
+    num_clients++; /* Watchers do not count */
   }
   return GNUNET_OK;
 }
@@ -212,12 +218,14 @@ client_disconnect_cb (void *cls,
                       struct GNUNET_SERVICE_Client *client,
                       void *app_cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "A client disconnected, cleaning up.\n");
+  num_clients--;
   if (NULL != watchers)
     GNUNET_CONTAINER_multihashmap_iterate (watchers,
                                            &client_disconnect_it,
                                            client);
-  num_clients--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "A client disconnected (%u remaining).\n",
+              num_clients);
   if ((0 == num_clients) && in_shutdown)
     do_shutdown ();
 }
@@ -540,6 +548,7 @@ run (void *cls,
   char *database;
 
   in_shutdown = GNUNET_NO;
+  num_clients = 0;
   cfg = c;
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                           "peerstore",
diff --git a/src/peerstore/peerstore_api.c b/src/peerstore/peerstore_api.c
index db5aee0d5..196d44faa 100644
--- a/src/peerstore/peerstore_api.c
+++ b/src/peerstore/peerstore_api.c
@@ -823,7 +823,12 @@ reconnect (void *cls)
                                  &handle_client_error,
                                  h);
   if (NULL == h->mq)
+  {
+    h->reconnect_task =
+      GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
+    h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
     return;
+  }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Resending pending requests after reconnect.\n");
   if (NULL != h->watches)
diff --git a/src/peerstore/test_peerstore_api_sync.c b/src/peerstore/test_peerstore_api_sync.c
index 4c826c654..5057c98b5 100644
--- a/src/peerstore/test_peerstore_api_sync.c
+++ b/src/peerstore/test_peerstore_api_sync.c
@@ -67,6 +67,24 @@ static const char *val = "test_peerstore_api_store_val";
 
 
 /**
+ * Timeout
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+
+/**
+ * Timeout task
+ */
+static struct GNUNET_SCHEDULER_Task *to;
+
+/**
+ * Iterate handle
+ */
+static struct GNUNET_PEERSTORE_IterateContext *it;
+
+static void
+test_cont (void *cls);
+
+/**
  * Function that should be called with the result of the
  * lookup, and finally once with NULL to signal the end
  * of the iteration.
@@ -89,9 +107,24 @@ iterate_cb (void *cls,
   GNUNET_break (NULL == emsg);
   if (NULL == record)
   {
-    GNUNET_PEERSTORE_disconnect (h,
-                                 GNUNET_NO);
-    GNUNET_SCHEDULER_shutdown ();
+    it = NULL;
+    if (0 == ok)
+    {
+      GNUNET_PEERSTORE_disconnect (h,
+                                   GNUNET_NO);
+      if (NULL != to)
+      {
+        GNUNET_SCHEDULER_cancel (to);
+        to = NULL;
+      }
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    /**
+     * Try again
+     */
+    GNUNET_SCHEDULER_add_now (&test_cont,
+                              NULL);
     return;
   }
   rec_val = record->value;
@@ -100,6 +133,22 @@ iterate_cb (void *cls,
 }
 
 
+static void
+timeout_task (void *cls)
+{
+  to = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout reached\n");
+  if (NULL != it)
+    GNUNET_PEERSTORE_iterate_cancel (it);
+  it = NULL;
+  GNUNET_PEERSTORE_disconnect (h,
+                               GNUNET_NO);
+  GNUNET_SCHEDULER_shutdown ();
+  return;
+}
+
+
 /**
  * Run the 2nd stage of the test where we fetch the
  * data that should have been stored.
@@ -109,12 +158,11 @@ iterate_cb (void *cls,
 static void
 test_cont (void *cls)
 {
-  h = GNUNET_PEERSTORE_connect (cfg);
-  GNUNET_PEERSTORE_iterate (h,
-                            subsystem,
-                            &pid, key,
-                            &iterate_cb,
-                            NULL);
+  it = GNUNET_PEERSTORE_iterate (h,
+                                 subsystem,
+                                 &pid, key,
+                                 &iterate_cb,
+                                 NULL);
 }
 
 
@@ -122,10 +170,9 @@ static void
 disc_cont (void *cls)
 {
   GNUNET_PEERSTORE_disconnect (h, GNUNET_YES);
-  h = NULL;
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                &test_cont,
-                                NULL);
+  h = GNUNET_PEERSTORE_connect (cfg);
+  GNUNET_SCHEDULER_add_now (&test_cont,
+                            NULL);
 }
 
 
@@ -133,12 +180,17 @@ static void
 store_cont (void *cls, int success)
 {
   ok = success;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Success: %s\n",
+              (GNUNET_SYSERR == ok) ? "no" : "yes");
   /* We need to wait a little bit to give the disconnect
      a chance to actually finish the operation; otherwise,
      the test may fail non-deterministically if the new
      connection is faster than the cleanup routine of the
-     old one. */GNUNET_SCHEDULER_add_now (&disc_cont,
-                            NULL);
+     old one. */
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                &disc_cont,
+                                NULL);
 }
 
 
@@ -174,7 +226,10 @@ run (void *cls,
 {
   cfg = c;
   memset (&pid, 1, sizeof(pid));
-  test1 ();
+  to = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                     &timeout_task,
+                                     NULL);
+  GNUNET_SCHEDULER_add_now (&test1, NULL);
 }
 
 
diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c
index 913b667b7..04c12735b 100644
--- a/src/reclaim/gnunet-service-reclaim.c
+++ b/src/reclaim/gnunet-service-reclaim.c
@@ -731,9 +731,12 @@ static int
 check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 {
   uint16_t size;
+  size_t attrs_len;
 
   size = ntohs (im->header.size);
-  if (size <= sizeof(struct IssueTicketMessage))
+  attrs_len = ntohs (im->attr_len);
+
+  if (attrs_len > size - sizeof(struct IssueTicketMessage))
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
diff --git a/src/reclaim/gnunet-service-reclaim_tickets.c b/src/reclaim/gnunet-service-reclaim_tickets.c
index ef2303bd7..48b3fe214 100644
--- a/src/reclaim/gnunet-service-reclaim_tickets.c
+++ b/src/reclaim/gnunet-service-reclaim_tickets.c
@@ -690,7 +690,10 @@ rvk_move_attr_cb (void *cls,
     return;
   }
   GNUNET_RECLAIM_id_generate (&rvk->move_attr->new_id);
-  new_label = NULL;
+  new_label =
+    GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->new_id,
+                                         sizeof (rvk->move_attr->new_id));
+
   attr_data = NULL;
   // new_rd = *rd;
   for (int i = 0; i < rd_count; i++)
@@ -714,9 +717,6 @@ rvk_move_attr_cb (void *cls,
       new_rd[i].record_type = rd[i].record_type;
       new_rd[i].flags = rd[i].flags;
       new_rd[i].expiration_time = rd[i].expiration_time;
-      new_label =
-        GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->new_id,
-                                             sizeof (rvk->move_attr->new_id));
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
       GNUNET_free (claim);
     }
@@ -738,9 +738,6 @@ rvk_move_attr_cb (void *cls,
       new_rd[i].record_type = rd[i].record_type;
       new_rd[i].flags = rd[i].flags;
       new_rd[i].expiration_time = rd[i].expiration_time;
-      new_label =
-        GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->new_id,
-                                             sizeof (rvk->move_attr->new_id));
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n",
                   new_label);
       GNUNET_free (credential);
@@ -1400,7 +1397,7 @@ issue_ticket (struct TicketIssueHandle *ih)
                                               attrs_record,
                                               &store_ticket_issue_cont,
                                               ih);
-  for (j = 0; j > i; j++)
+  for (j = 0; j < i; j++)
   {
     if (attrs_record[j].record_type
         != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION)
@@ -1585,7 +1582,7 @@ filter_tickets_cb (void *cls,
     cleanup_issue_handle (tih);
     return;
   }
-
+  GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
   // ticket not found in current record, checking next record set
   GNUNET_NAMESTORE_zone_iterator_next (tih->ns_it, 1);
 }
diff --git a/src/reclaim/oidc_helper.c b/src/reclaim/oidc_helper.c
index bd3a8ee05..7b24ee598 100644
--- a/src/reclaim/oidc_helper.c
+++ b/src/reclaim/oidc_helper.c
@@ -839,11 +839,17 @@ int
 OIDC_access_token_parse (const char *token,
                          struct GNUNET_RECLAIM_Ticket **ticket)
 {
-  if (sizeof (struct GNUNET_RECLAIM_Ticket) !=
-      GNUNET_STRINGS_base64_decode (token,
-                                    strlen (token),
-                                    (void**) ticket))
+  size_t sret;
+  char *decoded;
+  sret = GNUNET_STRINGS_base64_decode (token,
+                                       strlen (token),
+                                       (void**) &decoded);
+  if (sizeof (struct GNUNET_RECLAIM_Ticket) != sret)
+  {
+    GNUNET_free (decoded);
     return GNUNET_SYSERR;
+  }
+  *ticket = (struct GNUNET_RECLAIM_Ticket *) decoded;
   return GNUNET_OK;
 }
 
diff --git a/src/reclaim/pabc_helper.c b/src/reclaim/pabc_helper.c
index e76977d03..c435ad5b3 100644
--- a/src/reclaim/pabc_helper.c
+++ b/src/reclaim/pabc_helper.c
@@ -29,7 +29,8 @@ write_file (char const *const filename, const char *buffer)
   struct GNUNET_DISK_FileHandle *fh;
   fh = GNUNET_DISK_file_open (filename,
                               GNUNET_DISK_OPEN_WRITE
-                              | GNUNET_DISK_OPEN_TRUNCATE,
+                              | GNUNET_DISK_OPEN_TRUNCATE
+                              | GNUNET_DISK_OPEN_CREATE,
                               GNUNET_DISK_PERM_USER_WRITE);
   if (fh == NULL)
     return GNUNET_SYSERR;
diff --git a/src/reclaim/plugin_gnsrecord_reclaim.c b/src/reclaim/plugin_gnsrecord_reclaim.c
index 60c49fd6a..9e4f0a5c4 100644
--- a/src/reclaim/plugin_gnsrecord_reclaim.c
+++ b/src/reclaim/plugin_gnsrecord_reclaim.c
@@ -50,7 +50,6 @@ value_to_string (void *cls, uint32_t type, const void *data, size_t data_size)
   case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET:
-  case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION:
     return GNUNET_STRINGS_data_to_string_alloc (data, data_size);
@@ -87,7 +86,6 @@ string_to_value (void *cls, uint32_t type, const char *s, void **data,
     return GNUNET_OK;
   case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF:
-  case GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL:
   case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION:
@@ -112,7 +110,6 @@ static struct
   { "RECLAIM_ATTRIBUTE_REF", GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF },
   { "RECLAIM_CREDENTIAL", GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL },
   { "RECLAIM_PRESENTATION", GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION },
-  { "RECLAIM_MASTER", GNUNET_GNSRECORD_TYPE_RECLAIM_MASTER },
   { "RECLAIM_OIDC_CLIENT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_CLIENT },
   { "RECLAIM_OIDC_REDIRECT", GNUNET_GNSRECORD_TYPE_RECLAIM_OIDC_REDIRECT },
   { "RECLAIM_TICKET", GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET },
diff --git a/src/reclaim/plugin_reclaim_credential_pabc.c b/src/reclaim/plugin_reclaim_credential_pabc.c
index 148cfec13..87406e60b 100644
--- a/src/reclaim/plugin_reclaim_credential_pabc.c
+++ b/src/reclaim/plugin_reclaim_credential_pabc.c
@@ -144,6 +144,22 @@ pabc_number_to_typename (void *cls, uint32_t type)
 }
 
 
+static void
+inspect_attrs (char const *const key,
+                char const *const value,
+                void *ctx)
+{
+  struct GNUNET_RECLAIM_AttributeList *attrs = ctx;
+
+  GNUNET_RECLAIM_attribute_list_add (attrs,
+                                     key,
+                                     NULL,
+                                     GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING,
+                                     value,
+                                     strlen (value));
+}
+
+
 /**
  * Parse a pabc and return the respective claim value as Attribute
  *
@@ -156,14 +172,9 @@ pabc_parse_attributes (void *cls,
                        const char *data,
                        size_t data_size)
 {
-  const char *key;
   struct GNUNET_RECLAIM_AttributeList *attrs;
-  char *val_str = NULL;
-  char *tmp;
-  json_t *value;
-  json_t *attr;
-  json_t *json_attrs;
   json_t *json_root;
+  json_t *json_attrs;
   json_error_t *json_err = NULL;
 
   json_root = json_loads (data, JSON_DECODE_ANY, json_err);
@@ -177,55 +188,20 @@ pabc_parse_attributes (void *cls,
       json_decref (json_root);
     return NULL;
   }
-  json_attrs = json_object_get (json_root, "attributes");
+  json_attrs = json_object_get (json_root, PABC_JSON_PLAIN_ATTRS_KEY);
   if ((NULL == json_attrs) ||
-      (! json_is_array (json_attrs)))
+      (! json_is_object (json_attrs)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s is not a valid pabc credentials (attributes not an array)\n",
+                "%s is not a valid pabc credentials (attributes not an object)\n",
                 data);
     json_decref (json_root);
     return NULL;
   }
 
   attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
-  for (int i = 0; i < json_array_size (json_attrs); i++)
-  {
-    attr = json_array_get (json_attrs, i);
-    if (! json_is_object (attr))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Found json entry is not an object!\n");
-      GNUNET_RECLAIM_attribute_list_destroy (attrs);
-      json_decref (json_root);
-      return NULL;
-    }
-    /**
-     * This *should* only contain a single pair.
-     */
-    json_object_foreach (attr, key, value)
-    {
-      if ((0 == strcmp ("issuer", key)) ||
-          (0 == strcmp ("expiration", key)) ||
-          (0 == strcmp ("subject", key)))
-        continue;
-      val_str = json_dumps (value, JSON_ENCODE_ANY);
-      tmp = val_str;
-      // Remove leading " from jasson conversion
-      if (tmp[0] == '"')
-        tmp++;
-      // Remove trailing " from jansson conversion
-      if (tmp[strlen (tmp) - 1] == '"')
-        tmp[strlen (tmp) - 1] = '\0';
-      GNUNET_RECLAIM_attribute_list_add (attrs,
-                                         key,
-                                         NULL,
-                                         GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING,
-                                         tmp,
-                                         strlen (tmp));
-      GNUNET_free (val_str);
-    }
-  }
+  char *attr_str = json_dumps (json_attrs, JSON_DECODE_ANY);
+  pabc_cred_inspect_credential (attr_str, &inspect_attrs, attrs);
   json_decref (json_root);
   return attrs;
 }
@@ -260,6 +236,22 @@ pabc_parse_attributes_p (void *cls,
   return pabc_parse_attributes (cls, cred->data, cred->data_size);
 }
 
+struct Finder
+{
+  const char* target;
+  char *result;
+};
+
+static void
+find_attr (char const *const key,
+                char const *const value,
+                void *ctx)
+{
+  struct Finder *fdr = ctx;
+  if (0 == strcmp (key, fdr->target))
+    fdr->result = GNUNET_strdup (value);
+}
+
 
 /**
  * Parse a pabc and return an attribute value.
@@ -267,7 +259,7 @@ pabc_parse_attributes_p (void *cls,
  * @param cls the plugin
  * @param data the pabc credential data
  * @param data_size the pabc credential size
- * @param key the attribute key to look for.
+ * @param skey the attribute key to look for.
  * @return a string, containing the isser
  */
 char *
@@ -276,13 +268,8 @@ pabc_get_attribute (void *cls,
                     size_t data_size,
                     const char *skey)
 {
-  const char *key;
-  char *val_str = NULL;
-  char *tmp;
   json_t *json_root;
   json_t *json_attrs;
-  json_t *value;
-  json_t *attr;
   json_error_t *json_err = NULL;
 
   json_root = json_loads (data, JSON_DECODE_ANY, json_err);
@@ -290,50 +277,29 @@ pabc_get_attribute (void *cls,
       (! json_is_object (json_root)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s is not a valid pabc credentials (not an object)\n",
+                "%s is not a valid pabc credential (not an object)\n",
                 data);
     if (NULL != json_root)
       json_decref (json_root);
     return NULL;
   }
-  json_attrs = json_object_get (json_root, "attributes");
+  json_attrs = json_object_get (json_root, PABC_JSON_PLAIN_ATTRS_KEY);
   if ((NULL == json_attrs) ||
-      (! json_is_array (json_attrs)))
+      (! json_is_object (json_attrs)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s is not a valid pabc credentials (attributes not an array)\n",
+                "%s is not a valid pabc credential (attributes not an object)\n",
                 data);
     json_decref (json_root);
     return NULL;
   }
-
-  for (int i = 0; i < json_array_size (json_attrs); i++)
-  {
-    attr = json_array_get (json_attrs, i);
-    if (! json_is_object (attr))
-      continue;
-    /**
-     * This *should* only contain a single pair.
-     */
-    json_object_foreach (attr, key, value)
-    {
-      if (0 != strcmp (skey, key))
-        continue;
-      val_str = json_dumps (value, JSON_ENCODE_ANY);
-      tmp = val_str;
-      // Remove leading " from jasson conversion
-      if (tmp[0] == '"')
-        tmp++;
-      // Remove trailing " from jansson conversion
-      if (tmp[strlen (tmp) - 1] == '"')
-        tmp[strlen (tmp) - 1] = '\0';
-      GNUNET_free (val_str);
-      json_decref (json_root);
-      return tmp;
-    }
-  }
+  char *attr_str = json_dumps (json_attrs, JSON_DECODE_ANY);
   json_decref (json_root);
-  return NULL;
+  struct Finder fdr;
+  memset (&fdr, 0, sizeof (fdr));
+  fdr.target = skey;
+  pabc_cred_inspect_credential (attr_str, &find_attr, &fdr);
+  return fdr.result;
 }
 
 
@@ -403,9 +369,8 @@ pabc_get_expiration (void *cls,
   json_t *json_root;
   json_t *json_attrs;
   json_t *value;
-  json_t *attr;
+  json_t *exp_j;
   json_error_t *json_err = NULL;
-  const char*key;
 
   json_root = json_loads (data, JSON_DECODE_ANY, json_err);
   if ((NULL == json_root) ||
@@ -418,24 +383,23 @@ pabc_get_expiration (void *cls,
       json_decref (json_root);
     return GNUNET_SYSERR;
   }
-  for (int i = 0; i < json_array_size (json_attrs); i++)
+  json_attrs = json_object_get (json_root, PABC_JSON_PLAIN_ATTRS_KEY);
+  if ((NULL == json_attrs) ||
+      (! json_is_object (json_attrs)))
   {
-    attr = json_array_get (json_attrs, i);
-    if (! json_is_object (attr))
-      continue;
-    /**
-     * This *should* only contain a single pair.
-     */
-    json_object_foreach (attr, key, value)
-    {
-      if (0 != strcmp ("expiration", key))
-        continue;
-      if (! json_is_integer (value))
-        continue;
-      exp->abs_value_us = json_integer_value (value) * 1000 * 1000;
-      json_decref (json_root);
-      return GNUNET_OK;
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "%s is not a valid pabc credential (attributes not an object)\n",
+                data);
+    json_decref (json_root);
+    return GNUNET_SYSERR;
+  }
+  exp_j = json_object_get (json_attrs, "expiration");
+  if ((NULL != exp_j) &&
+      json_is_integer (exp_j))
+  {
+    exp->abs_value_us = json_integer_value (value) * 1000 * 1000;
+    json_decref (json_root);
+    return GNUNET_OK;
   }
   json_decref (json_root);
   return GNUNET_SYSERR;
diff --git a/src/reclaim/plugin_rest_openid_connect.c b/src/reclaim/plugin_rest_openid_connect.c
index 0ee61755b..c6259d745 100644
--- a/src/reclaim/plugin_rest_openid_connect.c
+++ b/src/reclaim/plugin_rest_openid_connect.c
@@ -686,7 +686,10 @@ do_userinfo_error (void *cls)
                    handle->emsg,
                    (NULL != handle->edesc) ? handle->edesc : "");
   resp = GNUNET_REST_create_response ("");
-  MHD_add_response_header (resp, MHD_HTTP_HEADER_WWW_AUTHENTICATE, "Bearer");
+  GNUNET_assert (MHD_NO !=
+                 MHD_add_response_header (resp,
+                                          MHD_HTTP_HEADER_WWW_AUTHENTICATE,
+                                          "Bearer"));
   handle->proc (handle->proc_cls, resp, handle->response_code);
   cleanup_handle (handle);
   GNUNET_free (error);
@@ -713,7 +716,8 @@ do_redirect_error (void *cls)
                    (NULL != handle->oidc->state) ? "&state=" : "",
                    (NULL != handle->oidc->state) ? handle->oidc->state : "");
   resp = GNUNET_REST_create_response ("");
-  MHD_add_response_header (resp, "Location", redirect);
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Location", redirect));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_FOUND);
   cleanup_handle (handle);
   GNUNET_free (redirect);
@@ -1022,7 +1026,8 @@ oidc_ticket_issue_cb (void *cls,
                      handle->oidc->state);
   }
   resp = GNUNET_REST_create_response ("");
-  MHD_add_response_header (resp, "Location", redirect_uri);
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Location", redirect_uri));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_FOUND);
   cleanup_handle (handle);
   GNUNET_free (redirect_uri);
@@ -1381,7 +1386,8 @@ build_redirect (void *cls)
                        handle->oidc->state);
     }
     resp = GNUNET_REST_create_response ("");
-    MHD_add_response_header (resp, "Location", redirect_uri);
+    GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                      "Location", redirect_uri));
     handle->proc (handle->proc_cls, resp, MHD_HTTP_FOUND);
     cleanup_handle (handle);
     GNUNET_free (redirect_uri);
@@ -1764,8 +1770,12 @@ login_cont (struct GNUNET_REST_RequestHandle *con_handle,
                    "%s;Max-Age=%d",
                    cookie,
                    OIDC_COOKIE_EXPIRATION);
-  MHD_add_response_header (resp, "Set-Cookie", header_val);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", "POST");
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Set-Cookie", header_val));
+  GNUNET_assert (MHD_NO !=
+                 MHD_add_response_header (resp,
+                                          "Access-Control-Allow-Methods",
+                                          "POST"));
   GNUNET_CRYPTO_hash (cookie, strlen (cookie), &cache_key);
 
   if (0 != strcmp (json_string_value (identity), "Denied"))
@@ -1880,7 +1890,8 @@ parse_credentials_post_body (struct RequestHandle *handle,
   }
   pass = GNUNET_CONTAINER_multihashmap_get (handle->rest_handle->url_param_map,
                                             &cache_key);
-  if (NULL == pass) {
+  if (NULL == pass)
+  {
     GNUNET_free (*client_id);
     *client_id = NULL;
     return GNUNET_SYSERR;
@@ -2134,6 +2145,8 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle,
     GNUNET_free (code);
     if (NULL != nonce)
       GNUNET_free (nonce);
+    GNUNET_RECLAIM_attribute_list_destroy (cl);
+    GNUNET_RECLAIM_presentation_list_destroy (pl);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -2149,6 +2162,8 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle,
     handle->edesc = GNUNET_strdup ("No signing secret configured!");
     handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
     GNUNET_free (code);
+    GNUNET_RECLAIM_attribute_list_destroy (cl);
+    GNUNET_RECLAIM_presentation_list_destroy (pl);
     if (NULL != nonce)
       GNUNET_free (nonce);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
@@ -2191,9 +2206,14 @@ token_endpoint (struct GNUNET_REST_RequestHandle *con_handle,
                              &json_response);
 
   resp = GNUNET_REST_create_response (json_response);
-  MHD_add_response_header (resp, "Cache-Control", "no-store");
-  MHD_add_response_header (resp, "Pragma", "no-cache");
-  MHD_add_response_header (resp, "Content-Type", "application/json");
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Cache-Control",
+                                                    "no-store"));
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Pragma", "no-cache"));
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Content-Type",
+                                                    "application/json"));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_RECLAIM_attribute_list_destroy (cl);
   GNUNET_RECLAIM_presentation_list_destroy (pl);
@@ -2665,8 +2685,14 @@ oidc_config_cors (struct GNUNET_REST_RequestHandle *con_handle,
 
   // For now, independent of path return all options
   resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
-  MHD_add_response_header (resp, "Access-Control-Allow-Origin", "*");
+  GNUNET_assert (MHD_NO !=
+                 MHD_add_response_header (resp,
+                                          "Access-Control-Allow-Methods",
+                                          allow_methods));
+  GNUNET_assert (MHD_NO !=
+                 MHD_add_response_header (resp,
+                                          "Access-Control-Allow-Origin",
+                                          "*"));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   cleanup_handle (handle);
   return;
diff --git a/src/reclaim/plugin_rest_pabc.c b/src/reclaim/plugin_rest_pabc.c
index 1c766a716..9c1ac3c47 100644
--- a/src/reclaim/plugin_rest_pabc.c
+++ b/src/reclaim/plugin_rest_pabc.c
@@ -264,9 +264,8 @@ set_attributes_from_idtoken (const struct pabc_context *ctx,
                                                json_string_value (value));
     if (PABC_OK != status)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to set attribute.\n");
-      return PABC_FAILURE;
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Failed to set attribute `%s'.\n", key);
     }
   }
   return PABC_OK;
@@ -370,7 +369,7 @@ cr_cont (struct GNUNET_REST_RequestHandle *con_handle,
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  idtoken_json = json_object_get (idtoken_json, "id_token");
+  idtoken_json = json_object_get (data_json, "id_token");
   if (NULL == idtoken_json)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -390,13 +389,18 @@ cr_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
 
   PABC_ASSERT (pabc_new_ctx (&ctx));
-  // FIXME jansson does stupid escaping here maybe expect ecoded?
+  char *pp_str = json_dumps (pp_json, JSON_ENCODE_ANY);
   status = pabc_decode_and_new_public_parameters (ctx,
                                                   &pp,
-                                                  json_string_value (pp_json));
+                                                  pp_str);
+  char *ppid;
+  GNUNET_assert (PABC_OK == pabc_cred_get_ppid_from_pp (pp_str, &ppid));
+  GNUNET_free (pp_str);
   if (status != PABC_OK)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to read public parameters.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to read public parameters: %s\n",
+                pp_str);
     json_decref (data_json);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
@@ -457,8 +461,8 @@ cr_cont (struct GNUNET_REST_RequestHandle *con_handle,
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  // FIXME: where does this come from???
-  status = pabc_decode_nonce (ctx, nonce, json_string_value (nonce_json));
+  char *nonce_str = json_dumps (nonce_json, JSON_ENCODE_ANY);
+  status = pabc_decode_nonce (ctx, nonce, nonce_str);
   if (status != PABC_OK)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to decode nonce.\n");
@@ -496,7 +500,9 @@ cr_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
   handle->resp_object = json_object ();
-  pabc_encode_credential_request (ctx, pp, cr, &response_str);
+  GNUNET_assert (PABC_OK == pabc_cred_encode_cr (ctx, pp, cr,
+                                                 json_string_value (identity_json),
+                                                 ppid, &response_str));
   if (PABC_OK != status)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to serialize cr.\n");
@@ -508,9 +514,9 @@ cr_cont (struct GNUNET_REST_RequestHandle *con_handle,
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
+  json_decref (handle->resp_object);
+  handle->resp_object = json_loads (response_str, JSON_DECODE_ANY, &err);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s\n", response_str);
-  json_object_set_new (handle->resp_object, "cr",
-                       json_string (response_str));
   GNUNET_free (response_str);
 
   // clean up
@@ -593,7 +599,7 @@ rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_rest_reclaim_init (void *cls)
+libgnunet_plugin_rest_pabc_init (void *cls)
 {
   static struct Plugin plugin;
   struct GNUNET_REST_Plugin *api;
diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c
index 84456b386..39d24ea61 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -353,14 +353,18 @@ finished_cont (void *cls, int32_t success, const char *emsg)
   struct MHD_Response *resp;
 
   handle->idp_op = NULL;
-  resp = GNUNET_REST_create_response (emsg);
-  MHD_add_response_header (resp, "Content-Type", "application/json");
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
   if (GNUNET_OK != success)
   {
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
+  resp = GNUNET_REST_create_response (emsg);
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Content-Type",
+                                                    "application/json"));
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Access-Control-Allow-Methods",
+                                                    allow_methods));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
@@ -372,13 +376,15 @@ delete_finished_cb (void *cls, int32_t success, const char *emsg)
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
-  resp = GNUNET_REST_create_response (emsg);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
   if (GNUNET_OK != success)
   {
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
+  resp = GNUNET_REST_create_response (emsg);
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Access-Control-Allow-Methods",
+                                                    allow_methods));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
@@ -399,7 +405,10 @@ return_response (void *cls)
   result_str = json_dumps (handle->resp_object, 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
+  GNUNET_assert (MHD_NO !=
+                 MHD_add_response_header (resp,
+                                          "Access-Control-Allow-Methods",
+                                          allow_methods));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free (result_str);
   cleanup_handle (handle);
@@ -461,8 +470,8 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 
 static void
 add_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                      const char *url,
-                      void *cls)
+                     const char *url,
+                     void *cls)
 {
   struct RequestHandle *handle = cls;
   const struct GNUNET_IDENTITY_PrivateKey *identity_priv;
@@ -513,7 +522,15 @@ add_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
                  handle->rest_handle->data,
                  handle->rest_handle->data_size);
   data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
-  GNUNET_JSON_parse (data_json, attrspec, NULL, NULL);
+  if (GNUNET_OK != GNUNET_JSON_parse (data_json, attrspec, NULL, NULL))
+  {
+    json_decref (data_json);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Unable to parse JSON from %s\n",
+                term_data);
+    GNUNET_SCHEDULER_add_now (&do_error, handle);
+    return;
+  }
   json_decref (data_json);
   if (NULL == attribute)
   {
@@ -530,11 +547,11 @@ add_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
     GNUNET_RECLAIM_id_generate (&attribute->id);
   exp = GNUNET_TIME_UNIT_HOURS;
   handle->idp_op = GNUNET_RECLAIM_credential_store (idp,
-                                                     identity_priv,
-                                                     attribute,
-                                                     &exp,
-                                                     &finished_cont,
-                                                     handle);
+                                                    identity_priv,
+                                                    attribute,
+                                                    &exp,
+                                                    &finished_cont,
+                                                    handle);
   GNUNET_JSON_parse_free (attrspec);
 }
 
@@ -545,8 +562,8 @@ add_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
  */
 static void
 cred_collect (void *cls,
-                const struct GNUNET_IDENTITY_PublicKey *identity,
-                const struct GNUNET_RECLAIM_Credential *cred)
+              const struct GNUNET_IDENTITY_PublicKey *identity,
+              const struct GNUNET_RECLAIM_Credential *cred)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_RECLAIM_AttributeList *attrs;
@@ -565,8 +582,8 @@ cred_collect (void *cls,
   attrs = GNUNET_RECLAIM_credential_get_attributes (cred);
   issuer = GNUNET_RECLAIM_credential_get_issuer (cred);
   tmp_value = GNUNET_RECLAIM_credential_value_to_string (cred->type,
-                                                          cred->data,
-                                                          cred->data_size);
+                                                         cred->data,
+                                                         cred->data_size);
   cred_obj = json_object ();
   json_object_set_new (cred_obj, "value", json_string (tmp_value));
   json_object_set_new (cred_obj, "name", json_string (cred->name));
@@ -578,7 +595,7 @@ cred_collect (void *cls,
     GNUNET_free (issuer);
   }
   if (GNUNET_OK == GNUNET_RECLAIM_credential_get_expiration (cred,
-                                                              &exp))
+                                                             &exp))
   {
     json_object_set_new (cred_obj, "expiration", json_integer (
                            exp.abs_value_us));
@@ -613,7 +630,8 @@ cred_collect (void *cls,
     json_object_set_new (cred_obj, "attributes", attr_arr);
   }
   json_array_append_new (handle->resp_object, cred_obj);
-  GNUNET_RECLAIM_attribute_list_destroy (attrs);
+  if (NULL != attrs)
+    GNUNET_RECLAIM_attribute_list_destroy (attrs);
   GNUNET_RECLAIM_get_credentials_next (handle->cred_it);
 }
 
@@ -627,8 +645,8 @@ cred_collect (void *cls,
  */
 static void
 list_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                       const char *url,
-                       void *cls)
+                      const char *url,
+                      void *cls)
 {
   struct RequestHandle *handle = cls;
   const struct GNUNET_IDENTITY_PrivateKey *priv_key;
@@ -664,14 +682,14 @@ list_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->cred_it = GNUNET_RECLAIM_get_credentials_start (idp,
-                                                             priv_key,
-                                                             &collect_error_cb,
-                                                             handle,
-                                                             &cred_collect,
-                                                             handle,
-                                                             &
-                                                             collect_finished_cb,
-                                                             handle);
+                                                          priv_key,
+                                                          &collect_error_cb,
+                                                          handle,
+                                                          &cred_collect,
+                                                          handle,
+                                                          &
+                                                          collect_finished_cb,
+                                                          handle);
 }
 
 
@@ -684,8 +702,8 @@ list_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
  */
 static void
 delete_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                         const char *url,
-                         void *cls)
+                        const char *url,
+                        void *cls)
 {
   struct RequestHandle *handle = cls;
   const struct GNUNET_IDENTITY_PrivateKey *priv_key;
@@ -734,10 +752,10 @@ delete_credential_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(attr.id));
   attr.name = "";
   handle->idp_op = GNUNET_RECLAIM_credential_delete (idp,
-                                                      priv_key,
-                                                      &attr,
-                                                      &delete_finished_cb,
-                                                      handle);
+                                                     priv_key,
+                                                     &attr,
+                                                     &delete_finished_cb,
+                                                     handle);
   GNUNET_free (identity_id_str);
 }
 
@@ -900,8 +918,8 @@ parse_jwt (const struct GNUNET_RECLAIM_Credential *cred,
   json_error_t *json_err = NULL;
 
   jwt_string = GNUNET_RECLAIM_credential_value_to_string (cred->type,
-                                                           cred->data,
-                                                           cred->data_size);
+                                                          cred->data,
+                                                          cred->data_size);
   char *jwt_body = strtok (jwt_string, delim);
   jwt_body = strtok (NULL, delim);
   GNUNET_STRINGS_base64_decode (jwt_body, strlen (jwt_body),
@@ -1424,25 +1442,24 @@ rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
   static const struct GNUNET_REST_RequestHandler handlers[] =
   { { MHD_HTTP_METHOD_GET,
       GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &list_attribute_cont },
-  { MHD_HTTP_METHOD_POST,
-    GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &add_attribute_cont },
-  { MHD_HTTP_METHOD_DELETE,
-    GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &delete_attribute_cont },
-  { MHD_HTTP_METHOD_GET,
-    GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &list_credential_cont },
-  { MHD_HTTP_METHOD_POST,
-    GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &add_credential_cont },
-  { MHD_HTTP_METHOD_DELETE,
-    GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &delete_credential_cont },
-  { MHD_HTTP_METHOD_GET,
-    GNUNET_REST_API_NS_IDENTITY_TICKETS, &list_tickets_cont },
-  { MHD_HTTP_METHOD_POST,
-    GNUNET_REST_API_NS_IDENTITY_REVOKE, &revoke_ticket_cont },
-  { MHD_HTTP_METHOD_POST,
-    GNUNET_REST_API_NS_IDENTITY_CONSUME, &consume_ticket_cont },
-  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &options_cont },
-  GNUNET_REST_HANDLER_END
-  };
+    { MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &add_attribute_cont },
+    { MHD_HTTP_METHOD_DELETE,
+      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &delete_attribute_cont },
+    { MHD_HTTP_METHOD_GET,
+      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &list_credential_cont },
+    { MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &add_credential_cont },
+    { MHD_HTTP_METHOD_DELETE,
+      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &delete_credential_cont },
+    { MHD_HTTP_METHOD_GET,
+      GNUNET_REST_API_NS_IDENTITY_TICKETS, &list_tickets_cont },
+    { MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_IDENTITY_REVOKE, &revoke_ticket_cont },
+    { MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_IDENTITY_CONSUME, &consume_ticket_cont },
+    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &options_cont },
+    GNUNET_REST_HANDLER_END};
 
   handle->response_code = 0;
   handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
diff --git a/src/reclaim/reclaim_api.c b/src/reclaim/reclaim_api.c
index f4f2b946a..c08cc868c 100644
--- a/src/reclaim/reclaim_api.c
+++ b/src/reclaim/reclaim_api.c
@@ -651,18 +651,15 @@ handle_consume_ticket_result (void *cls,
                         le->attribute, NULL);
           }
         }
-        if (NULL != attrs)
-          GNUNET_RECLAIM_attribute_list_destroy (attrs);
-        if (NULL != pl)
-          GNUNET_RECLAIM_presentation_list_destroy (pl);
-        attrs = NULL;
-        pl = NULL;
       }
       op->atr_cb (op->cls, NULL, NULL, NULL);
     }
+    if (NULL != attrs)
+      GNUNET_RECLAIM_attribute_list_destroy (attrs);
+    if (NULL != pl)
+      GNUNET_RECLAIM_presentation_list_destroy (pl);
     GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
     free_op (op);
-    GNUNET_free (attrs);
     return;
   }
   GNUNET_assert (0);
@@ -804,7 +801,7 @@ check_credential_result (void *cls, const struct CredentialResultMessage *msg)
  */
 static void
 handle_credential_result (void *cls, const struct
-                           CredentialResultMessage *msg)
+                          CredentialResultMessage *msg)
 {
   static struct GNUNET_IDENTITY_PrivateKey identity_dummy;
   struct GNUNET_RECLAIM_Handle *h = cls;
@@ -871,6 +868,7 @@ handle_credential_result (void *cls, const struct
   GNUNET_assert (0);
 }
 
+
 /**
    * Handle an incoming message of type
    * #GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT
@@ -925,7 +923,7 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg)
   if (NULL != op)
   {
     if (0 < pres_len)
-      pres = GNUNET_RECLAIM_presentation_list_deserialize ((char*)&msg[1],
+      pres = GNUNET_RECLAIM_presentation_list_deserialize ((char*) &msg[1],
                                                            pres_len);
     GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op);
     if (0 ==
@@ -1485,7 +1483,7 @@ GNUNET_RECLAIM_get_credentials_start (
  */
 void
 GNUNET_RECLAIM_get_credentials_next (struct
-                                      GNUNET_RECLAIM_CredentialIterator *ait)
+                                     GNUNET_RECLAIM_CredentialIterator *ait)
 {
   struct GNUNET_RECLAIM_Handle *h = ait->h;
   struct CredentialIterationNextMessage *msg;
@@ -1507,7 +1505,7 @@ GNUNET_RECLAIM_get_credentials_next (struct
  */
 void
 GNUNET_RECLAIM_get_credentials_stop (struct
-                                      GNUNET_RECLAIM_CredentialIterator *ait)
+                                     GNUNET_RECLAIM_CredentialIterator *ait)
 {
   struct GNUNET_RECLAIM_Handle *h = ait->h;
   struct GNUNET_MQ_Envelope *env;
diff --git a/src/reclaim/reclaim_attribute.c b/src/reclaim/reclaim_attribute.c
index 14690d7c9..21fdd83a2 100644
--- a/src/reclaim/reclaim_attribute.c
+++ b/src/reclaim/reclaim_attribute.c
@@ -96,10 +96,11 @@ init ()
   if (GNUNET_YES == initialized)
     return;
   initialized = GNUNET_YES;
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_reclaim_attribute_",
-                          NULL,
-                          &add_plugin,
-                          NULL);
+  GNUNET_PLUGIN_load_all_in_context (GNUNET_OS_project_data_default (),
+                                     "libgnunet_plugin_reclaim_attribute_",
+                                     NULL,
+                                     &add_plugin,
+                                     NULL);
 }
 
 /**
diff --git a/src/reclaim/reclaim_credential.c b/src/reclaim/reclaim_credential.c
index 05601c3d3..c8c0d397c 100644
--- a/src/reclaim/reclaim_credential.c
+++ b/src/reclaim/reclaim_credential.c
@@ -96,10 +96,11 @@ init ()
   if (GNUNET_YES == initialized)
     return;
   initialized = GNUNET_YES;
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_reclaim_credential_",
-                          NULL,
-                          &add_plugin,
-                          NULL);
+  GNUNET_PLUGIN_load_all_in_context (GNUNET_OS_project_data_default (),
+                                     "libgnunet_plugin_reclaim_credential_",
+                                     NULL,
+                                     &add_plugin,
+                                     NULL);
 }
 
 
diff --git a/src/rest/gnunet-rest-server.c b/src/rest/gnunet-rest-server.c
index e6e03b16d..ecb3e2ae5 100644
--- a/src/rest/gnunet-rest-server.c
+++ b/src/rest/gnunet-rest-server.c
@@ -1229,10 +1229,11 @@ run (void *cls,
     return;
   }
   /* Load plugins */
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_rest",
-                          (void *) cfg,
-                          &load_plugin,
-                          NULL);
+  GNUNET_PLUGIN_load_all_in_context (GNUNET_OS_project_data_default (),
+                                     "libgnunet_plugin_rest",
+                                     (void *) cfg,
+                                     &load_plugin,
+                                     NULL);
   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 }
 
diff --git a/src/rest/plugin_rest_copying.c b/src/rest/plugin_rest_copying.c
index 6d074d3d1..52783a81a 100644
--- a/src/rest/plugin_rest_copying.c
+++ b/src/rest/plugin_rest_copying.c
@@ -138,9 +138,9 @@ options_cont (struct GNUNET_REST_RequestHandle *con_handle,
   struct RequestHandle *handle = cls;
 
   resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp,
-                           "Access-Control-Allow-Methods",
-                           MHD_HTTP_METHOD_GET);
+  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
+                                                    "Access-Control-Allow-Methods",
+                                                    MHD_HTTP_METHOD_GET));
   handle->proc (handle->proc_cls,
                 resp,
                 MHD_HTTP_OK);
diff --git a/src/revocation/gnunet-revocation.c b/src/revocation/gnunet-revocation.c
index b5737158b..99fecdd35 100644
--- a/src/revocation/gnunet-revocation.c
+++ b/src/revocation/gnunet-revocation.c
@@ -307,17 +307,9 @@ calculate_pow (void *cls)
     return;
   }
   pow_passes++;
-  /**
-   * Otherwise CTRL-C does not work
-   */
-  if (0 == pow_passes % 128)
-    pow_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                             &calculate_pow,
-                                             ph);
-  else
-    pow_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                             &calculate_pow,
-                                             ph);
+  pow_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                           &calculate_pow,
+                                           ph);
 
 }
 
diff --git a/src/revocation/gnunet-service-revocation.c b/src/revocation/gnunet-service-revocation.c
index 863289aae..6f70720ba 100644
--- a/src/revocation/gnunet-service-revocation.c
+++ b/src/revocation/gnunet-service-revocation.c
@@ -306,12 +306,19 @@ publicize_rm (const struct RevokeMessage *rm)
   struct RevokeMessage *cp;
   struct GNUNET_HashCode hc;
   struct GNUNET_SETU_Element e;
+  ssize_t pklen;
   const struct GNUNET_IDENTITY_PublicKey *pk;
 
   struct GNUNET_REVOCATION_PowP *pow = (struct GNUNET_REVOCATION_PowP *) &rm[1];
   pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
+  pklen = GNUNET_IDENTITY_key_get_length (pk);
+  if (0 > pklen)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   GNUNET_CRYPTO_hash (pk,
-                      GNUNET_IDENTITY_key_get_length (pk),
+                      pklen,
                       &hc);
   if (GNUNET_YES ==
       GNUNET_CONTAINER_multihashmap_contains (revocation_map,
@@ -384,7 +391,8 @@ check_revoke_message (void *cls,
   uint16_t size;
 
   size = ntohs (rm->header.size);
-  if (size <= sizeof(struct RevokeMessage))
+  if (size <= sizeof(struct RevokeMessage) ||
+      (size > UINT16_MAX))
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
diff --git a/src/revocation/plugin_block_revocation.c b/src/revocation/plugin_block_revocation.c
index 3c9344a49..1928d09cd 100644
--- a/src/revocation/plugin_block_revocation.c
+++ b/src/revocation/plugin_block_revocation.c
@@ -134,6 +134,7 @@ block_plugin_revocation_evaluate (void *cls,
 {
   struct InternalContext *ic = cls;
   struct GNUNET_HashCode chash;
+  ssize_t pklen;
   const struct RevokeMessage *rm = reply_block;
 
   if (NULL == reply_block)
@@ -153,8 +154,14 @@ block_plugin_revocation_evaluate (void *cls,
     GNUNET_break_op (0);
     return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
   }
+  pklen = GNUNET_IDENTITY_key_get_length (pk);
+  if (0 > pklen)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+  }
   GNUNET_CRYPTO_hash (pk,
-                      GNUNET_IDENTITY_key_get_length (pk),
+                      pklen,
                       &chash);
   if (GNUNET_YES ==
       GNUNET_BLOCK_GROUP_bf_test_and_set (group,
diff --git a/src/revocation/revocation_api.c b/src/revocation/revocation_api.c
index 5cf191847..e2f871c23 100644
--- a/src/revocation/revocation_api.c
+++ b/src/revocation/revocation_api.c
@@ -492,6 +492,7 @@ GNUNET_REVOCATION_check_pow (const struct GNUNET_REVOCATION_PowP *pow,
   unsigned int tmp_score = 0;
   unsigned int epochs;
   uint64_t pow_val;
+  ssize_t pklen;
   const struct GNUNET_IDENTITY_PublicKey *pk;
 
   pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1];
@@ -517,9 +518,15 @@ GNUNET_REVOCATION_check_pow (const struct GNUNET_REVOCATION_PowP *pow,
   GNUNET_memcpy (&buf[sizeof(uint64_t)],
                  &pow->timestamp,
                  sizeof (uint64_t));
+  pklen = GNUNET_IDENTITY_key_get_length (pk);
+  if (0 > pklen)
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
   GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
                  pk,
-                 GNUNET_IDENTITY_key_get_length (pk));
+                 pklen);
   for (unsigned int i = 0; i < POW_COUNT; i++)
   {
     pow_val = GNUNET_ntohll (pow->pow[i]);
diff --git a/src/rps/gnunet-rps-profiler.c b/src/rps/gnunet-rps-profiler.c
index 82aeffb79..908dcca17 100644
--- a/src/rps/gnunet-rps-profiler.c
+++ b/src/rps/gnunet-rps-profiler.c
@@ -3067,9 +3067,10 @@ run (void *cls,
     }
     else
     {
-      duration = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                                (timeout.rel_value_us / 1000000)
-                                                * 0.75);
+      duration = GNUNET_TIME_relative_multiply (
+          GNUNET_TIME_UNIT_SECONDS,
+          ( (double) timeout.rel_value_us /  (double) 1000000)
+          * 0.75);
     }
   }
   else
diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index dc4c5dab7..56eab288e 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -965,8 +965,6 @@ remove_channel_ctx (struct ChannelCtx *channel_ctx)
     channel_ctx->destruction_task = NULL;
   }
 
-  GNUNET_free (channel_ctx);
-
   if (NULL == peer_ctx)
     return;
   if (channel_ctx == peer_ctx->send_channel_ctx)
@@ -978,6 +976,7 @@ remove_channel_ctx (struct ChannelCtx *channel_ctx)
   {
     peer_ctx->recv_channel_ctx = NULL;
   }
+  GNUNET_free (channel_ctx);
 }
 
 
@@ -2637,7 +2636,7 @@ insert_in_sampler (void *cls,
   }
 #ifdef TO_FILE
   sub->num_observed_peers++;
-  GNUNET_CONTAINER_multipeermap_put
+  (void) GNUNET_CONTAINER_multipeermap_put
     (sub->observed_unique_peers,
     peer,
     NULL,
@@ -2802,7 +2801,7 @@ clean_peer (struct Sub *sub,
                                                              peer))) &&
       (GNUNET_NO == View_contains_peer (sub->view, peer)) &&
       (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
-      (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
+      (GNUNET_NO == CustomPeerMap_contains_peer (sub->pull_map, peer)) &&
       (0 == RPS_sampler_count_id (sub->sampler, peer)) &&
       (GNUNET_YES == check_removable (get_peer_ctx (sub->peer_map, peer))))
   {   /* We can safely remove this peer */
@@ -2836,13 +2835,20 @@ cleanup_destroyed_channel (void *cls,
   (void) channel;
 
   channel_ctx->channel = NULL;
-  remove_channel_ctx (channel_ctx);
   if ((NULL != peer_ctx) &&
       (peer_ctx->send_channel_ctx == channel_ctx) &&
-      (GNUNET_YES == check_sending_channel_needed (channel_ctx->peer_ctx)) )
+      (GNUNET_YES == check_sending_channel_needed (peer_ctx)) )
   {
+    remove_channel_ctx (channel_ctx);
     remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
   }
+  else
+  {
+    /* We need this if-else construct because we need to make sure the channel
+     * (context) is cleaned up before removing the peer, but still neet to
+     * compare it while checking the condition */
+    remove_channel_ctx (channel_ctx);
+  }
 }
 
 
diff --git a/src/rps/gnunet-service-rps_custommap.c b/src/rps/gnunet-service-rps_custommap.c
index 54e361d32..392c29397 100644
--- a/src/rps/gnunet-service-rps_custommap.c
+++ b/src/rps/gnunet-service-rps_custommap.c
@@ -206,6 +206,7 @@ CustomPeerMap_remove_peer (const struct CustomPeerMap *c_peer_map,
   struct GNUNET_PeerIdentity *p;
   uint32_t *last_index;
   struct GNUNET_PeerIdentity *last_p;
+  int ret;
 
   if (GNUNET_NO == CustomPeerMap_contains_peer (c_peer_map,
                                                 peer))
@@ -234,9 +235,11 @@ CustomPeerMap_remove_peer (const struct CustomPeerMap *c_peer_map,
                                                     last_p);
     GNUNET_assert (NULL != last_index);
     GNUNET_assert (CustomPeerMap_size (c_peer_map) == *last_index);
-    GNUNET_CONTAINER_multihashmap32_put (c_peer_map->hash_map,
-                                         *index, last_p,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    ret = GNUNET_CONTAINER_multihashmap32_put (c_peer_map->hash_map,
+                                               *index,
+                                               last_p,
+                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    GNUNET_assert (GNUNET_OK == ret);
     GNUNET_CONTAINER_multihashmap32_remove_all (c_peer_map->hash_map,
                                                 *last_index);
     *last_index = *index;
diff --git a/src/rps/rps-test_util.c b/src/rps/rps-test_util.c
index 497225973..6dee20c95 100644
--- a/src/rps/rps-test_util.c
+++ b/src/rps/rps-test_util.c
@@ -152,12 +152,16 @@ close_all_files ()
 {
   int ret;
 
-  ret = GNUNET_CONTAINER_multihashmap_iterate (open_files,
-                                               close_files_iter,
-                                               NULL);
-  GNUNET_CONTAINER_multihashmap_destroy (open_files);
-  open_files = NULL;
-  return ret;
+  if (NULL != open_files)
+  {
+    ret = GNUNET_CONTAINER_multihashmap_iterate (open_files,
+                                                 close_files_iter,
+                                                 NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (open_files);
+    open_files = NULL;
+    return ret;
+  }
+  return GNUNET_YES;
 }
 
 
diff --git a/src/setu/.gitignore b/src/setu/.gitignore
index 35295449b..0ac10295e 100644
--- a/src/setu/.gitignore
+++ b/src/setu/.gitignore
@@ -4,3 +4,4 @@ gnunet-setu-ibf-profiler
 test_setu_api
 test_setu_copy
 test_setu_result_symmetric
+perf_setu_api
diff --git a/src/setu/Makefile.am b/src/setu/Makefile.am
index cc7711462..77d048add 100644
--- a/src/setu/Makefile.am
+++ b/src/setu/Makefile.am
@@ -69,7 +69,8 @@ libgnunetsetu_la_LDFLAGS = \
 
 if HAVE_TESTING
 check_PROGRAMS = \
- test_setu_api
+ test_setu_api \
+ perf_setu_api
 endif
 
 if ENABLE_TEST_RUN
@@ -84,6 +85,15 @@ test_setu_api_LDADD = \
   $(top_builddir)/src/testing/libgnunettesting.la \
   libgnunetsetu.la
 
+
+perf_setu_api_SOURCES = \
+ perf_setu_api.c
+perf_setu_api_LDADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  libgnunetsetu.la
+
+
 plugin_LTLIBRARIES = \
   libgnunet_plugin_block_setu_test.la
 
diff --git a/src/setu/gnunet-service-setu.c b/src/setu/gnunet-service-setu.c
index 540628afa..862b78aa9 100644
--- a/src/setu/gnunet-service-setu.c
+++ b/src/setu/gnunet-service-setu.c
@@ -400,6 +400,22 @@ struct Operation
    * was created.
    */
   unsigned int generation_created;
+
+  /**
+   * User defined Bandwidth Round Trips Tradeoff
+   */
+  double rtt_bandwidth_tradeoff;
+
+  /**
+   * Number of Element per bucket  in IBF
+   */
+  unsigned int ibf_number_buckets_per_element;
+
+  /**
+   * Number of buckets in IBF
+   */
+  unsigned ibf_bucket_number;
+
 };
 
 
@@ -621,6 +637,98 @@ static uint32_t suggest_id;
 
 
 /**
+ * Added Roundtripscounter
+ */
+
+
+struct perf_num_send_resived_msg {
+    int sent;
+    int sent_var_bytes;
+    int received;
+    int received_var_bytes;
+};
+
+
+struct perf_rtt_struct
+{
+    struct perf_num_send_resived_msg operation_request;
+    struct perf_num_send_resived_msg se;
+    struct perf_num_send_resived_msg request_full;
+    struct perf_num_send_resived_msg element_full;
+    struct perf_num_send_resived_msg full_done;
+    struct perf_num_send_resived_msg ibf;
+    struct perf_num_send_resived_msg inquery;
+    struct perf_num_send_resived_msg element;
+    struct perf_num_send_resived_msg demand;
+    struct perf_num_send_resived_msg offer;
+    struct perf_num_send_resived_msg done;
+    struct perf_num_send_resived_msg over;
+};
+
+struct perf_rtt_struct perf_rtt;
+
+
+static int
+sum_sent_received_bytes(int size, struct perf_num_send_resived_msg perf_rtt_struct) {
+    return  (size * perf_rtt_struct.sent) +
+            (size * perf_rtt_struct.received) +
+            perf_rtt_struct.sent_var_bytes +
+            perf_rtt_struct.received_var_bytes;
+}
+
+static float
+calculate_perf_rtt() {
+    /**
+     *  Calculate RTT of init phase normally always 1
+     */
+    float rtt = 1;
+    int bytes_transmitted = 0;
+
+    /**
+     *  Calculate RGNUNET_SETU_AcceptMessageRT of Fullsync normaly 1 or 1.5 depending
+     */
+     if (( perf_rtt.element_full.received != 0 ) ||
+         ( perf_rtt.element_full.sent != 0)
+        ) rtt += 1;
+
+     if (( perf_rtt.request_full.received != 0 ) ||
+        ( perf_rtt.request_full.sent != 0)
+         ) rtt += 0.5;
+
+    /**
+     *  In case of a differential sync 3 rtt's are needed.
+     *  for every active/passive switch additional 3.5 rtt's are used
+     */
+
+    int iterations = perf_rtt.ibf.received;
+    if(iterations > 1)
+        rtt += (iterations - 1 ) * 0.5;
+    rtt += 3 * iterations;
+
+    /**
+     * Calculate data sended size
+     */
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL), perf_rtt.request_full);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT), perf_rtt.element_full);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS), perf_rtt.element);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST), perf_rtt.operation_request);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_SE), perf_rtt.se);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE), perf_rtt.full_done);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_IBF), perf_rtt.ibf);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY), perf_rtt.inquery);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND), perf_rtt.demand);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER), perf_rtt.offer);
+    bytes_transmitted += sum_sent_received_bytes(sizeof(GNUNET_MESSAGE_TYPE_SETU_P2P_DONE), perf_rtt.done);
+
+    LOG(GNUNET_ERROR_TYPE_ERROR,"Bytes Transmitted: %d\n", bytes_transmitted);
+
+    LOG(GNUNET_ERROR_TYPE_ERROR,"Reached tradeoff bandwidth/rtt: %f\n", (bytes_transmitted / rtt ));
+
+    return rtt;
+}
+
+
+/**
  * Iterator over hash map entries, called to
  * destroy the linked list of colliding ibf key entries.
  *
@@ -1192,8 +1300,8 @@ send_ibf (struct Operation *op,
        1 << ibf_order);
 
   {
-    char name[64] = { 0 };
-    snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order);
+    char name[64];
+    GNUNET_snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order);
     GNUNET_STATISTICS_update (_GSS_statistics, name, 1, GNUNET_NO);
   }
 
@@ -1210,6 +1318,8 @@ send_ibf (struct Operation *op,
     if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE)
       buckets_in_message = MAX_BUCKETS_PER_MESSAGE;
 
+    perf_rtt.ibf.sent += 1;
+    perf_rtt.ibf.sent_var_bytes += ( buckets_in_message * IBF_BUCKET_SIZE );
     ev = GNUNET_MQ_msg_extra (msg,
                               buckets_in_message * IBF_BUCKET_SIZE,
                               GNUNET_MESSAGE_TYPE_SETU_P2P_IBF);
@@ -1281,6 +1391,8 @@ send_full_element_iterator (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending element %s\n",
        GNUNET_h2s (key));
+  perf_rtt.element_full.received += 1;
+  perf_rtt.element_full.received_var_bytes += el->size;
   ev = GNUNET_MQ_msg_extra (emsg,
                             el->size,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT);
@@ -1312,6 +1424,7 @@ send_full_set (struct Operation *op)
   (void) GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                                 &send_full_element_iterator,
                                                 op);
+  perf_rtt.full_done.sent += 1;
   ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE);
   GNUNET_MQ_send (op->mq,
                   ev);
@@ -1360,6 +1473,8 @@ static void
 handle_union_p2p_strata_estimator (void *cls,
                                    const struct StrataEstimatorMessage *msg)
 {
+  perf_rtt.se.received += 1;
+  perf_rtt.se.received_var_bytes += ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
   struct Operation *op = cls;
   struct StrataEstimator *remote_se;
   unsigned int diff;
@@ -1431,6 +1546,13 @@ handle_union_p2p_strata_estimator (void *cls,
     return;
   }
 
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx: %f\n", op->rtt_bandwidth_tradeoff);
+
+
+  /**
+   * Added rtt_bandwidth_tradeoff directly need future improvements
+   */
   if ((GNUNET_YES == op->force_full) ||
       (diff > op->initial_size / 4) ||
       (0 == other_size))
@@ -1455,6 +1577,7 @@ handle_union_p2p_strata_estimator (void *cls,
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Telling other peer that we expect its full set\n");
       op->phase = PHASE_FULL_RECEIVING;
+      perf_rtt.request_full.sent += 1;
       ev = GNUNET_MQ_msg_header (
         GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL);
       GNUNET_MQ_send (op->mq,
@@ -1504,6 +1627,9 @@ send_offers_iterator (void *cls,
   if (ke->ibf_key.key_val != sec->ibf_key.key_val)
     return GNUNET_YES;
 
+  perf_rtt.offer.sent += 1;
+  perf_rtt.offer.sent_var_bytes += sizeof(struct GNUNET_HashCode);
+
   ev = GNUNET_MQ_msg_header_extra (mh,
                                    sizeof(struct GNUNET_HashCode),
                                    GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER);
@@ -1659,6 +1785,8 @@ decode_and_send (struct Operation *op)
 
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "transmitted all values, sending DONE\n");
+
+      perf_rtt.done.sent += 1;
       ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_DONE);
       GNUNET_MQ_send (op->mq, ev);
       /* We now wait until we get a DONE message back
@@ -1681,6 +1809,8 @@ decode_and_send (struct Operation *op)
       struct GNUNET_MQ_Envelope *ev;
       struct InquiryMessage *msg;
 
+      perf_rtt.inquery.sent += 1;
+      perf_rtt.inquery.sent_var_bytes += sizeof(struct IBF_Key);
       /* It may be nice to merge multiple requests, but with CADET's corking it is not worth
        * the effort additional complexity. */
       ev = GNUNET_MQ_msg_extra (msg,
@@ -1780,6 +1910,9 @@ handle_union_p2p_ibf (void *cls,
   struct Operation *op = cls;
   unsigned int buckets_in_message;
 
+  perf_rtt.ibf.received += 1;
+  perf_rtt.ibf.received_var_bytes += (ntohs (msg->header.size) - sizeof *msg);
+
   buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
                        / IBF_BUCKET_SIZE;
   if ((op->phase == PHASE_PASSIVE_DECODING) ||
@@ -1908,6 +2041,7 @@ maybe_finish (struct Operation *op)
       struct GNUNET_MQ_Envelope *ev;
 
       op->phase = PHASE_FINISHED;
+      perf_rtt.done.sent += 1;
       ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_DONE);
       GNUNET_MQ_send (op->mq,
                       ev);
@@ -1968,8 +2102,12 @@ handle_union_p2p_elements (void *cls,
   struct KeyEntry *ke;
   uint16_t element_size;
 
+
   element_size = ntohs (emsg->header.size) - sizeof(struct
                                                     GNUNET_SETU_ElementMessage);
+  perf_rtt.element.received += 1;
+  perf_rtt.element.received_var_bytes += element_size;
+
   ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
   GNUNET_memcpy (&ee[1],
                  &emsg[1],
@@ -2080,19 +2218,33 @@ handle_union_p2p_full_element (void *cls,
   uint16_t element_size;
 
 
+
+  if(PHASE_EXPECT_IBF == op->phase) {
+      op->phase = PHASE_FULL_RECEIVING;
+  }
+
+
+
     /* Allow only receiving of full element message if in expect IBF or in PHASE_FULL_RECEIVING state */
-    if ( (PHASE_EXPECT_IBF != op->phase) &&
-         (PHASE_FULL_RECEIVING != op->phase) )
-    {
-        GNUNET_break_op (0);
-        fail_union_operation (op);
-        return;
-    }
+  if ((PHASE_FULL_RECEIVING != op->phase) &&
+       (PHASE_FULL_SENDING != op->phase))
+  {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+               "Handle full element phase is %u\n",
+               (unsigned) op->phase);
+      GNUNET_break_op (0);
+      fail_union_operation (op);
+      return;
+  }
+
 
-  op->phase = PHASE_FULL_RECEIVING;
 
   element_size = ntohs (emsg->header.size)
                  - sizeof(struct GNUNET_SETU_ElementMessage);
+
+  perf_rtt.element_full.received += 1;
+  perf_rtt.element_full.received_var_bytes += element_size;
+
   ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
   GNUNET_memcpy (&ee[1], &emsg[1], element_size);
   ee->element.size = element_size;
@@ -2204,6 +2356,9 @@ handle_union_p2p_inquiry (void *cls,
   const struct IBF_Key *ibf_key;
   unsigned int num_keys;
 
+  perf_rtt.inquery.received += 1;
+  perf_rtt.inquery.received_var_bytes += (ntohs (msg->header.size) - sizeof(struct InquiryMessage));
+
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received union inquiry\n");
   num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
@@ -2247,6 +2402,7 @@ send_missing_full_elements_iter (void *cls,
 
   if (GNUNET_YES == ke->received)
     return GNUNET_YES;
+  perf_rtt.element_full.received += 1;
   ev = GNUNET_MQ_msg_extra (emsg,
                             ee->element.size,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT);
@@ -2272,7 +2428,9 @@ handle_union_p2p_request_full (void *cls,
 {
   struct Operation *op = cls;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
+  perf_rtt.request_full.received += 1;
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received request for full set transmission\n");
   if (PHASE_EXPECT_IBF != op->phase)
   {
@@ -2300,9 +2458,11 @@ handle_union_p2p_full_done (void *cls,
 {
   struct Operation *op = cls;
 
+  perf_rtt.full_done.received += 1;
+
   switch (op->phase)
   {
-  case PHASE_EXPECT_IBF:
+  case PHASE_FULL_RECEIVING:
     {
       struct GNUNET_MQ_Envelope *ev;
 
@@ -2313,6 +2473,7 @@ handle_union_p2p_full_done (void *cls,
       GNUNET_CONTAINER_multihashmap32_iterate (op->key_to_element,
                                                &send_missing_full_elements_iter,
                                                op);
+      perf_rtt.full_done.sent += 1;
       ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE);
       GNUNET_MQ_send (op->mq,
                       ev);
@@ -2332,10 +2493,9 @@ handle_union_p2p_full_done (void *cls,
       _GSS_operation_destroy2 (op);
       return;
     }
-    break;
 
   default:
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Handle full done phase is %u\n",
                 (unsigned) op->phase);
     GNUNET_break_op (0);
@@ -2392,6 +2552,9 @@ handle_union_p2p_demand (void *cls,
   unsigned int num_hashes;
   struct GNUNET_MQ_Envelope *ev;
 
+  perf_rtt.demand.received += 1;
+  perf_rtt.demand.received_var_bytes += (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader));
+
   num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
                / sizeof(struct GNUNET_HashCode);
   for (hash = (const struct GNUNET_HashCode *) &mh[1];
@@ -2414,6 +2577,8 @@ handle_union_p2p_demand (void *cls,
       fail_union_operation (op);
       return;
     }
+    perf_rtt.element.sent += 1;
+    perf_rtt.element.sent_var_bytes += ee->element.size;
     ev = GNUNET_MQ_msg_extra (emsg,
                               ee->element.size,
                               GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS);
@@ -2489,6 +2654,9 @@ handle_union_p2p_offer (void *cls,
   const struct GNUNET_HashCode *hash;
   unsigned int num_hashes;
 
+  perf_rtt.offer.received += 1;
+  perf_rtt.offer.received_var_bytes += (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader));
+
   num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
                / sizeof(struct GNUNET_HashCode);
   for (hash = (const struct GNUNET_HashCode *) &mh[1];
@@ -2524,6 +2692,9 @@ handle_union_p2p_offer (void *cls,
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "[OP %p] Requesting element (hash %s)\n",
          op, GNUNET_h2s (hash));
+
+    perf_rtt.demand.sent += 1;
+    perf_rtt.demand.sent_var_bytes += sizeof(struct GNUNET_HashCode);
     ev = GNUNET_MQ_msg_header_extra (demands,
                                      sizeof(struct GNUNET_HashCode),
                                      GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND);
@@ -2548,6 +2719,7 @@ handle_union_p2p_done (void *cls,
 {
   struct Operation *op = cls;
 
+  perf_rtt.done.received += 1;
   switch (op->phase)
   {
   case PHASE_PASSIVE_DECODING:
@@ -2597,6 +2769,7 @@ static void
 handle_union_p2p_over (void *cls,
                        const struct GNUNET_MessageHeader *mh)
 {
+  perf_rtt.over.received += 1;
   send_client_done (cls);
 }
 
@@ -2770,7 +2943,7 @@ check_incoming_msg (void *cls,
   struct Listener *listener = op->listener;
   const struct GNUNET_MessageHeader *nested_context;
 
-  /* double operation request */
+    /* double operation request */
   if (0 != op->suggest_id)
   {
     GNUNET_break_op (0);
@@ -3377,6 +3550,7 @@ handle_client_evaluate (void *cls,
     struct GNUNET_MQ_Envelope *ev;
     struct OperationRequestMessage *msg;
 
+    perf_rtt.operation_request.sent += 1;
     ev = GNUNET_MQ_msg_nested_mh (msg,
                                   GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST,
                                   context);
@@ -3575,6 +3749,9 @@ handle_client_accept (void *cls,
     buf = GNUNET_malloc (se->strata_count * IBF_BUCKET_SIZE * se->ibf_size);
     len = strata_estimator_write (se,
                                   buf);
+    perf_rtt.se.sent += 1;
+    perf_rtt.se.sent_var_bytes += len;
+
     if (len < se->strata_count * IBF_BUCKET_SIZE * se->ibf_size)
       type = GNUNET_MESSAGE_TYPE_SETU_P2P_SEC;
     else
@@ -3623,6 +3800,8 @@ shutdown_task (void *cls)
                              GNUNET_YES);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "handled shutdown request\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "RTT:%f\n", calculate_perf_rtt());
 }
 
 
diff --git a/src/setu/gnunet-service-setu_strata_estimator.c b/src/setu/gnunet-service-setu_strata_estimator.c
index 0fa6a6f17..7c9a4deb6 100644
--- a/src/setu/gnunet-service-setu_strata_estimator.c
+++ b/src/setu/gnunet-service-setu_strata_estimator.c
@@ -30,13 +30,6 @@
 
 
 /**
- * Should we try compressing the strata estimator? This will
- * break compatibility with the 0.10.1-network.
- */
-#define FAIL_10_1_COMPATIBILTIY 1
-
-
-/**
  * Write the given strata estimator to the buffer.
  *
  * @param se strata estimator to serialize
@@ -48,11 +41,10 @@ strata_estimator_write (const struct StrataEstimator *se,
                         void *buf)
 {
   char *sbuf = buf;
-  unsigned int i;
   size_t osize;
 
   GNUNET_assert (NULL != se);
-  for (i = 0; i < se->strata_count; i++)
+  for (unsigned int i = 0; i < se->strata_count; i++)
   {
     ibf_write_slice (se->strata[i],
                      0,
@@ -60,7 +52,6 @@ strata_estimator_write (const struct StrataEstimator *se,
                      &sbuf[se->ibf_size * IBF_BUCKET_SIZE * i]);
   }
   osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count;
-#if FAIL_10_1_COMPATIBILTIY
   {
     char *cbuf;
     size_t nsize;
@@ -71,12 +62,13 @@ strata_estimator_write (const struct StrataEstimator *se,
                                 &cbuf,
                                 &nsize))
     {
-      GNUNET_memcpy (buf, cbuf, nsize);
+      GNUNET_memcpy (buf,
+                     cbuf,
+                     nsize);
       osize = nsize;
       GNUNET_free (cbuf);
     }
   }
-#endif
   return osize;
 }
 
@@ -97,7 +89,6 @@ strata_estimator_read (const void *buf,
                        int is_compressed,
                        struct StrataEstimator *se)
 {
-  unsigned int i;
   size_t osize;
   char *dbuf;
 
@@ -124,7 +115,7 @@ strata_estimator_read (const void *buf,
     return GNUNET_SYSERR;
   }
 
-  for (i = 0; i < se->strata_count; i++)
+  for (unsigned int i = 0; i < se->strata_count; i++)
   {
     ibf_read_slice (buf, 0, se->ibf_size, se->strata[i]);
     buf += se->ibf_size * IBF_BUCKET_SIZE;
@@ -190,22 +181,20 @@ strata_estimator_create (unsigned int strata_count,
                          uint8_t ibf_hashnum)
 {
   struct StrataEstimator *se;
-  unsigned int i;
-  unsigned int j;
 
   se = GNUNET_new (struct StrataEstimator);
   se->strata_count = strata_count;
   se->ibf_size = ibf_size;
   se->strata = GNUNET_new_array (strata_count,
                                  struct InvertibleBloomFilter *);
-  for (i = 0; i < strata_count; i++)
+  for (unsigned int i = 0; i < strata_count; i++)
   {
     se->strata[i] = ibf_create (ibf_size, ibf_hashnum);
     if (NULL == se->strata[i])
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Failed to allocate memory for strata estimator\n");
-      for (j = 0; j < i; j++)
+      for (unsigned int j = 0; j < i; j++)
         ibf_destroy (se->strata[i]);
       GNUNET_free (se);
       return NULL;
@@ -239,19 +228,23 @@ strata_estimator_difference (const struct StrataEstimator *se1,
 
     /* FIXME: implement this without always allocating new IBFs */
     diff = ibf_dup (se1->strata[i]);
-    ibf_subtract (diff, se2->strata[i]);
+    ibf_subtract (diff,
+                  se2->strata[i]);
     for (int ibf_count = 0; GNUNET_YES; ibf_count++)
     {
       int more;
 
-      more = ibf_decode (diff, NULL, NULL);
+      more = ibf_decode (diff,
+                         NULL,
+                         NULL);
       if (GNUNET_NO == more)
       {
         count += ibf_count;
         break;
       }
       /* Estimate if decoding fails or would not terminate */
-      if ((GNUNET_SYSERR == more) || (ibf_count > diff->size))
+      if ( (GNUNET_SYSERR == more) ||
+           (ibf_count > diff->size) )
       {
         ibf_destroy (diff);
         return count * (1 << (i + 1));
@@ -273,14 +266,13 @@ struct StrataEstimator *
 strata_estimator_dup (struct StrataEstimator *se)
 {
   struct StrataEstimator *c;
-  unsigned int i;
 
   c = GNUNET_new (struct StrataEstimator);
   c->strata_count = se->strata_count;
   c->ibf_size = se->ibf_size;
   c->strata = GNUNET_new_array (se->strata_count,
                                 struct InvertibleBloomFilter *);
-  for (i = 0; i < se->strata_count; i++)
+  for (unsigned int i = 0; i < se->strata_count; i++)
     c->strata[i] = ibf_dup (se->strata[i]);
   return c;
 }
@@ -294,9 +286,7 @@ strata_estimator_dup (struct StrataEstimator *se)
 void
 strata_estimator_destroy (struct StrataEstimator *se)
 {
-  unsigned int i;
-
-  for (i = 0; i < se->strata_count; i++)
+  for (unsigned int i = 0; i < se->strata_count; i++)
     ibf_destroy (se->strata[i]);
   GNUNET_free (se->strata);
   GNUNET_free (se);
diff --git a/src/setu/ibf.c b/src/setu/ibf.c
index 79b4f28db..1beba9065 100644
--- a/src/setu/ibf.c
+++ b/src/setu/ibf.c
@@ -20,7 +20,7 @@
 
 /**
  * @file set/ibf.c
- * @brief implementation of the invertible bloom filter
+ * @brief implementation of the invertible Bloom filter
  * @author Florian Dold
  */
 
@@ -58,12 +58,11 @@ ibf_hashcode_from_key (struct IBF_Key key,
                        struct GNUNET_HashCode *dst)
 {
   struct IBF_Key *p;
-  unsigned int i;
   const unsigned int keys_per_hashcode = sizeof(struct GNUNET_HashCode)
                                          / sizeof(struct IBF_Key);
 
   p = (struct IBF_Key *) dst;
-  for (i = 0; i < keys_per_hashcode; i++)
+  for (unsigned int i = 0; i < keys_per_hashcode; i++)
     *p++ = key;
 }
 
@@ -76,12 +75,12 @@ ibf_hashcode_from_key (struct IBF_Key key,
  * @return the newly created invertible bloom filter, NULL on error
  */
 struct InvertibleBloomFilter *
-ibf_create (uint32_t size, uint8_t hash_num)
+ibf_create (uint32_t size,
+            uint8_t hash_num)
 {
   struct InvertibleBloomFilter *ibf;
 
   GNUNET_assert (0 != size);
-
   ibf = GNUNET_new (struct InvertibleBloomFilter);
   ibf->count = GNUNET_malloc_large (size * sizeof(uint8_t));
   if (NULL == ibf->count)
@@ -106,7 +105,6 @@ ibf_create (uint32_t size, uint8_t hash_num)
   }
   ibf->size = size;
   ibf->hash_num = hash_num;
-
   return ibf;
 }
 
@@ -123,7 +121,8 @@ ibf_get_indices (const struct InvertibleBloomFilter *ibf,
   uint32_t i;
   uint32_t bucket;
 
-  bucket = GNUNET_CRYPTO_crc32_n (&key, sizeof key);
+  bucket = GNUNET_CRYPTO_crc32_n (&key,
+                                  sizeof (key));
   for (i = 0, filled = 0; filled < ibf->hash_num; i++)
   {
     uint64_t x;
@@ -134,7 +133,8 @@ ibf_get_indices (const struct InvertibleBloomFilter *ibf,
     dst[filled++] = bucket % ibf->size;
 try_next:
     x = ((uint64_t) bucket << 32) | i;
-    bucket = GNUNET_CRYPTO_crc32_n (&x, sizeof x);
+    bucket = GNUNET_CRYPTO_crc32_n (&x,
+                                    sizeof (x));
   }
 }
 
@@ -170,8 +170,13 @@ ibf_insert (struct InvertibleBloomFilter *ibf,
   int buckets[ibf->hash_num];
 
   GNUNET_assert (ibf->hash_num <= ibf->size);
-  ibf_get_indices (ibf, key, buckets);
-  ibf_insert_into (ibf, key, buckets, 1);
+  ibf_get_indices (ibf,
+                   key,
+                   buckets);
+  ibf_insert_into (ibf,
+                   key,
+                   buckets,
+                   1);
 }
 
 
@@ -188,8 +193,13 @@ ibf_remove (struct InvertibleBloomFilter *ibf,
   int buckets[ibf->hash_num];
 
   GNUNET_assert (ibf->hash_num <= ibf->size);
-  ibf_get_indices (ibf, key, buckets);
-  ibf_insert_into (ibf, key, buckets, -1);
+  ibf_get_indices (ibf,
+                   key,
+                   buckets);
+  ibf_insert_into (ibf,
+                   key,
+                   buckets,
+                   -1);
 }
 
 
@@ -234,8 +244,6 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 
   for (uint32_t i = 0; i < ibf->size; i++)
   {
-    int hit;
-
     /* we can only decode from pure buckets */
     if ( (1 != ibf->count[i].count_val) &&
          (-1 != ibf->count[i].count_val) )
@@ -249,23 +257,30 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 
     /* test if key in bucket hits its own location,
      * if not, the key hash was subject to collision */
-    hit = GNUNET_NO;
-    ibf_get_indices (ibf, ibf->key_sum[i], buckets);
-    for (int j = 0; j < ibf->hash_num; j++)
-      if (buckets[j] == i)
-        hit = GNUNET_YES;
-
-    if (GNUNET_NO == hit)
-      continue;
-
+    {
+      bool hit = false;
+
+      ibf_get_indices (ibf,
+                       ibf->key_sum[i],
+                       buckets);
+      for (int j = 0; j < ibf->hash_num; j++)
+        if (buckets[j] == i)
+        {
+          hit = true;
+          break;
+        }
+      if (! hit)
+        continue;
+    }
     if (NULL != ret_side)
       *ret_side = ibf->count[i].count_val;
     if (NULL != ret_id)
       *ret_id = ibf->key_sum[i];
 
     /* insert on the opposite side, effectively removing the element */
-    ibf_insert_into (ibf, ibf->key_sum[i], buckets, -ibf->count[i].count_val);
-
+    ibf_insert_into (ibf,
+                     ibf->key_sum[i], buckets,
+                     -ibf->count[i].count_val);
     return GNUNET_YES;
   }
 
@@ -287,7 +302,8 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 void
 ibf_write_slice (const struct InvertibleBloomFilter *ibf,
                  uint32_t start,
-                 uint32_t count, void *buf)
+                 uint32_t count,
+                 void *buf)
 {
   struct IBF_Key *key_dst;
   struct IBF_KeyHash *key_hash_dst;
diff --git a/src/setu/perf_setu_api.c b/src/setu/perf_setu_api.c
new file mode 100644
index 000000000..3b82e8af9
--- /dev/null
+++ b/src/setu/perf_setu_api.c
@@ -0,0 +1,428 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/test_setu_api.c
+ * @brief testcase for setu_api.c
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_setu_service.h"
+
+
+static struct GNUNET_PeerIdentity local_id;
+
+static struct GNUNET_HashCode app_id;
+
+static struct GNUNET_SETU_Handle *set1;
+
+static struct GNUNET_SETU_Handle *set2;
+
+static struct GNUNET_SETU_ListenHandle *listen_handle;
+
+static struct GNUNET_SETU_OperationHandle *oh1;
+
+static struct GNUNET_SETU_OperationHandle *oh2;
+
+static const struct GNUNET_CONFIGURATION_Handle *config;
+
+static int ret;
+
+static struct GNUNET_SCHEDULER_Task *tt;
+
+
+
+static void
+result_cb_set1 (void *cls,
+                const struct GNUNET_SETU_Element *element,
+                uint64_t size,
+                enum GNUNET_SETU_Status status)
+{
+    switch (status)
+    {
+        case GNUNET_SETU_STATUS_ADD_LOCAL:
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n");
+            break;
+
+        case GNUNET_SETU_STATUS_FAILURE:
+            GNUNET_break (0);
+            oh1 = NULL;
+            fprintf (stderr, "set 1: received failure status!\n");
+            ret = 1;
+            if (NULL != tt)
+            {
+                GNUNET_SCHEDULER_cancel (tt);
+                tt = NULL;
+            }
+            GNUNET_SCHEDULER_shutdown ();
+            break;
+
+        case GNUNET_SETU_STATUS_DONE:
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n");
+            oh1 = NULL;
+            if (NULL != set1)
+            {
+                GNUNET_SETU_destroy (set1);
+                set1 = NULL;
+            }
+            if (NULL == set2)
+            {
+                GNUNET_SCHEDULER_cancel (tt);
+                tt = NULL;
+                GNUNET_SCHEDULER_shutdown ();
+            }
+            break;
+
+        default:
+            GNUNET_assert (0);
+    }
+}
+
+
+static void
+result_cb_set2 (void *cls,
+                const struct GNUNET_SETU_Element *element,
+                uint64_t size,
+                enum GNUNET_SETU_Status status)
+{
+    switch (status)
+    {
+        case GNUNET_SETU_STATUS_ADD_LOCAL:
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n");
+            break;
+
+        case GNUNET_SETU_STATUS_FAILURE:
+            GNUNET_break (0);
+            oh2 = NULL;
+            fprintf (stderr, "set 2: received failure status\n");
+            GNUNET_SCHEDULER_shutdown ();
+            ret = 1;
+            break;
+
+        case GNUNET_SETU_STATUS_DONE:
+            oh2 = NULL;
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n");
+            GNUNET_SETU_destroy (set2);
+            set2 = NULL;
+            if (NULL == set1)
+            {
+                GNUNET_SCHEDULER_cancel (tt);
+                tt = NULL;
+                GNUNET_SCHEDULER_shutdown ();
+            }
+            break;
+
+        default:
+            GNUNET_assert (0);
+    }
+}
+
+
+static void
+listen_cb (void *cls,
+           const struct GNUNET_PeerIdentity *other_peer,
+           const struct GNUNET_MessageHeader *context_msg,
+           struct GNUNET_SETU_Request *request)
+{
+    GNUNET_assert (NULL != context_msg);
+    GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n");
+    oh2 = GNUNET_SETU_accept (request,
+                              (struct GNUNET_SETU_Option[]){ 0 },
+                              &result_cb_set2,
+                              NULL);
+    GNUNET_SETU_commit (oh2, set2);
+}
+
+
+/**
+ * Start the set operation.
+ *
+ * @param cls closure, unused
+ */
+static void
+start (void *cls)
+{
+    struct GNUNET_MessageHeader context_msg;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n");
+    context_msg.size = htons (sizeof context_msg);
+    context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY);
+    listen_handle = GNUNET_SETU_listen (config,
+                                        &app_id,
+                                        &listen_cb,
+                                        NULL);
+    oh1 = GNUNET_SETU_prepare (&local_id,
+                               &app_id,
+                               &context_msg,
+                               (struct GNUNET_SETU_Option[]){ 0 },
+                               &result_cb_set1,
+                               NULL);
+    GNUNET_SETU_commit (oh1, set1);
+}
+
+
+/**
+ * Initialize the second set, continue
+ *
+ * @param cls closure, unused
+ */
+static void
+init_set2 (void *cls)
+{
+    struct GNUNET_SETU_Element element;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n");
+
+    element.element_type = 0;
+    element.data = "hello1";
+    element.size = strlen (element.data);
+    GNUNET_SETU_add_element (set2, &element, NULL, NULL);
+    element.data = "quux";
+    element.size = strlen (element.data);
+    GNUNET_SETU_add_element (set2, &element, NULL, NULL);
+    element.data = "baz";
+    element.size = strlen (element.data);
+    GNUNET_SETU_add_element (set2, &element, &start, NULL);
+}
+
+/**
+ * Generate random byte stream
+ */
+
+unsigned char *gen_rdm_bytestream (size_t num_bytes)
+{
+    unsigned char *stream = GNUNET_malloc (num_bytes);
+    GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, stream, num_bytes);
+    return stream;
+}
+
+/**
+ * Generate random sets
+ */
+
+static void
+initRandomSets(int overlap, int set1_size, int set2_size, int element_size_in_bytes)
+{
+    struct GNUNET_SETU_Element element;
+    element.element_type = 0;
+
+    // Add elements to both sets
+    for (int i = 0; i < overlap; i++) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+        GNUNET_SETU_add_element (set1, &element, NULL, NULL);
+        GNUNET_SETU_add_element (set2, &element, NULL, NULL);
+        set1_size--;
+        set2_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in both sets\n");
+
+    // Add other elements to set 1
+    while(set1_size>0) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+        GNUNET_SETU_add_element (set1, &element, NULL, NULL);
+        set1_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set1\n");
+
+    // Add other elements to set 2
+    while(set2_size > 0) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+
+        if(set2_size != 1) {
+            GNUNET_SETU_add_element (set2, &element,NULL, NULL);
+        } else {
+            GNUNET_SETU_add_element (set2, &element,&start, NULL);
+        }
+
+        set2_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set2\n");
+}
+
+/**
+ * Initialize the first set, continue.
+ */
+static void
+init_set1 (void)
+{
+    struct GNUNET_SETU_Element element;
+
+    element.element_type = 0;
+    element.data = "hello";
+    element.size = strlen (element.data);
+    GNUNET_SETU_add_element (set1, &element, NULL, NULL);
+    element.data = "bar";
+    element.size = strlen (element.data);
+    GNUNET_SETU_add_element (set1, &element, &init_set2, NULL);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n");
+}
+
+
+/**
+ * Function run on timeout.
+ *
+ * @param cls closure
+ */
+static void
+timeout_fail (void *cls)
+{
+    tt = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n");
+    GNUNET_SCHEDULER_shutdown ();
+    ret = 1;
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+    if (NULL != tt)
+    {
+        GNUNET_SCHEDULER_cancel (tt);
+        tt = NULL;
+    }
+    if (NULL != oh1)
+    {
+        GNUNET_SETU_operation_cancel (oh1);
+        oh1 = NULL;
+    }
+    if (NULL != oh2)
+    {
+        GNUNET_SETU_operation_cancel (oh2);
+        oh2 = NULL;
+    }
+    if (NULL != set1)
+    {
+        GNUNET_SETU_destroy (set1);
+        set1 = NULL;
+    }
+    if (NULL != set2)
+    {
+        GNUNET_SETU_destroy (set2);
+        set2 = NULL;
+    }
+    if (NULL != listen_handle)
+    {
+        GNUNET_SETU_listen_cancel (listen_handle);
+        listen_handle = NULL;
+    }
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+    struct GNUNET_SETU_OperationHandle *my_oh;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Running preparatory tests\n");
+    tt = GNUNET_SCHEDULER_add_delayed (
+            GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+            &timeout_fail,
+            NULL);
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+
+    config = cfg;
+    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg,
+                                                                 &local_id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "my id (from CRYPTO): %s\n",
+                GNUNET_i2s (&local_id));
+    GNUNET_TESTING_peer_get_identity (peer,
+                                      &local_id);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "my id (from TESTING): %s\n",
+                GNUNET_i2s (&local_id));
+    set1 = GNUNET_SETU_create (cfg);
+    set2 = GNUNET_SETU_create (cfg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created sets %p and %p for union operation\n",
+                set1,
+                set2);
+    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
+
+    /* test if canceling an uncommited request works! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Launching and instantly stopping set operation\n");
+    my_oh = GNUNET_SETU_prepare (&local_id,
+                                 &app_id,
+                                 NULL,
+                                 (struct GNUNET_SETU_Option[]){ 0 },
+                                 NULL,
+                                 NULL);
+    GNUNET_SETU_operation_cancel (my_oh);
+
+    /* test the real set reconciliation */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Running real set-reconciliation\n");
+    //init_set1 ();
+    // limit ~23800 element total
+    initRandomSets(50,100,100,128);
+}
+
+static void execute_perf()
+{
+    for( int repeat_ctr = 0; repeat_ctr<1; repeat_ctr++ ) {
+
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "Executing perf round %d\n", repeat_ctr);
+
+        GNUNET_TESTING_service_run ("perf_setu_api",
+                                 "arm",
+                                 "test_setu.conf",
+                                 &run,
+                                 NULL);
+    }
+    return 0;
+}
+
+
+
+int
+main (int argc, char **argv)
+{
+    GNUNET_log_setup ("perf_setu_api",
+                      "WARNING",
+                      NULL);
+
+    execute_perf();
+    return 0;
+}
diff --git a/src/setu/setu.h b/src/setu/setu.h
index e9a0def95..f806c8eb1 100644
--- a/src/setu/setu.h
+++ b/src/setu/setu.h
@@ -121,6 +121,7 @@ struct GNUNET_SETU_AcceptMessage
    * byzantine mode is enabled.
    */
   uint32_t byzantine_lower_bound;
+
 };
 
 
diff --git a/src/setu/test_setu_api.c b/src/setu/test_setu_api.c
index 95119873c..d5c9f5b7a 100644
--- a/src/setu/test_setu_api.c
+++ b/src/setu/test_setu_api.c
@@ -193,7 +193,7 @@ init_set2 (void *cls)
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n");
 
   element.element_type = 0;
-  element.data = "hello";
+  element.data = "hello1";
   element.size = strlen (element.data);
   GNUNET_SETU_add_element (set2, &element, NULL, NULL);
   element.data = "quux";
@@ -204,6 +204,62 @@ init_set2 (void *cls)
   GNUNET_SETU_add_element (set2, &element, &start, NULL);
 }
 
+/**
+ * Generate random byte stream
+ */
+
+unsigned char *gen_rdm_bytestream (size_t num_bytes)
+{
+    unsigned char *stream = GNUNET_malloc (num_bytes);
+    GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, stream, num_bytes);
+    return stream;
+}
+
+/**
+ * Generate random sets
+ */
+
+static void
+initRandomSets(int overlap, int set1_size, int set2_size, int element_size_in_bytes)
+{
+    struct GNUNET_SETU_Element element;
+    element.element_type = 0;
+
+    // Add elements to both sets
+    for (int i = 0; i < overlap; i++) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+        GNUNET_SETU_add_element (set1, &element, NULL, NULL);
+        GNUNET_SETU_add_element (set2, &element, NULL, NULL);
+        set1_size--;
+        set2_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in both sets\n");
+
+    // Add other elements to set 1
+    while(set1_size>0) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+        GNUNET_SETU_add_element (set1, &element, NULL, NULL);
+        set1_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set1\n");
+
+    // Add other elements to set 2
+    while(set2_size > 0) {
+        element.data = gen_rdm_bytestream(element_size_in_bytes);
+        element.size = element_size_in_bytes;
+
+        if(set2_size != 1) {
+            GNUNET_SETU_add_element (set2, &element,NULL, NULL);
+        } else {
+            GNUNET_SETU_add_element (set2, &element,&start, NULL);
+        }
+
+        set2_size--;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set2\n");
+}
 
 /**
  * Initialize the first set, continue.
@@ -336,7 +392,9 @@ run (void *cls,
   /* test the real set reconciliation */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Running real set-reconciliation\n");
-  init_set1 ();
+  //init_set1 ();
+  initRandomSets(19500,20000,20000,4096);
+  //initRandomSets(19500,20000,20000,32);
 }
 
 
diff --git a/src/testbed/Makefile.am b/src/testbed/Makefile.am
index 7c1e217bb..740be2742 100644
--- a/src/testbed/Makefile.am
+++ b/src/testbed/Makefile.am
@@ -94,6 +94,8 @@ lib_LTLIBRARIES = \
 libgnunettestbed_la_SOURCES = \
   testbed_api.c testbed_api.h testbed.h \
   testbed_api_hosts.c testbed_api_hosts.h testbed_helper.h \
+  testbed_api_cmd_controller.c \
+  testbed_api_cmd_peer.c \
   testbed_api_operations.c testbed_api_operations.h \
   testbed_api_peers.c testbed_api_peers.h \
   testbed_api_services.c \
@@ -192,12 +194,6 @@ if ENABLE_TEST_RUN
   $(underlay_testcases)
 endif
 
-test_testbed_api_hosts_SOURCES = \
- test_testbed_api_hosts.c
-test_testbed_api_hosts_LDADD = \
- $(top_builddir)/src/util/libgnunetutil.la \
- libgnunettestbed.la
-
 test_testbed_api_SOURCES = \
  test_testbed_api.c
 test_testbed_api_LDADD = \
diff --git a/src/testbed/testbed_api_cmd_controller.c b/src/testbed/testbed_api_cmd_controller.c
new file mode 100644
index 000000000..da23df1ef
--- /dev/null
+++ b/src/testbed/testbed_api_cmd_controller.c
@@ -0,0 +1,293 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/testbed_api_cmd_controller.c
+ * @brief Command to create a controller.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet-service-testbed.h"
+#include "testbed_api_hosts.h"
+#include "gnunet_testbed_ng_service.h"
+
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...)                           \
+  GNUNET_log (kind, __VA_ARGS__)
+
+
+/**
+ * abort task to run on test timed out
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+do_abort (void *cls)
+{
+  struct ControllerState *cs = cls;
+
+  if (GNUNET_NO == cs->host_ready)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
+    cs->abort_task = NULL;
+    GNUNET_TESTBED_shutdown_controller (cs);
+  }
+}
+
+
+/**
+*
+*
+* @param cls closure
+* @param cmd current CMD being cleaned up.
+*/
+static void
+controller_cleanup (void *cls,
+                    const struct GNUNET_TESTING_Command *cmd)
+{
+  (void) cls;
+}
+
+
+/**
+ * Signature of the event handler function called by the
+ * respective event controller.
+ *
+ * @param cls closure
+ * @param event information about the event
+ */
+static void
+controller_cb (void *cls,
+               const struct GNUNET_TESTBED_EventInformation *event)
+{
+  struct ControllerState *cs = cls;
+
+  if (NULL != event->details.operation_finished.emsg)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "There was an operation error: %s\n",
+         event->details.operation_finished.emsg);
+    GNUNET_TESTBED_shutdown_controller (cs);
+  }
+  else if (NULL == event->details.operation_finished.generic)
+  {
+    GNUNET_TESTBED_operation_done (event->op);
+  }
+}
+
+
+/**
+ * Callback which will be called to after a host registration succeeded or failed
+ *
+ * @param cls the host which has been registered
+ * @param emsg the error message; NULL if host registration is successful
+ */
+static void
+registration_comp (void *cls,
+                   const char *emsg)
+{
+  struct ControllerState *cs = cls;
+
+  if (NULL != emsg)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "There was an error during host registration: %s\n",
+         emsg);
+    GNUNET_TESTBED_shutdown_controller (cs);
+  }
+  else
+  {
+    cs->reg_handle = NULL;
+    cs->host_ready = GNUNET_YES;
+  }
+}
+
+
+/**
+ * Callback to signal successfull startup of the controller process
+ *
+ * @param cls the closure from GNUNET_TESTBED_controller_start()
+ * @param cfg the configuration with which the controller has been started;
+ *          NULL if status is not #GNUNET_OK
+ * @param status #GNUNET_OK if the startup is successfull; #GNUNET_SYSERR if not,
+ *          GNUNET_TESTBED_controller_stop() shouldn't be called in this case
+ */
+static void
+controller_status_cb (void *cls,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg_,
+                      int status)
+{
+  struct ControllerState *cs = cls;
+
+  if (GNUNET_OK != status)
+  {
+    cs->cp = NULL;
+    return;
+  }
+
+  cs->controller =
+    GNUNET_TESTBED_controller_connect (cs->host, cs->event_mask, &controller_cb,
+                                       cs);
+  cs->reg_handle =
+    GNUNET_TESTBED_register_host (cs->controller, cs->host, &registration_comp,
+                                  cs);
+}
+
+
+static void
+controller_run (void *cls,
+                const struct GNUNET_TESTING_Command *cmd,
+                struct GNUNET_TESTING_Interpreter *is)
+{
+  struct ControllerState *cs = cls;
+
+  cs->is = is;
+  cs->host = GNUNET_TESTBED_host_create (cs->hostname, cs->username, cs->cfg,
+                                         cs->port);
+  cs->cp = GNUNET_TESTBED_controller_start (cs->trusted_ip,
+                                            cs->host,
+                                            &controller_status_cb,
+                                            cs);
+  cs->abort_task =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MINUTES, 5),
+                                  &do_abort,
+                                  cs);
+}
+
+/**
+*
+*
+* @param cls closure.
+* @param[out] ret result
+* @param trait name of the trait.
+* @param index index number of the object to offer.
+* @return #GNUNET_OK on success.
+*/
+static int
+controller_traits (void *cls,
+                   const void **ret,
+                   const char *trait,
+                   unsigned int index)
+{
+  (void) cls;
+
+  struct ControllerState *cs = cls;
+
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    {
+      .index = 0,
+      .trait_name = "controller",
+      .ptr = (const void *) cs->controller,
+    },
+    GNUNET_TESTING_trait_end ()
+  };
+
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Offer data from trait
+ *
+ * @param cmd command to extract the controller from.
+ * @param pt pointer to controller.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTBED_get_trait_controller (const struct GNUNET_TESTING_Command *cmd,
+                                     struct GNUNET_TESTBED_Controller **
+                                     controller)
+{
+  return cmd->traits (cmd->cls,
+                      (const void **) controller,
+                      "controller",
+                      (unsigned int) 0);
+}
+
+
+/**
+ * Shutdown nicely
+ *
+ * @param cs controller state.
+ */
+void
+GNUNET_TESTBED_shutdown_controller (struct ControllerState *cs)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down...\n");
+
+  cs->controller_going_down = GNUNET_YES;
+
+  if (NULL != cs->abort_task)
+    GNUNET_SCHEDULER_cancel (cs->abort_task);
+  if (NULL != cs->reg_handle)
+    GNUNET_TESTBED_cancel_registration (cs->reg_handle);
+  if (NULL != cs->controller)
+    GNUNET_TESTBED_controller_disconnect (cs->controller);
+  if (NULL != cs->cfg)
+    GNUNET_CONFIGURATION_destroy (cs->cfg);
+  if (NULL != cs->cp)
+    GNUNET_TESTBED_controller_stop (cs->cp);
+  if (NULL != cs->host)
+    GNUNET_TESTBED_host_destroy (cs->host);
+}
+
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_controller (const char *label,
+                               const char *trusted_ip,
+                               const char *hostname,
+                               const char *username,
+                               uint16_t port,
+                               struct GNUNET_CONFIGURATION_Handle *cfg,
+                               uint64_t event_mask)
+{
+  struct ControllerState *cs;
+
+  cs = GNUNET_new (struct ControllerState);
+  cs->event_mask = event_mask;
+  cs->trusted_ip = trusted_ip;
+  cs->hostname = hostname;
+  cs->username = username;
+  cs->port = port;
+  cs->cfg = cfg;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = cs,
+    .label = label,
+    .run = &controller_run,
+    .cleanup = &controller_cleanup,
+    .traits = &controller_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testbed/testbed_api_cmd_peer.c b/src/testbed/testbed_api_cmd_peer.c
new file mode 100644
index 000000000..2e253e408
--- /dev/null
+++ b/src/testbed/testbed_api_cmd_peer.c
@@ -0,0 +1,281 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+
+/**
+ * @file testbed/testbed_api_cmd_peer.c
+ * @brief Command to create a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testbed_ng_service.h"
+#include "gnunet-service-testbed.h"
+#include "testbed_api_peers.h"
+
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...)                           \
+  GNUNET_log (kind, __VA_ARGS__)
+
+
+/**
+*
+*
+* @param cls closure.
+* @param[out] ret result
+* @param trait name of the trait.
+* @param index index number of the object to offer.
+* @return #GNUNET_OK on success.
+*/
+static int
+peer_traits (void *cls,
+             const void **ret,
+             const char *trait,
+             unsigned int index)
+{
+  struct PeerCmdState *ps = cls;
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    {
+      .index = 0,
+      .trait_name = "peer",
+      .ptr = (const void *) ps->peer,
+    },
+    GNUNET_TESTING_trait_end ()
+  };
+
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+
+  return GNUNET_OK;
+}
+
+/**
+ * Offer data from trait
+ *
+ * @param cmd command to extract the controller from.
+ * @param peer pointer GNUNET_TESTBED_PEER
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTBED_get_trait_peer (const struct GNUNET_TESTING_Command *cmd,
+                               struct GNUNET_TESTBED_Peer **
+                               peer)
+{
+  return cmd->traits (cmd->cls,
+                      (const void **) peer,
+                      "peer",
+                      (unsigned int) 0);
+}
+
+
+/**
+*
+*
+* @param cls closure
+* @param cmd current CMD being cleaned up.
+*/
+static void
+peer_cleanup (void *cls,
+              const struct GNUNET_TESTING_Command *cmd)
+{
+  (void) cls;
+}
+
+
+/**
+ * abort task to run on test timed out
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+do_abort (void *cls)
+{
+  struct PeerCmdState *ps = cls;
+
+  if (GNUNET_NO == ps->peer_ready)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
+    ps->abort_task = NULL;
+    GNUNET_TESTBED_shutdown_peer (ps);
+  }
+}
+
+
+/**
+ * Functions of this signature are called when a peer has been successfully
+ * created
+ *
+ * @param cls the closure from GNUNET_TESTBED_peer_create()
+ * @param emsg MAY contain an error description, if starting peer failed.
+ */
+static void
+peer_started_cb (void *cls,
+                 const char *emsg)
+{
+  struct PeerCmdState *ps = cls;
+
+  GNUNET_TESTBED_operation_done (ps->operation);
+  if (NULL == emsg)
+  {
+    ps->peer_ready = GNUNET_YES;
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "There was an error starting a peer: %s\n",
+         emsg);
+  }
+
+}
+
+
+/**
+ * Functions of this signature are called when a peer has been successfully
+ * created
+ *
+ * @param cls the closure from GNUNET_TESTBED_peer_create()
+ * @param peer the handle for the created peer; NULL on any error during
+ *          creation
+ * @param emsg NULL if peer is not NULL; else MAY contain the error description
+ */
+static void
+peer_create_cb (void *cls,
+                struct GNUNET_TESTBED_Peer *peer,
+                const char *emsg)
+{
+  struct PeerCmdState *ps = cls;
+
+  ps->peer = peer;
+  GNUNET_TESTBED_operation_done (ps->operation);
+  ps->operation = GNUNET_TESTBED_peer_start (NULL,
+                                             peer,
+                                             &peer_started_cb,
+                                             ps);
+}
+
+
+static void
+peer_run (void *cls,
+          const struct GNUNET_TESTING_Command *cmd,
+          struct GNUNET_TESTING_Interpreter *is)
+{
+  struct PeerCmdState *ps = cls;
+  const struct GNUNET_TESTING_Command *controller_cmd;
+  struct GNUNET_TESTBED_Controller *controller;
+
+  ps->is = is;
+  controller_cmd = GNUNET_TESTING_interpreter_lookup_command (
+    ps->controller_label);
+  GNUNET_TESTBED_get_trait_controller (controller_cmd,
+                                       &controller);
+  ps->host = GNUNET_TESTBED_host_create (ps->hostname, ps->username, ps->cfg,
+                                         ps->port);
+  ps->operation =
+    GNUNET_TESTBED_peer_create (controller,
+                                ps->host,
+                                ps->cfg,
+                                &peer_create_cb,
+                                ps);
+
+  ps->abort_task =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MINUTES, 5),
+                                  &do_abort,
+                                  ps);
+}
+
+
+void
+peer_stopped_cb (void *cls,
+                 const char *emsg)
+{
+  struct PeerCmdState *ps = cls;
+
+  if (NULL != emsg)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "There was an error stopping a peer: %s\n",
+         emsg);
+  }
+  GNUNET_TESTBED_operation_done (ps->operation);
+  GNUNET_TESTBED_peer_destroy (ps->peer);
+}
+
+
+/**
+ * Shutdown nicely
+ *
+ * @param cs controller state.
+ */
+void
+GNUNET_TESTBED_shutdown_peer (struct PeerCmdState *ps)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down...\n");
+
+  ps->peer_going_down = GNUNET_YES;
+
+  if (NULL != ps->abort_task)
+    GNUNET_SCHEDULER_cancel (ps->abort_task);
+  if (NULL != ps->cfg)
+    GNUNET_CONFIGURATION_destroy (ps->cfg);
+  if (NULL != ps->host)
+    GNUNET_TESTBED_host_destroy (ps->host);
+
+  GNUNET_TESTBED_operation_done (ps->operation);
+  ps->operation = GNUNET_TESTBED_peer_stop (NULL, ps->peer, peer_stopped_cb,
+                                            ps);
+
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_peer (const char *label,
+                         const char *controller_label,
+                         const char *hostname,
+                         const char *username,
+                         uint16_t port,
+                         struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct PeerCmdState *ps;
+
+  ps = GNUNET_new (struct PeerCmdState);
+  ps->hostname = hostname;
+  ps->username = username;
+  ps->port = port;
+  ps->cfg = cfg;
+  ps->controller_label = controller_label;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = ps,
+    .label = label,
+    .run = &peer_run,
+    .cleanup = &peer_cleanup,
+    .traits = &peer_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testbed/testbed_api_cmd_peer_store.c b/src/testbed/testbed_api_cmd_peer_store.c
new file mode 100644
index 000000000..fc96f589c
--- /dev/null
+++ b/src/testbed/testbed_api_cmd_peer_store.c
@@ -0,0 +1,60 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/testbed_api_cmd_peer_store.c
+ * @brief Command to start the peer store service of a peer.
+ * @author t3sserakt
+ */
+
+
+static void
+service_run (void *cls,
+             const struct GNUNET_TESTING_Command *cmd,
+             struct GNUNET_TESTING_Interpreter *is)
+{
+  struct PeerStoreState *pss = cls;
+
+  pss->psh = GNUNET_PEERSTORE_connect (pss->cfg);
+  GNUNET_TESTING_interpreter_next (ps->is);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_peer_store (const char *label,
+                               struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+
+  struct PeerStoreState *pss;
+
+  pss = GNUNET_new (struct PeerStoreState);
+  pss->cfg = cfg;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = pss,
+    .label = label,
+    .run = &peer_store_run,
+    .cleanup = &peer_store_cleanup,
+    .traits = &peer_store_traits
+  };
+
+  return cmd;
+
+}
diff --git a/src/testbed/testbed_api_cmd_tng_connect.c b/src/testbed/testbed_api_cmd_tng_connect.c
new file mode 100644
index 000000000..e52cd3c76
--- /dev/null
+++ b/src/testbed/testbed_api_cmd_tng_connect.c
@@ -0,0 +1,55 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+
+/**
+ * @file testbed/testbed_api_cmd_peer.c
+ * @brief Command to create a peer.
+ * @author t3sserakt
+ */
+
+
+static void
+tng_connect_run (void *cls,
+                 const struct GNUNET_TESTING_Command *cmd,
+                 struct GNUNET_TESTING_Interpreter *is)
+{
+  struct TngConnectState *tcs = cls;
+
+  tcs->ah = GNUNET_TRANSPORT_application_init (tcs->cfg);
+}
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_tng_connect (const char *label)
+{
+  struct TngConnectState *tcs;
+
+  ts = GNUNET_new (struct TngConnectState);
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = tcs,
+    .label = label,
+    .run = &tng_connect_run,
+    .cleanup = &tmg_connect_cleanup,
+    .traits = &tng_connect_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testbed/testbed_api_cmd_tng_service.c b/src/testbed/testbed_api_cmd_tng_service.c
new file mode 100644
index 000000000..f9ef44bad
--- /dev/null
+++ b/src/testbed/testbed_api_cmd_tng_service.c
@@ -0,0 +1,276 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/testbed_api_cmd_tng.c
+ * @brief Command to start the transport service of a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet-service-testbed.h"
+#include "testbed_api_hosts.h"
+#include "gnunet_testbed_ng_service.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...)                           \
+  GNUNET_log (kind, __VA_ARGS__)
+
+
+/**
+ * abort task to run on test timed out
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+do_abort (void *cls)
+{
+  struct TngState *ts = cls;
+
+  if (GNUNET_NO == ts->service_ready)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
+    ts->abort_task = NULL;
+    GNUNET_TESTBED_shutdown_service (ts);
+  }
+}
+
+/**
+*
+*
+* @param cls closure
+* @param cmd current CMD being cleaned up.
+*/
+static void
+tng_service_cleanup (void *cls,
+                     const struct GNUNET_TESTING_Command *cmd)
+{
+  (void) cls;
+}
+
+/**
+*
+*
+* @param cls closure.
+* @param[out] ret result
+* @param trait name of the trait.
+* @param index index number of the object to offer.
+* @return #GNUNET_OK on success.
+*/
+static int
+tng_service_traits (void *cls,
+                    const void **ret,
+                    const char *trait,
+                    unsigned int index)
+{
+  (void) cls;
+  return GNUNET_OK;
+}
+
+
+static void *
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
+{
+  struct TngState *ts = cls;
+
+  if (NULL != emsg)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "There was an error starting the transport subsystem: %s\n",
+         emsg);
+  }
+  GNUNET_TESTING_interpreter_next (ps->is);
+  return ts->nc (ts->cb_cls);
+
+}
+
+
+static void
+notify_disconnect (void *cls,
+                   const struct GNUNET_PeerIdentity *peer,
+                   void *handler_cls)
+{
+}
+
+
+
+
+/**
+ * Adapter function called to establish a connection to
+ * a service.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer to connect to; will be available until
+ *          GNUNET_TESTBED_operation_done() is called on the operation returned
+ *          from GNUNET_TESTBED_service_connect()
+ * @return service handle to return in 'op_result', NULL on error
+ */
+static void *
+connect_adapter (void *cls,
+                 const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct TngState *ts = cls;
+
+  service_handle = GNUNET_TRANSPORT_core_connect (cfg,
+                                                  ts->peer_identity,
+                                                  ts->handlers,
+                                                  ts,
+                                                  &notify_connect,
+                                                  &notify_disconnect);
+  return service_handle;
+}
+
+
+/**
+ * Adapter function called to destroy a connection to
+ * a service.
+ *
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+disconnect_adapter (void *cls,
+                    void *op_result)
+{
+}
+
+/**
+ * Callback to be called when a service connect operation is completed
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @param op the operation that has been finished
+ * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+service_connect_comp_cb (void *cls,
+                         struct GNUNET_TESTBED_Operation *op,
+                         void *ca_result,
+                         const char *emsg)
+{
+  struct TngState *ts = cls;
+
+  if (NULL != emsg)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "An error occured connecting to service %s\n",
+         emsg);
+    GNUNET_TESTBED_operation_done (ts->operation);
+  }
+}
+
+
+/**
+ * Callback to be called when the requested peer information is available
+ *
+ * @param cls the closure from GNUNET_TESTBED_peer_getinformation()
+ * @param op the operation this callback corresponds to
+ * @param pinfo the result; will be NULL if the operation has failed
+ * @param emsg error message if the operation has failed;
+ *             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)
+{
+  struct TngState *ts = cls;
+
+  ts->peer_identity = pinfo->id;
+  ts->operation =
+    GNUNET_TESTBED_service_connect (NULL, peer, NULL,
+                                    &service_connect_comp_cb, ts,
+                                    &connect_adapter,
+                                    &disconnect_adapter,
+                                    ts);
+}
+
+
+static void
+tng_service_run (void *cls,
+                 const struct GNUNET_TESTING_Command *cmd,
+                 struct GNUNET_TESTING_Interpreter *is)
+{
+  struct TngState *ts = cls;
+  struct GNUNET_TESTBED_Peer *peer;
+  const struct GNUNET_TESTING_Command *peer_cmd;
+
+  ts->is = is;
+  peer_cmd = GNUNET_TESTING_interpreter_lookup_command (
+    ts->peer_label);
+  GNUNET_TESTBED_get_trait_peer (peer_cmd,
+                                 &peer);
+
+  ts->operation = GNUNET_TESTBED_peer_get_information (peer,
+                                                       GNUNET_TESTBED_PIT_IDENTITY,
+                                                       &pi_cb,
+                                                       ts);
+}
+
+/**
+ * Shutdown nicely
+ *
+ * @param cs service state.
+ */
+void
+GNUNET_TESTBED_shutdown_service (struct TngState *cs)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down...\n");
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TESTBED_cmd_tng_service (const char *label,
+                                const char *peer_label,
+                                const struct GNUNET_MQ_MessageHandler *handlers,
+                                GNUNET_TRANSPORT_NotifyConnect nc,
+                                void *cb_cls)
+
+{
+  struct TngState *ts;
+
+  ts = GNUNET_new (struct TngState);
+  ts->servicename = servicename;
+  ts->peer_label = peer_label;
+  ts->handlers = handlers;
+  ts->nc = nc;
+  ts->nd = nd;
+  ts->cb_cls;
+
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = ts,
+    .label = label,
+    .run = &tng_service_run,
+    .cleanup = &tmg_service_cleanup,
+    .traits = &tng_service_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testing/Makefile.am b/src/testing/Makefile.am
index 2b599f55b..95fc5c805 100644
--- a/src/testing/Makefile.am
+++ b/src/testing/Makefile.am
@@ -15,7 +15,14 @@ lib_LTLIBRARIES = \
   libgnunettesting.la
 
 libgnunettesting_la_SOURCES = \
-  testing.c
+  testing.c \
+  testing_api_cmd_batch.c \
+  testing_api_cmd_hello_world.c \
+  testing_api_cmd_hello_world_birth.c \
+  testing_api_loop.c \
+  testing_api_trait_cmd.c \
+  testing_api_trait_process.c \
+  testing_api_traits.c
 libgnunettesting_la_LIBADD = \
  $(top_builddir)/src/arm/libgnunetarm.la \
  $(top_builddir)/src/util/libgnunetutil.la \
@@ -48,6 +55,7 @@ list_keys_LDADD = \
 
 
 check_PROGRAMS = \
+ test_testing_hello_world \
  test_testing_portreservation \
  test_testing_servicestartup \
  test_testing_peerstartup \
@@ -57,12 +65,19 @@ check_PROGRAMS = \
 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 = \
+ test_testing_hello_world \
  test_testing_portreservation \
  test_testing_peerstartup \
  test_testing_peerstartup2 \
  test_testing_servicestartup
 endif
 
+test_testing_hello_world_SOURCES = \
+ test_testing_hello_world.c
+test_testing_hello_world_LDADD = \
+ libgnunettesting.la \
+ $(top_builddir)/src/util/libgnunetutil.la
+
 test_testing_portreservation_SOURCES = \
  test_testing_portreservation.c
 test_testing_portreservation_LDADD = \
diff --git a/src/testing/test_testing_hello_world.c b/src/testing/test_testing_hello_world.c
new file mode 100644
index 000000000..6300e26a4
--- /dev/null
+++ b/src/testing/test_testing_hello_world.c
@@ -0,0 +1,68 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/test_testing_hello_world.c
+ * @brief hello world test case
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_util_lib.h"
+
+/**
+ * Main function to run the test cases.
+ *
+ * @param cls not used.
+ *
+ */
+static void
+run (void *cls)
+{
+  (void *) cls;
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_hello_world_birth ("hello-world-birth-0",
+                                          &now),
+    GNUNET_TESTING_cmd_hello_world ("hello-world-0","hello-world-birth-0",""),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  GNUNET_TESTING_run (NULL,
+                      commands,
+                      GNUNET_TIME_UNIT_FOREVER_REL);
+}
+
+int
+main (int argc,
+      char *const *argv)
+{
+  int rv = 0;
+
+  GNUNET_log_setup ("test-hello-world",
+                    "DEBUG",
+                    NULL);
+
+  GNUNET_SCHEDULER_run (&run,
+                        NULL);
+
+  return rv;
+}
diff --git a/src/testing/testing.h b/src/testing/testing.h
new file mode 100644
index 000000000..b12466530
--- /dev/null
+++ b/src/testing/testing.h
@@ -0,0 +1,74 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @author t3sserakt
+ */
+
+#include "gnunet_util_lib.h"
+
+/**
+ * Global state of the interpreter, used by a command
+ * to access information about other commands.
+ */
+// SUGGESTION: consider making this struct opaque (only known inside of libgnunettesting,
+// say main loop and a few select commands, like next/fail/batch); + helper
+// function to access 'cfg'?
+struct GNUNET_TESTING_Interpreter
+{
+
+  /**
+   * Commands the interpreter will run.
+   */
+  struct GNUNET_TESTING_Command *commands;
+
+  /**
+   * Interpreter task (if one is scheduled).
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * Finish task of a blocking call to a commands finish method.
+   */
+  struct GNUNET_SCHEDULER_Task *finish_task;
+
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Task run on timeout.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  /**
+   * Instruction pointer.  Tells #interpreter_run() which instruction to run
+   * next.  Need (signed) int because it gets -1 when rewinding the
+   * interpreter to the first CMD.
+   */
+  int ip;
+
+  /**
+   * Result of the testcases, #GNUNET_OK on success
+   */
+  int result;
+
+};
diff --git a/src/testing/testing_api_cmd_batch.c b/src/testing/testing_api_cmd_batch.c
new file mode 100644
index 000000000..af260f80d
--- /dev/null
+++ b/src/testing/testing_api_cmd_batch.c
@@ -0,0 +1,256 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_cmd_batch.c
+ * @brief Implement batch-execution of CMDs.
+ * @author Marcello Stanisci (GNU Taler testing)
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+#include "testing.h"
+
+/**
+ * State for a "batch" CMD.
+ */
+struct BatchState
+{
+  /**
+   * CMDs batch.
+   */
+  struct GNUNET_TESTING_Command *batch;
+
+  /**
+   * Internal command pointer.
+   */
+  unsigned int batch_ip;
+};
+
+
+/**
+ * Run the command.
+ *
+ * @param cls closure.
+ * @param cmd the command being executed.
+ * @param is the interpreter state.
+ */
+static void
+batch_run (void *cls,
+           const struct GNUNET_TESTING_Command *cmd,
+           struct GNUNET_TESTING_Interpreter *is)
+{
+  struct BatchState *bs = cls;
+
+  if (NULL != bs->batch[bs->batch_ip].label)
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Running batched command: %s\n",
+                bs->batch[bs->batch_ip].label);
+
+  /* hit end command, leap to next top-level command.  */
+  if (NULL == bs->batch[bs->batch_ip].label)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Exiting from batch: %s\n",
+                cmd->label);
+    return;
+  }
+  bs->batch[bs->batch_ip].start_time
+    = bs->batch[bs->batch_ip].last_req_time
+      = GNUNET_TIME_absolute_get ();
+  bs->batch[bs->batch_ip].num_tries = 1;
+  bs->batch[bs->batch_ip].run (bs->batch[bs->batch_ip].cls,
+                               &bs->batch[bs->batch_ip],
+                               is);
+}
+
+
+/**
+ * Cleanup the state from a "reserve status" CMD, and possibly
+ * cancel a pending operation thereof.
+ *
+ * @param cls closure.
+ * @param cmd the command which is being cleaned up.
+ */
+static void
+batch_cleanup (void *cls,
+               const struct GNUNET_TESTING_Command *cmd)
+{
+  struct BatchState *bs = cls;
+
+  (void) cmd;
+  for (unsigned int i = 0;
+       NULL != bs->batch[i].label;
+       i++)
+    bs->batch[i].cleanup (bs->batch[i].cls,
+                          &bs->batch[i]);
+  GNUNET_free (bs->batch);
+  GNUNET_free (bs);
+}
+
+
+/**
+ * Offer internal data from a "batch" CMD, to other commands.
+ *
+ * @param cls closure.
+ * @param[out] ret result.
+ * @param trait name of the trait.
+ * @param index index number of the object to offer.
+ * @return #GNUNET_OK on success.
+ */
+static int
+batch_traits (void *cls,
+              const void **ret,
+              const char *trait,
+              unsigned int index)
+{
+#define CURRENT_CMD_INDEX 0
+#define BATCH_INDEX 1
+
+  struct BatchState *bs = cls;
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    GNUNET_TESTING_make_trait_cmd
+      (CURRENT_CMD_INDEX, &bs->batch[bs->batch_ip]),
+    GNUNET_TESTING_make_trait_cmd
+      (BATCH_INDEX, bs->batch),
+    GNUNET_TESTING_trait_end ()
+  };
+
+  /* Always return current command.  */
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+}
+
+
+/**
+ * Create a "batch" command.  Such command takes a
+ * end_CMD-terminated array of CMDs and executed them.
+ * Once it hits the end CMD, it passes the control
+ * to the next top-level CMD, regardless of it being
+ * another batch or ordinary CMD.
+ *
+ * @param label the command label.
+ * @param batch array of CMDs to execute.
+ *
+ * @return the command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_batch (const char *label,
+                          struct GNUNET_TESTING_Command *batch)
+{
+  struct BatchState *bs;
+  unsigned int i;
+
+  bs = GNUNET_new (struct BatchState);
+
+  /* Get number of commands.  */
+  for (i = 0; NULL != batch[i].label; i++)
+    /* noop */
+    ;
+
+  bs->batch = GNUNET_new_array (i + 1,
+                                struct GNUNET_TESTING_Command);
+  memcpy (bs->batch,
+          batch,
+          sizeof (struct GNUNET_TESTING_Command) * i);
+  {
+    struct GNUNET_TESTING_Command cmd = {
+      .cls = bs,
+      .label = label,
+      .run = &batch_run,
+      .cleanup = &batch_cleanup,
+      .traits = &batch_traits
+    };
+
+    return cmd;
+  }
+}
+
+
+/**
+ * Advance internal pointer to next command.
+ *
+ * @param is interpreter state.
+ */
+void
+GNUNET_TESTING_cmd_batch_next (struct GNUNET_TESTING_Interpreter *is)
+{
+  struct BatchState *bs = is->commands[is->ip].cls;
+
+  if (NULL == bs->batch[bs->batch_ip].label)
+  {
+    is->commands[is->ip].finish_time = GNUNET_TIME_absolute_get ();
+    is->ip++;
+    return;
+  }
+  bs->batch[bs->batch_ip].finish_time = GNUNET_TIME_absolute_get ();
+  bs->batch_ip++;
+}
+
+
+/**
+ * Test if this command is a batch command.
+ *
+ * @return false if not, true if it is a batch command
+ */
+int
+GNUNET_TESTING_cmd_is_batch (const struct GNUNET_TESTING_Command *cmd)
+{
+  return cmd->run == &batch_run;
+}
+
+
+/**
+ * Obtain what command the batch is at.
+ *
+ * @return cmd current batch command
+ */
+struct GNUNET_TESTING_Command *
+GNUNET_TESTING_cmd_batch_get_current (const struct GNUNET_TESTING_Command *cmd)
+{
+  struct BatchState *bs = cmd->cls;
+
+  GNUNET_assert (cmd->run == &batch_run);
+  return &bs->batch[bs->batch_ip];
+}
+
+
+/**
+ * Set what command the batch should be at.
+ *
+ * @param cmd current batch command
+ * @param new_ip where to move the IP
+ */
+void
+GNUNET_TESTING_cmd_batch_set_current (const struct GNUNET_TESTING_Command *cmd,
+                                      unsigned int new_ip)
+{
+  struct BatchState *bs = cmd->cls;
+
+  /* sanity checks */
+  GNUNET_assert (cmd->run == &batch_run);
+  for (unsigned int i = 0; i < new_ip; i++)
+    GNUNET_assert (NULL != bs->batch[i].label);
+  /* actual logic */
+  bs->batch_ip = new_ip;
+}
diff --git a/src/testing/testing_api_cmd_hello_world.c b/src/testing/testing_api_cmd_hello_world.c
new file mode 100644
index 000000000..4347ac818
--- /dev/null
+++ b/src/testing/testing_api_cmd_hello_world.c
@@ -0,0 +1,121 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_cmd_hello_world.c
+ * @brief implementation of a hello world command.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+
+struct HelloWorldState
+{
+  char *message;
+  const char *birthLabel;
+};
+
+/**
+*
+*
+* @param cls closure
+* @param cmd current CMD being cleaned up.
+*/
+static void
+hello_world_cleanup (void *cls,
+                     const struct GNUNET_TESTING_Command *cmd)
+{
+  struct HelloWorldState *hs = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Cleaning up message %s\n",
+              hs->message);
+}
+
+/**
+*
+*
+* @param cls closure.
+* @param[out] ret result
+* @param trait name of the trait.
+* @param index index number of the object to offer.
+* @return #GNUNET_OK on success.
+*/
+static int
+hello_world_traits (void *cls,
+                    const void **ret,
+                    const char *trait,
+                    unsigned int index)
+{
+  return GNUNET_OK;
+}
+
+/**
+* Run the "hello world" CMD.
+*
+* @param cls closure.
+* @param cmd CMD being run.
+* @param is interpreter state.
+*/
+static void
+hello_world_run (void *cls,
+                 const struct GNUNET_TESTING_Command *cmd,
+                 struct GNUNET_TESTING_Interpreter *is)
+{
+  struct HelloWorldState *hs = cls;
+  const struct GNUNET_TESTING_Command *birth_cmd;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "%s\n",
+              hs->message);
+  birth_cmd = GNUNET_TESTING_interpreter_lookup_command (hs->birthLabel);
+  GNUNET_TESTING_get_trait_what_am_i (birth_cmd, &hs->message);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Now I am a %s\n",
+              hs->message);
+}
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param message initial message.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_hello_world (const char *label,
+                                const char *birthLabel,
+                                char *message)
+{
+  struct HelloWorldState *hs;
+
+  hs = GNUNET_new (struct HelloWorldState);
+  hs->message = "Hello World, I was nobody!";
+  hs->birthLabel = birthLabel;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = hs,
+    .label = label,
+    .run = &hello_world_run,
+    .cleanup = &hello_world_cleanup,
+    .traits = &hello_world_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testing/testing_api_cmd_hello_world_birth.c b/src/testing/testing_api_cmd_hello_world_birth.c
new file mode 100644
index 000000000..2a5bded92
--- /dev/null
+++ b/src/testing/testing_api_cmd_hello_world_birth.c
@@ -0,0 +1,159 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_cmd_hello_world.c
+ * @brief implementation of a hello world command.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+
+struct HelloWorldBirthState
+{
+  struct GNUNET_TIME_Absolute *date;
+  char *what_am_i;
+};
+
+/**
+*
+*
+* @param cls closure
+* @param cmd current CMD being cleaned up.
+*/
+static void
+hello_world_birth_cleanup (void *cls,
+                           const struct GNUNET_TESTING_Command *cmd)
+{
+  struct HelloWorldBirthState *hbs = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Finished birth of %s\n",
+              hbs->what_am_i);
+}
+
+/**
+*
+*
+* @param cls closure.
+* @param[out] ret result
+* @param trait name of the trait.
+* @param index index number of the object to offer.
+* @return #GNUNET_OK on success.
+*/
+static int
+hello_world_birth_traits (void *cls,
+                          const void **ret,
+                          const char *trait,
+                          unsigned int index)
+{
+  struct HelloWorldBirthState *hbs = cls;
+  const char *what_am_i = hbs->what_am_i;
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    {
+      .index = 0,
+      .trait_name = "what_am_i",
+      .ptr = (const void *) what_am_i,
+    },
+    GNUNET_TESTING_trait_end ()
+  };
+
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+}
+
+/**
+* Run the "hello world" CMD.
+*
+* @param cls closure.
+* @param cmd CMD being run.
+* @param is interpreter state.
+*/
+static void
+hello_world_birth_run (void *cls,
+                       const struct GNUNET_TESTING_Command *cmd,
+                       struct GNUNET_TESTING_Interpreter *is)
+{
+  struct HelloWorldBirthState *hbs = cls;
+  struct GNUNET_TIME_Relative relativ;
+
+  relativ = GNUNET_TIME_absolute_get_difference (*hbs->date,
+                                                 GNUNET_TIME_absolute_get ());
+
+  if (0 == relativ.rel_value_us % 10)
+  {
+    hbs->what_am_i = "creature!";
+  }
+  else if (0 == relativ.rel_value_us % 2)
+  {
+    hbs->what_am_i = "girl!";
+  }
+  else
+  {
+    hbs->what_am_i = "boy!";
+  }
+}
+
+/**
+ * Offer data from trait
+ *
+ * @param cmd command to extract the message from.
+ * @param pt pointer to message.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_what_am_i (const struct GNUNET_TESTING_Command *cmd,
+                                    char **what_am_i)
+{
+  return cmd->traits (cmd->cls,
+                      (const void **) what_am_i,
+                      "what_am_i",
+                      (unsigned int) 0);
+}
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param now when the command was started.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_hello_world_birth (const char *label,
+                                      struct GNUNET_TIME_Absolute *now)
+{
+  struct HelloWorldBirthState *hbs;
+
+  hbs = GNUNET_new (struct HelloWorldBirthState);
+  hbs->date = now;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = hbs,
+    .label = label,
+    .run = &hello_world_birth_run,
+    .cleanup = &hello_world_birth_cleanup,
+    .traits = &hello_world_birth_traits
+  };
+
+  return cmd;
+}
diff --git a/src/testing/testing_api_loop.c b/src/testing/testing_api_loop.c
new file mode 100644
index 000000000..dbd86ba90
--- /dev/null
+++ b/src/testing/testing_api_loop.c
@@ -0,0 +1,510 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_loop.c
+ * @brief main interpreter loop for testcases
+ * @author Christian Grothoff (GNU Taler testing)
+ * @author Marcello Stanisci (GNU Taler testing)
+ * @author t3sserakt
+*/
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "testing.h"
+
+struct GNUNET_TESTING_Interpreter *is;
+
+/**
+ * Closure used to sync an asynchronous with an synchronous command.
+ */
+struct SyncTaskClosure
+{
+
+  /**
+   * The asynchronous command the synchronous command waits for.
+   */
+  const struct GNUNET_TESTING_Command *async_cmd;
+
+  /**
+   * The synchronous command that waits for the asynchronous command.
+   */
+  const struct GNUNET_TESTING_Command *sync_cmd;
+
+  /**
+   * The interpreter of the test.
+   */
+  struct GNUNET_TESTING_Interpreter *is;
+};
+
+/**
+* Closure used to run the finish task.
+*/
+struct FinishTaskClosure
+{
+
+  /**
+   * The asynchronous command the synchronous command waits for.
+   */
+  const struct GNUNET_TESTING_Command *cmd;
+
+  /**
+   * The interpreter of the test.
+   */
+  struct GNUNET_TESTING_Interpreter *is;
+};
+
+/**
+ * Lookup command by label.
+ *
+ * @param label label to look for
+ * @return NULL if command was not found
+ */
+const struct GNUNET_TESTING_Command *
+GNUNET_TESTING_interpreter_lookup_command (const char *label)
+{
+  if (NULL == label)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Attempt to lookup command for empty label\n");
+    return NULL;
+  }
+  /* Search backwards as we most likely reference recent commands */
+  for (int i = is->ip; i >= 0; i--)
+  {
+    const struct GNUNET_TESTING_Command *cmd = &is->commands[i];
+
+    /* Give precedence to top-level commands.  */
+    if ( (NULL != cmd->label) &&
+         (0 == strcmp (cmd->label,
+                       label)) )
+      return cmd;
+
+    if (GNUNET_TESTING_cmd_is_batch (cmd))
+    {
+#define BATCH_INDEX 1
+      struct GNUNET_TESTING_Command *batch;
+      struct GNUNET_TESTING_Command *current;
+      struct GNUNET_TESTING_Command *icmd;
+      const struct GNUNET_TESTING_Command *match;
+
+      current = GNUNET_TESTING_cmd_batch_get_current (cmd);
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_TESTING_get_trait_cmd (cmd,
+                                                   BATCH_INDEX,
+                                                   &batch));
+      /* We must do the loop forward, but we can find the last match */
+      match = NULL;
+      for (unsigned int j = 0;
+           NULL != (icmd = &batch[j])->label;
+           j++)
+      {
+        if (current == icmd)
+          break; /* do not go past current command */
+        if ( (NULL != icmd->label) &&
+             (0 == strcmp (icmd->label,
+                           label)) )
+          match = icmd;
+      }
+      if (NULL != match)
+        return match;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Command not found: %s\n",
+              label);
+  return NULL;
+
+}
+
+
+/**
+ * Run the main interpreter loop that performs exchange operations.
+ *
+ * @param cls contains the `struct InterpreterState`
+ */
+static void
+interpreter_run (void *cls);
+
+
+/**
+ * Current command is done, run the next one.
+ */
+static void
+interpreter_next (void *cls)
+{
+  struct GNUNET_TESTING_Interpreter *is = cls;
+  static unsigned long long ipc;
+  static struct GNUNET_TIME_Absolute last_report;
+  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
+
+  if (GNUNET_SYSERR == is->result)
+    return; /* ignore, we already failed! */
+  if (GNUNET_TESTING_cmd_is_batch (cmd))
+  {
+    GNUNET_TESTING_cmd_batch_next (is);
+  }
+  else
+  {
+    cmd->finish_time = GNUNET_TIME_absolute_get ();
+    is->ip++;
+  }
+  if (0 == (ipc % 1000))
+  {
+    if (0 != ipc)
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+                  "Interpreter executed 1000 instructions in %s\n",
+                  GNUNET_STRINGS_relative_time_to_string (
+                    GNUNET_TIME_absolute_get_duration (last_report),
+                    GNUNET_YES));
+    last_report = GNUNET_TIME_absolute_get ();
+  }
+  ipc++;
+  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
+                                       is);
+}
+
+
+static void
+run_finish_task_next (void *cls)
+{
+  struct FinishTaskClosure *ftc = cls;
+  const struct GNUNET_TESTING_Command *cmd = ftc->cmd;
+  struct GNUNET_TESTING_Interpreter *is = ftc->is;
+
+  if (cmd->finish (cmd->cls, &interpreter_next, is))
+  {
+    is->finish_task = GNUNET_SCHEDULER_add_now (&run_finish_task_next, ftc);
+  }
+  else
+  {
+    is->finish_task = NULL;
+  }
+
+}
+
+
+static void
+run_finish_task_sync (void *cls)
+{
+  struct SyncTaskClosure *stc = cls;
+  const struct GNUNET_TESTING_Command *cmd = stc->async_cmd;
+  const struct GNUNET_TESTING_Command *sync_cmd = stc->sync_cmd;
+  struct FinishTaskClosure *ftc;
+  struct SyncState *sync_state = sync_cmd->cls;
+  struct GNUNET_SCHEDULER_Task *finish_task = sync_state->finish_task;
+
+  GNUNET_assert (NULL != finish_task);
+  ftc = GNUNET_new (struct FinishTaskClosure);
+  ftc->cmd = stc->sync_cmd;
+  ftc->is = stc->is;
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  if (cmd->default_timeout.rel_value_us < now.abs_value_us
+      - sync_state->start_finish_time.abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "The command with label %s did not finish its asyncronous task in time.\n",
+                cmd->label);
+    is->result = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+
+  if (cmd->finish (cmd->cls, run_finish_task_next, ftc))
+  {
+    finish_task = GNUNET_SCHEDULER_add_now (&run_finish_task_sync, stc);
+  }
+  else
+  {
+    finish_task = NULL;
+  }
+}
+
+
+static void
+start_finish_on_ref (void *cls,
+                     const struct GNUNET_TESTING_Command *cmd,
+                     struct GNUNET_TESTING_Interpreter *is)
+{
+  struct SyncState *sync_state = cls;
+  struct SyncTaskClosure *stc;
+  const struct GNUNET_TESTING_Command *async_cmd;
+
+  async_cmd = sync_state->async_cmd;
+  stc = GNUNET_new (struct SyncTaskClosure);
+  stc->async_cmd = async_cmd;
+  stc->sync_cmd = cmd;
+  stc->is = is;
+  sync_state->start_finish_time = GNUNET_TIME_absolute_get ();
+  sync_state->finish_task = GNUNET_SCHEDULER_add_now (&run_finish_task_sync,
+                                                      stc);
+}
+
+
+const struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_finish (const char *finish_label,
+                           const char *cmd_ref,
+                           struct GNUNET_TIME_Relative timeout)
+{
+  const struct GNUNET_TESTING_Command *async_cmd;
+  struct SyncState *sync_state;
+
+  async_cmd = GNUNET_TESTING_interpreter_lookup_command (cmd_ref);
+  sync_state = GNUNET_new (struct SyncState);
+  sync_state->async_cmd = async_cmd;
+
+  struct GNUNET_TESTING_Command cmd = {
+    .cls = sync_state,
+    .label = finish_label,
+    .run = &start_finish_on_ref,
+    .asynchronous_finish = GNUNET_NO
+  };
+
+  return cmd;
+}
+
+
+const struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_make_asynchronous (const struct GNUNET_TESTING_Command cmd)
+{
+
+  GNUNET_assert (NULL != cmd.finish);
+  const struct GNUNET_TESTING_Command async_cmd = {
+    .cls = cmd.cls,
+    .label = cmd.label,
+    .run = cmd.run,
+    .cleanup = cmd.cleanup,
+    .traits = cmd.traits,
+    .finish = cmd.finish,
+    .asynchronous_finish = GNUNET_YES
+  };
+
+  return async_cmd;
+}
+
+
+/**
+ * Current command failed, clean up and fail the test case.
+ *
+ * @param is interpreter of the test
+ */
+void
+GNUNET_TESTING_interpreter_fail (struct GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Failed at command `%s'\n",
+              cmd->label);
+  while (GNUNET_TESTING_cmd_is_batch (cmd))
+  {
+    cmd = GNUNET_TESTING_cmd_batch_get_current (cmd);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Batch is at command `%s'\n",
+                cmd->label);
+  }
+  is->result = GNUNET_SYSERR;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Create command array terminator.
+ *
+ * @return a end-command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TESTING_cmd_end (void)
+{
+  static struct GNUNET_TESTING_Command cmd;
+  cmd.label = NULL;
+
+  return cmd;
+}
+
+
+/**
+ * Obtain current label.
+ */
+const char *
+GNUNET_TESTING_interpreter_get_current_label (struct
+                                              GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
+
+  return cmd->label;
+}
+
+
+/**
+ * Run the main interpreter loop.
+ *
+ * @param cls contains the `struct GNUNET_TESTING_Interpreter`
+ */
+static void
+interpreter_run (void *cls)
+{
+  struct FinishTaskClosure *ftc;
+  struct GNUNET_TESTING_Interpreter *is = cls;
+  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
+
+  is->task = NULL;
+
+  if (NULL == cmd->label)
+  {
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Running command END\n");
+    is->result = GNUNET_OK;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Running command `%s'\n",
+              cmd->label);
+  cmd->start_time
+    = cmd->last_req_time
+      = GNUNET_TIME_absolute_get ();
+  cmd->num_tries = 1;
+  cmd->run (cmd->cls,
+            cmd,
+            is);
+  if ((NULL != cmd->finish) && (GNUNET_NO == cmd->asynchronous_finish))
+  {
+    ftc = GNUNET_new (struct FinishTaskClosure);
+    ftc->cmd = cmd;
+    ftc->is = is;
+    cmd->finish_task = GNUNET_SCHEDULER_add_now (run_finish_task_next, ftc);
+  }
+  else
+  {
+    interpreter_next (is);
+  }
+}
+
+
+/**
+ * Function run when the test terminates (good or bad).
+ * Cleans up our state.
+ *
+ * @param cls the interpreter state.
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+  struct GNUNET_TESTING_Command *cmd;
+  const char *label;
+
+  label = is->commands[is->ip].label;
+  if (NULL == label)
+    label = "END";
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Executing shutdown at `%s'\n",
+              label);
+
+  for (unsigned int j = 0;
+       NULL != (cmd = &is->commands[j])->label;
+       j++) {
+    cmd->cleanup (cmd->cls,
+                  cmd);
+    if (NULL != cmd->finish_task)
+    {
+      GNUNET_SCHEDULER_cancel (cmd->finish_task);
+      cmd->finish_task = NULL;
+    }
+  }
+
+  if (NULL != is->task)
+  {
+    GNUNET_SCHEDULER_cancel (is->task);
+    is->task = NULL;
+  }
+  if (NULL != is->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (is->timeout_task);
+    is->timeout_task = NULL;
+  }
+  GNUNET_free (is->commands);
+}
+
+
+/**
+ * Function run when the test terminates (good or bad) with timeout.
+ *
+ * @param cls NULL
+ */
+static void
+do_timeout (void *cls)
+{
+  (void) cls;
+
+  is->timeout_task = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Terminating test due to timeout\n");
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Run the testsuite.  Note, CMDs are copied into
+ * the interpreter state because they are _usually_
+ * defined into the "run" method that returns after
+ * having scheduled the test interpreter.
+ *
+ * @param is the interpreter state
+ * @param commands the list of command to execute
+ * @param timeout how long to wait
+ */
+int
+GNUNET_TESTING_run (const char *cfg_filename,
+                    struct GNUNET_TESTING_Command *commands,
+                    struct GNUNET_TIME_Relative timeout)
+{
+  unsigned int i;
+
+  is = GNUNET_new (struct GNUNET_TESTING_Interpreter);
+
+  if (NULL != is->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (is->timeout_task);
+    is->timeout_task = NULL;
+  }
+  /* get the number of commands */
+  for (i = 0; NULL != commands[i].label; i++)
+    ;
+  is->commands = GNUNET_new_array (i + 1,
+                                   struct GNUNET_TESTING_Command);
+  memcpy (is->commands,
+          commands,
+          sizeof (struct GNUNET_TESTING_Command) * i);
+
+  is->timeout_task = GNUNET_SCHEDULER_add_delayed
+                       (timeout,
+                       &do_timeout,
+                       is);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, is);
+  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run, is);
+  return GNUNET_OK;
+}
+
+
+/* end of testing_api_loop.c */
diff --git a/src/testing/testing_api_trait_cmd.c b/src/testing/testing_api_trait_cmd.c
new file mode 100644
index 000000000..886baee5b
--- /dev/null
+++ b/src/testing/testing_api_trait_cmd.c
@@ -0,0 +1,79 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_trait_cmd.c
+ * @brief offers CMDs as traits.
+ * @author Marcello Stanisci (GNU Taler testing)
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+
+#define GNUNET_TESTING_TRAIT_CMD "cmd"
+
+
+/**
+ * Obtain a command from @a cmd.
+ *
+ * @param cmd command to extract the command from.
+ * @param index always zero.  Commands offering this
+ *        kind of traits do not need this index.  For
+ *        example, a "batch" CMD returns always the
+ *        CMD currently being executed.
+ * @param[out] _cmd where to write the wire details.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_cmd (const struct GNUNET_TESTING_Command *cmd,
+                              unsigned int index,
+                              struct GNUNET_TESTING_Command **_cmd)
+{
+  return cmd->traits (cmd->cls,
+                      (const void **) _cmd,
+                      GNUNET_TESTING_TRAIT_CMD,
+                      index);
+}
+
+
+/**
+ * Offer a command in a trait.
+ *
+ * @param index always zero.  Commands offering this
+ *        kind of traits do not need this index.  For
+ *        example, a "meta" CMD returns always the
+ *        CMD currently being executed.
+ * @param cmd wire details to offer.
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_cmd (unsigned int index,
+                               const struct GNUNET_TESTING_Command *cmd)
+{
+  struct GNUNET_TESTING_Trait ret = {
+    .index = index,
+    .trait_name = GNUNET_TESTING_TRAIT_CMD,
+    .ptr = (const struct GNUNET_TESTING_Command *) cmd
+  };
+  return ret;
+}
+
+
+/* end of testing_api_trait_cmd.c */
diff --git a/src/testing/testing_api_trait_process.c b/src/testing/testing_api_trait_process.c
new file mode 100644
index 000000000..31cdb01df
--- /dev/null
+++ b/src/testing/testing_api_trait_process.c
@@ -0,0 +1,81 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_trait_process.c
+ * @brief trait offering process handles.
+ * @author Christian Grothoff (GNU Taler testing)
+ * @author Marcello Stanisci (GNU Taler testing)
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+
+#define GNUNET_TESTING_TRAIT_PROCESS "process"
+
+
+/**
+ * Obtain location where a command stores a pointer to a process.
+ *
+ * @param cmd command to extract trait from.
+ * @param index which process to pick if @a cmd
+ *        has multiple on offer.
+ * @param[out] processp set to the address of the pointer to the
+ *        process.
+ * @return #GNUNET_OK on success.
+ */
+int
+GNUNET_TESTING_get_trait_process
+  (const struct GNUNET_TESTING_Command *cmd,
+  unsigned int index,
+  struct GNUNET_OS_Process ***processp)
+{
+  return cmd->traits (cmd->cls,
+                      (const void **) processp,
+                      GNUNET_TESTING_TRAIT_PROCESS,
+                      index);
+}
+
+
+/**
+ * Offer location where a command stores a pointer to a process.
+ *
+ * @param index offered location index number, in case there are
+ *        multiple on offer.
+ * @param processp process location to offer.
+ *
+ * @return the trait.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_make_trait_process
+  (unsigned int index,
+  struct GNUNET_OS_Process **processp)
+{
+  struct GNUNET_TESTING_Trait ret = {
+    .index = index,
+    .trait_name = GNUNET_TESTING_TRAIT_PROCESS,
+    .ptr = (const void *) processp
+  };
+
+  return ret;
+}
+
+
+/* end of testing_api_trait_process.c */
diff --git a/src/testing/testing_api_traits.c b/src/testing/testing_api_traits.c
new file mode 100644
index 000000000..66626833d
--- /dev/null
+++ b/src/testing/testing_api_traits.c
@@ -0,0 +1,81 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing/testing_api_traits.c
+ * @brief loop for trait resolution
+ * @author Christian Grothoff (GNU Taler testing)
+ * @author Marcello Stanisci (GNU Taler testing)
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_ng_lib.h"
+
+
+/**
+ * End a trait array.  Usually, commands offer several traits,
+ * and put them in arrays.
+ */
+struct GNUNET_TESTING_Trait
+GNUNET_TESTING_trait_end ()
+{
+  struct GNUNET_TESTING_Trait end = {
+    .index = 0,
+    .trait_name = NULL,
+    .ptr = NULL
+  };
+
+  return end;
+}
+
+
+/**
+ * Pick the chosen trait from the traits array.
+ *
+ * @param traits the traits array.
+ * @param ret where to store the result.
+ * @param trait type of the trait to extract.
+ * @param index index number of the object to extract.
+ * @return #GNUNET_OK if no error occurred, #GNUNET_SYSERR otherwise.
+ */
+int
+GNUNET_TESTING_get_trait (const struct GNUNET_TESTING_Trait *traits,
+                          const void **ret,
+                          const char *trait,
+                          unsigned int index)
+{
+  for (unsigned int i = 0; NULL != traits[i].trait_name; i++)
+  {
+    if ( (0 == strcmp (trait, traits[i].trait_name)) &&
+         (index == traits[i].index) )
+    {
+      *ret = (void *) traits[i].ptr;
+      return GNUNET_OK;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Trait %s/%u not found.\n",
+              trait, index);
+
+  return GNUNET_SYSERR;
+}
+
+
+/* end of testing_api_traits.c */
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am
index 67b35365d..bc3004a70 100644
--- a/src/transport/Makefile.am
+++ b/src/transport/Makefile.am
@@ -174,7 +174,6 @@ libgnunettransporttesting2_la_SOURCES = \
   transport-testing-send2.c \
   transport-testing-communicator.c transport-testing-communicator.h
 libgnunettransporttesting2_la_LIBADD = \
-  libgnunettransport.la \
   libgnunettransportapplication.la \
   libgnunettransportcore.la \
   $(top_builddir)/src/arm/libgnunetarm.la \
@@ -954,9 +953,8 @@ test_transport_api_tcp_LDADD = \
  libgnunettransporttesting.la
 
 test_transport_api2_tcp_SOURCES = \
- test_transport_api.c
+ test_transport_api2.c
 test_transport_api2_tcp_LDADD = \
- libgnunettransport.la \
  $(top_builddir)/src/hello/libgnunethello.la \
  $(top_builddir)/src/util/libgnunetutil.la  \
  libgnunettransporttesting2.la
diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index ed82dba9f..9dd2797df 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -739,7 +739,6 @@ struct Addresses
 };
 
 
-
 /**
  * Maximum queue length before we stop reading towards the transport service.
  */
@@ -878,12 +877,14 @@ queue_destroy (struct Queue *queue)
 {
   struct ListenTask *lt = NULL;
   struct GNUNET_HashCode h_sock;
+  int sockfd;
 
-  GNUNET_CRYPTO_hash (queue->listen_sock,
-                      sizeof(queue->listen_sock),
+  sockfd = GNUNET_NETWORK_get_fd (queue->listen_sock);
+  GNUNET_CRYPTO_hash (&sockfd,
+                      sizeof(int),
                       &h_sock);
 
-  lt =   GNUNET_CONTAINER_multihashmap_get (lt_map, &h_sock);
+  lt = GNUNET_CONTAINER_multihashmap_get (lt_map, &h_sock);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Disconnecting queue for peer `%s'\n",
@@ -953,6 +954,9 @@ queue_destroy (struct Queue *queue)
   else
     GNUNET_free (queue);
 
+  if (NULL == lt)
+    return;
+
   if ((! shutdown_running) && (NULL == lt->listen_task))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1193,6 +1197,7 @@ setup_cipher (const struct GNUNET_HashCode *dh,
                                     0));
 }
 
+
 /**
  * Callback called when peerstore store operation for rekey monotime value is finished.
  * @param cls Queue context the store operation was executed.
@@ -1210,6 +1215,7 @@ rekey_monotime_store_cb (void *cls, int success)
   queue->rekey_monotime_sc = NULL;
 }
 
+
 /**
  * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY
  * where found.
@@ -1259,13 +1265,15 @@ rekey_monotime_cb (void *cls,
                                                      pid,
                                                      GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY,
                                                      rekey_monotonic_time,
-                                                     sizeof(rekey_monotonic_time),
+                                                     sizeof(*
+                                                            rekey_monotonic_time),
                                                      GNUNET_TIME_UNIT_FOREVER_ABS,
                                                      GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                                                      &rekey_monotime_store_cb,
                                                      queue);
 }
 
+
 /**
  * Setup cipher of @a queue for decryption.
  *
@@ -1344,6 +1352,7 @@ do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
   setup_in_cipher (&rekey->ephemeral, queue);
 }
 
+
 /**
  * Callback called when peerstore store operation for handshake ack monotime value is finished.
  * @param cls Queue context the store operation was executed.
@@ -1362,6 +1371,7 @@ handshake_ack_monotime_store_cb (void *cls, int success)
   queue->handshake_ack_monotime_sc = NULL;
 }
 
+
 /**
  * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK
  * where found.
@@ -1406,20 +1416,21 @@ handshake_ack_monotime_cb (void *cls,
     queue_finish (queue);
     return;
   }
-  queue->handshake_ack_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
-                                                             "transport_tcp_communicator",
-                                                             pid,
-                                                             GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK,
-                                                             handshake_ack_monotonic_time,
-                                                             sizeof(
-                                                               handshake_ack_monotonic_time),
-                                                             GNUNET_TIME_UNIT_FOREVER_ABS,
-                                                             GNUNET_PEERSTORE_STOREOPTION_REPLACE,
-                                                             &
-                                                             handshake_ack_monotime_store_cb,
-                                                             queue);
+  queue->handshake_ack_monotime_sc =
+    GNUNET_PEERSTORE_store (peerstore,
+                            "transport_tcp_communicator",
+                            pid,
+                            GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK,
+                            handshake_ack_monotonic_time,
+                            sizeof(*handshake_ack_monotonic_time),
+                            GNUNET_TIME_UNIT_FOREVER_ABS,
+                            GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                            &
+                            handshake_ack_monotime_store_cb,
+                            queue);
 }
 
+
 /**
  * Sending challenge with TcpConfirmationAck back to sender of ephemeral key.
  *
@@ -1465,6 +1476,7 @@ send_challenge (struct ChallengeNonceP challenge, struct Queue *queue)
                            "sending challenge done\n");
 }
 
+
 /**
  * Setup cipher for outgoing data stream based on target and
  * our ephemeral private key.
@@ -1545,6 +1557,7 @@ inject_rekey (struct Queue *queue)
   setup_out_cipher (queue);
 }
 
+
 /**
  * We have been notified that our socket is ready to write.
  * Then reschedule this function to be called again once more is available.
@@ -1634,6 +1647,7 @@ queue_write (void *cls)
                                       queue);
 }
 
+
 /**
  * Test if we have received a full message in plaintext.
  * If so, handle it.
@@ -1778,7 +1792,7 @@ try_handle_plaintext (struct Queue *queue)
     queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch,
                                                       &queue->target,
                                                       foreign_addr,
-                                                      0 /* no MTU */,
+                                                      UINT32_MAX, /* no MTU */
                                                       GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
                                                       0, /* Priority */
                                                       queue->nt,
@@ -1975,6 +1989,7 @@ queue_read (void *cls)
   queue_finish (queue);
 }
 
+
 /**
  * Convert a `struct sockaddr_in6 to a `struct sockaddr *`
  *
@@ -2001,6 +2016,7 @@ tcp_address_to_sockaddr_numeric_v6 (socklen_t *sock_len, struct sockaddr_in6 v6,
   return in;
 }
 
+
 /**
  * Convert a `struct sockaddr_in4 to a `struct sockaddr *`
  *
@@ -2024,6 +2040,7 @@ tcp_address_to_sockaddr_numeric_v4 (socklen_t *sock_len, struct sockaddr_in v4,
   return in;
 }
 
+
 /**
  * Convert TCP bind specification to a `struct PortOnlyIpv4Ipv6  *`
  *
@@ -2083,6 +2100,7 @@ tcp_address_to_sockaddr_port_only (const char *bindto, unsigned int *port)
   return po;
 }
 
+
 /**
  * This Method extracts the address part of the BINDTO string.
  *
@@ -2117,7 +2135,8 @@ extract_address (const char *bindto)
     start++;   /* skip over '['*/
     cp[strlen (cp) - 1] = '\0';  /* eat ']'*/
   }
-  else {
+  else
+  {
     token = strtok_r (cp, "]", &rest);
     if (strlen (bindto) == strlen (token))
     {
@@ -2139,6 +2158,7 @@ extract_address (const char *bindto)
   return start;
 }
 
+
 /**
  * This Method extracts the port part of the BINDTO string.
  *
@@ -2217,6 +2237,7 @@ extract_port (const char *addr_and_port)
   return port;
 }
 
+
 /**
  * Convert TCP bind specification to a `struct sockaddr *`
  *
@@ -2245,7 +2266,6 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
               bindto);
 
 
-
   if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
   {
     // colon = strrchr (cp, ':');
@@ -2263,7 +2283,8 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
     port = extract_port (bindto);
     in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
   }
-  else{
+  else
+  {
     GNUNET_assert (0);
   }
 
@@ -2272,6 +2293,7 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
   return in;
 }
 
+
 /**
  * Signature of functions implementing the sending functionality of a
  * message queue.
@@ -2510,6 +2532,7 @@ start_initial_kx_out (struct Queue *queue)
   transmit_kx (queue, &epub);
 }
 
+
 /**
  * Callback called when peerstore store operation for handshake monotime is finished.
  * @param cls Queue context the store operation was executed.
@@ -2527,6 +2550,7 @@ handshake_monotime_store_cb (void *cls, int success)
   queue->handshake_monotime_sc = NULL;
 }
 
+
 /**
  * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE
  * where found.
@@ -2585,6 +2609,7 @@ handshake_monotime_cb (void *cls,
                                                          queue);
 }
 
+
 /**
  * We have received the first bytes from the other side on a @a queue.
  * Decrypt the @a tc contained in @a ibuf and check the signature.
@@ -2651,6 +2676,7 @@ free_proto_queue (struct ProtoQueue *pq)
   GNUNET_free (pq);
 }
 
+
 /**
  * Read from the socket of the proto queue until we have enough data
  * to upgrade to full queue.
@@ -2892,6 +2918,7 @@ queue_read_kx (void *cls)
     queue->read_task = GNUNET_SCHEDULER_add_now (&queue_read, queue);
 }
 
+
 /**
  * Function called by the transport service to initialize a
  * message queue given address information about another peer.
@@ -2991,6 +3018,7 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
   return GNUNET_OK;
 }
 
+
 /**
  * Iterator over all ListenTasks to clean up.
  *
@@ -3021,6 +3049,7 @@ get_lt_delete_it (void *cls,
   return GNUNET_OK;
 }
 
+
 /**
  * Iterator over all message queues to clean up.
  *
@@ -3042,6 +3071,7 @@ get_queue_delete_it (void *cls,
   return GNUNET_OK;
 }
 
+
 /**
  * Shutdown the UNIX communicator.
  *
@@ -3182,6 +3212,7 @@ nat_address_cb (void *cls,
   }
 }
 
+
 /**
  * This method adds addresses to the DLL, that are later register at the NAT service.
  */
@@ -3211,6 +3242,7 @@ add_addr (struct sockaddr *in, socklen_t in_len)
   addrs_lens++;
 }
 
+
 /**
  * This method launch network interactions for each address we like to bind to.
  *
@@ -3226,6 +3258,7 @@ init_socket (struct sockaddr *addr,
   socklen_t sto_len;
   struct GNUNET_NETWORK_Handle *listen_sock;
   struct ListenTask *lt;
+  int sockfd;
   struct GNUNET_HashCode h_sock;
 
   if (NULL == addr)
@@ -3314,8 +3347,9 @@ init_socket (struct sockaddr *addr,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "creating hash\n");
-  GNUNET_CRYPTO_hash (lt->listen_sock,
-                      sizeof(lt->listen_sock),
+  sockfd = GNUNET_NETWORK_get_fd (lt->listen_sock);
+  GNUNET_CRYPTO_hash (&sockfd,
+                      sizeof(int),
                       &h_sock);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -3336,7 +3370,7 @@ init_socket (struct sockaddr *addr,
   if (NULL == queue_map)
     queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
 
-  if (NULL == ch )
+  if (NULL == ch)
     ch = GNUNET_TRANSPORT_communicator_connect (cfg,
                                                 COMMUNICATOR_CONFIG_SECTION,
                                                 COMMUNICATOR_ADDRESS_PREFIX,
@@ -3360,6 +3394,7 @@ init_socket (struct sockaddr *addr,
 
 }
 
+
 /**
  * This method reads from the DLL addrs_head to register them at the NAT service.
  */
@@ -3421,6 +3456,7 @@ nat_register ()
   }
 }
 
+
 /**
  * This method is the callback called by the resolver API, and wraps method init_socket.
  *
@@ -3476,6 +3512,7 @@ init_socket_resolv (void *cls,
   }
 }
 
+
 /**
  * Setup communicator and launch network interactions.
  *
@@ -3532,6 +3569,7 @@ run (void *cls,
   peerstore = GNUNET_PEERSTORE_connect (cfg);
   if (NULL == peerstore)
   {
+    GNUNET_free (bindto);
     GNUNET_break (0);
     GNUNET_SCHEDULER_shutdown ();
     return;
@@ -3564,7 +3602,6 @@ run (void *cls,
     GNUNET_free (po);
     nat_register ();
     GNUNET_free (bindto);
-
     return;
   }
 
@@ -3577,8 +3614,8 @@ run (void *cls,
     in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
     init_socket (in, in_len);
     nat_register ();
+    GNUNET_free (start);
     GNUNET_free (bindto);
-
     return;
   }
 
@@ -3588,8 +3625,8 @@ run (void *cls,
     in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
     init_socket (in, in_len);
     nat_register ();
+    GNUNET_free (start);
     GNUNET_free (bindto);
-
     return;
   }
 
@@ -3603,6 +3640,7 @@ run (void *cls,
                                                    &init_socket_resolv,
                                                    &port);
   GNUNET_free (bindto);
+  GNUNET_free (start);
 }
 
 
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c
index 415dc4b48..d75f4ae00 100644
--- a/src/transport/gnunet-communicator-udp.c
+++ b/src/transport/gnunet-communicator-udp.c
@@ -1492,16 +1492,9 @@ add_acks (struct SharedSecret *ss, int acks_to_add)
 
   struct ReceiverAddress *receiver = ss->receiver;
 
-  if (NULL == ss)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "secret NULL!\n");
-
-  if (NULL == receiver)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Receiver NULL!\n");
-  if (NULL == receiver->d_qh)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Queue NULL!\n");
+  GNUNET_assert (NULL != ss);
+  GNUNET_assert (NULL != receiver);
+  GNUNET_assert (NULL != receiver->d_qh);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Tell transport we have %u more acks!\n",
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c
index 9c37f15e2..cbf795eea 100644
--- a/src/transport/gnunet-service-tng.c
+++ b/src/transport/gnunet-service-tng.c
@@ -2693,12 +2693,12 @@ static struct GNUNET_CONTAINER_MultiShortmap *dvlearn_map;
 /**
  * Head of a DLL sorted by launch time.
  */
-static struct LearnLaunchEntry *lle_head;
+static struct LearnLaunchEntry *lle_head = NULL;
 
 /**
  * Tail of a DLL sorted by launch time.
  */
-static struct LearnLaunchEntry *lle_tail;
+static struct LearnLaunchEntry *lle_tail = NULL;
 
 /**
  * MIN Heap sorted by "next_challenge" to `struct ValidationState` entries
@@ -2772,6 +2772,11 @@ static unsigned int pa_count;
  */
 static struct GNUNET_TIME_Absolute hello_mono_time;
 
+/**
+ * Indication if we have received a shutdown signal
+ * and are in the process of cleaning up.
+ */
+static int in_shutdown;
 
 /**
  * Get an offset into the transmission history buffer for `struct
@@ -2805,6 +2810,7 @@ free_incoming_request (struct IncomingRequest *ir)
   GNUNET_assert (ir_total > 0);
   ir_total--;
   GNUNET_PEERSTORE_watch_cancel (ir->wc);
+  ir->wc = NULL;
   GNUNET_free (ir);
 }
 
@@ -3333,6 +3339,8 @@ free_neighbour (struct Neighbour *neighbour)
                  GNUNET_CONTAINER_multipeermap_remove (neighbours,
                                                        &neighbour->pid,
                                                        neighbour));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Freeing neighbour\n");
   if (NULL != neighbour->reassembly_map)
   {
     GNUNET_CONTAINER_multihashmap32_iterate (neighbour->reassembly_map,
@@ -3451,6 +3459,8 @@ schedule_transmit_on_queue (struct Queue *queue,
   if (queue->tc->details.communicator.total_queue_length >=
       COMMUNICATOR_TOTAL_QUEUE_LIMIT)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission throttled due to communicator queue limit\n");
     GNUNET_STATISTICS_update (
       GST_stats,
       "# Transmission throttled due to communicator queue limit",
@@ -3461,6 +3471,8 @@ schedule_transmit_on_queue (struct Queue *queue,
   }
   if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission throttled due to communicator queue length limit\n");
     GNUNET_STATISTICS_update (GST_stats,
                               "# Transmission throttled due to queue queue limit",
                               1,
@@ -3495,15 +3507,21 @@ check_link_down (void *cls)
   struct GNUNET_TIME_Absolute dvh_timeout;
   struct GNUNET_TIME_Absolute q_timeout;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Checking if link is down\n");
   vl->visibility_task = NULL;
   dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
-  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
-       pos = pos->next_dv)
-    dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout, pos->path_valid_until);
-  if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
+  if (NULL != dv)
   {
-    vl->dv->vl = NULL;
-    vl->dv = NULL;
+    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+         pos = pos->next_dv)
+      dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
+                                              pos->path_valid_until);
+    if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
+    {
+      vl->dv->vl = NULL;
+      vl->dv = NULL;
+    }
   }
   q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
   for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
@@ -3543,6 +3561,8 @@ free_queue (struct Queue *queue)
   struct PendingAcknowledgement *pa;
   struct VirtualLink *vl;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cleaning up queue %u\n", queue->qid);
   if (NULL != queue->transmit_task)
   {
     GNUNET_SCHEDULER_cancel (queue->transmit_task);
@@ -3650,6 +3670,7 @@ stop_peer_request (void *cls,
   struct PeerRequest *pr = value;
 
   GNUNET_PEERSTORE_watch_cancel (pr->wc);
+  pr->wc = NULL;
   GNUNET_assert (
     GNUNET_YES ==
     GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
@@ -3661,6 +3682,9 @@ stop_peer_request (void *cls,
 }
 
 
+static void
+do_shutdown (void *cls);
+
 /**
  * Called whenever a client is disconnected.  Frees our
  * resources associated with that client.
@@ -3678,16 +3702,20 @@ client_disconnect_cb (void *cls,
 
   (void) cls;
   (void) client;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client %p disconnected, cleaning up.\n",
-              tc);
   GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
   switch (tc->type)
   {
   case CT_NONE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unknown Client %p disconnected, cleaning up.\n",
+                tc);
     break;
 
   case CT_CORE: {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "CORE Client %p disconnected, cleaning up.\n",
+                  tc);
+
       struct PendingMessage *pm;
 
       while (NULL != (pm = tc->details.core.pending_msg_head))
@@ -3702,9 +3730,17 @@ client_disconnect_cb (void *cls,
     break;
 
   case CT_MONITOR:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MONITOR Client %p disconnected, cleaning up.\n",
+                tc);
+
     break;
 
   case CT_COMMUNICATOR: {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "COMMUNICATOR Client %p disconnected, cleaning up.\n",
+                  tc);
+
       struct Queue *q;
       struct AddressListEntry *ale;
 
@@ -3717,6 +3753,10 @@ client_disconnect_cb (void *cls,
     break;
 
   case CT_APPLICATION:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "APPLICATION Client %p disconnected, cleaning up.\n",
+                tc);
+
     GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
                                            &stop_peer_request,
                                            tc);
@@ -3724,6 +3764,12 @@ client_disconnect_cb (void *cls,
     break;
   }
   GNUNET_free (tc);
+  if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Our last client disconnected\n");
+    do_shutdown (cls);
+  }
 }
 
 
@@ -4153,7 +4199,6 @@ queue_send_msg (struct Queue *queue,
   struct GNUNET_TRANSPORT_SendMessageTo *smt;
   struct GNUNET_MQ_Envelope *env;
 
-  queue->idle = GNUNET_NO;
   GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Queueing %u bytes of payload for transmission <%llu> on queue %llu to %s\n",
@@ -4226,7 +4271,7 @@ route_via_neighbour (const struct Neighbour *n,
   for (struct Queue *pos = n->queue_head; NULL != pos;
        pos = pos->next_neighbour)
   {
-    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) ||
+    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
         (pos->validated_until.abs_value_us > now.abs_value_us))
       candidates++;
   }
@@ -4255,7 +4300,7 @@ route_via_neighbour (const struct Neighbour *n,
   for (struct Queue *pos = n->queue_head; NULL != pos;
        pos = pos->next_neighbour)
   {
-    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) ||
+    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
         (pos->validated_until.abs_value_us > now.abs_value_us))
     {
       if ((sel1 == candidates) || (sel2 == candidates))
@@ -4702,6 +4747,24 @@ route_control_message_without_fc (const struct GNUNET_PeerIdentity *target,
 }
 
 
+static void
+consider_sending_fc (void *cls);
+
+/**
+ * Something changed on the virtual link with respect to flow
+ * control. Consider retransmitting the FC window size.
+ *
+ * @param cls a `struct VirtualLink` to work with
+ */
+static void
+task_consider_sending_fc (void *cls)
+{
+  struct VirtualLink *vl = cls;
+  vl->fc_retransmit_task = NULL;
+  consider_sending_fc (cls);
+}
+
+
 /**
  * Something changed on the virtual link with respect to flow
  * control. Consider retransmitting the FC window size.
@@ -4759,7 +4822,7 @@ consider_sending_fc (void *cls)
   if (NULL != vl->fc_retransmit_task)
     GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
   vl->fc_retransmit_task =
-    GNUNET_SCHEDULER_add_delayed (rtt, &consider_sending_fc, vl);
+    GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl);
 }
 
 
@@ -4812,16 +4875,22 @@ check_vl_transmission (struct VirtualLink *vl)
   }
   if (GNUNET_NO == elig)
     return;
-
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Not stalled. Scheduling transmission on queue\n");
   /* Notify queues at direct neighbours that we are interested */
   now = GNUNET_TIME_absolute_get ();
   if (NULL != n)
   {
     for (struct Queue *queue = n->queue_head; NULL != queue;
          queue = queue->next_neighbour)
+    {
       if ((GNUNET_YES == queue->idle) &&
           (queue->validated_until.abs_value_us > now.abs_value_us))
         schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Queue busy or invalid\n");
+    }
   }
   /* Notify queues via DV that we are interested */
   if (NULL != dv)
@@ -4869,6 +4938,9 @@ handle_client_send (void *cls, const struct OutboundMessage *obm)
   vl = lookup_virtual_link (&obm->peer);
   if (NULL == vl)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Don't have %s as a neighbour (anymore).\n",
+                GNUNET_i2s (&obm->peer));
     /* Failure: don't have this peer as a neighbour (anymore).
        Might have gone down asynchronously, so this is NOT
        a protocol violation by CORE. Still count the event,
@@ -5127,9 +5199,12 @@ handle_del_address (void *cls,
                 ale->address);
     free_address_list_entry (ale);
     GNUNET_SERVICE_client_continue (tc->client);
+    return;
   }
-  GNUNET_break (0);
-  GNUNET_SERVICE_client_drop (tc->client);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Communicator removed address we did not even have.\n");
+  GNUNET_SERVICE_client_continue (tc->client);
+  // GNUNET_SERVICE_client_drop (tc->client);
 }
 
 
@@ -5208,7 +5283,8 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
        we pass this on, CORE would be confused (link down, messages
        arrive).  We should investigate more if this happens often,
        or in a persistent manner, and possibly do "something" about
-       it. Thus logging as error for now. */GNUNET_break_op (0);
+       it. Thus logging as error for now. */
+    GNUNET_break_op (0);
     GNUNET_STATISTICS_update (GST_stats,
                               "# CORE messages droped (virtual link still down)",
                               1,
@@ -6100,6 +6176,7 @@ activate_core_visible_dv_path (struct DistanceVectorHop *hop)
   dv->vl = vl;
   vl->core_recv_window = RECV_WINDOW_SIZE;
   vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
+  vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
   vl->visibility_task =
     GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
   GNUNET_break (GNUNET_YES ==
@@ -6899,7 +6976,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
   if (MAX_DV_HOPS_ALLOWED == nhops)
   {
     /* At limit, we're out of here! */
-    finish_cmc_handling (cmc);
     return;
   }
 
@@ -7637,7 +7713,7 @@ start_address_validation (const struct GNUNET_PeerIdentity *pid,
                    validation_map,
                    &vs->pid,
                    vs,
-                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   update_next_challenge_time (vs, now);
 }
 
@@ -7730,13 +7806,26 @@ handle_validation_challenge (
                               &tvp,
                               &tvr.signature);
   }
-  route_control_message_without_fc (&cmc->im.sender,
-                                    &tvr.header,
-                                    RMO_ANYTHING_GOES | RMO_REDUNDANT);
   sender = cmc->im.sender;
-  finish_cmc_handling (cmc);
   vl = lookup_virtual_link (&sender);
   if (NULL != vl)
+  {
+    route_control_message_without_fc (&cmc->im.sender,
+                                      &tvr.header,
+                                      RMO_ANYTHING_GOES | RMO_REDUNDANT);
+  }
+  else
+  {
+    /* Use route via neighbour */
+    n = lookup_neighbour (&sender);
+    if (NULL != n)
+      route_via_neighbour (n, &tvr.header,
+                           RMO_ANYTHING_GOES | RMO_REDUNDANT
+                           | RMO_UNCONFIRMED_ALLOWED);
+  }
+
+  finish_cmc_handling (cmc);
+  if (NULL != vl)
     return;
 
   /* For us, the link is still down, but we need bi-directional
@@ -8010,8 +8099,10 @@ handle_validation_response (
   vl->target = n->pid;
   vl->n = n;
   n->vl = vl;
+  q->idle = GNUNET_YES;
   vl->core_recv_window = RECV_WINDOW_SIZE;
   vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
+  vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
   vl->visibility_task =
     GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
   GNUNET_break (GNUNET_YES ==
@@ -8067,11 +8158,15 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
   uint64_t os;
   uint64_t wnd;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender));
   vl = lookup_virtual_link (&cmc->im.sender);
   if (NULL == vl)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "FC dropped: VL unknown\n");
     GNUNET_STATISTICS_update (GST_stats,
-                              "# FC dropped: virtual link unknown",
+                              "# FC dropped: Virtual link unknown",
                               1,
                               GNUNET_NO);
     finish_cmc_handling (cmc);
@@ -8080,6 +8175,8 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
   st = GNUNET_TIME_absolute_ntoh (fc->sender_time);
   if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "FC dropped: Message out of order\n");
     /* out of order, drop */
     GNUNET_STATISTICS_update (GST_stats,
                               "# FC dropped: message out of order",
@@ -8112,8 +8209,10 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
       (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX)
        % FC_NO_CHANGE_REPLY_PROBABILITY))
   {
-    /* Consider re-sending our FC message, as clearly the
-       other peer's idea of the window is not up-to-date */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Consider re-sending our FC message, as clearly the  ther peer's idea of the window is not up-to-date (%llu vs %llu)\n",
+                (unsigned long long) wnd,
+                (unsigned long long) vl->incoming_fc_window_size);
     consider_sending_fc (vl);
   }
   if ((wnd == vl->incoming_fc_window_size) &&
@@ -8149,41 +8248,41 @@ demultiplex_with_cmc (struct CommunicatorMessageContext *cmc,
   { GNUNET_MQ_hd_var_size (fragment_box,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
                            struct TransportFragmentBoxMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_var_size (reliability_box,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
                            struct TransportReliabilityBoxMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_var_size (reliability_ack,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
                            struct TransportReliabilityAckMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_var_size (backchannel_encapsulation,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
                            struct TransportBackchannelEncapsulationMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_var_size (dv_learn,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
                            struct TransportDVLearnMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_var_size (dv_box,
                            GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
                            struct TransportDVBoxMessage,
-                           &cmc),
+                           cmc),
     GNUNET_MQ_hd_fixed_size (
       validation_challenge,
       GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
       struct TransportValidationChallengeMessage,
-      &cmc),
+      cmc),
     GNUNET_MQ_hd_fixed_size (flow_control,
                              GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
                              struct TransportFlowControlMessage,
-                             &cmc),
+                             cmc),
     GNUNET_MQ_hd_fixed_size (
       validation_response,
       GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
       struct TransportValidationResponseMessage,
-      &cmc),
+      cmc),
     GNUNET_MQ_handler_end () };
   int ret;
 
@@ -8202,7 +8301,7 @@ demultiplex_with_cmc (struct CommunicatorMessageContext *cmc,
   if (GNUNET_NO == ret)
   {
     /* unencapsulated 'raw' message */
-    handle_raw_message (&cmc, msg);
+    handle_raw_message (cmc, msg);
   }
 }
 
@@ -8770,6 +8869,8 @@ transmit_on_queue (void *cls)
     queue->idle = GNUNET_YES;
     return;
   }
+  /* There is a message pending, we are certainly not idle */
+  queue->idle = GNUNET_NO;
 
   /* Given selection in `sc`, do transmission */
   pm = sc.best;
@@ -8838,7 +8939,8 @@ transmit_on_queue (void *cls)
      via DV (and thus the ultimate target of the pending message is for
      a different virtual link than the one of the queue), then we need
      to use up not only the window of the direct link but also the
-     flow control window for the DV link! */pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
+     flow control window for the DV link! */
+  pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
 
   if (pm->vl != queue->neighbour->vl)
   {
@@ -8877,7 +8979,8 @@ transmit_on_queue (void *cls)
 
        OPTIMIZE: Note that in the future this heuristic should likely
        be improved further (measure RTT stability, consider message
-       urgency and size when delaying ACKs, etc.) */update_pm_next_attempt (pm,
+       urgency and size when delaying ACKs, etc.) */
+    update_pm_next_attempt (pm,
                             GNUNET_TIME_relative_to_absolute (
                               GNUNET_TIME_relative_multiply (queue->pd.aged_rtt,
                                                              4)));
@@ -8949,20 +9052,30 @@ handle_send_message_ack (void *cls,
 
   /* find our queue entry matching the ACK */
   qe = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Looking for queue for PID %s\n",
+              GNUNET_i2s (&sma->receiver));
   for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
        queue = queue->next_client)
   {
     if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
       continue;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found PID %s\n",
+                GNUNET_i2s (&queue->neighbour->pid));
+
+
     for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
          qep = qep->next)
     {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "QueueEntry MID: %lu, Ack MID: %lu\n",
+                  qep->mid, sma->mid);
       if (qep->mid != sma->mid)
         continue;
       qe = qep;
       break;
     }
-    break;
   }
   if (NULL == qe)
   {
@@ -8998,7 +9111,9 @@ handle_send_message_ack (void *cls,
     for (struct Queue *queue = tc->details.communicator.queue_head;
          NULL != queue;
          queue = queue->next_client)
+    {
       schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+    }
   }
   else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length)
   {
@@ -9211,6 +9326,9 @@ validation_start_cb (void *cls)
     (NULL != vs) &&
     (0 == GNUNET_TIME_absolute_get_remaining (vs->valid_until).rel_value_us))
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Validation response %s cleaned up\n",
+                GNUNET_sh2s (&vs->challenge.value));
     free_validation_state (vs);
     vs = GNUNET_CONTAINER_heap_peek (validation_heap);
   }
@@ -9333,6 +9451,7 @@ start_dv_learn (void *cls)
     return; /* lost all connectivity, cannot do learning */
   qqc.quality_count = 0;
   qqc.num_queues = 0;
+  qqc.k = GNUNET_CONTAINER_multipeermap_size (neighbours);
   GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                          &check_connection_quality,
                                          &qqc);
@@ -9352,7 +9471,7 @@ start_dv_learn (void *cls)
     return;
   }
   /* remove old entries in #dvlearn_map if it has grown too big */
-  while (MAX_DV_LEARN_PENDING >=
+  while (MAX_DV_LEARN_PENDING <=
          GNUNET_CONTAINER_multishortmap_size (dvlearn_map))
   {
     lle = lle_tail;
@@ -9505,8 +9624,7 @@ handle_add_queue_message (void *cls,
   const char *addr;
   uint16_t addr_len;
 
-  if ((0 != ntohl (aqm->mtu)) &&
-      (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage)))
+  if (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage))
   {
     /* MTU so small as to be useless for transmissions,
        required for #fragment_message()! */
@@ -9514,57 +9632,73 @@ handle_add_queue_message (void *cls,
     GNUNET_SERVICE_client_drop (tc->client);
     return;
   }
-  neighbour = lookup_neighbour (&aqm->receiver);
-  if (NULL == neighbour)
+  /* This may simply be a queue update */
+  for (queue = tc->details.communicator.queue_head;
+       NULL != queue;
+       queue = queue->next_client)
   {
-    neighbour = GNUNET_new (struct Neighbour);
-    neighbour->pid = aqm->receiver;
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONTAINER_multipeermap_put (
-                     neighbours,
-                     &neighbour->pid,
-                     neighbour,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    neighbour->get =
-      GNUNET_PEERSTORE_iterate (peerstore,
-                                "transport",
-                                &neighbour->pid,
-                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
-                                &neighbour_dv_monotime_cb,
-                                neighbour);
+    if (queue->qid != aqm->qid)
+      continue;
+    break;
+  }
+
+  if (NULL != queue)
+  {
+    neighbour = queue->neighbour;
+  } else {
+    neighbour = lookup_neighbour (&aqm->receiver);
+    if (NULL == neighbour)
+    {
+      neighbour = GNUNET_new (struct Neighbour);
+      neighbour->pid = aqm->receiver;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONTAINER_multipeermap_put (
+                       neighbours,
+                       &neighbour->pid,
+                       neighbour,
+                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+      neighbour->get =
+        GNUNET_PEERSTORE_iterate (peerstore,
+                                  "transport",
+                                  &neighbour->pid,
+                                  GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
+                                  &neighbour_dv_monotime_cb,
+                                  neighbour);
+    }
+    addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
+    addr = (const char *) &aqm[1];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "New queue %s to %s available with QID %llu\n",
+                addr,
+                GNUNET_i2s (&aqm->receiver),
+                (unsigned long long) aqm->qid);
+    queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
+    queue->tc = tc;
+    queue->address = (const char *) &queue[1];
+    queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
+    queue->qid = aqm->qid;
+    queue->neighbour = neighbour;
+    memcpy (&queue[1], addr, addr_len);
+    /* notify monitors about new queue */
+    {
+      struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
+
+      notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
+    }
+    GNUNET_CONTAINER_MDLL_insert (neighbour,
+                                  neighbour->queue_head,
+                                  neighbour->queue_tail,
+                                  queue);
+    GNUNET_CONTAINER_MDLL_insert (client,
+                                  tc->details.communicator.queue_head,
+                                  tc->details.communicator.queue_tail,
+                                  queue);
+
   }
-  addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
-  addr = (const char *) &aqm[1];
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "New queue %s to %s available with QID %llu\n",
-              addr,
-              GNUNET_i2s (&aqm->receiver),
-              (unsigned long long) aqm->qid);
-  queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
-  queue->tc = tc;
-  queue->address = (const char *) &queue[1];
-  queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
-  queue->qid = aqm->qid;
   queue->mtu = ntohl (aqm->mtu);
   queue->nt = (enum GNUNET_NetworkType) ntohl (aqm->nt);
   queue->cs = (enum GNUNET_TRANSPORT_ConnectionStatus) ntohl (aqm->cs);
-  queue->neighbour = neighbour;
   queue->idle = GNUNET_YES;
-  memcpy (&queue[1], addr, addr_len);
-  /* notify monitors about new queue */
-  {
-    struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
-
-    notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
-  }
-  GNUNET_CONTAINER_MDLL_insert (neighbour,
-                                neighbour->queue_head,
-                                neighbour->queue_tail,
-                                queue);
-  GNUNET_CONTAINER_MDLL_insert (client,
-                                tc->details.communicator.queue_head,
-                                tc->details.communicator.queue_tail,
-                                queue);
   /* check if valdiations are waiting for the queue */
   (void)
   GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
@@ -9623,7 +9757,6 @@ handle_update_queue_message (void *cls,
 }
 
 
-
 /**
  * Communicator tells us that our request to create a queue "worked", that
  * is setting up the queue is now in process.
@@ -9965,12 +10098,17 @@ do_shutdown (void *cls)
   struct LearnLaunchEntry *lle;
 
   (void) cls;
-
-  GNUNET_CONTAINER_multipeermap_iterate (neighbours, &free_neighbour_cb, NULL);
-  if (NULL != peerstore)
+  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                         &free_neighbour_cb, NULL);
+  if (NULL != validation_task)
   {
-    GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
-    peerstore = NULL;
+    GNUNET_SCHEDULER_cancel (validation_task);
+    validation_task = NULL;
+  }
+  if (NULL != dvlearn_task)
+  {
+    GNUNET_SCHEDULER_cancel (dvlearn_task);
+    dvlearn_task = NULL;
   }
   if (NULL != GST_stats)
   {
@@ -10016,6 +10154,13 @@ do_shutdown (void *cls)
     GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
     GNUNET_free (lle);
   }
+  if (NULL != peerstore)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from PEERSTORE service\n");
+    GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
+    peerstore = NULL;
+  }
   GNUNET_CONTAINER_multishortmap_destroy (dvlearn_map);
   dvlearn_map = NULL;
   GNUNET_CONTAINER_heap_destroy (validation_heap);
@@ -10023,6 +10168,16 @@ do_shutdown (void *cls)
   GNUNET_CONTAINER_multipeermap_iterate (dv_routes, &free_dv_routes_cb, NULL);
   GNUNET_CONTAINER_multipeermap_destroy (dv_routes);
   dv_routes = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+shutdown_task (void *cls)
+{
+  in_shutdown = GNUNET_YES;
+  if (NULL == clients_head)
+    do_shutdown (cls);
 }
 
 
@@ -10042,6 +10197,7 @@ run (void *cls,
   (void) service;
   /* setup globals */
   hello_mono_time = GNUNET_TIME_absolute_get_monotonic (c);
+  in_shutdown = GNUNET_NO;
   GST_cfg = c;
   backtalkers = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
   pending_acks = GNUNET_CONTAINER_multiuuidmap_create (32768, GNUNET_YES);
@@ -10071,7 +10227,7 @@ run (void *cls,
               "My identity is `%s'\n",
               GNUNET_i2s_full (&GST_my_identity));
   GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
   peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
   if (NULL == peerstore)
   {
diff --git a/src/transport/test_transport_api2_tcp_peer1.conf b/src/transport/test_transport_api2_tcp_peer1.conf
new file mode 100644
index 000000000..745ed6887
--- /dev/null
+++ b/src/transport/test_transport_api2_tcp_peer1.conf
@@ -0,0 +1,23 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[transport]
+BINARY = gnunet-service-tng
+PLUGINS = tcp
+#PREFIX = valgrind --log-file=/tmp/vg_peer1-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p1.sock
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p1.sock
+#PREFIX = valgrind --log-file=/tmp/vg_cpeer1-%p
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/transport/test_transport_api2_tcp_peer2.conf b/src/transport/test_transport_api2_tcp_peer2.conf
new file mode 100644
index 000000000..022468bcd
--- /dev/null
+++ b/src/transport/test_transport_api2_tcp_peer2.conf
@@ -0,0 +1,22 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[transport]
+BINARY = gnunet-service-tng
+#PREFIX = valgrind --log-file=/tmp/vg_peer2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p2.sock
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 60003
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+#PREFIX = valgrind --log-file=/tmp/vg_comm2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p2.sock
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/transport/transport-testing-communicator.c b/src/transport/transport-testing-communicator.c
index de356fb9c..040f16d5d 100644
--- a/src/transport/transport-testing-communicator.c
+++ b/src/transport/transport-testing-communicator.c
@@ -548,6 +548,11 @@ handle_update_queue_message (void *cls,
       tc_queue = tc_queue->next;
     }
   }
+  if (NULL == tc_queue)
+  {
+    GNUNET_SERVICE_client_continue (client->client);
+    return;
+  }
   GNUNET_assert (tc_queue->qid == msg->qid);
   GNUNET_assert (0 == GNUNET_memcmp (&tc_queue->peer_id, &msg->receiver));
   tc_queue->nt = msg->nt;
diff --git a/src/transport/transport-testing-ng.h b/src/transport/transport-testing-ng.h
new file mode 100644
index 000000000..cd5ba65a9
--- /dev/null
+++ b/src/transport/transport-testing-ng.h
@@ -0,0 +1,71 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @author t3sserakt
+ */
+
+struct TngState
+{
+  /**
+   * Handle to operation
+   */
+  struct GNUNET_TESTBED_Operation *operation;
+
+  /**
+   * Flag indicating if service is ready.
+   */
+  int service_ready;
+
+  /**
+   * Abort task identifier
+   */
+  struct GNUNET_SCHEDULER_Task *abort_task;
+
+  /**
+   * Label of peer command.
+   */
+  const char *peer_label;
+
+  /**
+   * Name of service to start.
+   */
+  const char *servicename;
+
+  /**
+   * Peer identity of the system.
+   */
+  struct GNUNET_PeerIdentity *peer_identity;
+
+  /**
+   * Message handler for transport service.
+   */
+  const struct GNUNET_MQ_MessageHandler *handlers;
+
+  /**
+   * Notify connect callback
+   */
+  GNUNET_TRANSPORT_NotifyConnect nc;
+
+  /**
+   * Closure for the @a nc callback
+   */
+  void *cb_cls;
+};
diff --git a/src/transport/transport-testing2.c b/src/transport/transport-testing2.c
index d9f1d5e56..eaa8a5f15 100644
--- a/src/transport/transport-testing2.c
+++ b/src/transport/transport-testing2.c
@@ -328,6 +328,8 @@ notify_disconnect (void *cls,
   }
 }
 
+static void
+retrieve_hello (void *cls);
 
 static void
 hello_iter_cb (void *cb_cls,
@@ -337,16 +339,19 @@ hello_iter_cb (void *cb_cls,
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cb_cls;
   if ((NULL == record) && (NULL == emsg))
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Iteration End\n");
+    p->pic = NULL;
+    if (NULL != p->start_cb)
+      p->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, p);
     return;
   }
-  //Check record type et al?
+  // Check record type et al?
   p->hello_size = record->value_size;
   p->hello = GNUNET_malloc (p->hello_size);
   memcpy (p->hello, record->value, p->hello_size);
-  p->hello[p->hello_size-1] = '\0';
+  p->hello[p->hello_size - 1] = '\0';
 
   GNUNET_PEERSTORE_iterate_cancel (p->pic);
+  p->pic = NULL;
   if (NULL != p->start_cb)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -358,13 +363,12 @@ hello_iter_cb (void *cb_cls,
   }
 }
 
+
 static void
-retrieve_hello(void *cls)
+retrieve_hello (void *cls)
 {
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Getting hello...\n");
-
+  p->rh_task = NULL;
   p->pic = GNUNET_PEERSTORE_iterate (p->ph,
                                      "transport",
                                      &p->id,
@@ -375,7 +379,6 @@ retrieve_hello(void *cls)
 }
 
 
-
 /**
  * Start a peer with the given configuration
  * @param tth the testing handle
@@ -504,15 +507,13 @@ GNUNET_TRANSPORT_TESTING_start_peer (struct
        "Peer %u configured with identity `%s'\n",
        p->no,
        GNUNET_i2s_full (&p->id));
-  p->tmh = GNUNET_TRANSPORT_manipulation_connect (p->cfg);
   p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
                                          NULL,
                                          handlers,
                                          p,
                                          &notify_connect,
                                          &notify_disconnect);
-  if ((NULL == p->th) ||
-      (NULL == p->tmh))
+  if (NULL == p->th)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          "Failed to connect to transport service for peer `%s': `%s'\n",
@@ -535,11 +536,8 @@ GNUNET_TRANSPORT_TESTING_start_peer (struct
   // FIXME Error handling
   p->ah = GNUNET_TRANSPORT_application_init (p->cfg);
   GNUNET_assert (NULL != p->ah);
-  // FIXME Error handleing
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                retrieve_hello,
-                                p);
-  //GNUNET_assert (NULL != p->pic);
+  // FIXME Error handling
+  p->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, p);
 
   return p;
 }
@@ -577,11 +575,6 @@ GNUNET_TRANSPORT_TESTING_restart_peer (struct
     GNUNET_TRANSPORT_core_disconnect (p->th);
     p->th = NULL;
   }
-  if (NULL != p->tmh)
-  {
-    GNUNET_TRANSPORT_manipulation_disconnect (p->tmh);
-    p->tmh = NULL;
-  }
   for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
   {
     ccn = cc->next;
@@ -655,6 +648,11 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct
   struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+  /* shutdown */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Stopping peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
 
   for (cc = tth->cc_head; NULL != cc; cc = ccn)
   {
@@ -668,16 +666,29 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct
     GNUNET_PEERSTORE_iterate_cancel (p->pic);
     p->pic = NULL;
   }
-  if (NULL != p->tmh)
-  {
-    GNUNET_TRANSPORT_manipulation_disconnect (p->tmh);
-    p->tmh = NULL;
-  }
   if (NULL != p->th)
   {
     GNUNET_TRANSPORT_core_disconnect (p->th);
     p->th = NULL;
   }
+  if (NULL != p->ats)
+  {
+    GNUNET_ATS_connectivity_done (p->ats);
+    p->ats = NULL;
+  }
+  if (NULL != p->ah)
+  {
+    GNUNET_TRANSPORT_application_done (p->ah);
+    p->ah = NULL;
+  }
+  if (NULL != p->ph)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from PEERSTORE service\n");
+    GNUNET_PEERSTORE_disconnect (p->ph, GNUNET_NO);
+    p->ph = NULL;
+  }
+
   if (NULL != p->peer)
   {
     if (GNUNET_OK !=
@@ -691,11 +702,6 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct
     GNUNET_TESTING_peer_destroy (p->peer);
     p->peer = NULL;
   }
-  if (NULL != p->ats)
-  {
-    GNUNET_ATS_connectivity_done (p->ats);
-    p->ats = NULL;
-  }
   if (NULL != p->hello)
   {
     GNUNET_free (p->hello);
@@ -718,6 +724,9 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct
        "Peer %u (`%s') stopped\n",
        p->no,
        GNUNET_i2s (&p->id));
+  if (NULL != p->rh_task)
+    GNUNET_SCHEDULER_cancel (p->rh_task);
+  p->rh_task = NULL;
   GNUNET_free (p);
 }
 
@@ -728,16 +737,16 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct
  * FIXME maybe schedule the application_validate somehow
  */
 /*
-static void
-hello_offered (void *cls)
-{
-  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
-
-  cc->oh = NULL;
-  cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                          &offer_hello,
-                                          cc);
-}*/
+   static void
+   hello_offered (void *cls)
+   {
+   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
+
+   cc->oh = NULL;
+   cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+   &offer_hello,
+   cc);
+   }*/
 
 
 /**
diff --git a/src/transport/transport-testing2.h b/src/transport/transport-testing2.h
index 3554436d8..db8700df9 100644
--- a/src/transport/transport-testing2.h
+++ b/src/transport/transport-testing2.h
@@ -85,11 +85,6 @@ struct GNUNET_TRANSPORT_TESTING_PeerContext
   struct GNUNET_TRANSPORT_CoreHandle *th;
 
   /**
-   * Peer's transport service manipulation handle
-   */
-  struct GNUNET_TRANSPORT_ManipulationHandle *tmh;
-
-  /**
    * Peer's ATS handle.
    */
   struct GNUNET_ATS_ConnectivityHandle *ats;
@@ -150,6 +145,11 @@ struct GNUNET_TRANSPORT_TESTING_PeerContext
   GNUNET_SCHEDULER_TaskCallback start_cb;
 
   /**
+   * Hello get task
+   */
+  struct GNUNET_SCHEDULER_Task *rh_task;
+
+  /**
    * Closure for the @a nc and @a nd callbacks
    */
   void *cb_cls;
diff --git a/src/transport/transport_api2_communication.c b/src/transport/transport_api2_communication.c
index b048ad851..3d9da08e4 100644
--- a/src/transport/transport_api2_communication.c
+++ b/src/transport/transport_api2_communication.c
@@ -677,7 +677,7 @@ handle_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
   struct GNUNET_TRANSPORT_QueueHandle *qh;
 
   for (qh = ch->queue_head; NULL != qh; qh = qh->next)
-    if ((qh->queue_id == smt->qid) &&
+    if ((qh->queue_id == ntohl (smt->qid)) &&
         (0 == memcmp (&qh->peer,
                       &smt->receiver,
                       sizeof(struct GNUNET_PeerIdentity))))
diff --git a/src/util/.gitignore b/src/util/.gitignore
index 8556ee7b8..7c7b7045d 100644
--- a/src/util/.gitignore
+++ b/src/util/.gitignore
@@ -80,3 +80,4 @@ python27_location
 perf_malloc
 perf_mq
 perf_scheduler
+gnunet-base32
diff --git a/src/util/Makefile.am b/src/util/Makefile.am
index 33fe26e34..e2614e5e3 100644
--- a/src/util/Makefile.am
+++ b/src/util/Makefile.am
@@ -25,6 +25,11 @@ if ENABLE_BENCHMARK
   PTHREAD = -lpthread
 endif
 
+if HAVE_NOLIBGCRYPT19
+  DLOG = crypto_ecc_dlog.c
+  DLOG_TEST = test_crypto_ecc_dlog
+endif
+
 gnunet_config_diff_SOURCES = \
  gnunet-config-diff.c
 gnunet_config_diff_LDADD = \
@@ -58,7 +63,7 @@ libgnunetutil_la_SOURCES = \
   crypto_symmetric.c \
   crypto_crc.c \
   crypto_ecc.c \
-  crypto_ecc_dlog.c \
+  $(DLOG) \
   crypto_ecc_setup.c \
   crypto_hash.c \
   crypto_hash_file.c \
@@ -152,9 +157,10 @@ libexec_PROGRAMS = \
  gnunet-timeout
 
 bin_PROGRAMS = \
- gnunet-resolver \
+ gnunet-base32 \
  gnunet-config \
  gnunet-crypto-tvg \
+ gnunet-resolver \
  $(GNUNET_ECC) \
  $(GNUNET_SCRYPT) \
  gnunet-uri
@@ -203,6 +209,12 @@ gnunet_ecc_LDADD = \
   libgnunetutil.la \
   $(GN_LIBINTL) -lgcrypt
 
+gnunet_base32_SOURCES = \
+ gnunet-base32.c
+gnunet_base32_LDADD = \
+  libgnunetutil.la \
+  $(GN_LIBINTL)
+
 gnunet_scrypt_SOURCES = \
  gnunet-scrypt.c
 gnunet_scrypt_LDADD = \
@@ -241,7 +253,6 @@ libgnunet_plugin_test_la_LDFLAGS = \
 if HAVE_BENCHMARKS
  BENCHMARKS = \
   perf_crypto_hash \
-  perf_crypto_ecc_dlog \
   perf_crypto_rsa \
   perf_crypto_paillier \
   perf_crypto_symmetric \
@@ -249,6 +260,10 @@ if HAVE_BENCHMARKS
   perf_malloc \
   perf_mq \
   perf_scheduler
+
+if HAVE_NOLIBGCRYPT19
+  BENCHMARKS += perf_crypto_ecc_dlog
+endif
 endif
 
 if HAVE_SSH_KEY
@@ -280,7 +295,7 @@ check_PROGRAMS = \
  test_crypto_ecdhe \
  test_crypto_ecdh_eddsa \
  test_crypto_ecdh_ecdsa \
- test_crypto_ecc_dlog \
+ $(DLOG_TEST) \
  test_crypto_hash \
  test_crypto_hash_context \
  test_crypto_hkdf \
@@ -441,11 +456,13 @@ test_crypto_eddsa_LDADD = \
  libgnunetutil.la \
  $(LIBGCRYPT_LIBS)
 
+if HAVE_NOLIBGCRYPT19
 test_crypto_ecc_dlog_SOURCES = \
  test_crypto_ecc_dlog.c
 test_crypto_ecc_dlog_LDADD = \
  libgnunetutil.la \
  $(LIBGCRYPT_LIBS)
+endif
 
 test_crypto_ecdhe_SOURCES = \
  test_crypto_ecdhe.c
@@ -588,11 +605,13 @@ perf_crypto_hash_SOURCES = \
 perf_crypto_hash_LDADD = \
  libgnunetutil.la
 
+if HAVE_NOLIBGCRYPT19
 perf_crypto_ecc_dlog_SOURCES = \
  perf_crypto_ecc_dlog.c
 perf_crypto_ecc_dlog_LDADD = \
  libgnunetutil.la \
  -lgcrypt
+endif
 
 perf_crypto_rsa_SOURCES = \
  perf_crypto_rsa.c
diff --git a/src/util/configuration.c b/src/util/configuration.c
index bda643b83..3294d11f4 100644
--- a/src/util/configuration.c
+++ b/src/util/configuration.c
@@ -606,6 +606,7 @@ GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle *cfg,
     if (NULL == h)
     {
       GNUNET_free (fn);
+      GNUNET_free (cfg_buf);
       return GNUNET_SYSERR;
     }
     if (((ssize_t) size) !=
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
index b66a7b258..efaac1136 100644
--- a/src/util/container_meta_data.c
+++ b/src/util/container_meta_data.c
@@ -964,6 +964,9 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
     {
       /* does not fit! */
       GNUNET_free (ent);
+      if (NULL != cdata)
+        GNUNET_free (cdata);
+      cdata = NULL;
       return GNUNET_SYSERR;
     }
 
@@ -976,9 +979,9 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
     if (NULL != pos->mime_type)
       left -= strlen (pos->mime_type) + 1;
 
-    GNUNET_free (cdata);
+    if (NULL != cdata)
+      GNUNET_free (cdata);
     cdata = NULL;
-
     i++;
   }
   GNUNET_free (ent);
diff --git a/src/util/crypto_ecc.c b/src/util/crypto_ecc.c
index bc58142c2..efbf2ee17 100644
--- a/src/util/crypto_ecc.c
+++ b/src/util/crypto_ecc.c
@@ -33,6 +33,22 @@
 
 #define EXTRA_CHECKS 0
 
+/**
+ * IMPLEMENTATION NOTICE:
+ *
+ * ECDSA: We use a non-standard curve for ECDSA: Ed25519.
+ * For performance reasons, we use cryptographic operations from
+ * libsodium wherever we can get away with it, even though libsodium
+ * itself does not support ECDSA.
+ * This is why the sign and verifiy functionality from libgcrypt is
+ * required and used.
+ *
+ * EdDSA: We use a standard EdDSA construction.
+ * (We still use libgcrypt for hashing and RNG, but not EC)
+ *
+ * ECDHE: For both EdDSA and ECDSA keys, we use libsodium for
+ * ECDHE due to performance benefits over libgcrypt.
+ */
 
 /**
  * Name of the curve we are using.  Note that we have hard-coded
@@ -476,6 +492,10 @@ GNUNET_CRYPTO_ecdsa_key_get_anonymous ()
   GNUNET_CRYPTO_mpi_print_unsigned (anonymous.d,
                                     sizeof(anonymous.d),
                                     GCRYMPI_CONST_ONE);
+  anonymous.d[0] &= 248;
+  anonymous.d[31] &= 127;
+  anonymous.d[31] |= 64;
+
   once = 1;
   return &anonymous;
 }
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
index 63232cab6..5e4c4d1e6 100644
--- a/src/util/crypto_rsa.c
+++ b/src/util/crypto_rsa.c
@@ -863,6 +863,7 @@ rsa_sign_mpi (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
          __FILE__,
          __LINE__,
          gcry_strerror (rc));
+    gcry_sexp_release (data);
     GNUNET_break (0);
     return NULL;
   }
diff --git a/src/util/gnunet-base32.c b/src/util/gnunet-base32.c
new file mode 100644
index 000000000..2c797f56e
--- /dev/null
+++ b/src/util/gnunet-base32.c
@@ -0,0 +1,152 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file util/gnunet-base32.c
+ * @brief tool to encode/decode from/to the Crockford Base32 encoding GNUnet uses
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+
+/**
+ * The main function of gnunet-base32
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc,
+      char *const *argv)
+{
+  int decode = 0;
+  const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_flag ('d',
+                               "decode",
+                               gettext_noop ("run decoder modus, otherwise runs as encoder"),
+                               &decode),
+    GNUNET_GETOPT_option_help ("Crockford base32 encoder/decoder"),
+    GNUNET_GETOPT_option_version (PACKAGE_VERSION),
+    GNUNET_GETOPT_OPTION_END
+  };
+  int ret;
+  char *in;
+  unsigned int in_size;
+  ssize_t iret;
+  char *out;
+  size_t out_size;
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+  ret = GNUNET_GETOPT_run ("gnunet-base32",
+                           options,
+                           argc,
+                           argv);
+  if (ret < 0)
+    return 1;
+  if (0 == ret)
+    return 0;
+  in_size = 0;
+  in = NULL;
+  iret = 1;
+  while (iret > 0)
+  {
+    /* read in blocks of 4k */
+    char buf[4092];
+
+    iret = read (0,
+                 buf,
+                 sizeof (buf));
+    if (iret < 0)
+    {
+      GNUNET_free (in);
+      return 2;
+    }
+    if (iret > 0)
+    {
+      if (iret + in_size < in_size)
+      {
+        GNUNET_break (0);
+        GNUNET_free (in);
+        return 1;
+      }
+      GNUNET_array_grow (in,
+                         in_size,
+                         in_size + iret);
+      memcpy (&in[in_size - iret],
+              buf,
+              iret);
+    }
+  }
+  if (decode)
+  {
+    /* This formula can overestimate by 1 byte, so we try both
+       out_size and out_size-1 below */
+    out_size = in_size * 5 / 8;
+    out = GNUNET_malloc (out_size);
+    if (GNUNET_OK !=
+        GNUNET_STRINGS_string_to_data (in,
+                                       in_size,
+                                       out,
+                                       out_size))
+    {
+      out_size--;
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_string_to_data (in,
+                                         in_size,
+                                         out,
+                                         out_size))
+      {
+        GNUNET_free (out);
+        GNUNET_free (in);
+        return 3;
+      }
+    }
+  }
+  else
+  {
+    out = GNUNET_STRINGS_data_to_string_alloc (in,
+                                               in_size);
+    out_size = strlen (out);
+  }
+  {
+    size_t pos = 0;
+
+    while (pos < out_size)
+    {
+      iret = write (1,
+                    &out[pos],
+                    out_size - pos);
+      if (iret <= 0)
+        return 4;
+      pos += iret;
+    }
+  }
+  GNUNET_free (out);
+  GNUNET_free_nz ((void *) argv);
+  return 0;
+}
+
+
+/* end of gnunet-uri.c */
diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c
index 8949f427c..28e44e28b 100644
--- a/src/util/gnunet-crypto-tvg.c
+++ b/src/util/gnunet-crypto-tvg.c
@@ -128,6 +128,7 @@ d2j (json_t *vec,
   json_object_set_new (vec, label, json);
 }
 
+
 /**
  * Add a number to a test vector.
  *
@@ -138,8 +139,8 @@ d2j (json_t *vec,
  */
 static void
 uint2j (json_t *vec,
-     const char *label,
-     unsigned int num)
+        const char *label,
+        unsigned int num)
 {
   json_t *json = json_integer (num);
 
@@ -154,7 +155,7 @@ expect_data_fixed (json_t *vec,
                    size_t expect_len)
 {
   const char *s = json_string_value (json_object_get (vec, name));
-  
+
   if (NULL == s)
     return GNUNET_NO;
 
@@ -166,6 +167,7 @@ expect_data_fixed (json_t *vec,
   return GNUNET_OK;
 }
 
+
 static int
 expect_data_dynamic (json_t *vec,
                      const char *name,
@@ -173,6 +175,7 @@ expect_data_dynamic (json_t *vec,
                      size_t *ret_len)
 {
   const char *s = json_string_value (json_object_get (vec, name));
+  char *tmp;
   size_t len;
 
   if (NULL == s)
@@ -181,10 +184,14 @@ expect_data_dynamic (json_t *vec,
   len = (strlen (s) * 5) / 8;
   if (NULL != ret_len)
     *ret_len = len;
-  *data = GNUNET_malloc (len);
+  tmp = GNUNET_malloc (len);
 
-  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s, strlen (s), *data, len))
+  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s, strlen (s), tmp, len))
+  {
+    GNUNET_free (tmp);
     return GNUNET_NO;
+  }
+  *data = tmp;
   return GNUNET_OK;
 }
 
@@ -197,7 +204,7 @@ expect_data_dynamic (json_t *vec,
  *
  * @returns GNUNET_OK if the vector is okay
  */
-static int 
+static int
 checkvec (const char *operation,
           json_t *vec)
 {
@@ -220,10 +227,11 @@ checkvec (const char *operation,
       return GNUNET_SYSERR;
     }
     if (GNUNET_OK != expect_data_fixed (vec,
-                                 "output",
-                                 &hash_out,
-                                 sizeof (hash_out)))
+                                        "output",
+                                        &hash_out,
+                                        sizeof (hash_out)))
     {
+      GNUNET_free (data);
       GNUNET_break (0);
       return GNUNET_NO;
     }
@@ -232,9 +240,11 @@ checkvec (const char *operation,
 
     if (0 != GNUNET_memcmp (&hc, &hash_out))
     {
+      GNUNET_free (data);
       GNUNET_break (0);
       return GNUNET_NO;
     }
+    GNUNET_free (data);
   }
   else if (0 == strcmp (operation, "ecc_ecdh"))
   {
@@ -245,33 +255,33 @@ checkvec (const char *operation,
     struct GNUNET_HashCode skm_comp;
 
     if (GNUNET_OK != expect_data_fixed (vec,
-                                 "priv1",
-                                 &priv1,
-                                 sizeof (priv1)))
+                                        "priv1",
+                                        &priv1,
+                                        sizeof (priv1)))
     {
       GNUNET_break (0);
       return GNUNET_NO;
     }
     if (GNUNET_OK != expect_data_fixed (vec,
-                                 "priv2",
-                                 &priv2,
-                                 sizeof (priv2)))
+                                        "priv2",
+                                        &priv2,
+                                        sizeof (priv2)))
     {
       GNUNET_break (0);
       return GNUNET_NO;
     }
     if (GNUNET_OK != expect_data_fixed (vec,
-                                 "pub1",
-                                 &pub1,
-                                 sizeof (pub1)))
+                                        "pub1",
+                                        &pub1,
+                                        sizeof (pub1)))
     {
       GNUNET_break (0);
       return GNUNET_NO;
     }
     if (GNUNET_OK != expect_data_fixed (vec,
-                                 "skm",
-                                 &skm,
-                                 sizeof (skm)))
+                                        "skm",
+                                        &skm,
+                                        sizeof (skm)))
     {
       GNUNET_break (0);
       return GNUNET_NO;
@@ -407,6 +417,8 @@ checkvec (const char *operation,
                                           &ikm,
                                           &ikm_len))
     {
+      GNUNET_free (out);
+      GNUNET_free (out_comp);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -416,6 +428,9 @@ checkvec (const char *operation,
                                           &salt,
                                           &salt_len))
     {
+      GNUNET_free (out);
+      GNUNET_free (out_comp);
+      GNUNET_free (ikm);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -425,6 +440,10 @@ checkvec (const char *operation,
                                           &ctx,
                                           &ctx_len))
     {
+      GNUNET_free (out);
+      GNUNET_free (out_comp);
+      GNUNET_free (ikm);
+      GNUNET_free (salt);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -442,10 +461,19 @@ checkvec (const char *operation,
 
     if (0 != memcmp (out, out_comp, out_len))
     {
+      GNUNET_free (out);
+      GNUNET_free (out_comp);
+      GNUNET_free (ikm);
+      GNUNET_free (salt);
+      GNUNET_free (ctx);
       GNUNET_break (0);
       return GNUNET_NO;
     }
-
+    GNUNET_free (out);
+    GNUNET_free (out_comp);
+    GNUNET_free (ikm);
+    GNUNET_free (salt);
+    GNUNET_free (ctx);
   }
   else if (0 == strcmp (operation, "eddsa_ecdh"))
   {
@@ -562,6 +590,7 @@ checkvec (const char *operation,
                                           &public_enc_data,
                                           &public_enc_len))
     {
+      GNUNET_free (blinded_data);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -571,6 +600,8 @@ checkvec (const char *operation,
                                           &secret_enc_data,
                                           &secret_enc_len))
     {
+      GNUNET_free (blinded_data);
+      GNUNET_free (public_enc_data);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -580,6 +611,9 @@ checkvec (const char *operation,
                                           &sig_enc_data,
                                           &sig_enc_length))
     {
+      GNUNET_free (blinded_data);
+      GNUNET_free (public_enc_data);
+      GNUNET_free (secret_enc_data);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
@@ -601,6 +635,11 @@ checkvec (const char *operation,
                                                             blinded_data_comp,
                                                             blinded_len)) )
     {
+      GNUNET_free (blinded_data);
+      GNUNET_free (public_enc_data);
+      GNUNET_free (secret_enc_data);
+      GNUNET_free (sig_enc_data);
+      GNUNET_free (skey);
       GNUNET_break (0);
       return GNUNET_NO;
     }
@@ -611,14 +650,27 @@ checkvec (const char *operation,
                                                            pkey));
     public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey,
                                                           &public_enc_data);
-    sig_enc_length_comp = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data_comp);
+    sig_enc_length_comp = GNUNET_CRYPTO_rsa_signature_encode (sig,
+                                                              &sig_enc_data_comp);
 
     if ( (sig_enc_length != sig_enc_length_comp) ||
          (0 != memcmp (sig_enc_data, sig_enc_data_comp, sig_enc_length) ))
     {
+      GNUNET_free (blinded_sig);
+      GNUNET_free (blinded_data);
+      GNUNET_free (public_enc_data);
+      GNUNET_free (secret_enc_data);
+      GNUNET_free (sig_enc_data);
+      GNUNET_free (skey);
       GNUNET_break (0);
       return GNUNET_NO;
     }
+    GNUNET_free (blinded_sig);
+    GNUNET_free (blinded_data);
+    GNUNET_free (public_enc_data);
+    GNUNET_free (secret_enc_data);
+    GNUNET_free (sig_enc_data);
+    GNUNET_free (skey);
   }
   else
   {
@@ -629,6 +681,7 @@ checkvec (const char *operation,
   return GNUNET_OK;
 }
 
+
 /**
  * Check test vectors from stdin.
  *
@@ -656,7 +709,7 @@ check_vectors ()
     return 1;
   }
   vectors = json_object_get (vecfile, "vectors");
-  if (!json_is_array (vectors))
+  if (! json_is_array (vectors))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bad vectors\n");
     json_decref (vecfile);
@@ -692,6 +745,7 @@ check_vectors ()
   }
 }
 
+
 /**
  * Output test vectors.
  *
@@ -868,20 +922,20 @@ output_vectors ()
     GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material);
 
     d2j (vec, "priv_ecdhe",
-                  &priv_ecdhe,
-                  sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
+         &priv_ecdhe,
+         sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
     d2j (vec, "pub_ecdhe",
-                  &pub_ecdhe,
-                  sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
+         &pub_ecdhe,
+         sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
     d2j (vec, "priv_eddsa",
-                  &priv_eddsa,
-                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+         &priv_eddsa,
+         sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
     d2j (vec, "pub_eddsa",
-                  &pub_eddsa,
-                  sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+         &pub_eddsa,
+         sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
     d2j (vec, "key_material",
-                  &key_material,
-                  sizeof (struct GNUNET_HashCode));
+         &key_material,
+         sizeof (struct GNUNET_HashCode));
   }
 
   {
@@ -968,6 +1022,7 @@ output_vectors ()
     GNUNET_free (blinded_data);
     GNUNET_free (sig_enc_data);
     GNUNET_free (blinded_sig_enc_data);
+    GNUNET_free (secret_enc_data);
   }
 
   json_dumpf (vecfile, stdout, JSON_INDENT (2));
@@ -977,6 +1032,7 @@ output_vectors ()
   return 0;
 }
 
+
 /**
  * Main function that will be run.
  *
diff --git a/src/util/gnunet-scrypt.c b/src/util/gnunet-scrypt.c
index 5c3dfc12e..fe8b6769f 100644
--- a/src/util/gnunet-scrypt.c
+++ b/src/util/gnunet-scrypt.c
@@ -290,8 +290,8 @@ run (void *cls,
 int
 main (int argc, char *const *argv)
 {
-  struct GNUNET_GETOPT_CommandLineOption options[] =
-  { GNUNET_GETOPT_option_ulong (
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_ulong (
       'b',
       "bits",
       "BITS",
@@ -315,7 +315,8 @@ main (int argc, char *const *argv)
                                         gettext_noop (
                                           "time to wait between calculations"),
                                         &proof_find_delay),
-    GNUNET_GETOPT_OPTION_END };
+    GNUNET_GETOPT_OPTION_END
+  };
   int ret;
 
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
diff --git a/src/util/mq.c b/src/util/mq.c
index 2342b2c5c..9b59cd338 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -363,7 +363,7 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
   GNUNET_assert (NULL == ev->parent_queue);
 
   mq->queue_length++;
-  if (mq->queue_length >= 10000)
+  if (mq->queue_length >= 10000000)
   {
     /* This would seem like a bug... */
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
diff --git a/src/util/os_installation.c b/src/util/os_installation.c
index d1e5e0da5..02d4d439d 100644
--- a/src/util/os_installation.c
+++ b/src/util/os_installation.c
@@ -736,7 +736,12 @@ GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                            "SUID_BINARY_PATH",
                                            &path);
   if ((NULL == path) || (0 == strlen (path)))
+  {
+    if (NULL != path)
+      GNUNET_free (path);
+    cache = NULL;
     return GNUNET_OS_get_libexec_binary_path (progname);
+  }
   path_len = strlen (path);
   GNUNET_asprintf (&binary,
                    "%s%s%s",
diff --git a/src/util/plugin.c b/src/util/plugin.c
index d169bc911..feb661f24 100644
--- a/src/util/plugin.c
+++ b/src/util/plugin.c
@@ -388,6 +388,11 @@ find_libraries (void *cls,
  * `basename_ANYTHING_init` and `basename_ANYTHING__done`.  These will
  * be called when the library is loaded and unloaded respectively.
  *
+ * If you are writing a service to which third-party applications can connect,
+ * like GNUnet's own GNS service for example, you should use
+ * #GNUNET_PLUGIN_load_all_in_context instead of this function, passing your
+ * service's project data as context.
+ *
  * @param basename basename of the plugins to load
  * @param arg argument to the plugin initialization function
  * @param cb function to call for each plugin found
@@ -420,4 +425,32 @@ GNUNET_PLUGIN_load_all (const char *basename,
 }
 
 
+/**
+ * Load all compatible plugins with the given base name while inside the given
+ * context (i.e. a specific project data structure.)
+ *
+ * Note that the library must export symbols called `basename_ANYTHING_init`
+ * and `basename_ANYTHING__done`.  These will be called when the library is
+ * loaded and unloaded respectively.
+ *
+ * @param ctx the context used to find the plugins
+ * @param basename basename of the plugins to load
+ * @param arg argument to the plugin initialization function
+ * @param cb function to call for each plugin found
+ * @param cb_cls closure for @a cb
+ */
+void
+GNUNET_PLUGIN_load_all_in_context (const struct GNUNET_OS_ProjectData *ctx,
+                                   const char *basename,
+                                   void *arg,
+                                   GNUNET_PLUGIN_LoaderCallback cb,
+                                   void *cb_cls)
+{
+  const struct GNUNET_OS_ProjectData *cpd = GNUNET_OS_project_data_get ();
+  GNUNET_OS_init (ctx);
+  GNUNET_PLUGIN_load_all (basename, arg, cb, cb_cls);
+  GNUNET_OS_init (cpd);
+}
+
+
 /* end of plugin.c */
diff --git a/src/util/time.c b/src/util/time.c
index 9e41305f1..456ee660b 100644
--- a/src/util/time.c
+++ b/src/util/time.c
@@ -44,11 +44,6 @@
  */
 static long long timestamp_offset;
 
-/**
- * Set the timestamp offset for this instance.
- *
- * @param offset the offset to skew the locale time by
- */
 void
 GNUNET_TIME_set_offset (long long offset)
 {
@@ -56,11 +51,6 @@ GNUNET_TIME_set_offset (long long offset)
 }
 
 
-/**
- * Get the timestamp offset for this instance.
- *
- * @return the offset we currently skew the locale time by
- */
 long long
 GNUNET_TIME_get_offset ()
 {
@@ -68,14 +58,6 @@ GNUNET_TIME_get_offset ()
 }
 
 
-/**
- * Round a time value so that it is suitable for transmission
- * via JSON encodings.
- *
- * @param at time to round
- * @return #GNUNET_OK if time was already rounded, #GNUNET_NO if
- *         it was just now rounded
- */
 int
 GNUNET_TIME_round_abs (struct GNUNET_TIME_Absolute *at)
 {
@@ -88,14 +70,6 @@ GNUNET_TIME_round_abs (struct GNUNET_TIME_Absolute *at)
 }
 
 
-/**
- * Round a time value so that it is suitable for transmission
- * via JSON encodings.
- *
- * @param rt time to round
- * @return #GNUNET_OK if time was already rounded, #GNUNET_NO if
- *         it was just now rounded
- */
 int
 GNUNET_TIME_round_rel (struct GNUNET_TIME_Relative *rt)
 {
@@ -108,12 +82,6 @@ GNUNET_TIME_round_rel (struct GNUNET_TIME_Relative *rt)
 }
 
 
-/**
- * Get the current time (works just as "time", just that we use the
- * unit of time that the cron-jobs use (and is 64 bit)).
- *
- * @return the current time
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_get ()
 {
@@ -128,9 +96,6 @@ GNUNET_TIME_absolute_get ()
 }
 
 
-/**
- * Return relative time of 0ms.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_zero_ ()
 {
@@ -140,9 +105,6 @@ GNUNET_TIME_relative_get_zero_ ()
 }
 
 
-/**
- * Return absolute time of 0ms.
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_get_zero_ ()
 {
@@ -152,9 +114,6 @@ GNUNET_TIME_absolute_get_zero_ ()
 }
 
 
-/**
- * Return relative time of 1us.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_unit_ ()
 {
@@ -164,9 +123,6 @@ GNUNET_TIME_relative_get_unit_ ()
 }
 
 
-/**
- * Return relative time of 1ms.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_millisecond_ ()
 {
@@ -176,9 +132,6 @@ GNUNET_TIME_relative_get_millisecond_ ()
 }
 
 
-/**
- * Return relative time of 1s.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_second_ ()
 {
@@ -188,9 +141,6 @@ GNUNET_TIME_relative_get_second_ ()
 }
 
 
-/**
- * Return relative time of 1 minute.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_minute_ ()
 {
@@ -200,9 +150,6 @@ GNUNET_TIME_relative_get_minute_ ()
 }
 
 
-/**
- * Return relative time of 1 hour.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_hour_ ()
 {
@@ -212,9 +159,6 @@ GNUNET_TIME_relative_get_hour_ ()
 }
 
 
-/**
- * Return "forever".
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_forever_ ()
 {
@@ -224,9 +168,6 @@ GNUNET_TIME_relative_get_forever_ ()
 }
 
 
-/**
- * Return "forever".
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_get_forever_ ()
 {
@@ -236,12 +177,6 @@ GNUNET_TIME_absolute_get_forever_ ()
 }
 
 
-/**
- * Convert relative time to an absolute time in the
- * future.
- *
- * @return timestamp that is "rel" in the future, or FOREVER if rel==FOREVER (or if we would overflow)
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
 {
@@ -261,13 +196,6 @@ GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
 }
 
 
-/**
- * Return the minimum of two relative time values.
- *
- * @param t1 first timestamp
- * @param t2 other timestamp
- * @return timestamp that is smaller
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2)
@@ -276,13 +204,6 @@ GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
 }
 
 
-/**
- * Return the maximum of two relative time values.
- *
- * @param t1 first timestamp
- * @param t2 other timestamp
- * @return timestamp that is larger
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2)
@@ -291,13 +212,6 @@ GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
 }
 
 
-/**
- * Return the minimum of two relative time values.
- *
- * @param t1 first timestamp
- * @param t2 other timestamp
- * @return timestamp that is smaller
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2)
@@ -306,13 +220,6 @@ GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
 }
 
 
-/**
- * Return the maximum of two relative time values.
- *
- * @param t1 first timestamp
- * @param t2 other timestamp
- * @return timestamp that is bigger
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2)
@@ -321,12 +228,6 @@ GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
 }
 
 
-/**
- * Given a timestamp in the future, how much time
- * remains until then?
- *
- * @return future - now, or 0 if now >= future, or FOREVER if future==FOREVER.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
 {
@@ -343,13 +244,6 @@ GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
 }
 
 
-/**
- * Compute the time difference between the given start and end times.
- * Use this function instead of actual subtraction to ensure that
- * "FOREVER" and overflows are handled correctly.
- *
- * @return 0 if start >= end; FOREVER if end==FOREVER; otherwise end - start
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
                                      struct GNUNET_TIME_Absolute end)
@@ -365,12 +259,6 @@ GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
 }
 
 
-/**
- * Get the duration of an operation as the
- * difference of the current time and the given start time "whence".
- *
- * @return 0 if whence > now, otherwise now-whence.
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute whence)
 {
@@ -385,12 +273,6 @@ GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute whence)
 }
 
 
-/**
- * Add a given relative duration to the
- * given start time.
- *
- * @return FOREVER if either argument is FOREVER or on overflow; start+duration otherwise
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
                           struct GNUNET_TIME_Relative duration)
@@ -410,14 +292,6 @@ GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
 }
 
 
-/**
- * Subtract a given relative duration from the
- * given start time.
- *
- * @param start some absolute time
- * @param duration some relative time to subtract
- * @return ZERO if start <= duration, or FOREVER if start time is FOREVER; start-duration otherwise
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
                                struct GNUNET_TIME_Relative duration)
@@ -433,11 +307,6 @@ GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
 }
 
 
-/**
- * Multiply relative time by a given factor.
- *
- * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
                                unsigned long long factor)
@@ -458,12 +327,6 @@ GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
 }
 
 
-/**
- * Multiply relative time by a given floating-point factor.  The factor must be
- * positive.
- *
- * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
- */
 struct GNUNET_TIME_Relative
 relative_multiply_double (struct GNUNET_TIME_Relative rel, double factor)
 {
@@ -490,13 +353,6 @@ relative_multiply_double (struct GNUNET_TIME_Relative rel, double factor)
 }
 
 
-/**
- * Saturating multiply relative time by a given factor.
- *
- * @param rel some duration
- * @param factor integer to multiply with
- * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_saturating_multiply (struct GNUNET_TIME_Relative rel,
                                           unsigned long long factor)
@@ -516,13 +372,6 @@ GNUNET_TIME_relative_saturating_multiply (struct GNUNET_TIME_Relative rel,
 }
 
 
-/**
- * Divide relative time by a given factor.
- *
- * @param rel some duration
- * @param factor integer to divide by
- * @return FOREVER if rel=FOREVER or factor==0; otherwise rel/factor
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
                              unsigned long long factor)
@@ -537,16 +386,6 @@ GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
 }
 
 
-/**
- * Calculate the estimate time of arrival/completion
- * for an operation.
- *
- * @param start when did the operation start?
- * @param finished how much has been done?
- * @param total how much must be done overall (same unit as for "finished")
- * @return remaining duration for the operation,
- *        assuming it continues at the same speed
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
                            uint64_t finished,
@@ -568,13 +407,6 @@ GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start,
 }
 
 
-/**
- * Add relative times together.
- *
- * @param a1 first timestamp
- * @param a2 second timestamp
- * @return FOREVER if either argument is FOREVER or on overflow; a1+a2 otherwise
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
                           struct GNUNET_TIME_Relative a2)
@@ -593,13 +425,6 @@ GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
 }
 
 
-/**
- * Subtract relative timestamp from the other.
- *
- * @param a1 first timestamp
- * @param a2 second timestamp
- * @return ZERO if a2>=a1 (including both FOREVER), FOREVER if a1 is FOREVER, a1-a2 otherwise
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
                                struct GNUNET_TIME_Relative a2)
@@ -615,12 +440,6 @@ GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
 }
 
 
-/**
- * Convert relative time to network byte order.
- *
- * @param a time to convert
- * @return time in network byte order
- */
 struct GNUNET_TIME_RelativeNBO
 GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
 {
@@ -631,12 +450,6 @@ GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
 }
 
 
-/**
- * Convert relative time from network byte order.
- *
- * @param a time to convert
- * @return time in host byte order
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
 {
@@ -647,12 +460,6 @@ GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
 }
 
 
-/**
- * Convert absolute time to network byte order.
- *
- * @param a time to convert
- * @return time in network byte order
- */
 struct GNUNET_TIME_AbsoluteNBO
 GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
 {
@@ -663,12 +470,6 @@ GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
 }
 
 
-/**
- * Convert absolute time from network byte order.
- *
- * @param a time to convert
- * @return time in host byte order
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
 {
@@ -679,9 +480,6 @@ GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
 }
 
 
-/**
- * Return the current year (i.e. '2011').
- */
 unsigned int
 GNUNET_TIME_get_current_year ()
 {
@@ -696,12 +494,6 @@ GNUNET_TIME_get_current_year ()
 }
 
 
-/**
- * Convert an expiration time to the respective year (rounds)
- *
- * @param at absolute time
- * @return year a year (after 1970), 0 on error
- */
 unsigned int
 GNUNET_TIME_time_to_year (struct GNUNET_TIME_Absolute at)
 {
@@ -742,12 +534,6 @@ my_timegm (struct tm *tm)
 #endif
 
 
-/**
- * Convert a year to an expiration time of January 1st of that year.
- *
- * @param year a year (after 1970, please ;-)).
- * @return absolute time for January 1st of that year.
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_year_to_time (unsigned int year)
 {
@@ -777,15 +563,6 @@ GNUNET_TIME_year_to_time (unsigned int year)
 }
 
 
-/**
- * Randomized exponential back-off, starting at 1 ms
- * and going up by a factor of 2+r, where 0 <= r <= 0.5, up
- * to a maximum of the given threshold.
- *
- * @param r current backoff time, initially zero
- * @param threshold maximum value for backoff
- * @return the next backoff time
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_randomized_backoff (struct GNUNET_TIME_Relative rt,
                                 struct GNUNET_TIME_Relative threshold)
@@ -800,39 +577,15 @@ GNUNET_TIME_randomized_backoff (struct GNUNET_TIME_Relative rt,
 }
 
 
-/**
- * Return a random time value between 0.5*r and 1.5*r.
- *
- * @param r input time for scaling
- * @return randomized time
- */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_randomize (struct GNUNET_TIME_Relative r)
 {
-  double d = ((rand () % 1001) - 500) / 1000.0;
+  double d = ((rand () % 1001) + 500) / 1000.0;
 
   return relative_multiply_double (r, d);
 }
 
 
-/**
- * Obtain the current time and make sure it is monotonically
- * increasing.  Guards against systems without an RTC or
- * clocks running backwards and other nasty surprises. Does
- * not guarantee that the returned time is near the current
- * time returned by #GNUNET_TIME_absolute_get().  Two
- * subsequent calls (within a short time period) may return the
- * same value. Persists the last returned time on disk to
- * ensure that time never goes backwards. As a result, the
- * resulting value can be used to check if a message is the
- * "most recent" value and replays of older messages (from
- * the same origin) would be discarded.
- *
- * @param cfg configuration, used to determine where to
- *   store the time; user can also insist RTC is working
- *   nicely and disable the feature
- * @return monotonically increasing time
- */
 struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_get_monotonic (
   const struct GNUNET_CONFIGURATION_Handle *cfg)