78 files changed, 19969 insertions, 0 deletions

diff --git a/src/service/messenger/.gitignore b/src/service/messenger/.gitignore
new file mode 100644
index 000000000..ed78c5562
--- /dev/null
+++ b/src/service/messenger/.gitignore
@@ -0,0 +1,14 @@
+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/service/messenger/Makefile.am b/src/service/messenger/Makefile.am
new file mode 100644
index 000000000..876b19985
--- /dev/null
+++ b/src/service/messenger/Makefile.am
@@ -0,0 +1,162 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+pkgcfg_DATA = \
+  messenger.conf
+
+plugindir = $(libdir)/gnunet
+
+AM_CLFAGS = -g
+
+libexec_PROGRAMS = \
+ gnunet-service-messenger \
+ $(EXP_LIBEXEC)
+
+plugin_LTLIBRARIES = \
+  libgnunet_test_messenger_plugin_cmd_simple_join.la
+
+TESTING_LIBS = \
+  libgnunetmessengertesting.la
+
+lib_LTLIBRARIES = \
+  libgnunetmessenger.la \
+  $(EXP_LIB) \
+  $(TESTING_LIBS)
+
+libgnunetmessenger_la_SOURCES = \
+  messenger_api.c \
+  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_message_control.c messenger_api_message_control.h \
+  messenger_api_message_kind.c messenger_api_message_kind.h \
+  messenger_api_list_tunnels.c messenger_api_list_tunnels.h \
+  messenger_api_queue_messages.c messenger_api_queue_messages.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/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(XLIB) \
+  $(LTLIBINTL)
+libgnunetmessenger_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+libgnunetmessengertesting_la_SOURCES = \
+  messenger_api_cmd_join_room.c \
+  messenger_api_cmd_start_service.c \
+  messenger_api_cmd_stop_service.c \
+  messenger_api_traits.c \
+  messenger-testing.c messenger-testing.h
+libgnunetmessengertesting_la_LIBADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/transport/libgnunettransporttesting2.la \
+  $(top_builddir)/src/service/transport/libgnunettransportapplication.la \
+  $(top_builddir)/src/service/transport/libgnunettransportcore.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunetmessengertesting_la_LDFLAGS = \
+  $(GN_LIBINTL) \
+  $(GN_LIB_LDFLAGS) \
+  -version-info 0:0:0
+
+libgnunet_test_messenger_plugin_cmd_simple_join_la_SOURCES = \
+  messenger-testing-cmds.h \
+  test_messenger_plugin_cmd_simple_join.c
+libgnunet_test_messenger_plugin_cmd_simple_join_la_LIBADD = \
+  libgnunetmessenger.la \
+  libgnunetmessengertesting.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/service/core/libgnunetcoretesting.la \
+  $(top_builddir)/src/service/transport/libgnunettransporttesting2.la \
+  $(top_builddir)/src/service/transport/libgnunettransportapplication.la \
+  $(top_builddir)/src/service/transport/libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_messenger_plugin_cmd_simple_join_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+gnunet_service_messenger_SOURCES = \
+  gnunet-service-messenger.c gnunet-service-messenger.h \
+  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_sender_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_peer_store.c gnunet-service-messenger_peer_store.h \
+  gnunet-service-messenger_basement.c gnunet-service-messenger_basement.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_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(GN_LIBINTL)
+
+check_PROGRAMS = \
+  test_messenger_api \
+  test_messenger_anonymous
+
+#check_SCRIPTS= \
+#  test_messenger_start_testcase.sh
+
+if ENABLE_TEST_RUN
+AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
+TESTS = $(check_PROGRAMS) \
+  $(check_SCRIPTS)
+endif
+
+test_messenger_api_SOURCES = \
+  test_messenger.c
+test_messenger_api_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_messenger_anonymous_SOURCES = \
+  test_messenger_anonymous.c
+test_messenger_anonymous_LDADD = \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+EXTRA_DIST = \
+  test_messenger_start_testcase.sh \
+  test_messenger_api.conf
diff --git a/src/service/messenger/gnunet-service-messenger.c b/src/service/messenger/gnunet-service-messenger.c
new file mode 100644
index 000000000..06f9384aa
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger.c
@@ -0,0 +1,569 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger.h"
+
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_room.h"
+#include "gnunet-service-messenger_service.h"
+#include "gnunet_common.h"
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_Client
+{
+  struct GNUNET_SERVICE_Client *client;
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+};
+
+struct GNUNET_MESSENGER_Service *messenger;
+
+static void
+handle_create (void *cls,
+               const struct GNUNET_MESSENGER_CreateMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle created\n");
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+
+static void
+handle_destroy (void *cls,
+                const struct GNUNET_MESSENGER_DestroyMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle destroyed\n");
+
+  GNUNET_SERVICE_client_drop (msg_client->client);
+}
+
+
+static enum GNUNET_GenericReturnValue
+check_room_initial_key (const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size);
+
+  if (full_length < sizeof(*msg))
+    return GNUNET_NO;
+
+  const uint16_t msg_length = full_length - sizeof(*msg);
+  const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
+
+  if (0 == msg_length)
+    return GNUNET_OK;
+
+  struct GNUNET_CRYPTO_PublicKey key;
+  size_t key_len;
+
+  if (GNUNET_OK != GNUNET_CRYPTO_read_public_key_from_buffer (msg_buffer,
+                                                              msg_length,
+                                                              &key, &key_len))
+    return GNUNET_NO;
+
+  return key_len == msg_length ? GNUNET_OK : GNUNET_NO;
+}
+
+
+static void
+initialize_handle_via_key (struct GNUNET_MESSENGER_SrvHandle *handle,
+                           const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  GNUNET_assert (handle);
+
+  const uint16_t full_length = ntohs (msg->header.size);
+  const uint16_t msg_length = full_length - sizeof(*msg);
+  const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
+
+  if (msg_length > 0)
+  {
+    struct GNUNET_CRYPTO_PublicKey key;
+    size_t key_len;
+
+    if (GNUNET_OK == GNUNET_CRYPTO_read_public_key_from_buffer (msg_buffer,
+                                                                msg_length,
+                                                                &key,
+                                                                &key_len))
+      set_srv_handle_key (handle, &key);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Initialization failed while reading invalid key!\n");
+  }
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Initialization is missing key!\n");
+}
+
+
+static enum GNUNET_GenericReturnValue
+check_room_open (void *cls,
+                 const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  return check_room_initial_key (msg);
+}
+
+
+static void
+handle_room_open (void *cls,
+                  const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  initialize_handle_via_key (msg_client->handle, msg);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening room: %s\n", GNUNET_h2s (
+                &(msg->key)));
+
+  if (GNUNET_YES == open_srv_handle_room (msg_client->handle, &(msg->key)))
+  {
+    struct GNUNET_HashCode prev;
+    sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
+                              &prev);
+
+    const struct GNUNET_ShortHashCode *member_id = get_srv_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));
+
+    struct GNUNET_MESSENGER_RoomMessage *response;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (response, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
+    GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
+    GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
+    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_SERVICE_client_continue (msg_client->client);
+}
+
+
+static enum GNUNET_GenericReturnValue
+check_room_entry (void *cls,
+                  const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  return check_room_initial_key (msg);
+}
+
+
+static void
+handle_room_entry (void *cls,
+                   const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  initialize_handle_via_key (msg_client->handle, msg);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entering room: %s, %s\n", GNUNET_h2s (
+                &(msg->key)), GNUNET_i2s (&(msg->door)));
+
+  if (GNUNET_YES == entry_srv_handle_room (msg_client->handle, &(msg->door),
+                                           &(msg->key)))
+  {
+    struct GNUNET_HashCode prev;
+    sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
+                              &prev);
+
+    const struct GNUNET_ShortHashCode *member_id = get_srv_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));
+
+    struct GNUNET_MESSENGER_RoomMessage *response;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (response, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
+    GNUNET_memcpy (&(response->door), &(msg->door), sizeof(response->door));
+    GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
+    GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
+    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_SERVICE_client_continue (msg_client->client);
+}
+
+
+static void
+handle_room_close (void *cls,
+                   const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing room: %s\n", GNUNET_h2s (
+                &(msg->key)));
+
+  if (GNUNET_YES == close_srv_handle_room (msg_client->handle, &(msg->key)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing room succeeded: %s\n",
+                GNUNET_h2s (&(msg->key)));
+
+    struct GNUNET_MESSENGER_RoomMessage *response;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (response, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
+    GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
+    GNUNET_memcpy (&(response->previous), &(msg->previous),
+                   sizeof(response->previous));
+    GNUNET_MQ_send (msg_client->handle->mq, env);
+  }
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Closing room failed: %s\n",
+                GNUNET_h2s (&(msg->key)));
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+
+static void
+handle_room_sync (void *cls,
+                  const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Syncing room: %s\n", GNUNET_h2s (
+                &(msg->key)));
+
+  struct GNUNET_HashCode prev;
+  sync_srv_handle_messages (msg_client->handle, &(msg->key), &(msg->previous),
+                            &prev);
+
+  struct GNUNET_MESSENGER_RoomMessage *response;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg (response, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC);
+  GNUNET_memcpy (&(response->key), &(msg->key), sizeof(response->key));
+  GNUNET_memcpy (&(response->previous), &prev, sizeof(response->previous));
+  GNUNET_MQ_send (msg_client->handle->mq, env);
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+
+static enum GNUNET_GenericReturnValue
+check_send_message (void *cls,
+                    const struct GNUNET_MESSENGER_SendMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size);
+
+  if (full_length < sizeof(*msg))
+    return GNUNET_NO;
+
+  const uint16_t msg_length = full_length - sizeof(*msg);
+  const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+
+  if (msg_length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+                                          GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Too short message: %s\n", GNUNET_h2s (
+                  &(msg->key)));
+    return GNUNET_NO;
+  }
+
+  if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer,
+                                    GNUNET_YES,
+                                    NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Decoding message failed: %s\n",
+                GNUNET_h2s (
+                  &(msg->key)));
+    return GNUNET_NO;
+  }
+
+  enum GNUNET_GenericReturnValue allowed;
+  allowed = filter_message_sending (&message);
+
+  if (GNUNET_SYSERR == allowed)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Sending message not allowed: %s to %s\n",
+                GNUNET_MESSENGER_name_of_kind (message.header.kind),
+                GNUNET_h2s (&(msg->key)));
+
+  cleanup_message (&message);
+  return GNUNET_SYSERR != allowed? GNUNET_OK : GNUNET_NO;
+}
+
+
+static void
+handle_send_message (void *cls,
+                     const struct GNUNET_MESSENGER_SendMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const char *msg_buffer = ((const char*) msg) + sizeof(*msg);
+  const uint16_t msg_length = ntohs (msg->header.size) - sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+  decode_message (&message, msg_length, msg_buffer, GNUNET_YES, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message: %s to %s (by %s)\n",
+              GNUNET_MESSENGER_name_of_kind (message.header.kind),
+              GNUNET_h2s (key),
+              GNUNET_sh2s (&(message.header.sender_id)));
+
+  if (GNUNET_YES != send_srv_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));
+
+  cleanup_message (&message);
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+
+static void
+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)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Notifying client about missing message: %s\n",
+                GNUNET_h2s (hash));
+
+    struct GNUNET_MESSENGER_GetMessage *response;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (response,
+                         GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
+    GNUNET_memcpy (&(response->key), &(room->key), sizeof(room->key));
+    GNUNET_memcpy (&(response->hash), hash, sizeof(*hash));
+    GNUNET_MQ_send (msg_client->handle->mq, env);
+    return;
+  }
+
+  struct GNUNET_MESSENGER_SenderSession session;
+
+  if (GNUNET_YES == is_peer_message (message))
+  {
+    struct GNUNET_MESSENGER_PeerStore *store = get_srv_room_peer_store (room);
+
+    session.peer = get_store_peer_of (store, message, hash);
+
+    if (! session.peer)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Peer session from sender of message (%s) unknown!\n",
+                  GNUNET_h2s (hash));
+      return;
+    }
+  }
+  else
+  {
+    struct GNUNET_MESSENGER_MemberStore *store = get_srv_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;
+    }
+
+    session.member = get_member_session_of (member, message, hash);
+
+    if (! session.member)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Member session from sender of message (%s) unknown!\n",
+                  GNUNET_h2s (hash));
+      return;
+    }
+  }
+
+  notify_srv_handle_message (msg_client->handle, room, &session, message,
+                             hash, GNUNET_NO);
+}
+
+
+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, "Requested message: %s\n",
+              GNUNET_h2s (&(msg->hash)));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (messenger,
+                                                            &(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_srv_room_member_store (room);
+
+  const struct GNUNET_ShortHashCode *member_id;
+  member_id = get_srv_handle_member_id (msg_client->handle,
+                                        &(msg->key));
+
+  struct GNUNET_MESSENGER_Member *member = get_store_member (member_store,
+                                                             member_id);
+
+  if (! member)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Member not valid to request a message! (%s)\n",
+                GNUNET_sh2s (member_id));
+    goto end_handling;
+  }
+
+  const struct GNUNET_CRYPTO_PublicKey *pubkey = get_srv_handle_key (
+    msg_client->handle);
+
+  if (! pubkey)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Handle needs to have a public key to request a message! (%s)\n",
+                GNUNET_sh2s (member_id));
+    goto end_handling;
+  }
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member,
+                                                                       pubkey);
+
+  if (! session)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Session not valid to request a message! (%s)\n",
+                GNUNET_sh2s (member_id));
+    goto end_handling;
+  }
+
+  request_srv_room_message (room, &(msg->hash), session, callback_found_message,
+                            msg_client);
+
+end_handling:
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+
+static void*
+callback_client_connect (void *cls,
+                         struct GNUNET_SERVICE_Client *client,
+                         struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = GNUNET_new (struct
+                                                           GNUNET_MESSENGER_Client);
+
+  msg_client->client = client;
+  msg_client->handle = add_service_handle (messenger, mq);
+
+  return msg_client;
+}
+
+
+static void
+callback_client_disconnect (void *cls,
+                            struct GNUNET_SERVICE_Client *client,
+                            void *internal_cls)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = internal_cls;
+
+  remove_service_handle (messenger, msg_client->handle);
+
+  GNUNET_free (msg_client);
+}
+
+
+/**
+ * Setup MESSENGER internals.
+ *
+ * @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)
+    GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  GNUNET_MESSENGER_SERVICE_NAME,
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &callback_client_connect,
+  &callback_client_disconnect,
+  NULL,
+  GNUNET_MQ_hd_fixed_size (create,
+                           GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE,
+                           struct
+                           GNUNET_MESSENGER_CreateMessage, NULL),
+  GNUNET_MQ_hd_fixed_size (destroy,
+                           GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY,
+                           struct
+                           GNUNET_MESSENGER_DestroyMessage, NULL),
+  GNUNET_MQ_hd_var_size (room_open, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
+                         struct GNUNET_MESSENGER_RoomMessage, NULL),
+  GNUNET_MQ_hd_var_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_GetMessage, NULL),
+  GNUNET_MQ_hd_fixed_size (room_sync, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC,
+                           struct GNUNET_MESSENGER_RoomMessage, NULL),
+  GNUNET_MQ_handler_end ());
diff --git a/src/service/messenger/gnunet-service-messenger.h b/src/service/messenger/gnunet-service-messenger.h
new file mode 100644
index 000000000..5d96cc345
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger.h
@@ -0,0 +1,106 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_H
+#define GNUNET_SERVICE_MESSENGER_H
+
+#include "gnunet_util_lib.h"
+
+/**
+ * Message to create a handle for a client
+ */
+struct GNUNET_MESSENGER_CreateMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message to destroy the handle for a client
+ */
+struct GNUNET_MESSENGER_DestroyMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * General message to confirm interaction with a room
+ */
+struct GNUNET_MESSENGER_RoomMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_PeerIdentity door;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode previous;
+};
+
+/**
+ * Message to receive the current member id of a handle in room
+ */
+struct GNUNET_MESSENGER_MemberMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_HashCode key;
+  struct GNUNET_ShortHashCode id;
+  uint32_t reset;
+};
+
+/**
+ * Message to send something into a room
+ */
+struct GNUNET_MESSENGER_SendMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_HashCode key;
+};
+
+/**
+ * Message to request something from a room
+ */
+struct GNUNET_MESSENGER_GetMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode hash;
+};
+
+/**
+ * Message to receive something from a room
+ */
+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/service/messenger/gnunet-service-messenger_basement.c b/src/service/messenger/gnunet-service-messenger_basement.c
new file mode 100644
index 000000000..5d1d475e9
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_basement.c
@@ -0,0 +1,66 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_basement.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_basement.h"
+
+size_t
+count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels *tunnels)
+{
+  GNUNET_assert (tunnels);
+
+  const struct GNUNET_MESSENGER_ListTunnel *element;
+  size_t count = 0;
+
+  for (element = tunnels->head; element; element = element->next)
+    count++;
+
+  return count;
+}
+
+
+enum GNUNET_GenericReturnValue
+should_connect_tunnel_to (size_t count,
+                          size_t src,
+                          size_t dst)
+{
+  if ((src + 1) % count == dst % count)
+    return GNUNET_YES;
+
+  return GNUNET_NO;
+}
+
+
+enum GNUNET_GenericReturnValue
+required_connection_between (size_t count,
+                             size_t src,
+                             size_t dst)
+{
+  if (GNUNET_YES == should_connect_tunnel_to (count, src, dst))
+    return GNUNET_YES;
+  if (GNUNET_YES == should_connect_tunnel_to (count, dst, src))
+    return GNUNET_YES;
+
+  return GNUNET_NO;
+}
diff --git a/src/service/messenger/gnunet-service-messenger_basement.h b/src/service/messenger/gnunet-service-messenger_basement.h
new file mode 100644
index 000000000..988ff9d1a
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_basement.h
@@ -0,0 +1,70 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_basement.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_BASEMENT_H
+#define GNUNET_SERVICE_MESSENGER_BASEMENT_H
+
+#include "messenger_api_list_tunnels.h"
+
+/**
+ * Returns the count of peers in a list (typically from the basement of a room).
+ *
+ * @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
+ * 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[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
+ */
+enum GNUNET_GenericReturnValue
+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
+ * index <i>dst</i> should be connected in any direction to construct a complete
+ * basement with a given <i>count</i> of peers.
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+required_connection_between (size_t count,
+                             size_t src,
+                             size_t dst);
+
+#endif //GNUNET_SERVICE_MESSENGER_BASEMENT_H
diff --git a/src/service/messenger/gnunet-service-messenger_handle.c b/src/service/messenger/gnunet-service-messenger_handle.c
new file mode 100644
index 000000000..ca9dcfb15
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_handle.c
@@ -0,0 +1,570 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_handle.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "platform.h"
+#include "gnunet_messenger_service.h"
+
+#include "gnunet-service-messenger.h"
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_room.h"
+
+#include "messenger_api_util.h"
+
+struct GNUNET_MESSENGER_NextMemberId
+{
+  struct GNUNET_ShortHashCode id;
+  enum GNUNET_GenericReturnValue reset;
+};
+
+struct GNUNET_MESSENGER_SrvHandle*
+create_srv_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->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  handle->next_ids = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
+  handle->routing = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
+
+  handle->notify = NULL;
+
+  return handle;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_close_rooms (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+  close_service_room (handle->service, handle, key, GNUNET_NO);
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_free_values (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
+{
+  GNUNET_free (value);
+  return GNUNET_YES;
+}
+
+
+void
+destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert (handle);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->routing,
+                                         iterate_close_rooms, handle);
+
+  if (handle->notify)
+    GNUNET_SCHEDULER_cancel (handle->notify);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+                                         iterate_free_values, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids,
+                                         iterate_free_values, NULL);
+
+  GNUNET_CONTAINER_multihashmap_destroy (handle->next_ids);
+  GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);
+  GNUNET_CONTAINER_multihashmap_destroy (handle->routing);
+
+  GNUNET_free (handle);
+}
+
+
+void
+set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_CRYPTO_PublicKey *key)
+{
+  GNUNET_assert (handle);
+
+  if ((handle->key) && (! key))
+  {
+    GNUNET_free (handle->key);
+    handle->key = NULL;
+  }
+  else if (! handle->key)
+    handle->key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+
+  if (key)
+    memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_PublicKey));
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert (handle);
+
+  return handle->key;
+}
+
+
+void
+get_srv_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);
+  else
+    GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
+                     DIR_SEPARATOR);
+}
+
+
+static enum GNUNET_GenericReturnValue
+create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle,
+                         const struct GNUNET_HashCode *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))
+  {
+    GNUNET_free (random_id);
+    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));
+
+  return GNUNET_YES;
+}
+
+
+const struct GNUNET_ShortHashCode*
+get_srv_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);
+}
+
+
+enum GNUNET_GenericReturnValue
+change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
+                             const struct GNUNET_HashCode *key,
+                             const struct GNUNET_ShortHashCode *unique_id)
+{
+  GNUNET_assert ((handle) && (key) && (unique_id));
+
+  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (
+    handle->member_ids, key);
+
+  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))
+    return GNUNET_OK;
+
+  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));
+  return GNUNET_OK;
+}
+
+
+enum GNUNET_GenericReturnValue
+open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                      const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (key));
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->routing,
+                                                      key,
+                                                      NULL,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
+
+    return GNUNET_NO;
+
+  if ((! get_srv_handle_member_id (handle, key)) &&
+      (GNUNET_YES != create_handle_member_id (handle,
+                                              key)))
+    return GNUNET_NO;
+
+  return open_service_room (handle->service, handle, key);
+}
+
+
+enum GNUNET_GenericReturnValue
+entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_PeerIdentity *door,
+                       const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (door) && (key));
+
+  if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
+                                                     create_handle_member_id (
+                                                       handle, key)))
+    return GNUNET_NO;
+
+  return entry_service_room (handle->service, handle, door, key);
+}
+
+
+enum GNUNET_GenericReturnValue
+close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (key));
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key,
+                                              iterate_free_values, NULL);
+  GNUNET_CONTAINER_multihashmap_remove_all (handle->next_ids, key);
+
+  if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
+                             handle->next_ids)))
+  {
+    GNUNET_SCHEDULER_cancel (handle->notify);
+    handle->notify = NULL;
+  }
+
+  if (! get_srv_handle_member_id (handle, key))
+    return GNUNET_NO;
+
+  enum GNUNET_GenericReturnValue result;
+  result = close_service_room (handle->service, handle, key, GNUNET_YES);
+
+  if (GNUNET_YES != result)
+    return result;
+
+  GNUNET_CONTAINER_multihashmap_remove_all (handle->routing, key);
+  return result;
+}
+
+
+enum GNUNET_GenericReturnValue
+is_srv_handle_routing (const struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (key));
+
+  return GNUNET_CONTAINER_multihashmap_contains (handle->routing, key);
+}
+
+
+void
+sync_srv_handle_messages (struct GNUNET_MESSENGER_SrvHandle *handle,
+                          const struct GNUNET_HashCode *key,
+                          const struct GNUNET_HashCode *prev,
+                          struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((handle) && (key) && (prev) && (hash));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+                                                            key);
+
+  if ((! room) || (! get_srv_handle_member_id (handle, key)))
+  {
+    GNUNET_memcpy (hash, prev, sizeof(*hash));
+    return;
+  }
+
+  merge_srv_room_last_messages (room, handle);
+  get_message_state_chain_hash (&(room->state), hash);
+}
+
+
+enum GNUNET_GenericReturnValue
+send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
+                         const struct GNUNET_HashCode *key,
+                         const struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert ((handle) && (key) && (message));
+
+  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+                                                                    key);
+
+  if (! id)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "It is required to be a member of a room to send messages!\n");
+    return GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
+              GNUNET_sh2s (id));
+
+  if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Member id does not match with handle!\n");
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+                                                            key);
+
+  if (! room)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
+                GNUNET_h2s (key));
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_Message *msg = copy_message (message);
+  return send_srv_room_message (room, handle, msg);
+}
+
+
+static const struct GNUNET_HashCode*
+get_next_member_session_context (const struct
+                                 GNUNET_MESSENGER_MemberSession *session)
+{
+  if (session->next)
+    return get_next_member_session_context (session->next);
+  else
+    return get_member_session_context (session);
+}
+
+
+static const struct GNUNET_MESSENGER_MemberSession*
+get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle,
+                           struct GNUNET_MESSENGER_SrvRoom *room,
+                           const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (room) && (key) && (handle->service));
+
+  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+                                                                    key);
+
+  if (! id)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Handle is missing a member id for its member session! (%s)\n",
+                GNUNET_h2s (key));
+    return NULL;
+  }
+
+  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member (store, id);
+
+  const struct GNUNET_CRYPTO_PublicKey *pubkey = get_srv_handle_key (handle);
+
+  if (! pubkey)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Handle is missing a public key for its member session! (%s)\n",
+                GNUNET_h2s (key));
+    return NULL;
+  }
+
+  return get_member_session (member, pubkey);
+}
+
+
+void
+notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
+                           struct GNUNET_MESSENGER_SrvRoom *room,
+                           const struct GNUNET_MESSENGER_SenderSession *session,
+                           const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash,
+                           enum GNUNET_GenericReturnValue recent)
+{
+  GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
+
+  const struct GNUNET_HashCode *key = get_srv_room_key (room);
+
+  if ((! handle->mq) || (! get_srv_handle_member_id (handle, key)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Notifying client about message requires membership!\n");
+    return;
+  }
+
+  struct GNUNET_HashCode sender;
+  const struct GNUNET_HashCode *context = NULL;
+
+  if (GNUNET_YES == is_peer_message (message))
+  {
+    const struct GNUNET_PeerIdentity *identity = session->peer;
+    GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
+
+    context = &sender;
+  }
+  else
+  {
+    const struct GNUNET_CRYPTO_PublicKey *pubkey;
+    pubkey = get_member_session_public_key (session->member);
+    GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
+
+    context = get_next_member_session_context (session->member);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Notifying client about message: %s (%s)\n",
+              GNUNET_h2s (hash), GNUNET_MESSENGER_name_of_kind (
+                message->header.kind));
+
+  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) GNUNET_MESSENGER_FLAG_NONE;
+
+  if (GNUNET_YES == is_peer_message (message))
+    msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
+  else if (get_handle_member_session (handle, room, key) == session->member)
+    msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
+
+  if (GNUNET_YES == recent)
+    msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_RECENT;
+
+  char *buffer = ((char*) msg) + sizeof(*msg);
+  encode_message (message, length, buffer, GNUNET_YES);
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_next_member_ids (void *cls,
+                         const struct GNUNET_HashCode *key,
+                         void *value)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+  struct GNUNET_MESSENGER_NextMemberId *next = value;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Notifying client about next member id: %s (%s)\n",
+              GNUNET_sh2s (&(next->id)), GNUNET_h2s (key));
+
+  struct GNUNET_MESSENGER_MemberMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+
+  GNUNET_memcpy (&(msg->key), key, sizeof(*key));
+  GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
+  msg->reset = (uint32_t) next->reset;
+
+  GNUNET_MQ_send (handle->mq, env);
+
+  GNUNET_free (next);
+  return GNUNET_YES;
+}
+
+
+static void
+task_notify_srv_handle_member_id (void *cls)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+  handle->notify = NULL;
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+                                         iterate_next_member_ids, handle);
+  GNUNET_CONTAINER_multihashmap_clear (handle->next_ids);
+}
+
+
+void
+notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
+                             struct GNUNET_MESSENGER_SrvRoom *room,
+                             const struct GNUNET_ShortHashCode *member_id,
+                             enum GNUNET_GenericReturnValue reset)
+{
+  GNUNET_assert ((handle) && (room) && (member_id));
+
+  struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
+                                                           GNUNET_MESSENGER_NextMemberId);
+  if (! next)
+  {
+    return;
+  }
+
+  GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
+  next->reset = reset;
+
+  const struct GNUNET_HashCode *key = get_srv_room_key (room);
+
+  struct GNUNET_MESSENGER_NextMemberId *prev =
+    GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put (handle->next_ids, key,
+                                                       next,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
+  {
+    return;
+  }
+
+  if (prev)
+    GNUNET_free (prev);
+
+  if (! handle->notify)
+    handle->notify = GNUNET_SCHEDULER_add_now (task_notify_srv_handle_member_id,
+                                               handle);
+}
diff --git a/src/service/messenger/gnunet-service-messenger_handle.h b/src/service/messenger/gnunet-service-messenger_handle.h
new file mode 100644
index 000000000..9b41c738d
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_handle.h
@@ -0,0 +1,241 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_handle.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_HANDLE_H
+#define GNUNET_SERVICE_MESSENGER_HANDLE_H
+
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-messenger_service.h"
+#include "gnunet-service-messenger_sender_session.h"
+
+struct GNUNET_MESSENGER_SrvHandle
+{
+  struct GNUNET_MESSENGER_Service *service;
+  struct GNUNET_MQ_Handle *mq;
+
+  struct GNUNET_CRYPTO_PublicKey *key;
+
+  struct GNUNET_CONTAINER_MultiHashMap *member_ids;
+  struct GNUNET_CONTAINER_MultiHashMap *next_ids;
+  struct GNUNET_CONTAINER_MultiHashMap *routing;
+
+  struct GNUNET_SCHEDULER_Task *notify;
+};
+
+/**
+ * Creates and allocates a new handle related to a <i>service</i> and using a given <i>mq</i> (message queue).
+ *
+ * @param[in,out] service MESSENGER Service
+ * @param[in,out] mq Message queue
+ * @return New handle
+ */
+struct GNUNET_MESSENGER_SrvHandle*
+create_srv_handle (struct GNUNET_MESSENGER_Service *service,
+                   struct GNUNET_MQ_Handle *mq);
+
+/**
+ * Destroys a handle and frees its memory fully.
+ *
+ * @param[in,out] handle Handle
+ */
+void
+destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Sets the public key of a given <i>handle</i>.
+ *
+ * @param[out] handle Handle
+ * @param[in] key Public key
+ */
+void
+set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_CRYPTO_PublicKey *key);
+
+/**
+ * Returns the public key of a given <i>handle</i>.
+ *
+ * @param[in] handle Handle
+ * @return Public key of handle
+ */
+const struct GNUNET_CRYPTO_PublicKey*
+get_srv_handle_key (const 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[in] handle Handle
+ * @param[in] name Potential name of the handle
+ * @param[out] dir Path to store data
+ */
+void
+get_srv_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[in] handle Handle
+ * @param[in] key Key of a room
+ * @return Member id or NULL
+ */
+const struct GNUNET_ShortHashCode*
+get_srv_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>
+ * and returns GNUNET_OK on success.
+ *
+ * The client connected to the <i>handle</i> will be informed afterwards automatically.
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
+                             const struct GNUNET_HashCode *key,
+                             const struct GNUNET_ShortHashCode *unique_id);
+
+/**
+ * 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[in,out] handle Handle
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                      const struct GNUNET_HashCode *key);
+
+/**
+ * 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[in,out] handle Handle
+ * @param[in] door Peer identity
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_PeerIdentity *door,
+                       const struct GNUNET_HashCode *key);
+
+/**
+ * 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[in,out] handle Handle
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_HashCode *key);
+
+/**
+ * Returns whether a given <i>handle</i> has enabled routing for a room using a specific <i>key</i>
+ * by opening that room.
+ *
+ * @param[in] handle Handle
+ * @param[in] key Key of a room
+ * @return #GNUNET_YES is routing is enabled, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+is_srv_handle_routing (const struct GNUNET_MESSENGER_SrvHandle *handle,
+                       const struct GNUNET_HashCode *key);
+
+
+/**
+ * Returns the latest merged hash from a room of a given <i>handle</i> using a specific <i>key</i>
+ * and the handles own latest known <i>hash</i> of a message. If the room does not contain other
+ * messages being accessible to the handle and older than the provided hash, the function returns
+ * the originally provided hash as fallback.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] key Key of a room
+ * @param[in] prev Known hash of a message
+ * @param[out] hash Hash of the latest merged message in a room available to the handle
+ */
+void
+sync_srv_handle_messages (struct GNUNET_MESSENGER_SrvHandle *handle,
+                          const struct GNUNET_HashCode *key,
+                          const struct GNUNET_HashCode *prev,
+                          struct GNUNET_HashCode *hash);
+
+/**
+ * Sends a <i>message</i> from a given <i>handle</i> to the room using a specific <i>key</i>.
+ *
+ * @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.
+ */
+enum GNUNET_GenericReturnValue
+send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
+                         const struct GNUNET_HashCode *key,
+                         const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Notifies the handle that a new message was received or sent.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] room Room of the message
+ * @param[in] session Sender session
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @param[in] recent Whether the message was recently handled
+ */
+void
+notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
+                           struct GNUNET_MESSENGER_SrvRoom *room,
+                           const struct GNUNET_MESSENGER_SenderSession *session,
+                           const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash,
+                           enum GNUNET_GenericReturnValue recent);
+
+/**
+ * Notifies the handle that a new member id needs to be used.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] room Room of the member
+ * @param[in] member_id Member id
+ * @param[in] reset Reset member session with join message
+ */
+void
+notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
+                             struct GNUNET_MESSENGER_SrvRoom *room,
+                             const struct GNUNET_ShortHashCode *member_id,
+                             enum GNUNET_GenericReturnValue reset);
+
+#endif //GNUNET_SERVICE_MESSENGER_HANDLE_H
diff --git a/src/service/messenger/gnunet-service-messenger_list_handles.c b/src/service/messenger/gnunet-service-messenger_list_handles.c
new file mode 100644
index 000000000..6002dfe7b
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_list_handles.c
@@ -0,0 +1,117 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_list_handles.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_list_handles.h"
+
+#include "gnunet-service-messenger_handle.h"
+
+void
+init_list_handles (struct GNUNET_MESSENGER_ListHandles *handles)
+{
+  GNUNET_assert (handles);
+
+  handles->head = NULL;
+  handles->tail = NULL;
+}
+
+
+void
+clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles)
+{
+  GNUNET_assert (handles);
+
+  while (handles->head)
+  {
+    struct GNUNET_MESSENGER_ListHandle *element = handles->head;
+
+    GNUNET_CONTAINER_DLL_remove (handles->head, handles->tail, element);
+    destroy_srv_handle (element->handle);
+    GNUNET_free (element);
+  }
+
+  handles->head = NULL;
+  handles->tail = NULL;
+}
+
+
+void
+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;
+
+  GNUNET_CONTAINER_DLL_insert_tail (handles->head, handles->tail, element);
+}
+
+
+enum GNUNET_GenericReturnValue
+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)
+    if (element->handle == handle)
+      break;
+
+  if (! element)
+    return GNUNET_NO;
+
+  GNUNET_CONTAINER_DLL_remove (handles->head, handles->tail, element);
+  GNUNET_free (element);
+
+  return GNUNET_YES;
+}
+
+
+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;
+  struct GNUNET_MESSENGER_SrvHandle *handle = NULL;
+
+  for (element = handles->head; element; element = element->next)
+  {
+    if (get_srv_handle_member_id ((struct
+                                   GNUNET_MESSENGER_SrvHandle *) element->handle,
+                                  key))
+      handle = (struct GNUNET_MESSENGER_SrvHandle *) element->handle;
+
+    if ((handle) && (GNUNET_YES == is_srv_handle_routing (handle, key)))
+      break;
+  }
+
+  return handle;
+}
diff --git a/src/service/messenger/gnunet-service-messenger_list_handles.h b/src/service/messenger/gnunet-service-messenger_list_handles.h
new file mode 100644
index 000000000..64dee6544
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_list_handles.h
@@ -0,0 +1,100 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_list_handles.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
+#define GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
+
+#include "gnunet_common.h"
+
+struct GNUNET_MESSENGER_SrvHandle;
+
+struct GNUNET_MESSENGER_ListHandle
+{
+  struct GNUNET_MESSENGER_ListHandle *prev;
+  struct GNUNET_MESSENGER_ListHandle *next;
+
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+};
+
+struct GNUNET_MESSENGER_ListHandles
+{
+  struct GNUNET_MESSENGER_ListHandle *head;
+  struct GNUNET_MESSENGER_ListHandle *tail;
+};
+
+/**
+ * Initializes list of <i>handles</i> as empty list.
+ *
+ * @param[out] handles List of handles
+ */
+void
+init_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
+
+/**
+ * Destroys remaining <i>handles</i> and clears the list.
+ *
+ * @param[in,out] handles List of handles
+ */
+void
+clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
+
+/**
+ * Adds a specific <i>handle</i> to the end of the list.
+ *
+ * @param[in,out] handles List of handles
+ * @param[in,out] handle Handle
+ */
+void
+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 of
+ * <i>handles</i> and returns #GNUNET_YES on success or #GNUNET_NO on failure.
+ *
+ * @param[in,out] handles List of handles
+ * @param[in,out] handle Handle
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles,
+                    struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Searches linearly through the list of <i>handles</i> for members of a specific room
+ * which is identified by a given <i>key</i>. The handle returned will be one that has
+ * enabled routing for the room if possible.
+ *
+ * If no handle is found which is a current member, NULL gets returned.
+ *
+ * @param[in] handles List of handles
+ * @param[in] key Common key of a room
+ * @return A handle which is a current member
+ */
+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/service/messenger/gnunet-service-messenger_list_messages.c b/src/service/messenger/gnunet-service-messenger_list_messages.c
new file mode 100644
index 000000000..cd59c8aec
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_list_messages.c
@@ -0,0 +1,168 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_list_messages.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_list_messages.h"
+
+#include "gnunet_util_lib.h"
+
+void
+init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages)
+{
+  GNUNET_assert (messages);
+
+  messages->head = NULL;
+  messages->tail = NULL;
+}
+
+
+void
+clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages)
+{
+  GNUNET_assert (messages);
+
+  while (messages->head)
+  {
+    struct GNUNET_MESSENGER_ListMessage *element = messages->head;
+
+    GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+    GNUNET_free (element);
+  }
+
+  messages->head = NULL;
+  messages->tail = NULL;
+}
+
+
+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));
+
+  GNUNET_CONTAINER_DLL_insert_tail (messages->head, messages->tail, element);
+}
+
+
+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)
+    if (0 == GNUNET_CRYPTO_hash_cmp (&(element->hash), hash))
+    {
+      GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+      GNUNET_free (element);
+      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 (const 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/service/messenger/gnunet-service-messenger_list_messages.h b/src/service/messenger/gnunet-service-messenger_list_messages.h
new file mode 100644
index 000000000..133091506
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_list_messages.h
@@ -0,0 +1,111 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_list_messages.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
+#define GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
+
+#include "gnunet_common.h"
+
+struct GNUNET_MESSENGER_ListMessage
+{
+  struct GNUNET_MESSENGER_ListMessage *prev;
+  struct GNUNET_MESSENGER_ListMessage *next;
+
+  struct GNUNET_HashCode hash;
+};
+
+struct GNUNET_MESSENGER_ListMessages
+{
+  struct GNUNET_MESSENGER_ListMessage *head;
+  struct GNUNET_MESSENGER_ListMessage *tail;
+};
+
+/**
+ * Initializes list of message hashes as empty list.
+ *
+ * @param[out] messages List of hashes
+ */
+void
+init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
+
+/**
+ * Clears the list of message hashes.
+ *
+ * @param[in,out] messages List of hashes
+ */
+void
+clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
+
+/**
+ * Adds a specific <i>hash</i> from a message to the end of the list.
+ *
+ * @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[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 (const struct GNUNET_MESSENGER_ListMessages *messages,
+                    const char *path);
+
+#endif //GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
diff --git a/src/service/messenger/gnunet-service-messenger_member.c b/src/service/messenger/gnunet-service-messenger_member.c
new file mode 100644
index 000000000..0940c42ce
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member.c
@@ -0,0 +1,462 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "platform.h"
+#include "gnunet-service-messenger_member.h"
+
+#include "gnunet-service-messenger_member_session.h"
+
+#include "messenger_api_util.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 enum GNUNET_GenericReturnValue
+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 enum GNUNET_GenericReturnValue
+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);
+    GNUNET_free (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;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n",
+              config_file);
+
+  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 enum GNUNET_GenericReturnValue
+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 enum GNUNET_GenericReturnValue
+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");
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n",
+              config_file);
+
+  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 enum GNUNET_GenericReturnValue
+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_CRYPTO_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 enum GNUNET_GenericReturnValue
+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_CRYPTO_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_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_CRYPTO_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_CRYPTO_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 enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_member.h b/src/service/messenger/gnunet-service-messenger_member.h
new file mode 100644
index 000000000..0e5afaa6a
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member.h
@@ -0,0 +1,175 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "gnunet-service-messenger_member_store.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
+ * @return Member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+get_member_session (const struct GNUNET_MESSENGER_Member *member,
+                    const struct GNUNET_CRYPTO_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/service/messenger/gnunet-service-messenger_member_session.c b/src/service/messenger/gnunet-service-messenger_member_session.c
new file mode 100644
index 000000000..ed1fd75b7
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member_session.c
@@ -0,0 +1,866 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021--2023 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_CRYPTO_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);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Check session history (%s) for completion.\n",
+              GNUNET_sh2s (get_member_session_id (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_srv_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_log (GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
+                GNUNET_sh2s (get_member_session_id (session)));
+
+    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 enum GNUNET_GenericReturnValue
+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);
+}
+
+
+enum GNUNET_GenericReturnValue
+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);
+}
+
+
+enum GNUNET_GenericReturnValue
+is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession *session)
+{
+  GNUNET_assert (session);
+
+  return session->closed;
+}
+
+
+enum GNUNET_GenericReturnValue
+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_CRYPTO_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;
+}
+
+
+enum GNUNET_GenericReturnValue
+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))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using history!\n",
+                GNUNET_h2s (hash));
+
+    if (GNUNET_YES == check_member_session_history (session, hash, GNUNET_YES))
+      return GNUNET_OK;
+    else
+      return GNUNET_SYSERR;
+  }
+
+  if (0 != GNUNET_memcmp (get_member_session_id (session),
+                          &(message->header.sender_id)))
+    return GNUNET_SYSERR;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
+              GNUNET_h2s (hash),
+              GNUNET_CRYPTO_public_key_to_string (
+                get_member_session_public_key (session)));
+
+  return verify_message (message, hash, get_member_session_public_key (
+                           session));
+}
+
+
+enum GNUNET_GenericReturnValue
+check_member_session_history (const struct
+                              GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash,
+                              enum GNUNET_GenericReturnValue 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,
+                             enum GNUNET_GenericReturnValue 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;
+
+  enum GNUNET_GenericReturnValue 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;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Load session configuration of member: %s\n", config_file);
+
+  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_CRYPTO_PublicKey key;
+
+    enum GNUNET_GenericReturnValue key_return =
+      GNUNET_CRYPTO_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;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Load next session configuration of member: %s\n", config_file);
+
+  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_CRYPTO_PublicKey next_key;
+
+    enum GNUNET_GenericReturnValue key_return =
+      GNUNET_CRYPTO_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 enum GNUNET_GenericReturnValue
+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");
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Save session configuration of member: %s\n", config_file);
+
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+  char *key_data = GNUNET_CRYPTO_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_CRYPTO_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/service/messenger/gnunet-service-messenger_member_session.h b/src/service/messenger/gnunet-service-messenger_member_session.h
new file mode 100644
index 000000000..8cd944afa
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member_session.h
@@ -0,0 +1,296 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021--2024 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 "gnunet_util_lib.h"
+#include "gnunet_time_lib.h"
+
+#include "gnunet-service-messenger_list_messages.h"
+#include "gnunet-service-messenger_member.h"
+
+#include "messenger_api_contact.h"
+
+struct GNUNET_MESSENGER_MemberSession
+{
+  struct GNUNET_MESSENGER_Member *member;
+
+  struct GNUNET_CRYPTO_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;
+
+  enum GNUNET_GenericReturnValue closed;
+  enum GNUNET_GenericReturnValue 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
+ * @return New member session
+ */
+struct GNUNET_MESSENGER_MemberSession*
+create_member_session (struct GNUNET_MESSENGER_Member *member,
+                       const struct GNUNET_CRYPTO_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
+ */
+enum GNUNET_GenericReturnValue
+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
+ */
+enum GNUNET_GenericReturnValue
+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
+ */
+enum GNUNET_GenericReturnValue
+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 of a given member <i>session</i>.
+ *
+ * @param[in] session Member session
+ * @return Public key
+ */
+const struct GNUNET_CRYPTO_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);
+
+/**
+ * Returns 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
+ */
+enum GNUNET_GenericReturnValue
+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
+ */
+enum GNUNET_GenericReturnValue
+check_member_session_history (const struct
+                              GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_HashCode *hash,
+                              enum GNUNET_GenericReturnValue 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/service/messenger/gnunet-service-messenger_member_store.c b/src/service/messenger/gnunet-service-messenger_member_store.c
new file mode 100644
index 000000000..77e816c2e
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member_store.c
@@ -0,0 +1,315 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "platform.h"
+#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"
+
+#include "messenger_api_message.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 enum GNUNET_GenericReturnValue
+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_log (GNUNET_ERROR_TYPE_DEBUG, "Clear member store of room: %s\n",
+              GNUNET_h2s (get_srv_room_key (store->room)));
+
+  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_srv_room_key ((const struct
+                            GNUNET_MESSENGER_SrvRoom*) store->room);
+}
+
+
+static enum GNUNET_GenericReturnValue
+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 enum GNUNET_GenericReturnValue
+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 enum GNUNET_GenericReturnValue
+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);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load member store from directory: %s\n",
+              scan_dir);
+
+  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 enum GNUNET_GenericReturnValue
+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);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save member store to directory: %s\n",
+              save_dir);
+
+  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)
+{
+  GNUNET_assert ((store) && (message));
+
+  if (GNUNET_YES == is_peer_message (message))
+    return NULL;
+
+  if (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;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added store member with id: %s\n",
+              GNUNET_sh2s (get_member_id (member)));
+
+  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/service/messenger/gnunet-service-messenger_member_store.h b/src/service/messenger/gnunet-service-messenger_member_store.h
new file mode 100644
index 000000000..181593e6b
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_member_store.h
@@ -0,0 +1,158 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "gnunet_util_lib.h"
+
+#include "gnunet_messenger_service.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 enum GNUNET_GenericReturnValue (*GNUNET_MESSENGER_MemberIteratorCallback) (
+  void *cls,
+  const struct GNUNET_CRYPTO_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 message is a peer message or 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/service/messenger/gnunet-service-messenger_message_handle.c b/src/service/messenger/gnunet-service-messenger_message_handle.c
new file mode 100644
index 000000000..ee099d893
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_handle.c
@@ -0,0 +1,185 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_handle.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_handle.h"
+
+#include "gnunet-service-messenger_room.h"
+
+static void
+handle_member_session_switch (struct GNUNET_MESSENGER_MemberSession *session,
+                              const struct GNUNET_MESSENGER_Message *message,
+                              const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_MemberSession *next = switch_member_session (session,
+                                                                       message,
+                                                                       hash);
+
+  if (next != session)
+    add_member_session (next->member, next);
+}
+
+
+void
+handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_SenderSession *session,
+                     const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member (%s) joins room (%s).\n",
+              GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s (
+                get_srv_room_key (room)));
+
+  if (GNUNET_OK != reset_member_session (session->member, hash))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Resetting member session failed!\n");
+
+  solve_srv_room_member_collisions (
+    room,
+    &(message->body.join.key),
+    &(message->header.sender_id),
+    GNUNET_TIME_absolute_ntoh (message->header.timestamp)
+    );
+}
+
+
+void
+handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room,
+                      struct GNUNET_MESSENGER_SenderSession *session,
+                      const struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_HashCode *hash)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member (%s) leaves room (%s).\n",
+              GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s (
+                get_srv_room_key (room)));
+
+  close_member_session (session->member);
+}
+
+
+void
+handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
+                    struct GNUNET_MESSENGER_SenderSession *session,
+                    const struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash)
+{
+  handle_member_session_switch (session->member, message, hash);
+}
+
+
+void
+handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_SenderSession *session,
+                     const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_PeerStore *store = get_srv_room_peer_store (room);
+
+  if (0 == GNUNET_memcmp (session->peer, &(message->body.peer.peer)))
+    update_store_peer (store, &(message->body.peer.peer), GNUNET_YES);
+
+  if (GNUNET_NO == contains_list_tunnels (&(room->basement),
+                                          &(message->body.peer.peer)))
+    add_to_list_tunnels (&(room->basement), &(message->body.peer.peer), hash);
+
+  if (room->peer_message)
+    rebuild_srv_room_basement_structure (room);
+}
+
+
+void
+handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SenderSession *session,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  handle_member_session_switch (session->member, message, hash);
+
+  solve_srv_room_member_collisions (
+    room,
+    get_member_session_public_key (session->member),
+    &(message->body.id.id),
+    GNUNET_TIME_absolute_ntoh (message->header.timestamp)
+    );
+}
+
+
+void
+handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_SenderSession *session,
+                     const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_PeerStore *store = get_srv_room_peer_store (room);
+
+  if (0 == GNUNET_memcmp (session->peer, &(message->body.miss.peer)))
+    update_store_peer (store, &(message->body.miss.peer), GNUNET_NO);
+
+  struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (
+    &(room->basement), &(message->body.miss.peer), NULL);
+
+  if (! element)
+    return;
+
+  remove_from_list_tunnels (&(room->basement), element);
+
+  if (room->peer_message)
+    rebuild_srv_room_basement_structure (room);
+}
+
+
+void
+handle_message_delete (struct GNUNET_MESSENGER_SrvRoom *room,
+                       struct GNUNET_MESSENGER_SenderSession *session,
+                       const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_TIME_Relative delay = GNUNET_TIME_relative_ntoh (
+    message->body.deletion.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_srv_room_message (room, session->member,
+                           &(message->body.deletion.hash), delay);
+}
+
+
+void
+handle_message_connection (struct GNUNET_MESSENGER_SrvRoom *room,
+                           struct GNUNET_MESSENGER_SenderSession *session,
+                           const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (
+    &(room->basement), session->peer, NULL);
+
+  if (! element)
+    return;
+
+  memcpy (&(element->connection), &(message->body.connection),
+          sizeof (struct GNUNET_MESSENGER_MessageConnection));
+}
diff --git a/src/service/messenger/gnunet-service-messenger_message_handle.h b/src/service/messenger/gnunet-service-messenger_message_handle.h
new file mode 100644
index 000000000..a66c45192
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_handle.h
@@ -0,0 +1,151 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_handle.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
+
+#include "gnunet-service-messenger_sender_session.h"
+
+/**
+ * Handles a received or sent join message to make changes of current member information.
+ * (add matching member and clear member info)
+ *
+ * @param[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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[in,out] room Room of the message
+ * @param[in,out] session Sender 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_SenderSession *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 Sender 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_SenderSession *session,
+                       const struct GNUNET_MESSENGER_Message *message,
+                       const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent connection message to update connection information about a peer.
+ * (update a peer in the basement)
+ *
+ * @param[in,out] room Room of the message
+ * @param[in,out] session Sender session
+ * @param[in] message DELETE-Message
+ * @param[in] hash Hash of the message
+ */
+void
+handle_message_connection (struct GNUNET_MESSENGER_SrvRoom *room,
+                           struct GNUNET_MESSENGER_SenderSession *session,
+                           const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
diff --git a/src/service/messenger/gnunet-service-messenger_message_kind.c b/src/service/messenger/gnunet-service-messenger_message_kind.c
new file mode 100644
index 000000000..f1a79b321
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_kind.c
@@ -0,0 +1,129 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_kind.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_kind.h"
+
+#include "gnunet-service-messenger_room.h"
+
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_Message*
+create_message_info (struct GNUNET_MESSENGER_Service *service)
+{
+  if (! service)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_INFO);
+
+  if (! message)
+    return NULL;
+
+  message->body.info.messenger_version = GNUNET_MESSENGER_VERSION;
+
+  return message;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+create_message_peer (struct GNUNET_MESSENGER_Service *service)
+{
+  if (! service)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_PEER);
+
+  if (! message)
+    return NULL;
+
+  if (GNUNET_OK == get_service_peer_identity (service,
+                                              &(message->body.peer.peer)))
+    return message;
+  else
+  {
+    destroy_message (message);
+    return NULL;
+  }
+}
+
+
+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)
+  {
+    return NULL;
+  }
+
+  GNUNET_memcpy (&(message->body.miss.peer), peer, sizeof(struct
+                                                          GNUNET_PeerIdentity));
+
+  return message;
+}
+
+
+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)
+    return NULL;
+
+  GNUNET_memcpy (&(message->body.merge.previous), previous, sizeof(struct
+                                                                   GNUNET_HashCode));
+
+  return message;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+create_message_connection (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  if (! room)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_CONNECTION);
+
+  if (! message)
+    return NULL;
+
+  message->body.connection.amount = get_srv_room_amount_of_tunnels (room);
+  message->body.connection.flags = get_srv_room_connection_flags (room);
+
+  return message;
+}
diff --git a/src/service/messenger/gnunet-service-messenger_message_kind.h b/src/service/messenger/gnunet-service-messenger_message_kind.h
new file mode 100644
index 000000000..7fc7a7cc0
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_kind.h
@@ -0,0 +1,86 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_kind.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
+
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-messenger_service.h"
+
+/**
+ * Creates and allocates a new info message containing the hosts service peer identity and version.
+ * (all values are stored as copy)
+ *
+ * @param[in,out] service Service
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_info (struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Creates and allocates a new peer message containing a services peer identity.
+ * (all values are stored as copy)
+ *
+ * @param[in,out] service Service
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_peer (struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Creates and allocates a new miss message containing the missing <i>peer</i> identity.
+ * (all values are stored as copy)
+ *
+ * @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 <i>previous</i> message
+ * besides the regular previous message mentioned in a messages header.
+ * (all values are stored as copy)
+ *
+ * @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 connection message containing the amount of the peer's connections
+ * in a given <i>room</i> as well as flags from the peer about its connections.
+ * (all values are stored as copy)
+ *
+ * @param[in] room Room
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_connection (const struct GNUNET_MESSENGER_SrvRoom *room);
+
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
diff --git a/src/service/messenger/gnunet-service-messenger_message_recv.c b/src/service/messenger/gnunet-service-messenger_message_recv.c
new file mode 100644
index 000000000..6d4d537b6
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_recv.c
@@ -0,0 +1,246 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_recv.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_recv.h"
+
+#include "gnunet-service-messenger_basement.h"
+#include "gnunet-service-messenger_message_kind.h"
+#include "gnunet-service-messenger_operation.h"
+
+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);
+
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_room_message_store (room);
+  struct GNUNET_MESSENGER_ListMessage *element;
+
+  for (element = session->messages.head; element; element = element->next)
+  {
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map,
+                                                              &(element->hash)))
+      continue;
+
+    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");
+
+    const struct GNUNET_MESSENGER_Message *message = get_store_message (
+      message_store, &(element->hash));
+
+    if (message)
+      forward_tunnel_message (tunnel, message, &(element->hash));
+  }
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_forward_members (void *cls,
+                         const struct GNUNET_CRYPTO_PublicKey *public_key,
+                         struct GNUNET_MESSENGER_MemberSession *session)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (GNUNET_YES == is_member_session_completed (session))
+    return GNUNET_YES;
+
+  struct GNUNET_CONTAINER_MultiHashMap *map =
+    GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
+
+  forward_about_members (tunnel->room, tunnel, session, map);
+
+  GNUNET_CONTAINER_multihashmap_destroy (map);
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+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 uint32_t version = get_tunnel_messenger_version (tunnel);
+
+  if (GNUNET_OK != update_tunnel_messenger_version (tunnel,
+                                                    message->body.info.
+                                                    messenger_version))
+  {
+    disconnect_tunnel (tunnel);
+    return GNUNET_NO;
+  }
+
+  if (version == get_tunnel_messenger_version (tunnel))
+    return GNUNET_NO;
+
+  if (room->host)
+    send_tunnel_message (tunnel, room->host, create_message_info (
+                           room->service));
+
+  struct GNUNET_PeerIdentity peer;
+  get_tunnel_peer_identity (tunnel, &peer);
+
+  if (GNUNET_YES != contains_list_tunnels (&(room->basement), &peer))
+  {
+    struct GNUNET_MESSENGER_MessageStore *message_store =
+      get_srv_room_message_store (room);
+
+    struct GNUNET_MESSENGER_ListTunnel *element;
+    for (element = room->basement.head; element; element = element->next)
+    {
+      if (! element->hash)
+        continue;
+
+      const struct GNUNET_MESSENGER_Message *message = get_store_message (
+        message_store, element->hash);
+
+      if (message)
+        forward_tunnel_message (tunnel, message, element->hash);
+    }
+  }
+
+  if (GNUNET_YES != contains_list_tunnels (&(room->basement), &peer))
+  {
+    struct GNUNET_MESSENGER_MemberStore *member_store =
+      get_srv_room_member_store (room);
+
+    iterate_store_members (member_store, iterate_forward_members, tunnel);
+  }
+
+  check_srv_room_peer_status (room, tunnel);
+  return GNUNET_NO;
+}
+
+
+enum GNUNET_GenericReturnValue
+recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_PeerIdentity peer;
+  GNUNET_PEER_resolve (tunnel->peer, &peer);
+
+  if (0 == GNUNET_memcmp (&peer, &(message->body.peer.peer)))
+  {
+    if (! tunnel->peer_message)
+      tunnel->peer_message = GNUNET_new (struct GNUNET_HashCode);
+
+    GNUNET_memcpy (tunnel->peer_message, &hash, sizeof(hash));
+  }
+
+  update_to_list_tunnels (&(room->basement), &(message->body.peer.peer), hash);
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Service *service = room->service;
+
+  if ((GNUNET_YES == service->auto_routing) &&
+      (service->min_routers > count_of_tunnels (&(room->basement))))
+    open_srv_room (room, NULL);
+
+  return GNUNET_YES;
+}
+
+
+static void
+callback_found_message (void *cls,
+                        struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (! message)
+  {
+    struct GNUNET_MESSENGER_OperationStore *operation_store =
+      get_srv_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);
+}
+
+
+/*
+ * Function returns GNUNET_NO to drop forwarding the request.
+ * It will only be forwarded if it can't be answered!
+ */
+enum GNUNET_GenericReturnValue
+recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room,
+                      struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      const struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_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,
+                                                                  &(message->
+                                                                    body.request
+                                                                    .hash),
+                                                                  GNUNET_NO)))
+    return GNUNET_NO;
+
+  if (GNUNET_NO == request_srv_room_message (room,
+                                             &(message->body.request.hash),
+                                             session, callback_found_message,
+                                             tunnel))
+    return GNUNET_YES;
+
+  return GNUNET_NO;
+}
diff --git a/src/service/messenger/gnunet-service-messenger_message_recv.h b/src/service/messenger/gnunet-service-messenger_message_recv.h
new file mode 100644
index 000000000..58eb1d5cc
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_recv.h
@@ -0,0 +1,96 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_recv.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
+
+#include "gnunet-service-messenger_tunnel.h"
+
+/**
+ * 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[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
+ */
+enum GNUNET_GenericReturnValue
+recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   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)
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received miss message to react to activity in the basement of a room.
+ * (the miss message can cause automatic opening of the room)
+ *
+ * @param[in,out] room Room of the message
+ * @param[in,out] tunnel Receiving connection
+ * @param[in] message MISS-Message
+ * @param[in] hash Hash of the message
+ * @return #GNUNET_YES to forward the message
+ */
+enum GNUNET_GenericReturnValue
+recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   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)
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room,
+                      struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      const struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
diff --git a/src/service/messenger/gnunet-service-messenger_message_send.c b/src/service/messenger/gnunet-service-messenger_message_send.c
new file mode 100644
index 000000000..05032e455
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_send.c
@@ -0,0 +1,220 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_send.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_send.h"
+
+#include "gnunet-service-messenger_handle.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_operation.h"
+#include "gnunet-service-messenger_room.h"
+#include "gnunet_common.h"
+
+struct GNUNET_MESSENGER_MemberNotify
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_MemberSession *session;
+};
+
+static void
+notify_about_members (struct GNUNET_MESSENGER_MemberNotify *notify,
+                      struct GNUNET_MESSENGER_MemberSession *session,
+                      struct GNUNET_CONTAINER_MultiHashMap *map,
+                      enum GNUNET_GenericReturnValue check_permission)
+{
+  if (session->prev)
+    notify_about_members (notify, session->prev, map, GNUNET_YES);
+
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_room_message_store (notify->room);
+  struct GNUNET_MESSENGER_ListMessage *element;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Notify through all of member session: %s\n",
+              GNUNET_sh2s (get_member_session_id (session)));
+
+  for (element = session->messages.head; element; element = element->next)
+  {
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map,
+                                                              &(element->hash)))
+      continue;
+
+    if ((GNUNET_YES == check_permission) &&
+        (GNUNET_YES != check_member_session_history (notify->session,
+                                                     &(element->hash),
+                                                     GNUNET_NO)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Permission for notification of session message denied!\n");
+      continue;
+    }
+
+    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) || (GNUNET_YES == is_peer_message (message)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Session message for notification is invalid!\n");
+      continue;
+    }
+
+    struct GNUNET_MESSENGER_SenderSession sender;
+    sender.member = session;
+
+    notify_srv_handle_message (notify->handle, notify->room, &sender, message,
+                               &(element->hash), GNUNET_NO);
+  }
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_notify_about_members (void *cls,
+                              const struct
+                              GNUNET_CRYPTO_PublicKey *public_key,
+                              struct GNUNET_MESSENGER_MemberSession *session)
+{
+  struct GNUNET_MESSENGER_MemberNotify *notify = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Notify about member session: %s\n",
+              GNUNET_sh2s (get_member_session_id (session)));
+
+  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;
+}
+
+
+void
+send_message_join (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvHandle *handle,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  set_srv_handle_key (handle, &(message->body.join.key));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+                                                             &(message->header.
+                                                               sender_id));
+
+  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of (
+    member, message, hash);
+
+  if (! session)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "A valid session is required to join a room!\n");
+    goto skip_member_notification;
+  }
+
+  struct GNUNET_MESSENGER_MemberNotify notify;
+
+  notify.room = room;
+  notify.handle = handle;
+  notify.session = session;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Notify about all member sessions except: %s\n",
+              GNUNET_sh2s (get_member_session_id (session)));
+
+  iterate_store_members (get_srv_room_member_store (room),
+                         iterate_notify_about_members, &notify);
+
+skip_member_notification:
+  check_srv_room_peer_status (room, NULL);
+}
+
+
+void
+send_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
+                  struct GNUNET_MESSENGER_SrvHandle *handle,
+                  const struct GNUNET_MESSENGER_Message *message,
+                  const struct GNUNET_HashCode *hash)
+{
+  set_srv_handle_key (handle, &(message->body.key.key));
+}
+
+
+void
+send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvHandle *handle,
+                   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));
+
+  send_srv_room_message (room, room->host, create_message_connection (room));
+}
+
+
+void
+send_message_id (struct GNUNET_MESSENGER_SrvRoom *room,
+                 struct GNUNET_MESSENGER_SrvHandle *handle,
+                 const struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_HashCode *hash)
+{
+  change_srv_handle_member_id (handle, get_srv_room_key (room),
+                               &(message->body.id.id));
+}
+
+
+void
+send_message_request (struct GNUNET_MESSENGER_SrvRoom *room,
+                      struct GNUNET_MESSENGER_SrvHandle *handle,
+                      const struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_OperationStore *operation_store =
+    get_srv_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/service/messenger/gnunet-service-messenger_message_send.h b/src/service/messenger/gnunet-service-messenger_message_send.h
new file mode 100644
index 000000000..ee4d8b0a4
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_send.h
@@ -0,0 +1,105 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_send.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
+
+#include "gnunet-service-messenger_room.h"
+
+/**
+ * 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[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,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent key message to ensure changes to the public key of the sending handle.
+ *
+ * @param[in,out] room Room of the message
+ * @param[in,out] handle Sending handle
+ * @param[in] message KEY-Message
+ * @param[in] hash Hash of the message
+ */
+void
+send_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
+                  struct GNUNET_MESSENGER_SrvHandle *handle,
+                  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[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,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent id message to update the handles member id in the room.
+ * (changing member id is useful to prevent collisions)
+ *
+ * @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,
+                 const struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent request message to trigger the request operation for this service.
+ * (the request operation will deactivate the possibility of spamming requests)
+ *
+ * @param[in,out] room Room of the message
+ * @param[in,out] handle Sending handle
+ * @param[in] message REQUEST-Message
+ * @param[in] hash Hash of the message
+ */
+void
+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/service/messenger/gnunet-service-messenger_message_state.c b/src/service/messenger/gnunet-service-messenger_message_state.c
new file mode 100644
index 000000000..7229eb6ba
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_state.c
@@ -0,0 +1,119 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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,
+                      enum GNUNET_GenericReturnValue 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/service/messenger/gnunet-service-messenger_message_state.h b/src/service/messenger/gnunet-service-messenger_message_state.h
new file mode 100644
index 000000000..9723c7654
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_state.h
@@ -0,0 +1,66 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "gnunet_messenger_service.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,
+                      enum GNUNET_GenericReturnValue 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/service/messenger/gnunet-service-messenger_message_store.c b/src/service/messenger/gnunet-service-messenger_message_store.c
new file mode 100644
index 000000000..1eb275f9b
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_store.c
@@ -0,0 +1,677 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_store.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_store.h"
+#include "messenger_api_message.h"
+
+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 enum GNUNET_GenericReturnValue
+iterate_destroy_entries (void *cls,
+                         const struct GNUNET_HashCode *key,
+                         void *value)
+{
+  struct GNUNET_MESSENGER_MessageEntry *entry = value;
+
+  GNUNET_free (entry);
+
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_messages (void *cls,
+                          const struct GNUNET_HashCode *key,
+                          void *value)
+{
+  struct GNUNET_MESSENGER_Message *message = value;
+
+  destroy_message (message);
+
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+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);
+
+    store->storage_messages = NULL;
+  }
+
+  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
+{
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_MessageEntry entry;
+};
+
+#define load_message_store_attribute_failed(file, attribute) \
+        sizeof(attribute) != GNUNET_DISK_file_read (file, &(attribute), \
+                                                    sizeof(attribute))
+
+#define save_message_store_attribute_failed(file, attribute) \
+        sizeof(attribute) != GNUNET_DISK_file_write (file, &(attribute), \
+                                                     sizeof(attribute))
+
+static void
+load_message_store_entries (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_MessageEntryStorage storage;
+  struct GNUNET_MESSENGER_MessageEntry *entry;
+
+  memset (&storage, 0, sizeof(storage));
+
+  do
+  {
+    entry = NULL;
+
+    if ((load_message_store_attribute_failed (entries, storage.hash)) ||
+        (load_message_store_attribute_failed (entries, storage.entry.offset)) ||
+        (load_message_store_attribute_failed (entries, storage.entry.length)))
+      break;
+
+    entry = GNUNET_new (struct GNUNET_MESSENGER_MessageEntry);
+
+    GNUNET_memcpy (entry, &(storage.entry), sizeof(*entry));
+
+    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;
+      break;
+    }
+  }
+  while (entry);
+
+  if (entry)
+    GNUNET_free (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;
+
+  memset (&storage, 0, sizeof(storage));
+
+  do
+  {
+    link = NULL;
+
+    if ((load_message_store_attribute_failed (entries, storage.hash)) ||
+        (load_message_store_attribute_failed (entries,
+                                              storage.link.multiple)) ||
+        (load_message_store_attribute_failed (entries, storage.link.first)) ||
+        ((GNUNET_YES == storage.link.multiple) &&
+         (load_message_store_attribute_failed (entries, 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);
+
+  GNUNET_free (filename);
+}
+
+
+struct GNUNET_MESSENGER_ClosureMessageSave
+{
+  struct GNUNET_MESSENGER_MessageStore *store;
+
+  struct GNUNET_DISK_FileHandle *storage;
+};
+
+static enum GNUNET_GenericReturnValue
+iterate_save_entries (void *cls,
+                      const struct GNUNET_HashCode *key,
+                      void *value)
+{
+  struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
+  struct GNUNET_MESSENGER_MessageEntry *entry = value;
+
+  GNUNET_DISK_file_write (save->storage, key, sizeof(*key));
+  GNUNET_DISK_file_write (save->storage, &(entry->offset),
+                          sizeof(entry->offset));
+  GNUNET_DISK_file_write (save->storage, &(entry->length),
+                          sizeof(entry->length));
+
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_save_messages (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
+{
+  struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
+
+  if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (save->store->entries,
+                                                           key))
+    return GNUNET_YES;
+
+  struct GNUNET_MESSENGER_Message *message = value;
+  struct GNUNET_MESSENGER_MessageEntryStorage storage;
+
+  GNUNET_memcpy (&(storage.hash), key, sizeof(storage.hash));
+
+  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) ||
+      (save_message_store_attribute_failed (save->storage, storage.hash)) ||
+      (save_message_store_attribute_failed (save->storage,
+                                            storage.entry.offset)) ||
+      (save_message_store_attribute_failed (save->storage,
+                                            storage.entry.length)))
+    return GNUNET_YES;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message with hash: %s\n",
+              GNUNET_h2s (&(storage.hash)));
+
+  char *buffer = GNUNET_malloc (storage.entry.length);
+
+  encode_message (message, storage.entry.length, buffer, GNUNET_YES);
+
+  GNUNET_DISK_file_write (save->store->storage_messages, buffer,
+                          storage.entry.length);
+
+  GNUNET_free (buffer);
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+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)
+{
+  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 = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE
+                                        | GNUNET_DISK_OPEN_CREATE, permission);
+
+  GNUNET_free (filename);
+
+  if (! save.storage)
+    return;
+
+  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)
+    GNUNET_DISK_file_close (store->storage_messages);
+
+  GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
+
+  store->storage_messages = GNUNET_DISK_file_open (filename,
+                                                   GNUNET_DISK_OPEN_READWRITE
+                                                   | GNUNET_DISK_OPEN_CREATE,
+                                                   permission);
+
+  GNUNET_free (filename);
+
+  if (store->storage_messages)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (store->messages,
+                                           iterate_save_messages, &save);
+
+    GNUNET_DISK_file_sync (store->storage_messages);
+    GNUNET_DISK_file_sync (save.storage);
+  }
+
+close_entries:
+  GNUNET_DISK_file_close (save.storage);
+}
+
+
+enum GNUNET_GenericReturnValue
+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;
+
+  return GNUNET_CONTAINER_multihashmap_contains (store->entries, hash);
+}
+
+
+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)
+    return message;
+
+  if (! store->storage_messages)
+    return NULL;
+
+  const struct GNUNET_MESSENGER_MessageEntry *entry =
+    GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
+
+  if (! entry)
+    return NULL;
+
+  if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages,
+                                              entry->offset,
+                                              GNUNET_DISK_SEEK_SET))
+    return message;
+
+  char *buffer = GNUNET_malloc (entry->length);
+
+  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,
+                                              GNUNET_YES)))
+    goto free_buffer;
+
+  message = create_message (GNUNET_MESSENGER_KIND_UNKNOWN);
+
+  enum GNUNET_GenericReturnValue decoding;
+  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))
+  {
+    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));
+
+    store->rewrite_entries = GNUNET_YES;
+
+    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,
+                        enum GNUNET_GenericReturnValue 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);
+}
+
+
+enum GNUNET_GenericReturnValue
+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);
+  else
+    store->write_links = GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_message_store.h b/src/service/messenger/gnunet-service-messenger_message_store.h
new file mode 100644
index 000000000..9daf8fd11
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_message_store.h
@@ -0,0 +1,167 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
+
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_MessageEntry
+{
+  off_t offset;
+  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;
+
+  enum GNUNET_GenericReturnValue rewrite_entries;
+  enum GNUNET_GenericReturnValue write_links;
+};
+
+/**
+ * Initializes a message <i>store</i> as fully empty.
+ *
+ * @param[out] store Message store
+ */
+void
+init_message_store (struct GNUNET_MESSENGER_MessageStore *store);
+
+/**
+ * Clears a message <i>store</i>, wipes its content and deallocates its memory.
+ *
+ * @param[in,out] store Message store
+ */
+void
+clear_message_store (struct GNUNET_MESSENGER_MessageStore *store);
+
+/**
+ * Loads messages from a <i>directory</i> into a message <i>store</i>.
+ *
+ * @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 <i>store</i> into a <i>directory</i>.
+ *
+ * @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 <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[in] store Message store
+ * @param[in] hash Hash of message
+ * @return #GNUNET_YES on match, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+contains_store_message (const struct GNUNET_MESSENGER_MessageStore *store,
+                        const struct GNUNET_HashCode *hash);
+
+/**
+ * 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[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,
+                        enum GNUNET_GenericReturnValue deleted_only);
+
+/**
+ * Stores a message into the message store. The result indicates if the operation was successful.
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+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
+ */
+enum GNUNET_GenericReturnValue
+delete_store_message (struct GNUNET_MESSENGER_MessageStore *store,
+                      const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
diff --git a/src/service/messenger/gnunet-service-messenger_operation.c b/src/service/messenger/gnunet-service-messenger_operation.c
new file mode 100644
index 000000000..66cefb9ac
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_operation.c
@@ -0,0 +1,238 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021, 2023 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));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load operation configuration: %s\n",
+              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));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save operation configuration: %s\n",
+              path);
+
+  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));
+}
+
+
+enum GNUNET_GenericReturnValue
+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;
+}
+
+
+enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_operation.h b/src/service/messenger/gnunet-service-messenger_operation.h
new file mode 100644
index 000000000..26282bea8
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_operation.h
@@ -0,0 +1,128 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021--2024 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 "gnunet_util_lib.h"
+#include "gnunet_scheduler_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 operation 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
+ */
+enum GNUNET_GenericReturnValue
+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
+ */
+enum GNUNET_GenericReturnValue
+stop_operation (struct GNUNET_MESSENGER_Operation *op);
+
+#endif //GNUNET_SERVICE_MESSENGER_OPERATION_H
diff --git a/src/service/messenger/gnunet-service-messenger_operation_store.c b/src/service/messenger/gnunet-service-messenger_operation_store.c
new file mode 100644
index 000000000..630ed6dbd
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_operation_store.c
@@ -0,0 +1,268 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021--2024 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 "platform.h"
+#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 enum GNUNET_GenericReturnValue
+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_log (GNUNET_ERROR_TYPE_DEBUG, "Clear operation store of room: %s\n",
+              GNUNET_h2s (get_srv_room_key (store->room)));
+
+  GNUNET_CONTAINER_multihashmap_iterate (store->operations,
+                                         iterate_destroy_operations, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (store->operations);
+}
+
+
+static enum GNUNET_GenericReturnValue
+callback_scan_for_operations (void *cls,
+                              const char *filename)
+{
+  struct GNUNET_MESSENGER_OperationStore *store = cls;
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+    return GNUNET_OK;
+
+  if ((strlen (filename) <= 4) || (0 != strcmp (filename + strlen (filename)
+                                                - 4, ".cfg")))
+    return GNUNET_OK;
+
+  struct GNUNET_MESSENGER_Operation *op = load_operation (store, filename);
+
+  if ((op) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
+                 store->operations,
+                 &(op->hash), op,
+                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  {
+    destroy_operation (op);
+  }
+
+  return GNUNET_OK;
+}
+
+
+void
+load_operation_store (struct GNUNET_MESSENGER_OperationStore *store,
+                      const char *directory)
+{
+  GNUNET_assert ((store) && (directory));
+
+  char *load_dir;
+  GNUNET_asprintf (&load_dir, "%s%s%c", directory, "operations", DIR_SEPARATOR);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Load operation store from directory: %s\n",
+              load_dir);
+
+  if (GNUNET_OK == GNUNET_DISK_directory_test (load_dir, GNUNET_YES))
+    GNUNET_DISK_directory_scan (load_dir, callback_scan_for_operations, store);
+
+  GNUNET_free (load_dir);
+}
+
+
+static enum GNUNET_GenericReturnValue
+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);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Save operation store to directory: %s\n",
+              save_dir);
+
+  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;
+}
+
+
+enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_operation_store.h b/src/service/messenger/gnunet-service-messenger_operation_store.h
new file mode 100644
index 000000000..9b1c3259a
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_operation_store.h
@@ -0,0 +1,129 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021, 2023 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 "gnunet_util_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);
+
+/**
+ * Returns 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
+ */
+enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_peer_store.c b/src/service/messenger/gnunet-service-messenger_peer_store.c
new file mode 100644
index 000000000..fdfbf599b
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_peer_store.c
@@ -0,0 +1,384 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2023--2024 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_peer_store.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_peer_store.h"
+
+#include "gnunet-service-messenger_service.h"
+#include "gnunet_common.h"
+#include "messenger_api_message.h"
+#include "messenger_api_util.h"
+
+struct GNUNET_MESSENGER_PeerStoreEntry
+{
+  struct GNUNET_PeerIdentity peer;
+  enum GNUNET_GenericReturnValue active;
+};
+
+void
+init_peer_store (struct GNUNET_MESSENGER_PeerStore *store,
+                 struct GNUNET_MESSENGER_Service *service)
+{
+  GNUNET_assert ((store) && (service));
+
+  store->service = service;
+  store->peers = GNUNET_CONTAINER_multishortmap_create (4, GNUNET_NO);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_peers (void *cls, const struct GNUNET_ShortHashCode *id,
+                       void *value)
+{
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry = value;
+  GNUNET_free (entry);
+  return GNUNET_YES;
+}
+
+
+void
+clear_peer_store (struct GNUNET_MESSENGER_PeerStore *store)
+{
+  GNUNET_assert ((store) && (store->peers));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Clear peer store\n");
+
+  GNUNET_CONTAINER_multishortmap_iterate (store->peers, iterate_destroy_peers,
+                                          NULL);
+  GNUNET_CONTAINER_multishortmap_destroy (store->peers);
+
+  store->peers = NULL;
+}
+
+
+void
+load_peer_store (struct GNUNET_MESSENGER_PeerStore *store,
+                 const char *path)
+{
+  GNUNET_assert ((store) && (path));
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (path))
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load peer store from path: %s\n",
+              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_READ, permission
+    );
+
+  if (! handle)
+    return;
+
+  GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
+
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
+  struct GNUNET_ShortHashCode peer_id;
+  struct GNUNET_PeerIdentity peer;
+  ssize_t len;
+
+  do {
+    len = GNUNET_DISK_file_read (handle, &peer, sizeof(peer));
+
+    if (len != sizeof(peer))
+      break;
+
+
+    entry = GNUNET_new (struct GNUNET_MESSENGER_PeerStoreEntry);
+
+    if (! entry)
+      continue;
+
+    GNUNET_memcpy (&(entry->peer), &peer, sizeof(entry->peer));
+    entry->active = GNUNET_YES;
+
+    convert_peer_identity_to_id (&peer, &peer_id);
+
+    if (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (
+          store->peers, &peer_id, entry,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
+      continue;
+
+    GNUNET_free (entry);
+  } while (len == sizeof(peer));
+
+  GNUNET_DISK_file_close (handle);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_save_peers (void *cls, const struct GNUNET_ShortHashCode *id,
+                    void *value)
+{
+  struct GNUNET_DISK_FileHandle *handle = cls;
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry = value;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save peer store entry: %s\n",
+              GNUNET_sh2s (id));
+
+  if ((! entry) || (GNUNET_YES != entry->active))
+    return GNUNET_YES;
+
+  GNUNET_DISK_file_write (handle, &(entry->peer), sizeof(entry->peer));
+  return GNUNET_YES;
+}
+
+
+void
+save_peer_store (const struct GNUNET_MESSENGER_PeerStore *store,
+                 const char *path)
+{
+  GNUNET_assert ((store) && (path));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save peer store to path: %s\n",
+              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_multishortmap_iterate (store->peers, iterate_save_peers,
+                                          handle);
+
+  GNUNET_DISK_file_sync (handle);
+  GNUNET_DISK_file_close (handle);
+}
+
+
+struct GNUNET_MESSENGER_ClosureVerifyPeer
+{
+  const struct GNUNET_MESSENGER_Message *message;
+  const struct GNUNET_HashCode *hash;
+  struct GNUNET_PeerIdentity *sender;
+};
+
+static enum GNUNET_GenericReturnValue
+verify_store_peer (void *cls, const struct GNUNET_ShortHashCode *id,
+                   void *value)
+{
+  struct GNUNET_MESSENGER_ClosureVerifyPeer *verify = cls;
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry = value;
+
+  if (! entry)
+    return GNUNET_YES;
+
+  if (GNUNET_OK == verify_message_by_peer (verify->message,
+                                           verify->hash, &(entry->peer)))
+  {
+    verify->sender = &(entry->peer);
+    return GNUNET_NO;
+  }
+
+  return GNUNET_YES;
+}
+
+
+static struct GNUNET_MESSENGER_PeerStoreEntry*
+add_peer_store_entry (struct GNUNET_MESSENGER_PeerStore *store,
+                      const struct GNUNET_PeerIdentity *peer,
+                      const struct GNUNET_ShortHashCode *id,
+                      enum GNUNET_GenericReturnValue active)
+{
+  GNUNET_assert ((store) && (peer));
+
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
+  entry = GNUNET_new (struct GNUNET_MESSENGER_PeerStoreEntry);
+
+  if (! entry)
+    return NULL;
+
+  GNUNET_memcpy (&(entry->peer), peer, sizeof(entry->peer));
+  entry->active = active;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (
+        store->peers, id, entry,
+        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
+  {
+    GNUNET_free (entry);
+    return NULL;
+  }
+
+  return entry;
+}
+
+
+static const struct GNUNET_PeerIdentity*
+get_store_service_peer_identity (struct GNUNET_MESSENGER_PeerStore *store)
+{
+  static struct GNUNET_PeerIdentity peer;
+
+  if (GNUNET_OK != get_service_peer_identity (store->service, &peer))
+    return NULL;
+
+  return &peer;
+}
+
+
+struct GNUNET_PeerIdentity*
+get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((store) && (store->peers) && (message) && (hash));
+
+  if (GNUNET_YES != is_peer_message (message))
+    return NULL;
+
+  struct GNUNET_MESSENGER_ClosureVerifyPeer verify;
+  verify.message = message;
+  verify.hash = hash;
+  verify.sender = NULL;
+
+  GNUNET_CONTAINER_multishortmap_get_multiple (store->peers,
+                                               &(message->header.sender_id),
+                                               verify_store_peer, &verify);
+
+  if (verify.sender)
+    return verify.sender;
+
+  const struct GNUNET_PeerIdentity *peer;
+  enum GNUNET_GenericReturnValue active;
+
+  if (GNUNET_MESSENGER_KIND_PEER == message->header.kind)
+  {
+    peer = &(message->body.peer.peer);
+    active = GNUNET_YES;
+  }
+  else if (GNUNET_MESSENGER_KIND_MISS == message->header.kind)
+  {
+    peer = &(message->body.miss.peer);
+    active = GNUNET_NO;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Peer message does not contain a peer identity\n");
+
+    peer = get_store_service_peer_identity (store);
+    active = GNUNET_NO;
+
+    if (! peer)
+      return NULL;
+  }
+
+  struct GNUNET_ShortHashCode peer_id;
+  convert_peer_identity_to_id (peer, &peer_id);
+
+  if (0 != GNUNET_memcmp (&peer_id, &(message->header.sender_id)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Sender id does not match peer identity\n");
+    return NULL;
+  }
+
+  if (GNUNET_OK != verify_message_by_peer (message, hash, peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Verification of message with peer identity failed!\n");
+  }
+
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
+  entry = add_peer_store_entry (store, peer, &peer_id, active);
+
+  if (! entry)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Initialization of entry in peer store failed: %s\n",
+                GNUNET_sh2s (&peer_id));
+
+    return NULL;
+  }
+
+  return &(entry->peer);
+}
+
+
+struct GNUNET_MESSENGER_ClosureFindPeer
+{
+  const struct GNUNET_PeerIdentity *requested;
+  struct GNUNET_MESSENGER_PeerStoreEntry *match;
+};
+
+static enum GNUNET_GenericReturnValue
+find_store_peer (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
+{
+  struct GNUNET_MESSENGER_ClosureFindPeer *find = cls;
+  struct GNUNET_MESSENGER_PeerStoreEntry *entry = value;
+
+  if (! entry)
+    return GNUNET_YES;
+
+  if (0 == GNUNET_memcmp (find->requested, &(entry->peer)))
+  {
+    find->match = entry;
+    return GNUNET_NO;
+  }
+
+  return GNUNET_YES;
+}
+
+
+void
+update_store_peer (struct GNUNET_MESSENGER_PeerStore *store,
+                   const struct GNUNET_PeerIdentity *peer,
+                   enum GNUNET_GenericReturnValue active)
+{
+  GNUNET_assert ((store) && (store->peers) && (peer));
+
+  struct GNUNET_ShortHashCode peer_id;
+  convert_peer_identity_to_id (peer, &peer_id);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update peer store entry: %s\n",
+              GNUNET_sh2s (&peer_id));
+
+  struct GNUNET_MESSENGER_ClosureFindPeer find;
+  find.requested = peer;
+  find.match = NULL;
+
+  GNUNET_CONTAINER_multishortmap_get_multiple (store->peers, &peer_id,
+                                               find_store_peer, &find);
+
+  if (find.match)
+  {
+    find.match->active = active;
+    return;
+  }
+
+  if (! add_peer_store_entry (store, peer, &peer_id, active))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Initial update of entry in peer store failed: %s\n",
+                GNUNET_sh2s (&peer_id));
+}
diff --git a/src/service/messenger/gnunet-service-messenger_peer_store.h b/src/service/messenger/gnunet-service-messenger_peer_store.h
new file mode 100644
index 000000000..7badfad2c
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_peer_store.h
@@ -0,0 +1,108 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2023--2024 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_peer_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_PEER_STORE_H
+#define GNUNET_SERVICE_MESSENGER_PEER_STORE_H
+
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_Message;
+struct GNUNET_MESSENGER_Service;
+
+struct GNUNET_MESSENGER_PeerStore
+{
+  struct GNUNET_MESSENGER_Service *service;
+  struct GNUNET_CONTAINER_MultiShortmap *peers;
+};
+
+/**
+ * Initializes a peer store as fully empty.
+ *
+ * @param[out] store Peer store
+ * @param[in,out] service Messenger service
+ */
+void
+init_peer_store (struct GNUNET_MESSENGER_PeerStore *store,
+                 struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Clears a peer store, wipes its content and deallocates its memory.
+ *
+ * @param[in,out] store Peer store
+ */
+void
+clear_peer_store (struct GNUNET_MESSENGER_PeerStore *store);
+
+/**
+ * Loads peer identities from a <i>file</i> into a peer <i>store</i>.
+ *
+ * @param[out] store Peer store
+ * @param[in] path Path to a file
+ */
+void
+load_peer_store (struct GNUNET_MESSENGER_PeerStore *store,
+                 const char *path);
+
+/**
+ * Saves peer identities from a peer <i>store</i> into a <i>file</i>.
+ *
+ * @param[in] store Peer store
+ * @param[in] path Path to a file
+ */
+void
+save_peer_store (const struct GNUNET_MESSENGER_PeerStore *store,
+                 const char *path);
+
+/**
+ * Returns the peer identity inside the <i>store</i> which verifies the
+ * signature of a given <i>message</i> as valid. The specific peer identity
+ * has to be added to the <i>store</i> previously. Otherwise the function
+ * returns NULL.
+ *
+ * @param[in,out] store Peer store
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @return Peer identity or NULL
+ */
+struct GNUNET_PeerIdentity*
+get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
+                   const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Adds a <i>peer</i> identity to the <i>store</i> if necessary. It ensures
+ * that the given <i>peer</i> can be verified as sender of a message
+ * afterwards by the <i>store</i>.
+ *
+ * @param[in,out] store Peer store
+ * @param[in] peer Peer identity
+ * @param[in] active Whether the peer is active or not
+ */
+void
+update_store_peer (struct GNUNET_MESSENGER_PeerStore *store,
+                   const struct GNUNET_PeerIdentity *peer,
+                   enum GNUNET_GenericReturnValue active);
+
+#endif //GNUNET_SERVICE_MESSENGER_PEER_STORE_H
diff --git a/src/service/messenger/gnunet-service-messenger_room.c b/src/service/messenger/gnunet-service-messenger_room.c
new file mode 100644
index 000000000..570d2f990
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_room.c
@@ -0,0 +1,1524 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_room.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "platform.h"
+#include "gnunet-service-messenger_room.h"
+
+#include "gnunet-service-messenger_basement.h"
+#include "gnunet-service-messenger_member.h"
+#include "gnunet-service-messenger_member_session.h"
+#include "gnunet-service-messenger_sender_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_service.h"
+#include "gnunet-service-messenger_tunnel.h"
+
+#include "messenger_api_util.h"
+
+static void
+idle_request_room_messages (void *cls);
+
+struct GNUNET_MESSENGER_SrvRoom*
+create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                 const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (key));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = GNUNET_new (struct
+                                                      GNUNET_MESSENGER_SrvRoom);
+
+  room->service = handle->service;
+  room->host = handle;
+  room->port = NULL;
+
+  GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
+
+  room->tunnels = GNUNET_CONTAINER_multipeermap_create (8, GNUNET_NO);
+
+  init_peer_store (get_srv_room_peer_store (room), room->service);
+  init_member_store (get_srv_room_member_store (room), room);
+  init_message_store (get_srv_room_message_store (room));
+  init_operation_store (get_srv_room_operation_store (room), room);
+
+  init_list_tunnels (&(room->basement));
+  init_message_state (&(room->state));
+
+  room->peer_message = NULL;
+
+  init_list_messages (&(room->handling));
+  room->idle = NULL;
+
+  if (room->service->dir)
+    load_srv_room (room);
+
+  room->idle = GNUNET_SCHEDULER_add_with_priority (
+    GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
+
+  return room;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_tunnels (void *cls,
+                         const struct GNUNET_PeerIdentity *key,
+                         void *value)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
+  destroy_tunnel (tunnel);
+  return GNUNET_YES;
+}
+
+
+static void
+close_srv_room (struct GNUNET_MESSENGER_SrvRoom *room);
+
+static void
+handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room);
+
+void
+destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
+                  enum GNUNET_GenericReturnValue deletion)
+{
+  GNUNET_assert (room);
+
+  if (room->idle)
+  {
+    GNUNET_SCHEDULER_cancel (room->idle);
+    room->idle = NULL;
+  }
+
+  close_srv_room (room);
+
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_destroy_tunnels,
+                                         NULL);
+  handle_room_messages (room);
+
+  if (! (room->service->dir))
+    goto skip_saving;
+
+  if (GNUNET_YES == deletion)
+    remove_srv_room (room);
+  else
+    save_srv_room (room);
+
+skip_saving:
+  clear_peer_store (get_srv_room_peer_store (room));
+  clear_member_store (get_srv_room_member_store (room));
+  clear_message_store (get_srv_room_message_store (room));
+  clear_operation_store (get_srv_room_operation_store (room));
+
+  GNUNET_CONTAINER_multipeermap_destroy (room->tunnels);
+  clear_list_tunnels (&(room->basement));
+  clear_message_state (&(room->state));
+
+  if (room->peer_message)
+    GNUNET_free (room->peer_message);
+
+  GNUNET_free (room);
+}
+
+
+struct GNUNET_MESSENGER_PeerStore*
+get_srv_room_peer_store (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return &(room->peer_store);
+}
+
+
+struct GNUNET_MESSENGER_MemberStore*
+get_srv_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return &(room->member_store);
+}
+
+
+struct GNUNET_MESSENGER_MessageStore*
+get_srv_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return &(room->message_store);
+}
+
+
+struct GNUNET_MESSENGER_OperationStore*
+get_srv_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return &(room->operation_store);
+}
+
+
+static enum GNUNET_GenericReturnValue
+send_room_info (struct GNUNET_MESSENGER_SrvRoom *room,
+                struct GNUNET_MESSENGER_SrvHandle *handle,
+                struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  if ((! handle) || (! is_tunnel_connected (tunnel)))
+    return GNUNET_NO;
+
+  return send_tunnel_message (tunnel, handle, create_message_info (
+                                room->service));
+}
+
+
+static void*
+callback_room_connect (void *cls,
+                       struct GNUNET_CADET_Channel *channel,
+                       const struct GNUNET_PeerIdentity *source)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = cls;
+
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = create_tunnel (room, source);
+
+  if ((tunnel) &&
+      (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, source,
+                                                       tunnel,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+  {
+    destroy_tunnel (tunnel);
+    tunnel = NULL;
+  }
+
+  if (! tunnel)
+  {
+    delayed_disconnect_channel (channel);
+    return NULL;
+  }
+
+  bind_tunnel (tunnel, channel);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "New tunnel in room (%s) established to peer: %s\n",
+              GNUNET_h2s (get_srv_room_key (room)), GNUNET_i2s (source));
+
+  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 enum GNUNET_GenericReturnValue
+join_room (struct GNUNET_MESSENGER_SrvRoom *room,
+           struct GNUNET_MESSENGER_SrvHandle *handle,
+           struct GNUNET_MESSENGER_Member *member,
+           const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert ((room) && (handle) && (member));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (
+                get_srv_room_key (room)),
+              GNUNET_sh2s (get_member_id (member)));
+
+  const struct GNUNET_ShortHashCode *member_id = get_member_id (member);
+
+  if (GNUNET_OK != change_srv_handle_member_id (handle, get_srv_room_key (room),
+                                                member_id))
+    return GNUNET_NO;
+
+  enum GNUNET_GenericReturnValue reset;
+  if ((! id) || (0 != GNUNET_memcmp (id, member_id)))
+    reset = GNUNET_YES;
+  else
+    reset = GNUNET_NO;
+
+  notify_srv_handle_member_id (handle, room, member_id, reset);
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
+    handle, get_srv_room_key (room));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+                                                             member_id);
+
+  if (GNUNET_NO == join_room (room, handle, member, member_id))
+    return GNUNET_NO;
+
+  return GNUNET_YES;
+}
+
+
+extern enum GNUNET_GenericReturnValue
+check_tunnel_message (void *cls,
+                      const struct GNUNET_MessageHeader *header);
+
+extern void
+handle_tunnel_message (void *cls,
+                       const struct GNUNET_MessageHeader *header);
+
+extern void
+callback_tunnel_disconnect (void *cls,
+                            const struct GNUNET_CADET_Channel *channel);
+
+
+enum GNUNET_GenericReturnValue
+open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
+               struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert (room);
+
+  if (handle)
+    room->host = handle;
+
+  if (room->port)
+  {
+    if (! handle)
+      return GNUNET_YES;
+
+    return join_room_locally (room, handle);
+  }
+
+  struct GNUNET_CADET_Handle *cadet = get_srv_room_cadet (room);
+  const struct GNUNET_HashCode *key = get_srv_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 () };
+
+  struct GNUNET_HashCode port;
+  convert_messenger_key_to_port (key, &port);
+  room->port = GNUNET_CADET_open_port (cadet, &port, 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_srv_room_key (room)));
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Port of room (%s) could not be opened!\n",
+                GNUNET_h2s (get_srv_room_key (room)));
+
+  if (! handle)
+    goto complete_opening;
+
+  const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
+    handle, get_srv_room_key (room));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+                                                             member_id);
+
+  if ((GNUNET_NO == join_room (room, handle, member, member_id)) &&
+      (room->port))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "You could not join the room, therefore it keeps closed!\n");
+
+    close_srv_room (room);
+    return GNUNET_NO;
+  }
+
+complete_opening:
+  if (! room->port)
+    return GNUNET_NO;
+
+  return send_srv_room_message (room, handle, create_message_peer (
+                                  room->service));
+}
+
+
+static void
+close_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  if (! room->port)
+    return;
+
+  struct GNUNET_PeerIdentity peer;
+  if ((room->peer_message) &&
+      (GNUNET_OK == get_service_peer_identity (room->service, &peer)))
+    send_srv_room_message (room, room->host, create_message_miss (&peer));
+
+  GNUNET_CADET_close_port (room->port);
+  room->port = NULL;
+}
+
+
+enum GNUNET_GenericReturnValue
+enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvHandle *handle,
+                   const struct GNUNET_PeerIdentity *door)
+{
+  GNUNET_assert ((room) && (handle) && (door));
+
+  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)
+  {
+    tunnel = create_tunnel (room, door);
+
+    if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, door,
+                                                        tunnel,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "You could not connect to that door!\n");
+      destroy_tunnel (tunnel);
+      return GNUNET_NO;
+    }
+  }
+
+  if (GNUNET_SYSERR == connect_tunnel (tunnel))
+  {
+    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;
+  }
+
+  return join_room_locally (room, handle);
+}
+
+
+static void
+sign_srv_room_message_by_peer (const void *cls,
+                               struct GNUNET_MESSENGER_Message *message,
+                               uint16_t length,
+                               char *buffer,
+                               const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+
+  GNUNET_assert ((handle) && (handle->service));
+
+  sign_message_by_peer (message, length, buffer, hash, handle->service->config);
+}
+
+
+struct GNUNET_MQ_Envelope*
+pack_srv_room_message (const struct GNUNET_MESSENGER_SrvRoom *room,
+                       const struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message,
+                       struct GNUNET_HashCode *hash,
+                       enum GNUNET_MESSENGER_PackMode mode)
+{
+  GNUNET_assert ((room) && (handle) && (message) && (hash));
+
+  if (GNUNET_YES != is_peer_message (message))
+    return pack_message (message, hash, NULL, mode, NULL);
+
+  message->header.timestamp = GNUNET_TIME_absolute_hton (
+    GNUNET_TIME_absolute_get ());
+
+  struct GNUNET_PeerIdentity peer;
+  if (GNUNET_OK != get_service_peer_identity (handle->service, &peer))
+    return NULL;
+
+  convert_peer_identity_to_id (&peer, &(message->header.sender_id));
+  get_message_state_chain_hash (&(room->state), &(message->header.previous));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Packing message with peer signature: %s\n",
+              GNUNET_sh2s (&(message->header.sender_id)));
+
+  message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
+  return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
+                       handle);
+}
+
+
+struct GNUNET_MESSENGER_ClosureSendRoom
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_SrvTunnel *exclude;
+  struct GNUNET_MESSENGER_Message *message;
+  struct GNUNET_HashCode *hash;
+  enum GNUNET_GenericReturnValue packed;
+};
+
+static enum GNUNET_GenericReturnValue
+iterate_send_room_message (void *cls,
+                           const struct GNUNET_PeerIdentity *key,
+                           void *value)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
+
+  if ((! is_tunnel_connected (tunnel)) ||
+      (get_tunnel_messenger_version (tunnel) < GNUNET_MESSENGER_VERSION))
+    return GNUNET_YES;
+
+  struct GNUNET_MESSENGER_ClosureSendRoom *closure = cls;
+
+  if (tunnel == closure->exclude)
+    return GNUNET_YES;
+
+  struct GNUNET_MQ_Envelope *env = NULL;
+
+  if (closure->packed == GNUNET_NO)
+  {
+    env = pack_srv_room_message (closure->room, closure->handle,
+                                 closure->message, closure->hash,
+                                 GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+
+    if (env)
+      closure->packed = GNUNET_YES;
+  }
+  else
+    env = pack_message (closure->message, NULL, NULL,
+                        GNUNET_MESSENGER_PACK_MODE_ENVELOPE, NULL);
+
+  if (env)
+    send_tunnel_envelope (tunnel, env, closure->hash);
+
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+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,
+                              const struct GNUNET_MESSENGER_Message *message,
+                              const struct GNUNET_HashCode *hash);
+
+enum GNUNET_GenericReturnValue
+send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                       struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert ((room) && (handle));
+
+  if (! message)
+    return GNUNET_NO;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending message from handle in room: %s (%s)\n",
+              GNUNET_h2s (&(room->key)),
+              GNUNET_MESSENGER_name_of_kind (message->header.kind));
+
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_ClosureSendRoom closure;
+
+  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 (GNUNET_NO == closure.packed)
+    pack_srv_room_message (room, handle, message, &hash,
+                           GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+
+  enum GNUNET_GenericReturnValue new_message;
+  new_message = update_room_message (room, message, &hash);
+
+  if (GNUNET_YES != new_message)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sending duplicate message failed!\n");
+    return GNUNET_SYSERR;
+  }
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    send_message_join (room, handle, message, &hash);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    send_message_key (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, message, &hash);
+  return GNUNET_YES;
+}
+
+
+void
+forward_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                          struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                          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;
+
+  GNUNET_memcpy (&message_hash, hash, sizeof(struct GNUNET_HashCode));
+
+  closure.room = room;
+  closure.handle = NULL;
+  closure.exclude = tunnel;
+  closure.message = message;
+  closure.hash = &message_hash;
+  closure.packed = GNUNET_YES;
+
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
+                                         iterate_send_room_message, &closure);
+}
+
+
+void
+check_srv_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_srv_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;
+  }
+
+  if (tunnel)
+    forward_tunnel_message (tunnel, message, room->peer_message);
+}
+
+
+void
+merge_srv_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room,
+                              struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert (room);
+
+  if (! handle)
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Merging messages by handle in room: %s\n",
+              GNUNET_h2s (&(room->key)));
+
+  const struct GNUNET_HashCode *hash;
+
+merge_next:
+  hash = get_message_state_merge_hash (&(room->state));
+
+  if (! hash)
+    return;
+
+  send_srv_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_srv_room_message_store (room),
+                                         hash))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deletion of message failed! (%s)\n",
+                GNUNET_h2s (hash));
+    return;
+  }
+}
+
+
+void
+callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room,
+                     const struct GNUNET_HashCode *hash)
+{
+  if (! room->host)
+    return;
+
+  send_srv_room_message (room, room->host, create_message_merge (hash));
+}
+
+
+enum GNUNET_GenericReturnValue
+delete_srv_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));
+
+  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_srv_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_srv_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_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return room->service->cadet;
+}
+
+
+const struct GNUNET_HashCode*
+get_srv_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return &(room->key);
+}
+
+
+const struct GNUNET_MESSENGER_SrvTunnel*
+get_srv_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);
+}
+
+
+static enum GNUNET_GenericReturnValue
+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;
+
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_room_message_store (room);
+
+  const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link (
+    message_store, hash, GNUNET_YES
+    );
+
+  if (! link)
+    goto forward;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Requesting link of message with hash: %s\n",
+              GNUNET_h2s (hash));
+
+  enum GNUNET_GenericReturnValue result;
+  result = request_room_message_step (room, &(link->first), session,
+                                      callback, cls);
+
+  if ((GNUNET_YES == link->multiple) &&
+      (GNUNET_YES == request_room_message_step (room, &(link->second), session,
+                                                callback, cls)))
+    return GNUNET_YES;
+  else
+    return result;
+
+forward:
+  message = get_store_message (message_store, hash);
+
+  if (! message)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Requested message is missing in local storage: %s\n",
+                GNUNET_h2s (hash));
+    return GNUNET_NO;
+  }
+
+  if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_NO))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unpermitted request for access by member (%s) of message (%s)!\n",
+                GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (
+                  hash));
+  else if (callback)
+    callback (cls, room, message, hash);
+
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+request_srv_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));
+
+  enum GNUNET_GenericReturnValue result;
+  result = request_room_message_step (room, hash, session, callback, cls);
+
+  if ((GNUNET_NO == result) && (callback))
+    callback (cls, room, NULL, hash);
+
+  return result;
+}
+
+
+void
+callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room,
+                          void *cls)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (! room->host)
+    return;
+
+  struct GNUNET_PeerIdentity identity;
+  get_tunnel_peer_identity (tunnel, &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))
+    send_srv_room_message (room, room->host, create_message_miss (&identity));
+
+  if ((0 < GNUNET_CONTAINER_multipeermap_size (room->tunnels)) ||
+      (GNUNET_NO == room->service->auto_connecting))
+    return;
+
+  struct GNUNET_MESSENGER_ListTunnel *element;
+  element = find_list_tunnels_alternate (&(room->basement), &identity);
+
+  if (! element)
+    return;
+
+  GNUNET_PEER_resolve (element->peer, &identity);
+  enter_srv_room_at (room, room->host, &identity);
+}
+
+
+enum GNUNET_GenericReturnValue
+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)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Message error: Kind is unknown! (%d)\n", message->header.kind);
+    return GNUNET_SYSERR;
+  }
+
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_room_message_store (room);
+
+  const struct GNUNET_MESSENGER_Message *previous = get_store_message (
+    message_store, &(message->header.previous));
+
+  if (! previous)
+    goto skip_time_comparison;
+
+  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_TIME_relative_get_zero_ ().rel_value_us !=
+      GNUNET_TIME_absolute_get_difference (timestamp, last).rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Message warning: Timestamp does not check out!\n");
+  }
+
+skip_time_comparison:
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
+              GNUNET_MESSENGER_name_of_kind (message->header.kind));
+
+  return GNUNET_OK;
+}
+
+
+static void
+idle_request_room_messages (void *cls)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = cls;
+
+  room->idle = NULL;
+
+  struct GNUNET_MESSENGER_OperationStore *operation_store =
+    get_srv_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
+solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room,
+                                  const struct
+                                  GNUNET_CRYPTO_PublicKey *public_key,
+                                  const struct GNUNET_ShortHashCode *member_id,
+                                  struct GNUNET_TIME_Absolute timestamp)
+{
+  GNUNET_assert ((room) && (public_key) && (member_id));
+
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member (member_store,
+                                                             member_id);
+
+  if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
+                       member->sessions)))
+    return;
+
+  struct GNUNET_MESSENGER_ListHandles *handles = &(room->service->handles);
+  struct GNUNET_MESSENGER_ListHandle *element;
+
+  const struct GNUNET_CRYPTO_PublicKey *pubkey;
+
+  for (element = handles->head; element; element = element->next)
+  {
+    if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
+                              element->handle, get_srv_room_key (room))))
+      continue;
+
+    pubkey = get_srv_handle_key (element->handle);
+
+    if (0 == GNUNET_memcmp (public_key, pubkey))
+      continue;
+
+    struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member,
+                                                                         pubkey);
+
+    if (! session)
+      continue;
+
+    struct GNUNET_TIME_Absolute start = get_member_session_start (session);
+
+    if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
+        GNUNET_TIME_absolute_get_difference (start, timestamp).rel_value_us)
+      continue;
+
+    struct GNUNET_ShortHashCode random_id;
+    generate_free_member_id (&random_id, member_store->members);
+
+    notify_srv_handle_member_id (element->handle, room, &random_id, GNUNET_NO);
+  }
+}
+
+
+void
+rebuild_srv_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))
+    return;
+
+  size_t count = count_of_tunnels (&(room->basement));
+
+  if (! find_list_tunnels (&(room->basement), &peer, &src))
+    return;
+
+  if ((count > room->service->min_routers) &&
+      (GNUNET_NO == is_srv_handle_routing (room->host, &(room->key))) &&
+      (GNUNET_OK == verify_list_tunnels_flag_token (&(room->basement),
+                                                    &peer,
+                                                    GNUNET_MESSENGER_FLAG_CONNECTION_AUTO)))
+  {
+    close_srv_room (room);
+    return;
+  }
+
+  struct GNUNET_MESSENGER_ListTunnel *element = room->basement.head;
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
+
+  size_t dst = 0;
+
+  while (element)
+  {
+    GNUNET_PEER_resolve (element->peer, &peer);
+
+    tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, &peer);
+
+    if (! tunnel)
+    {
+      element = remove_from_list_tunnels (&(room->basement), element);
+      continue;
+    }
+
+    if (GNUNET_YES == required_connection_between (count, src, dst))
+    {
+      if (GNUNET_SYSERR == connect_tunnel (tunnel))
+      {
+        element = remove_from_list_tunnels (&(room->basement), element);
+        continue;
+      }
+    }
+    else
+      disconnect_tunnel (tunnel);
+
+    element = element->next;
+    dst++;
+  }
+}
+
+
+uint32_t
+get_srv_room_amount_of_tunnels (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  return GNUNET_CONTAINER_multipeermap_size (room->tunnels);
+}
+
+
+uint32_t
+get_srv_room_connection_flags (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  uint32_t flags = GNUNET_MESSENGER_FLAG_CONNECTION_NONE;
+
+  if (GNUNET_YES == room->service->auto_routing)
+    flags |= GNUNET_MESSENGER_FLAG_CONNECTION_AUTO;
+
+  return flags;
+}
+
+
+static void
+handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_room_message_store (room);
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store (
+    room);
+  
+  const struct GNUNET_HashCode *key = get_srv_room_key (room);
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Handling room messages: %s\n", GNUNET_h2s (key));
+
+  while (room->handling.head)
+  {
+    struct GNUNET_MESSENGER_ListMessage *element = room->handling.head;
+
+    const struct GNUNET_MESSENGER_Message *message = get_store_message (
+      message_store, &(element->hash));
+
+    if (! message)
+      goto finish_handling;
+
+    struct GNUNET_MESSENGER_SenderSession session;
+
+    if (GNUNET_YES == is_peer_message (message))
+    {
+      session.peer = get_store_peer_of (peer_store, message, &(element->hash));
+
+      if (! session.peer)
+        goto finish_handling;
+    }
+    else
+    {
+      struct GNUNET_MESSENGER_Member *member = get_store_member_of (
+        member_store, message);
+
+      if (! member)
+        goto finish_handling;
+
+      session.member = get_member_session_of (member, message,
+                                              &(element->hash));
+
+      if (! session.member)
+        goto finish_handling;
+    }
+
+    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);
+  }
+}
+
+
+enum GNUNET_GenericReturnValue
+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_srv_room_operation_store (room);
+
+  enum GNUNET_GenericReturnValue requested;
+  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_srv_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_srv_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 enum GNUNET_GenericReturnValue
+iterate_update_member_sessions (void *cls,
+                                const struct
+                                GNUNET_CRYPTO_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_handle_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                              const struct GNUNET_MESSENGER_Message *message,
+                              const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((room) && (message) && (hash));
+
+  struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store (
+    room);
+  struct GNUNET_MESSENGER_MemberStore *member_store =
+    get_srv_room_member_store (room);
+
+  struct GNUNET_MESSENGER_SenderSession session;
+
+  if (GNUNET_YES == is_peer_message (message))
+  {
+    session.peer = get_store_peer_of (peer_store, message, hash);
+
+    if (! session.peer)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Message handling dropped: Peer is missing!\n");
+      return;
+    }
+  }
+  else
+  {
+    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 (! member)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Message handling dropped: Member is missing!\n");
+      return;
+    }
+
+    session.member = get_member_session_of (member, message, hash);
+
+    if (! session.member)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Message handling dropped: Session is missing!\n");
+      return;
+    }
+  }
+
+  struct GNUNET_MESSENGER_MemberUpdate update;
+  update.message = message;
+  update.hash = 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);
+  }
+
+  enum GNUNET_GenericReturnValue start_handle;
+  start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
+
+  add_to_list_messages (&(room->handling), hash);
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    handle_message_join (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    handle_message_leave (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    handle_message_key (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    handle_message_peer (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    handle_message_id (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    handle_message_miss (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    handle_message_delete (room, &session, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    handle_message_connection (room, &session, message, hash);
+    break;
+  default:
+    break;
+  }
+
+  if (GNUNET_YES == start_handle)
+    handle_room_messages (room);
+}
+
+
+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_srv_room_key (room)),
+                   DIR_SEPARATOR);
+}
+
+
+void
+load_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load room from directory: %s\n",
+              room_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
+  {
+    char *peers_file;
+    GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
+
+    load_peer_store (get_srv_room_peer_store (room), peers_file);
+    GNUNET_free (peers_file);
+
+    load_member_store (get_srv_room_member_store (room), room_dir);
+    load_message_store (get_srv_room_message_store (room), room_dir);
+    load_operation_store (get_srv_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);
+
+    load_message_state (&(room->state), room_dir);
+  }
+
+  GNUNET_free (room_dir);
+}
+
+
+void
+save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save room to directory: %s\n",
+              room_dir);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create (room_dir)))
+  {
+    char *peers_file;
+    GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
+
+    save_peer_store (get_srv_room_peer_store (room), peers_file);
+    GNUNET_free (peers_file);
+
+    save_member_store (get_srv_room_member_store (room), room_dir);
+    save_message_store (get_srv_room_message_store (room), room_dir);
+    save_operation_store (get_srv_room_operation_store (room), room_dir);
+
+    char *basement_file;
+    GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
+
+    save_list_tunnels (&(room->basement), basement_file);
+    GNUNET_free (basement_file);
+
+    save_message_state (&(room->state), room_dir);
+  }
+
+  GNUNET_free (room_dir);
+}
+
+
+void
+remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert (room);
+
+  char *room_dir;
+  get_room_data_subdir (room, &room_dir);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove room from directory: %s\n",
+              room_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
+    GNUNET_DISK_directory_remove (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));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Remove member session from room: %s (%s)\n",
+              GNUNET_sh2s (get_member_session_id (session)),
+              GNUNET_h2s (get_srv_room_key (room)));
+
+  remove_member_session (session->member, session);
+
+  const struct GNUNET_CRYPTO_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/service/messenger/gnunet-service-messenger_room.h b/src/service/messenger/gnunet-service-messenger_room.h
new file mode 100644
index 000000000..e9395cfc4
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_room.h
@@ -0,0 +1,404 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_room.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_ROOM_H
+#define GNUNET_SERVICE_MESSENGER_ROOM_H
+
+#include "gnunet_cadet_service.h"
+#include "gnunet_util_lib.h"
+
+#include "gnunet_messenger_service.h"
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_message_state.h"
+#include "gnunet-service-messenger_list_messages.h"
+#include "gnunet-service-messenger_member_store.h"
+#include "gnunet-service-messenger_message_store.h"
+#include "gnunet-service-messenger_operation_store.h"
+#include "gnunet-service-messenger_peer_store.h"
+
+#include "messenger_api_list_tunnels.h"
+#include "messenger_api_message.h"
+
+#define GNUNET_MESSENGER_IDLE_DELAY GNUNET_TIME_relative_multiply \
+          (GNUNET_TIME_relative_get_second_ (), 5)
+
+#define GNUNET_MESSENGER_REQUEST_DELAY GNUNET_TIME_relative_multiply \
+          (GNUNET_TIME_relative_get_minute_ (), 5)
+
+#define GNUNET_MESSENGER_MERGE_DELAY GNUNET_TIME_relative_multiply \
+          (GNUNET_TIME_relative_get_second_ (), 30)
+
+struct GNUNET_MESSENGER_SrvTunnel;
+struct GNUNET_MESSENGER_MemberSession;
+
+struct GNUNET_MESSENGER_SrvRoom
+{
+  struct GNUNET_MESSENGER_Service *service;
+  struct GNUNET_MESSENGER_SrvHandle *host;
+  struct GNUNET_CADET_Port *port;
+
+  struct GNUNET_HashCode key;
+
+  struct GNUNET_CONTAINER_MultiPeerMap *tunnels;
+
+  struct GNUNET_MESSENGER_PeerStore peer_store;
+  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_MessageState state;
+
+  struct GNUNET_HashCode *peer_message;
+
+  struct GNUNET_MESSENGER_ListMessages handling;
+  struct GNUNET_SCHEDULER_Task *idle;
+};
+
+/**
+ * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i>.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] key Key of room
+ * @return New room
+ */
+struct GNUNET_MESSENGER_SrvRoom*
+create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
+                 const struct GNUNET_HashCode *key);
+
+/**
+ * Destroys a room and frees its memory fully.
+ *
+ * The <i>deletion</i> flag should only be set to #GNUNET_YES if the
+ * room gets dropped by the service, otherwise #GNUNET_NO.
+ *
+ * @param[in,out] room Room
+ * @param[in] deletion Flag to indicate context of destruction
+ */
+void
+destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
+                  enum GNUNET_GenericReturnValue deletion);
+
+/**
+ * Returns the used peer store of a given <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @return Peer store
+ */
+struct GNUNET_MESSENGER_PeerStore*
+get_srv_room_peer_store (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the used member store of a given <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @return Member store
+ */
+struct GNUNET_MESSENGER_MemberStore*
+get_srv_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the used message store of a given <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @return Message store
+ */
+struct GNUNET_MESSENGER_MessageStore*
+get_srv_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the used operation store of a given <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @return Operation store
+ */
+struct GNUNET_MESSENGER_OperationStore*
+get_srv_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
+ * will locally join the room.
+ *
+ * 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 guaranteed to be open for incoming connections.
+ *
+ * @param[in,out] room Room
+ * @param[in,out] handle Handle
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
+ */
+enum GNUNET_GenericReturnValue
+open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
+               struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Connects a tunnel to a hosting peer of a <i>room</i> through a so called <i>door</i> which is represented by
+ * 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[in,out] room Room
+ * @param[in,out] handle Handle
+ * @param[in] door Peer identity
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
+ */
+enum GNUNET_GenericReturnValue
+enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room,
+                   struct GNUNET_MESSENGER_SrvHandle *handle,
+                   const struct GNUNET_PeerIdentity *door);
+
+/**
+ * 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 private key.
+ *
+ * If the optional <i>hash</i> parameter is a valid pointer, its value will be overridden 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
+ * through a message queue, otherwise NULL.
+ *
+ * @param[in] room Room
+ * @param[in] handle Handle
+ * @param[in,out] message Message
+ * @param[out] hash Hash of message
+ * @param[in] mode Packing mode
+ * @return New envelope or NULL
+ */
+struct GNUNET_MQ_Envelope*
+pack_srv_room_message (const struct GNUNET_MESSENGER_SrvRoom *room,
+                       const struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message,
+                       struct GNUNET_HashCode *hash,
+                       enum GNUNET_MESSENGER_PackMode mode);
+
+/**
+ * Sends a <i>message</i> from a given <i>handle</i> into a <i>room</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.
+ *
+ * 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.
+ */
+enum GNUNET_GenericReturnValue
+send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                       struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Forwards a <i>message</i> with a given <i>hash</i> to a specific <i>tunnel</i> inside of a <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @param[in,out] tunnel Tunnel
+ * @param[in,out] message Message
+ * @param[in] hash Hash of message
+ */
+void
+forward_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                          struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                          struct GNUNET_MESSENGER_Message *message,
+                          const struct GNUNET_HashCode *hash);
+
+/**
+ * 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[in,out] room Room
+ * @param[in,out] tunnel Tunnel
+ */
+void
+check_srv_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[in,out] room Room
+ * @param[in,out] handle Handle
+ */
+void
+merge_srv_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
+ */
+enum GNUNET_GenericReturnValue
+delete_srv_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[in,out] room Room
+ * @return CADET handle
+ */
+struct GNUNET_CADET_Handle*
+get_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the shared secret you need to access a <i>room</i>.
+ *
+ * @param[in] room Room
+ * @return Shared secret
+ */
+const struct GNUNET_HashCode*
+get_srv_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[in] room Room
+ * @param[in] peer Peer identity
+ * @return Tunnel or NULL
+ */
+const struct GNUNET_MESSENGER_SrvTunnel*
+get_srv_room_tunnel (const struct GNUNET_MESSENGER_SrvRoom *room,
+                     const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Method called whenever a <i>message</i> is found during a request in a <i>room</i>.
+ *
+ * @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
+ */
+typedef void (GNUNET_MESSENGER_MessageRequestCallback) (
+  void *cls,
+  struct GNUNET_MESSENGER_SrvRoom *room,
+  const struct GNUNET_MESSENGER_Message *message,
+  const struct GNUNET_HashCode *hash
+  );
+
+/**
+ * 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
+ */
+enum GNUNET_GenericReturnValue
+request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                          const struct GNUNET_HashCode *hash,
+                          const struct GNUNET_MESSENGER_MemberSession *session,
+                          GNUNET_MESSENGER_MessageRequestCallback callback,
+                          void *cls);
+
+/**
+ * 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[in,out] room Room
+ * @param[in] public_key Public key
+ * @param[in] member_id Member ID
+ * @param[in] timestamp Timestamp
+ */
+void
+solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room,
+                                  const struct
+                                  GNUNET_CRYPTO_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[in,out] room Room
+ */
+void
+rebuild_srv_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the amount of active tunnels of a given <i>room</i>.
+ *
+ * @param[in] room Room
+ * @return Amount of tunnels
+ */
+uint32_t
+get_srv_room_amount_of_tunnels (const struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns connection flags about connection information of a given <i>room</i> and the service managing it.
+ *
+ * @param[in] room Room
+ * @return Connection flags
+ */
+uint32_t
+get_srv_room_connection_flags (const struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * 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_srv_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[in] room Room
+ */
+void
+save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Removes the configuration for a given <i>room</i> of a service.
+ *
+ * @param[in] room Room
+ */
+void
+remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room);
+
+#endif //GNUNET_SERVICE_MESSENGER_ROOM_H
diff --git a/src/service/messenger/gnunet-service-messenger_sender_session.h b/src/service/messenger/gnunet-service-messenger_sender_session.h
new file mode 100644
index 000000000..8da9044ce
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_sender_session.h
@@ -0,0 +1,42 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2023 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_sender_session.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_SENDER_SESSION_H
+#define GNUNET_SERVICE_MESSENGER_SENDER_SESSION_H
+
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-messenger_member_session.h"
+
+struct GNUNET_MESSENGER_SenderSession
+{
+  union
+  {
+    struct GNUNET_MESSENGER_MemberSession *member;
+    struct GNUNET_PeerIdentity *peer;
+  };
+};
+
+#endif /* GNUNET_SERVICE_MESSENGER_SENDER_SESSION_H */
diff --git a/src/service/messenger/gnunet-service-messenger_service.c b/src/service/messenger/gnunet-service-messenger_service.c
new file mode 100644
index 000000000..11656d6b7
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_service.c
@@ -0,0 +1,461 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_service.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_service.h"
+
+#include "gnunet-service-messenger_message_kind.h"
+#include "gnunet-service-messenger_room.h"
+
+#include "gnunet_common.h"
+#include "messenger_api_util.h"
+
+static void
+callback_shutdown_service (void *cls)
+{
+  struct GNUNET_MESSENGER_Service *service = cls;
+
+  if (service)
+  {
+    service->shutdown = NULL;
+
+    destroy_service (service);
+  }
+}
+
+
+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;
+  service->service = service_handle;
+
+  service->shutdown = GNUNET_SCHEDULER_add_shutdown (&callback_shutdown_service,
+                                                     service);
+
+  service->peer = NULL;
+  service->dir = NULL;
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (service->config,
+                                                            GNUNET_MESSENGER_SERVICE_NAME,
+                                                            "MESSENGER_DIR",
+                                                            &(service->dir)))
+  {
+    if (service->dir)
+      GNUNET_free (service->dir);
+
+    service->dir = NULL;
+  }
+  else
+  {
+    if ((GNUNET_YES != GNUNET_DISK_directory_test (service->dir, GNUNET_YES)) &&
+        (GNUNET_OK
+         !=
+         GNUNET_DISK_directory_create (service->dir)))
+    {
+      GNUNET_free (service->dir);
+
+      service->dir = NULL;
+    }
+  }
+
+  service->auto_connecting = GNUNET_CONFIGURATION_get_value_yesno (
+    service->config,
+    GNUNET_MESSENGER_SERVICE_NAME,
+    "MESSENGER_AUTO_CONNECTING");
+
+  service->auto_routing = GNUNET_CONFIGURATION_get_value_yesno (service->config,
+                                                                GNUNET_MESSENGER_SERVICE_NAME,
+                                                                "MESSENGER_AUTO_ROUTING");
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (service->config,
+                                                          GNUNET_MESSENGER_SERVICE_NAME,
+                                                          "MESSENGER_MIN_ROUTERS",
+                                                          &(service->min_routers)))
+    service->min_routers = 0;
+
+  service->cadet = GNUNET_CADET_connect (service->config);
+
+  init_list_handles (&(service->handles));
+
+  service->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_contact_store (get_service_contact_store (service));
+
+  return service;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_rooms (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = value;
+  destroy_srv_room (room, GNUNET_NO);
+  return GNUNET_YES;
+}
+
+
+void
+destroy_service (struct GNUNET_MESSENGER_Service *service)
+{
+  GNUNET_assert (service);
+
+  if (service->shutdown)
+  {
+    GNUNET_SCHEDULER_cancel (service->shutdown);
+
+    service->shutdown = NULL;
+  }
+
+  clear_list_handles (&(service->handles));
+
+  GNUNET_CONTAINER_multihashmap_iterate (service->rooms, iterate_destroy_rooms,
+                                         NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (service->rooms);
+
+  clear_contact_store (get_service_contact_store (service));
+
+  if (service->cadet)
+  {
+    GNUNET_CADET_disconnect (service->cadet);
+
+    service->cadet = NULL;
+  }
+
+  if (service->dir)
+  {
+    GNUNET_free (service->dir);
+
+    service->dir = NULL;
+  }
+
+  if (service->peer)
+  {
+    GNUNET_free (service->peer);
+
+    service->peer = NULL;
+  }
+
+  GNUNET_SERVICE_shutdown (service->service);
+
+  GNUNET_free (service);
+}
+
+
+struct GNUNET_MESSENGER_ContactStore*
+get_service_contact_store (struct GNUNET_MESSENGER_Service *service)
+{
+  GNUNET_assert (service);
+
+  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_srv_handle (service, mq);
+
+  if (handle)
+  {
+    add_list_handle (&(service->handles), handle);
+  }
+
+  return handle;
+}
+
+
+void
+remove_service_handle (struct GNUNET_MESSENGER_Service *service,
+                       struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert ((service) && (handle));
+
+  if (! handle)
+    return;
+
+  if (GNUNET_YES == remove_list_handle (&(service->handles), handle))
+    destroy_srv_handle (handle);
+}
+
+
+enum GNUNET_GenericReturnValue
+get_service_peer_identity (struct GNUNET_MESSENGER_Service *service,
+                           struct GNUNET_PeerIdentity *peer)
+{
+  GNUNET_assert ((service) && (peer));
+
+  if (service->peer)
+  {
+    GNUNET_memcpy (peer, service->peer, sizeof(struct GNUNET_PeerIdentity));
+    return GNUNET_OK;
+  }
+
+  enum GNUNET_GenericReturnValue result;
+  result = GNUNET_CRYPTO_get_peer_identity (service->config, peer);
+
+  if (GNUNET_OK != result)
+    return result;
+
+  if (! service->peer)
+    service->peer = GNUNET_new (struct GNUNET_PeerIdentity);
+
+  GNUNET_memcpy (service->peer, peer, sizeof(struct GNUNET_PeerIdentity));
+  return result;
+}
+
+
+struct GNUNET_MESSENGER_SrvRoom*
+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);
+}
+
+
+struct HandleInitializationClosure
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  const struct GNUNET_CRYPTO_PublicKey *pubkey;
+};
+
+static enum GNUNET_GenericReturnValue
+find_member_session_in_room (void *cls,
+                             const struct GNUNET_CRYPTO_PublicKey *public_key,
+                             struct GNUNET_MESSENGER_MemberSession *session)
+{
+  struct HandleInitializationClosure *init = cls;
+
+  if (! public_key)
+    return GNUNET_YES;
+
+  const struct GNUNET_CRYPTO_PublicKey *pubkey = get_srv_handle_key (
+    init->handle);
+
+  if (0 != GNUNET_memcmp (pubkey, public_key))
+    return GNUNET_YES;
+
+  const struct GNUNET_ShortHashCode *id = get_member_session_id (session);
+
+  if (! id)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialitation: Missing member id!");
+    return GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Initialitation: Matching member found (%s)!\n",
+              GNUNET_sh2s (id));
+
+  change_srv_handle_member_id (init->handle, get_srv_room_key (init->room), id);
+  return GNUNET_NO;
+}
+
+
+static void
+initialize_service_handle (struct GNUNET_MESSENGER_SrvHandle *handle,
+                           struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert ((handle) && (room));
+
+  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store (room);
+  if (! store)
+    return;
+
+  const struct GNUNET_CRYPTO_PublicKey *pubkey = get_srv_handle_key (handle);
+  if ((! pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key ())))
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initialize member id of handle via matching member in room!\n");
+
+  struct HandleInitializationClosure init;
+  init.handle = handle;
+  init.room = room;
+  init.pubkey = pubkey;
+
+  iterate_store_members (store, find_member_session_in_room, &init);
+}
+
+
+enum GNUNET_GenericReturnValue
+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)
+  {
+    initialize_service_handle (handle, room);
+    return open_srv_room (room, handle);
+  }
+
+  room = create_srv_room (handle, key);
+  initialize_service_handle (handle, room);
+
+  if ((GNUNET_YES == open_srv_room (room, handle)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
+                                                       key, room,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    return GNUNET_YES;
+
+  destroy_srv_room (room, GNUNET_YES);
+  return GNUNET_NO;
+}
+
+
+enum GNUNET_GenericReturnValue
+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)
+  {
+    initialize_service_handle (handle, room);
+
+    if (GNUNET_YES == enter_srv_room_at (room, handle, door))
+      return GNUNET_YES;
+    else
+      return GNUNET_NO;
+  }
+
+  room = create_srv_room (handle, key);
+  initialize_service_handle (handle, room);
+
+  if ((GNUNET_YES == enter_srv_room_at (room, handle, door)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
+                                                       key, room,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  {
+    return GNUNET_YES;
+  }
+  else
+  {
+    destroy_srv_room (room, GNUNET_YES);
+    return GNUNET_NO;
+  }
+
+}
+
+
+enum GNUNET_GenericReturnValue
+close_service_room (struct GNUNET_MESSENGER_Service *service,
+                    struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_HashCode *key,
+                    enum GNUNET_GenericReturnValue deletion)
+{
+  GNUNET_assert ((service) && (handle) && (key));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
+
+  if (! room)
+    return GNUNET_NO;
+
+  struct GNUNET_ShortHashCode *id = (struct GNUNET_ShortHashCode*) (
+    GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key));
+
+  GNUNET_assert (id);
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (handle->member_ids,
+                                                          key, id))
+    return GNUNET_NO;
+
+  GNUNET_free (id);
+
+  struct GNUNET_MESSENGER_SrvHandle *member_handle = (struct
+                                                      GNUNET_MESSENGER_SrvHandle
+                                                      *)
+                                                     find_list_handle_by_member (
+    &(service->handles), key);
+
+  if (! member_handle)
+  {
+    if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (service->rooms, key,
+                                                           room))
+    {
+      destroy_srv_room (room, deletion);
+      return GNUNET_YES;
+    }
+    else
+      return GNUNET_NO;
+  }
+
+  if (room->host == handle)
+  {
+    room->host = member_handle;
+
+    if (room->peer_message)
+      send_srv_room_message (room, room->host, create_message_connection (
+                               room));
+  }
+
+  return GNUNET_YES;
+}
+
+
+void
+handle_service_message (struct GNUNET_MESSENGER_Service *service,
+                        struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_SenderSession *session,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((service) && (room) && (session) && (message) && (hash));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Notify active clients about message: %s (%s)\n",
+              GNUNET_h2s (hash), GNUNET_MESSENGER_name_of_kind (
+                message->header.kind));
+
+  struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
+
+  while (element)
+  {
+    notify_srv_handle_message (element->handle, room, session, message, hash,
+                               GNUNET_YES);
+    element = element->next;
+  }
+}
diff --git a/src/service/messenger/gnunet-service-messenger_service.h b/src/service/messenger/gnunet-service-messenger_service.h
new file mode 100644
index 000000000..7634dba8e
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_service.h
@@ -0,0 +1,205 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_service.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_SERVICE_H
+#define GNUNET_SERVICE_MESSENGER_SERVICE_H
+
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-messenger_list_handles.h"
+#include "gnunet-service-messenger_sender_session.h"
+
+#include "messenger_api_contact_store.h"
+
+struct GNUNET_MESSENGER_SrvRoom;
+
+struct GNUNET_MESSENGER_Service
+{
+  const struct GNUNET_CONFIGURATION_Handle *config;
+  struct GNUNET_SERVICE_Handle *service;
+
+  struct GNUNET_SCHEDULER_Task *shutdown;
+
+  struct GNUNET_PeerIdentity *peer;
+  char *dir;
+
+  enum GNUNET_GenericReturnValue auto_connecting;
+  enum GNUNET_GenericReturnValue auto_routing;
+  unsigned long long min_routers;
+
+  struct GNUNET_CADET_Handle *cadet;
+
+  struct GNUNET_MESSENGER_ContactStore contact_store;
+
+  struct GNUNET_MESSENGER_ListHandles handles;
+
+  struct GNUNET_CONTAINER_MultiHashMap *rooms;
+};
+
+/**
+ * Creates and allocates a new service using a given <i>config</i> and a GNUnet service handle.
+ *
+ * @param[in] config Configuration
+ * @param[in,out] service_handle GNUnet service handle
+ * @return New service
+ */
+struct GNUNET_MESSENGER_Service*
+create_service (const struct GNUNET_CONFIGURATION_Handle *config,
+                struct GNUNET_SERVICE_Handle *service_handle);
+
+/**
+ * Destroys a <i>service</i> and frees its memory fully.
+ *
+ * @param[in,out] service Service
+ */
+void
+destroy_service (struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Returns the used contact store of a given <i>service</i>.
+ *
+ * @param[in,out] service Service
+ * @return Contact store
+ */
+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[in,out] service Service
+ * @param[in,out] mq Message queue
+ * @return New handle
+ */
+struct GNUNET_MESSENGER_SrvHandle*
+add_service_handle (struct GNUNET_MESSENGER_Service *service,
+                    struct GNUNET_MQ_Handle *mq);
+
+/**
+ * Removes a <i>handle</i> from a <i>service</i> and destroys it.
+ *
+ * @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.
+ *
+ * @param[in,out] service Service
+ * @param[out] peer Peer identity
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+enum GNUNET_GenericReturnValue
+get_service_peer_identity (struct GNUNET_MESSENGER_Service *service,
+                           struct GNUNET_PeerIdentity *peer);
+
+/**
+ * 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[in] service Service
+ * @param[in] key Key of room
+ * @return Room or NULL
+ */
+struct GNUNET_MESSENGER_SrvRoom*
+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.
+ *
+ * @param[in,out] service Service
+ * @param[in,out] handle Handle
+ * @param[in] key Key of room
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+open_service_room (struct GNUNET_MESSENGER_Service *service,
+                   struct GNUNET_MESSENGER_SrvHandle *handle,
+                   const struct GNUNET_HashCode *key);
+
+/**
+ * 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.
+ *
+ * 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[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
+ */
+enum GNUNET_GenericReturnValue
+entry_service_room (struct GNUNET_MESSENGER_Service *service,
+                    struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_PeerIdentity *door,
+                    const struct GNUNET_HashCode *key);
+
+/**
+ * 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.
+ *
+ * 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[in,out] service Service
+ * @param[in,out] handle Handle
+ * @param[in] key Key of room
+ * @param[in] deletion Flag to indicate context of closing
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+close_service_room (struct GNUNET_MESSENGER_Service *service,
+                    struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_HashCode *key,
+                    enum GNUNET_GenericReturnValue deletion);
+
+/**
+ * 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[in,out] service Service
+ * @param[in,out] room Room
+ * @param[in] session Sender 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_SenderSession *session,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_SERVICE_H
diff --git a/src/service/messenger/gnunet-service-messenger_tunnel.c b/src/service/messenger/gnunet-service-messenger_tunnel.c
new file mode 100644
index 000000000..98d0ab1ce
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_tunnel.c
@@ -0,0 +1,441 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_tunnel.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_tunnel.h"
+
+#include "gnunet-service-messenger_handle.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)
+{
+  GNUNET_assert ((room) && (door));
+
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_new (struct
+                                                          GNUNET_MESSENGER_SrvTunnel);
+
+  tunnel->room = room;
+  tunnel->channel = NULL;
+
+  tunnel->peer = GNUNET_PEER_intern (door);
+
+  tunnel->messenger_version = 0;
+
+  tunnel->peer_message = NULL;
+
+  init_message_state (&(tunnel->state));
+
+  return tunnel;
+}
+
+
+void
+destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  GNUNET_assert (tunnel);
+
+  if (tunnel->channel)
+    GNUNET_CADET_channel_destroy (tunnel->channel);
+
+  GNUNET_PEER_change_rc (tunnel->peer, -1);
+
+  if (tunnel->peer_message)
+    GNUNET_free (tunnel->peer_message);
+
+  clear_message_state (&(tunnel->state));
+
+  GNUNET_free (tunnel);
+}
+
+
+void
+bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+             struct GNUNET_CADET_Channel *channel)
+{
+  GNUNET_assert (tunnel);
+
+  if (tunnel->channel)
+    delayed_disconnect_channel (tunnel->channel);
+
+  tunnel->channel = channel;
+}
+
+
+extern void
+callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room,
+                          void *cls);
+
+void
+callback_tunnel_disconnect (void *cls,
+                            const struct GNUNET_CADET_Channel *channel)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (tunnel)
+  {
+    tunnel->channel = NULL;
+
+    callback_room_disconnect (tunnel->room, cls);
+  }
+}
+
+
+extern enum GNUNET_GenericReturnValue
+callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                              void *cls,
+                              struct GNUNET_MESSENGER_Message *message,
+                              struct GNUNET_HashCode *hash);
+
+enum GNUNET_GenericReturnValue
+check_tunnel_message (void *cls,
+                      const struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (! tunnel)
+    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 < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+                                      GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Tunnel error: Message too short! (%d)\n", length);
+    return GNUNET_SYSERR;
+  }
+
+  uint16_t padding = 0;
+
+  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
+                                    &padding))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
+    return GNUNET_SYSERR;
+  }
+
+  struct GNUNET_HashCode hash;
+  hash_message (&message, length - padding, buffer, &hash);
+
+  return callback_verify_room_message (tunnel->room, cls, &message, &hash);
+}
+
+
+extern enum GNUNET_GenericReturnValue
+update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                     struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash);
+
+extern void
+callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom *room,
+                              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_srv_room_operation_store (tunnel->room);
+
+  enum GNUNET_GenericReturnValue requested;
+  requested = (GNUNET_MESSENGER_OP_REQUEST ==
+               get_store_operation_type (operation_store, hash)?
+               GNUNET_YES : GNUNET_NO);
+
+  struct GNUNET_MESSENGER_MessageStore *message_store =
+    get_srv_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)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (! tunnel)
+    return;
+
+  const uint16_t length = ntohs (header->size) - sizeof(*header);
+  const char *buffer = (const char*) &header[1];
+
+  struct GNUNET_MESSENGER_Message message;
+  struct GNUNET_HashCode hash;
+
+  uint16_t padding = 0;
+
+  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));
+
+  enum GNUNET_GenericReturnValue new_message;
+  new_message = update_room_message (tunnel->room,
+                                     copy_message (&message),
+                                     &hash);
+
+  if (GNUNET_YES != new_message)
+    goto receive_done;
+
+  update_tunnel_last_message (tunnel, &hash);
+
+  enum GNUNET_GenericReturnValue 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_MISS:
+    forward_message = recv_message_miss (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_srv_room_message (tunnel->room, tunnel, &message, &hash);
+    callback_room_handle_message (tunnel->room, &message, &hash);
+  }
+
+receive_done:
+  cleanup_message (&message);
+
+  GNUNET_CADET_receive_done (tunnel->channel);
+}
+
+
+enum GNUNET_GenericReturnValue
+connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  GNUNET_assert (tunnel);
+
+  if (tunnel->channel)
+    return GNUNET_NO;
+
+  const struct GNUNET_PeerIdentity *door = GNUNET_PEER_resolve2 (tunnel->peer);
+
+  struct GNUNET_CADET_Handle *cadet = get_srv_room_cadet (tunnel->room);
+  const struct GNUNET_HashCode *key = get_srv_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),
+                                                 GNUNET_MQ_handler_end () };
+
+  struct GNUNET_HashCode port;
+  convert_messenger_key_to_port (key, &port);
+  tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port,
+                                                 NULL,
+                                                 callback_tunnel_disconnect,
+                                                 handlers);
+
+  return GNUNET_YES;
+}
+
+
+void
+disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  GNUNET_assert (tunnel);
+
+  if (tunnel->channel)
+  {
+    delayed_disconnect_channel (tunnel->channel);
+
+    tunnel->channel = NULL;
+  }
+}
+
+
+enum GNUNET_GenericReturnValue
+is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  GNUNET_assert (tunnel);
+
+  return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
+}
+
+
+struct GNUNET_MESSENGER_MessageSent
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
+  struct GNUNET_HashCode hash;
+};
+
+static void
+callback_tunnel_sent (void *cls)
+{
+  struct GNUNET_MESSENGER_MessageSent *sent = cls;
+
+  if (sent->tunnel)
+    update_tunnel_last_message (sent->tunnel, &(sent->hash));
+
+  GNUNET_free (sent);
+}
+
+
+void
+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);
+
+  GNUNET_memcpy (&(sent->hash), hash, sizeof(struct GNUNET_HashCode));
+
+  sent->tunnel = tunnel;
+
+  GNUNET_MQ_notify_sent (env, callback_tunnel_sent, sent);
+  GNUNET_MQ_send (mq, env);
+}
+
+
+enum GNUNET_GenericReturnValue
+send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     void *handle,
+                     struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert ((tunnel) && (handle));
+
+  if (! message)
+    return GNUNET_NO;
+
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MQ_Envelope *env = pack_srv_room_message (
+    tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
+    message, &hash, GNUNET_MESSENGER_PACK_MODE_ENVELOPE
+    );
+
+  destroy_message (message);
+
+  if (! env)
+    return GNUNET_NO;
+
+  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)
+{
+  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,
+                                                 NULL);
+
+  destroy_message (copy);
+
+  if (! env)
+    return;
+
+  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;
+}
+
+
+enum GNUNET_GenericReturnValue
+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/service/messenger/gnunet-service-messenger_tunnel.h b/src/service/messenger/gnunet-service-messenger_tunnel.h
new file mode 100644
index 000000000..6a8452f61
--- /dev/null
+++ b/src/service/messenger/gnunet-service-messenger_tunnel.h
@@ -0,0 +1,193 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_tunnel.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_TUNNEL_H
+#define GNUNET_SERVICE_MESSENGER_TUNNEL_H
+
+#include "gnunet_cadet_service.h"
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-messenger_room.h"
+#include "gnunet-service-messenger_message_state.h"
+
+struct GNUNET_MESSENGER_SrvTunnel
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_CADET_Channel *channel;
+
+  GNUNET_PEER_Id peer;
+
+  uint32_t messenger_version;
+
+  struct GNUNET_HashCode *peer_message;
+  struct GNUNET_MESSENGER_MessageState state;
+};
+
+/**
+ * Creates and allocates a tunnel of a <i>room</i> to a specific peer identity (called <i>door</i>).
+ *
+ * @param[in,out] room Room
+ * @param[in] door Peer identity
+ * @return New tunnel
+ */
+struct GNUNET_MESSENGER_SrvTunnel*
+create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room,
+               const struct GNUNET_PeerIdentity *door);
+
+/**
+ * Destroys a <i>tunnel</i> and frees its memory fully.
+ *
+ * @param[in,out] tunnel
+ */
+void
+destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Binds a CADET <i>channel</i> to a <i>tunnel</i> and replaces its channel
+ * the tunnel is currently bound to if necessary.
+ *
+ * @param[in,out] tunnel Tunnel
+ * @param[in,out] channel CADET channel
+ */
+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.
+ *
+ * @param[in,out] tunnel Tunnel
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Disconnects and unbinds a channel from a <i>tunnel</i>. The actual disconnection
+ * will be asynchronous.
+ *
+ * @param[in,out] tunnel Tunnel
+ */
+void
+disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Returns the status of a currently bound channel of a <i>tunnel</i>.
+ *
+ * @param[in] tunnel Tunnel
+ * @return #GNUNET_YES or #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+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>.
+ *
+ * @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,
+                      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[in,out] tunnel Tunnel
+ * @param[in,out] handle Handle
+ * @param[in,out] message Message
+ * @return #GNUNET_YES on success, GNUNET_NO otherwise
+ */
+enum GNUNET_GenericReturnValue
+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[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,
+                        const struct GNUNET_HashCode *hash);
+
+/**
+ * Returns the hash of the latest peer message published through a given <i>tunnel</i>
+ * and matching the tunnels peer identity. If no peer message has been linked to the tunnel
+ * yet, NULL gets returned.
+ *
+ * @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
+ * @result #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+enum GNUNET_GenericReturnValue
+update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                                 uint32_t version);
+
+#endif //GNUNET_SERVICE_MESSENGER_TUNNEL_H
diff --git a/src/service/messenger/meson.build b/src/service/messenger/meson.build
new file mode 100644
index 000000000..4a472b6b5
--- /dev/null
+++ b/src/service/messenger/meson.build
@@ -0,0 +1,70 @@
+libgnunetmessenger_src = ['messenger_api.c',
+                          'messenger_api_contact.c',
+                          'messenger_api_contact_store.c',
+                          'messenger_api_message.c',
+                          'messenger_api_message_control.c',
+                          'messenger_api_message_kind.c',
+                          'messenger_api_list_tunnels.c',
+                          'messenger_api_queue_messages.c',
+                          'messenger_api_util.c',
+                          'messenger_api_handle.c',
+                          'messenger_api_room.c']
+
+gnunetservicemessenger_src = ['gnunet-service-messenger.c',
+                              'gnunet-service-messenger_service.c',
+                              'gnunet-service-messenger_list_handles.c',
+                              'gnunet-service-messenger_list_messages.c',
+                              'gnunet-service-messenger_member_session.c',
+                              'gnunet-service-messenger_member.c',
+                              'gnunet-service-messenger_member_store.c',
+                              'gnunet-service-messenger_message_handle.c',
+                              'gnunet-service-messenger_message_kind.c',
+                              'gnunet-service-messenger_message_recv.c',
+                              'gnunet-service-messenger_message_send.c',
+                              'gnunet-service-messenger_message_state.c',
+                              'gnunet-service-messenger_message_store.c',
+                              'gnunet-service-messenger_operation_store.c',
+                              'gnunet-service-messenger_operation.c',
+                              'gnunet-service-messenger_peer_store.c',
+                              'gnunet-service-messenger_basement.c',
+                              'gnunet-service-messenger_handle.c',
+                              'gnunet-service-messenger_room.c',
+                              'gnunet-service-messenger_tunnel.c']
+
+configure_file(input : 'messenger.conf.in',
+               output : 'messenger.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+
+if get_option('monolith')
+  foreach p : libgnunetmessenger_src + gnunetservicemessenger_src
+    gnunet_src += 'messenger/' + p
+  endforeach
+endif
+
+libgnunetmessenger = library('gnunetmessenger',
+        libgnunetmessenger_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunetcadet_dep,
+                       libgnunetidentity_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetmessenger_dep = declare_dependency(link_with : libgnunetmessenger)
+pkg.generate(libgnunetmessenger, url: 'https://www.gnunet.org',
+             description : 'Provides API to access the GNUnet Messenger subsystem')
+
+executable ('gnunet-service-messenger',
+            gnunetservicemessenger_src,
+            dependencies: [libgnunetmessenger_dep,
+                           libgnunetutil_dep,
+                           libgnunetidentity_dep,
+                           libgnunetcadet_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
diff --git a/src/service/messenger/messenger-testing-cmds.h b/src/service/messenger/messenger-testing-cmds.h
new file mode 100644
index 000000000..222633355
--- /dev/null
+++ b/src/service/messenger/messenger-testing-cmds.h
@@ -0,0 +1,103 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2023 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-cmds.h
+ * @brief testing lib for messenger service
+ * @author Tobias Frisch
+ */
+#ifndef MESSENGER_TESTING_CMDS_H
+#define MESSENGER_TESTING_CMDS_H
+
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_plugin.h"
+
+#include "messenger-testing.h"
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_start_service (const char *label,
+                                    const char *peer_label,
+                                    const char *system_label,
+                                    struct GNUNET_MESSENGER_TestStageTopology *
+                                    topology,
+                                    unsigned int peer_index);
+
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_stop_service (const char *label,
+                                   const char *service_label);
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_join_room (const char *label,
+                                const char *service_label,
+                                const char *room_key);
+
+/**
+ * Create headers for a trait with name @a name for
+ * statically allocated data of type @a type.
+ */
+#define GNUNET_MESSENGER_MAKE_DECL_SIMPLE_TRAIT(name,type)   \
+        enum GNUNET_GenericReturnValue                          \
+        GNUNET_MESSENGER_get_trait_ ## name (                    \
+          const struct GNUNET_TESTING_Command *cmd,              \
+          type **ret);                                          \
+        struct GNUNET_TESTING_Trait                              \
+        GNUNET_MESSENGER_make_trait_ ## name (                   \
+          type * value);
+
+
+/**
+ * Create C implementation for a trait with name @a name for statically
+ * allocated data of type @a type.
+ */
+#define GNUNET_MESSENGER_MAKE_IMPL_SIMPLE_TRAIT(name,type)  \
+        enum GNUNET_GenericReturnValue                         \
+        GNUNET_MESSENGER_get_trait_ ## name (                   \
+          const struct GNUNET_TESTING_Command *cmd,             \
+          type * *ret)                                          \
+        {                                                      \
+          if (NULL == cmd->traits) return GNUNET_SYSERR;       \
+          return cmd->traits (cmd->cls,                        \
+                              (const void **) ret,             \
+                              GNUNET_S (name),                  \
+                              0);                              \
+        }                                                      \
+        struct GNUNET_TESTING_Trait                             \
+        GNUNET_MESSENGER_make_trait_ ## name (                  \
+          type * value)                                        \
+        {                                                      \
+          struct GNUNET_TESTING_Trait ret = {                   \
+            .trait_name = GNUNET_S (name),                      \
+            .ptr = (const void *) value                        \
+          };                                                   \
+          return ret;                                          \
+        }
+
+
+/**
+ * Call #op on all simple traits.
+ */
+#define GNUNET_MESSENGER_SIMPLE_TRAITS(op) \
+        op (state, struct GNUNET_MESSENGER_StartServiceState)
+
+GNUNET_MESSENGER_SIMPLE_TRAITS (GNUNET_MESSENGER_MAKE_DECL_SIMPLE_TRAIT)
+
+#endif
+/* end of messenger-testing-cmds.h */
diff --git a/src/service/messenger/messenger-testing.c b/src/service/messenger/messenger-testing.c
new file mode 100644
index 000000000..b3f7e3137
--- /dev/null
+++ b/src/service/messenger/messenger-testing.c
@@ -0,0 +1,114 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2023 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.c
+ * @brief testing lib for messenger service
+ * @author Tobias Frisch
+ */
+
+#include "messenger-testing.h"
+
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_skip ()
+{
+  struct GNUNET_MESSENGER_TestStage stage;
+  stage.door_id = 0;
+  stage.join = GNUNET_MESSENGER_STAGE_JOIN_NONE;
+  return stage;
+}
+
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_open_room ()
+{
+  struct GNUNET_MESSENGER_TestStage stage;
+  stage.door_id = 0;
+  stage.join = GNUNET_MESSENGER_STAGE_JOIN_OPEN_ROOM;
+  return stage;
+}
+
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_enter_room (uint32_t door_id)
+{
+  struct GNUNET_MESSENGER_TestStage stage;
+  stage.door_id = door_id;
+  stage.join = GNUNET_MESSENGER_STAGE_JOIN_ENTER_ROOM;
+  return stage;
+}
+
+
+struct GNUNET_MESSENGER_TestStageTopology *
+GNUNET_MESSENGER_create_topo (unsigned int peer_amount,
+                              unsigned int stage_amount,
+                              const struct GNUNET_MESSENGER_TestStage
+                              peer_stages[static peer_amount * stage_amount])
+{
+  GNUNET_assert ((peer_amount) && (stage_amount) && (peer_stages));
+
+  struct GNUNET_MESSENGER_TestStageTopology *tp;
+  tp = GNUNET_new (struct GNUNET_MESSENGER_TestStageTopology);
+  tp->peer_amount = peer_amount;
+  tp->stage_amount = stage_amount;
+
+  const unsigned int size = tp->peer_amount * tp->stage_amount;
+  tp->peer_stages = GNUNET_new_array (size, struct GNUNET_MESSENGER_TestStage);
+
+  for (unsigned int i = 0; i < size; i++)
+    tp->peer_stages[i] = peer_stages[i];
+
+  return tp;
+}
+
+
+void
+GNUNET_MESSENGER_destroy_topo (struct
+                               GNUNET_MESSENGER_TestStageTopology *topology)
+{
+  GNUNET_assert ((topology) && (topology->peer_stages));
+  GNUNET_free (topology->peer_stages);
+  GNUNET_free (topology);
+}
+
+
+struct GNUNET_MESSENGER_RoomState *
+GNUNET_MESSENGER_create_room_state (struct
+                                    GNUNET_MESSENGER_TestStageTopology *topology)
+{
+  struct GNUNET_MESSENGER_RoomState *rs;
+  rs = GNUNET_new (struct GNUNET_MESSENGER_RoomState);
+  rs->doors = GNUNET_CONTAINER_multipeermap_create (topology->peer_amount,
+                                                    GNUNET_NO);
+  rs->required_doors = 0;
+  return rs;
+}
+
+
+void
+GNUNET_MESSENGER_destroy_room_state (struct
+                                     GNUNET_MESSENGER_RoomState *room_state)
+{
+  GNUNET_assert ((room_state) && (room_state->doors));
+  GNUNET_CONTAINER_multipeermap_destroy (room_state->doors);
+  GNUNET_free (room_state);
+}
diff --git a/src/service/messenger/messenger-testing.h b/src/service/messenger/messenger-testing.h
new file mode 100644
index 000000000..850c37243
--- /dev/null
+++ b/src/service/messenger/messenger-testing.h
@@ -0,0 +1,102 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2023 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.h
+ * @brief testing lib for messenger service
+ * @author Tobias Frisch
+ */
+
+#ifndef MESSENGER_TESTING_H
+#define MESSENGER_TESTING_H
+
+enum GNUNET_MESSENGER_TestStageJoin
+{
+  GNUNET_MESSENGER_STAGE_JOIN_NONE = 0x0,
+  GNUNET_MESSENGER_STAGE_JOIN_OPEN_ROOM = 0x1,
+  GNUNET_MESSENGER_STAGE_JOIN_ENTER_ROOM = 0x2,
+};
+
+struct GNUNET_MESSENGER_TestStage
+{
+  unsigned int door_id;
+  enum GNUNET_MESSENGER_TestStageJoin join;
+};
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_skip ();
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_open_room ();
+
+struct GNUNET_MESSENGER_TestStage
+GNUNET_MESSENGER_create_stage_enter_room (unsigned int door_id);
+
+struct GNUNET_MESSENGER_TestStageTopology
+{
+  unsigned int peer_amount;
+  unsigned int stage_amount;
+
+  struct GNUNET_MESSENGER_TestStage *peer_stages;
+};
+
+struct GNUNET_MESSENGER_TestStageTopology *
+GNUNET_MESSENGER_create_topo (unsigned int peer_amount,
+                              unsigned int stage_amount,
+                              const struct GNUNET_MESSENGER_TestStage
+                              peer_stages[static peer_amount * stage_amount]);
+
+void
+GNUNET_MESSENGER_destroy_topo (struct
+                               GNUNET_MESSENGER_TestStageTopology *topology);
+
+struct GNUNET_MESSENGER_RoomState
+{
+  struct GNUNET_CONTAINER_MultiPeerMap *doors;
+
+  unsigned int required_doors;
+};
+
+struct GNUNET_MESSENGER_RoomState *
+GNUNET_MESSENGER_create_room_state (struct
+                                    GNUNET_MESSENGER_TestStageTopology *topology);
+
+void
+GNUNET_MESSENGER_destroy_room_state (struct
+                                     GNUNET_MESSENGER_RoomState *room_state);
+
+struct GNUNET_MESSENGER_StartServiceState
+{
+  char *peer_label;
+  char *system_label;
+
+  struct GNUNET_MESSENGER_TestStageTopology *topology;
+
+  struct GNUNET_TESTING_Interpreter *is;
+  const struct GNUNET_TESTING_System *tl_system;
+  struct GNUNET_MESSENGER_Handle *msg;
+  struct GNUNET_CONTAINER_MultiHashMap *rooms;
+
+  unsigned int peer_index;
+  unsigned int stage_index;
+};
+
+#endif
+/* end of messenger-testing.h */
diff --git a/src/service/messenger/messenger.conf.in b/src/service/messenger/messenger.conf.in
new file mode 100644
index 000000000..6e29dea44
--- /dev/null
+++ b/src/service/messenger/messenger.conf.in
@@ -0,0 +1,17 @@
+[messenger]
+START_ON_DEMAND = @START_ON_DEMAND@
+RUN_PER_USER = YES
+@JAVAPORT@PORT = 2125
+HOSTNAME = localhost
+BINARY = gnunet-service-messenger
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_USER_RUNTIME_DIR/gnunet-service-messenger.sock
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+
+# Directory to store messages and contacts
+MESSENGER_DIR = $GNUNET_DATA_HOME/messenger/
+MESSENGER_AUTO_CONNECTING = YES
+MESSENGER_AUTO_ROUTING = YES
+MESSENGER_MIN_ROUTERS = 3
\ No newline at end of file
diff --git a/src/service/messenger/messenger_api.c b/src/service/messenger/messenger_api.c
new file mode 100644
index 000000000..12a326202
--- /dev/null
+++ b/src/service/messenger/messenger_api.c
@@ -0,0 +1,1263 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "gnunet_common.h"
+#include "gnunet_messenger_service.h"
+
+#include "gnunet-service-messenger.h"
+
+#include "gnunet_reclaim_service.h"
+#include "gnunet_time_lib.h"
+#include "messenger_api_contact.h"
+#include "messenger_api_contact_store.h"
+#include "messenger_api_handle.h"
+#include "messenger_api_message.h"
+#include "messenger_api_message_control.h"
+#include "messenger_api_message_kind.h"
+#include "messenger_api_room.h"
+#include "messenger_api_util.h"
+
+const char*
+GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
+{
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    return "INFO";
+  case GNUNET_MESSENGER_KIND_JOIN:
+    return "JOIN";
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    return "LEAVE";
+  case GNUNET_MESSENGER_KIND_NAME:
+    return "NAME";
+  case GNUNET_MESSENGER_KIND_KEY:
+    return "KEY";
+  case GNUNET_MESSENGER_KIND_PEER:
+    return "PEER";
+  case GNUNET_MESSENGER_KIND_ID:
+    return "ID";
+  case GNUNET_MESSENGER_KIND_MISS:
+    return "MISS";
+  case GNUNET_MESSENGER_KIND_MERGE:
+    return "MERGE";
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    return "REQUEST";
+  case GNUNET_MESSENGER_KIND_INVITE:
+    return "INVITE";
+  case GNUNET_MESSENGER_KIND_TEXT:
+    return "TEXT";
+  case GNUNET_MESSENGER_KIND_FILE:
+    return "FILE";
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    return "PRIVATE";
+  case GNUNET_MESSENGER_KIND_DELETE:
+    return "DELETE";
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    return "CONNECTION";
+  case GNUNET_MESSENGER_KIND_TICKET:
+    return "TICKET";
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    return "TRANSCRIPT";
+  case GNUNET_MESSENGER_KIND_TAG:
+    return "TAG";
+  default:
+    return "UNKNOWN";
+  }
+}
+
+
+static enum GNUNET_GenericReturnValue
+dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room);
+
+static void
+handle_room_open (void *cls,
+                  const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *prev = &(msg->previous);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
+
+  open_handle_room (handle, key);
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+    return;
+
+  update_room_last_message (room, prev);
+
+  dequeue_messages_from_room (room);
+}
+
+
+static void
+handle_room_entry (void *cls,
+                   const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_PeerIdentity *door = &(msg->door);
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *prev = &(msg->previous);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entered room: %s\n", GNUNET_h2s (key));
+
+  entry_handle_room_at (handle, door, key);
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+    return;
+
+  update_room_last_message (room, prev);
+
+  dequeue_messages_from_room (room);
+}
+
+
+static void
+handle_room_close (void *cls,
+                   const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *prev = &(msg->previous);
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (room)
+    update_room_last_message (room, prev);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closed room: %s\n", GNUNET_h2s (key));
+
+  close_handle_room (handle, key);
+}
+
+
+static void
+handle_room_sync (void *cls,
+                  const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *prev = &(msg->previous);
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+    return;
+
+  update_room_last_message (room, prev);
+
+  room->wait_for_sync = GNUNET_NO;
+
+  dequeue_messages_from_room (room);
+}
+
+
+static void
+enqueue_message_to_room (struct GNUNET_MESSENGER_Room *room,
+                         struct GNUNET_MESSENGER_Message *message,
+                         struct GNUNET_MESSENGER_Message *transcript);
+
+static void
+handle_member_id (void *cls,
+                  const struct GNUNET_MESSENGER_MemberMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_ShortHashCode *id = &(msg->id);
+  const uint32_t reset = msg->reset;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Changed member id in room: %s\n",
+              GNUNET_h2s (key));
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Room is unknown to handle: %s\n",
+                GNUNET_h2s (key));
+    return;
+  }
+
+  struct GNUNET_MESSENGER_Message *message;
+  if ((! get_room_sender_id (room)) || (GNUNET_YES == reset))
+  {
+    set_room_sender_id (room, id);
+    message = create_message_join (get_handle_key (handle));
+  }
+  else
+    message = create_message_id (id);
+
+  if (! message)
+    return;
+
+  enqueue_message_to_room (room, message, NULL);
+}
+
+
+static enum GNUNET_GenericReturnValue
+check_recv_message (void *cls,
+                    const struct GNUNET_MESSENGER_RecvMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size);
+
+  if (full_length < sizeof(*msg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Receiving failed: Message invalid!\n");
+    return GNUNET_NO;
+  }
+
+  const uint16_t length = full_length - sizeof(*msg);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+
+  if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+                                      GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Receiving failed: Message too short!\n");
+    return GNUNET_NO;
+  }
+
+  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Receiving failed: Message decoding failed!\n");
+    return GNUNET_NO;
+  }
+
+  cleanup_message (&message);
+  return GNUNET_OK;
+}
+
+
+static void
+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);
+
+  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, GNUNET_YES, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n",
+              GNUNET_MESSENGER_name_of_kind (message.header.kind));
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n",
+                GNUNET_h2s (key));
+
+    goto skip_message;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Raw contact from sender and context: (%s : %s)\n",
+              GNUNET_h2s (sender), GNUNET_h2s_full (context));
+
+  process_message_control (room->control,
+                           sender,
+                           context,
+                           hash,
+                           &message,
+                           flags);
+
+skip_message:
+  cleanup_message (&message);
+}
+
+
+static void
+handle_miss_message (void *cls,
+                     const struct GNUNET_MESSENGER_GetMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_HashCode *key = &(msg->key);
+  const struct GNUNET_HashCode *hash = &(msg->hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Missing message in room: %s\n",
+              GNUNET_h2s (hash));
+
+  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
+
+  if (! room)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Miss in unknown room for this client: %s\n", GNUNET_h2s (key));
+    return;
+  }
+
+  if (! get_room_sender_id (room))
+    return;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_request (hash);
+  if (! message)
+    return;
+
+  enqueue_message_to_room (room, message, NULL);
+}
+
+
+static void
+reconnect (struct GNUNET_MESSENGER_Handle *handle);
+
+static void
+send_open_room (struct GNUNET_MESSENGER_Handle *handle,
+                struct GNUNET_MESSENGER_Room *room)
+{
+  const struct GNUNET_CRYPTO_PublicKey *key = get_handle_pubkey (handle);
+
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Open room (%s) by member using key: %s\n",
+              GNUNET_h2s (&(room->key)),
+              GNUNET_CRYPTO_public_key_to_string (key));
+
+  const ssize_t len = GNUNET_CRYPTO_public_key_get_length (key);
+
+  env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
+                             GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
+  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+  GNUNET_memcpy (&(msg->previous), &(room->last_message),
+                 sizeof(msg->previous));
+
+  char *msg_buffer = ((char*) msg) + sizeof(*msg);
+
+  if (len > 0)
+    GNUNET_CRYPTO_write_public_key_to_buffer (key, msg_buffer, len);
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+
+static void
+send_enter_room (struct GNUNET_MESSENGER_Handle *handle,
+                 struct GNUNET_MESSENGER_Room *room,
+                 const struct GNUNET_PeerIdentity *door)
+{
+  const struct GNUNET_CRYPTO_PublicKey *key = get_handle_pubkey (handle);
+
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Enter room (%s) via door: %s (%s)\n",
+              GNUNET_h2s (&(room->key)),
+              GNUNET_i2s (door),
+              GNUNET_CRYPTO_public_key_to_string (key));
+
+  const ssize_t len = GNUNET_CRYPTO_public_key_get_length (key);
+
+  env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
+                             GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
+  GNUNET_memcpy (&(msg->door), door, sizeof(*door));
+  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+  GNUNET_memcpy (&(msg->previous), &(room->last_message),
+                 sizeof(msg->previous));
+
+  char *msg_buffer = ((char*) msg) + sizeof(*msg);
+
+  if (len > 0)
+    GNUNET_CRYPTO_write_public_key_to_buffer (key, msg_buffer, len);
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+
+static void
+send_close_room (struct GNUNET_MESSENGER_Handle *handle,
+                 struct GNUNET_MESSENGER_Room *room)
+{
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Close room (%s)!\n",
+              GNUNET_h2s (&(room->key)));
+
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
+
+  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+  GNUNET_memcpy (&(msg->previous), &(room->last_message),
+                 sizeof(msg->previous));
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+
+static void
+send_sync_room (struct GNUNET_MESSENGER_Handle *handle,
+                struct GNUNET_MESSENGER_Room *room)
+{
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  room->wait_for_sync = GNUNET_YES;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sync room (%s)!\n",
+              GNUNET_h2s (&(room->key)));
+
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC);
+
+  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+  GNUNET_memcpy (&(msg->previous), &(room->last_message),
+                 sizeof(msg->previous));
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_reset_room (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+  struct GNUNET_MESSENGER_Room *room = value;
+
+  if (GNUNET_YES == room->opened)
+    send_open_room (handle, room);
+
+  struct GNUNET_MESSENGER_ListTunnel *entry = room->entries.head;
+
+  struct GNUNET_PeerIdentity door;
+
+  while (entry)
+  {
+    GNUNET_PEER_resolve (entry->peer, &door);
+
+    send_enter_room (handle, room, &door);
+
+    entry = entry->next;
+  }
+
+  return GNUNET_YES;
+}
+
+
+static void
+callback_reconnect (void *cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  handle->reconnect_task = NULL;
+  handle->reconnect_time = GNUNET_TIME_STD_BACKOFF (handle->reconnect_time);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnect messenger!\n");
+
+  reconnect (handle);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_reset_room,
+                                         handle);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_close_room (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+  struct GNUNET_MESSENGER_Room *room = value;
+
+  send_close_room (handle, room);
+
+  return GNUNET_YES;
+}
+
+
+static void
+callback_mq_error (void *cls,
+                   enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_close_room,
+                                         handle);
+
+  if (handle->mq)
+  {
+    GNUNET_MQ_destroy (handle->mq);
+    handle->mq = NULL;
+  }
+
+  handle->reconnect_task = GNUNET_SCHEDULER_add_delayed (handle->reconnect_time,
+                                                         &callback_reconnect,
+                                                         handle);
+}
+
+
+static void
+reconnect (struct GNUNET_MESSENGER_Handle *handle)
+{
+  const struct GNUNET_MQ_MessageHandler handlers[] = {
+    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_hd_fixed_size (
+      miss_message,
+      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE,
+      struct GNUNET_MESSENGER_GetMessage, handle
+      ),
+    GNUNET_MQ_hd_fixed_size (
+      room_sync,
+      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC,
+      struct GNUNET_MESSENGER_RoomMessage, 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*
+GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                          const char *name,
+                          const struct GNUNET_CRYPTO_PrivateKey *key,
+                          GNUNET_MESSENGER_MessageCallback msg_callback,
+                          void *msg_cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, msg_callback,
+                                                          msg_cls);
+
+  reconnect (handle);
+
+  if (handle->mq)
+  {
+    set_handle_name (handle, name);
+
+    if ((! key) || (0 < GNUNET_CRYPTO_private_key_get_length (key)))
+      set_handle_key (handle, key);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connect handle!\n");
+
+    struct GNUNET_MESSENGER_CreateMessage *msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
+    GNUNET_MQ_send (handle->mq, env);
+    return handle;
+  }
+  else
+  {
+    destroy_handle (handle);
+    return NULL;
+  }
+}
+
+
+void
+GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (! handle)
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect handle!\n");
+
+  struct GNUNET_MESSENGER_DestroyMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY);
+  GNUNET_MQ_send (handle->mq, env);
+
+  destroy_handle (handle);
+}
+
+
+static void
+callback_leave_message_sent (void *cls)
+{
+  struct GNUNET_MESSENGER_Room *room = cls;
+
+  room->opened = GNUNET_NO;
+  clear_list_tunnels (&(room->entries));
+
+  send_close_room (room->handle, room);
+}
+
+
+static void
+send_message_to_room (struct GNUNET_MESSENGER_Room *room,
+                      struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_CRYPTO_PrivateKey *key,
+                      struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_ShortHashCode *sender_id = get_room_sender_id (room);
+
+  message->header.timestamp = GNUNET_TIME_absolute_hton (
+    GNUNET_TIME_absolute_get ());
+
+  GNUNET_memcpy (&(message->header.sender_id), sender_id,
+                 sizeof(message->header.sender_id));
+  GNUNET_memcpy (&(message->header.previous), &(room->last_message),
+                 sizeof(message->header.previous));
+
+  message->header.signature.type = key->type;
+
+  const uint16_t msg_length = get_message_size (message, GNUNET_YES);
+
+  struct GNUNET_MESSENGER_SendMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra (
+    msg, msg_length,
+    GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
+    );
+
+  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+
+  char *msg_buffer = ((char*) msg) + sizeof(*msg);
+  encode_message (message, msg_length, msg_buffer, GNUNET_YES);
+
+  hash_message (message, msg_length, msg_buffer, hash);
+  sign_message (message, msg_length, msg_buffer, hash, key);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send message (%s)!\n",
+              GNUNET_h2s (hash));
+
+  update_room_last_message (room, hash);
+
+  if (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind)
+    GNUNET_MQ_notify_sent (env, callback_leave_message_sent, room);
+
+  GNUNET_MQ_send (room->handle->mq, env);
+}
+
+
+static void
+enqueue_message_to_room (struct GNUNET_MESSENGER_Room *room,
+                         struct GNUNET_MESSENGER_Message *message,
+                         struct GNUNET_MESSENGER_Message *transcript)
+{
+  GNUNET_assert ((room) && (message));
+
+  const struct GNUNET_CRYPTO_PrivateKey *key = get_handle_key (room->handle);
+  enum GNUNET_GenericReturnValue priority;
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    priority = GNUNET_YES;
+    break;
+  default:
+    priority = GNUNET_NO;
+    break;
+  }
+
+  enqueue_to_messages (&(room->queue), key, message, transcript, priority);
+
+  if (GNUNET_YES != is_room_available (room))
+    return;
+
+  if (GNUNET_YES == is_message_session_bound (message))
+    send_sync_room (room->handle, room);
+  else if (GNUNET_YES != room->wait_for_sync)
+    dequeue_messages_from_room (room);
+}
+
+
+static enum GNUNET_GenericReturnValue
+dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room)
+{
+  if (GNUNET_YES != is_room_available (room))
+    return room->queue.head ? GNUNET_NO : GNUNET_YES;
+
+  struct GNUNET_MESSENGER_Message *message = NULL;
+  struct GNUNET_MESSENGER_Message *transcript = NULL;
+  struct GNUNET_CRYPTO_PublicKey pubkey;
+  struct GNUNET_CRYPTO_PrivateKey key;
+  struct GNUNET_HashCode hash, other;
+
+  do {
+    if (message)
+      destroy_message (message);
+
+    memset (&key, 0, sizeof(key));
+    message = dequeue_from_messages (&(room->queue), &key, &transcript);
+
+    if (! message)
+    {
+      message = transcript;
+      transcript = NULL;
+      continue;
+    }
+
+    send_message_to_room (room, message, &key, &hash);
+
+    if (! transcript)
+    {
+      GNUNET_CRYPTO_private_key_clear (&key);
+      continue;
+    }
+
+    GNUNET_memcpy (&(transcript->body.transcript.hash), &hash, sizeof(hash));
+
+    memset (&pubkey, 0, sizeof(pubkey));
+    GNUNET_CRYPTO_key_get_public (&key, &pubkey);
+
+    if (GNUNET_YES == encrypt_message (transcript, &pubkey))
+    {
+      send_message_to_room (room, transcript, &key, &other);
+      GNUNET_CRYPTO_private_key_clear (&key);
+
+      link_room_message (room, &hash, &other);
+      link_room_message (room, &other, &hash);
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Sending transcript aborted: Encryption failed!\n");
+
+    destroy_message (transcript);
+    transcript = NULL;
+  } while (message);
+
+  return GNUNET_YES;
+}
+
+
+const char*
+GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (! handle)
+    return NULL;
+
+  return get_handle_name (handle);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_send_name_to_room (void *cls,
+                           struct GNUNET_MESSENGER_Room *room,
+                           const struct GNUNET_MESSENGER_Contact *contact)
+{
+  const struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  if (GNUNET_YES != room->use_handle_name)
+    return GNUNET_YES;
+
+  const char *name = get_handle_name (handle);
+
+  if (! name)
+    return GNUNET_YES;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_name (name);
+
+  if (! message)
+    return GNUNET_NO;
+
+  enqueue_message_to_room (room, message, NULL);
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle,
+                           const char *name)
+{
+  if (! handle)
+    return GNUNET_SYSERR;
+
+  set_handle_name (handle, strlen (name) > 0 ? name : NULL);
+  GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_name_to_room, handle);
+  return GNUNET_YES;
+}
+
+
+static const struct GNUNET_CRYPTO_PublicKey*
+get_non_anonymous_key (const struct GNUNET_CRYPTO_PublicKey *public_key)
+{
+  if (0 == GNUNET_memcmp (public_key, get_anonymous_public_key ()))
+    return NULL;
+
+  return public_key;
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (! handle)
+    return NULL;
+
+  return get_non_anonymous_key (get_handle_pubkey (handle));
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_send_key_to_room (void *cls,
+                          struct GNUNET_MESSENGER_Room *room,
+                          const struct GNUNET_MESSENGER_Contact *contact)
+{
+  const struct GNUNET_CRYPTO_PrivateKey *key = cls;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_key (key);
+
+  if (! message)
+    return GNUNET_NO;
+
+  enqueue_message_to_room (room, message, NULL);
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle,
+                          const struct GNUNET_CRYPTO_PrivateKey *key)
+{
+  if (! handle)
+    return GNUNET_SYSERR;
+
+  if (! key)
+  {
+    GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, NULL);
+    set_handle_key (handle, NULL);
+    return GNUNET_YES;
+  }
+
+  if (0 >= GNUNET_CRYPTO_private_key_get_length (key))
+    return GNUNET_SYSERR;
+
+  struct GNUNET_CRYPTO_PrivateKey priv;
+  GNUNET_memcpy (&priv, key, sizeof (priv));
+
+  GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, &priv);
+  GNUNET_CRYPTO_private_key_clear (&priv);
+
+  set_handle_key (handle, key);
+  return GNUNET_YES;
+}
+
+
+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)
+  {
+    room = create_room (handle, key);
+
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
+                                                        room,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    {
+      destroy_room (room);
+      return NULL;
+    }
+  }
+
+  send_open_room (handle, room);
+  return room;
+}
+
+
+struct GNUNET_MESSENGER_Room*
+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)
+  {
+    room = create_room (handle, key);
+
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
+                                                        room,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    {
+      destroy_room (room);
+      return NULL;
+    }
+  }
+
+  send_enter_room (handle, room, door);
+  return room;
+}
+
+
+void
+GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
+{
+  if (! room)
+    return;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_leave ();
+
+  if (! message)
+    return;
+
+  enqueue_message_to_room (room, message, NULL);
+}
+
+
+struct GNUNET_MESSENGER_RoomFind
+{
+  const struct GNUNET_MESSENGER_Contact *contact;
+  GNUNET_MESSENGER_MemberCallback callback;
+  size_t counter;
+  void *cls;
+};
+
+static enum GNUNET_GenericReturnValue
+iterate_find_room (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   void *value)
+{
+  struct GNUNET_MESSENGER_RoomFind *find = cls;
+  struct GNUNET_MESSENGER_Room *room = value;
+
+  if ((find->counter > 0) && ((! find->contact) || (GNUNET_YES ==
+                                                    find_room_member (room,
+                                                                      find->
+                                                                      contact)))
+      )
+  {
+    find->counter--;
+
+    if (! find->callback)
+      return GNUNET_YES;
+
+    return find->callback (find->cls, room, find->contact);
+  }
+  else
+    return GNUNET_NO;
+}
+
+
+int
+GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle *handle,
+                             const struct GNUNET_MESSENGER_Contact *contact,
+                             GNUNET_MESSENGER_MemberCallback callback,
+                             void *cls)
+{
+  if (! handle)
+    return GNUNET_SYSERR;
+
+  struct GNUNET_MESSENGER_RoomFind find;
+
+  find.contact = contact;
+  find.callback = callback;
+  find.counter = (contact? contact->rc : SIZE_MAX);
+  find.cls = cls;
+
+  return GNUNET_CONTAINER_multihashmap_iterate (handle->rooms,
+                                                iterate_find_room, &find);
+}
+
+
+const struct GNUNET_HashCode*
+GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
+{
+  if (! room)
+    return NULL;
+
+  return &(room->key);
+}
+
+
+const struct GNUNET_MESSENGER_Contact*
+GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room,
+                             const struct GNUNET_HashCode *hash)
+{
+  if ((! room) || (! hash))
+    return NULL;
+
+  return get_room_sender (room, hash);
+}
+
+
+const struct GNUNET_MESSENGER_Contact*
+GNUNET_MESSENGER_get_recipient (const struct GNUNET_MESSENGER_Room *room,
+                                const struct GNUNET_HashCode *hash)
+{
+  if ((! room) || (! hash))
+    return NULL;
+
+  return get_room_recipient (room, hash);
+}
+
+
+const char*
+GNUNET_MESSENGER_contact_get_name (const struct
+                                   GNUNET_MESSENGER_Contact *contact)
+{
+  if (! contact)
+    return NULL;
+
+  return get_contact_name (contact);
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+GNUNET_MESSENGER_contact_get_key (const struct
+                                  GNUNET_MESSENGER_Contact *contact)
+{
+  if (! contact)
+    return NULL;
+
+  return get_non_anonymous_key (get_contact_key (contact));
+}
+
+
+size_t
+GNUNET_MESSENGER_contact_get_id (const struct
+                                 GNUNET_MESSENGER_Contact *contact)
+{
+  if (! contact)
+    return 0;
+
+  return get_contact_id (contact);
+}
+
+
+static void
+send_message_to_room_with_key (struct GNUNET_MESSENGER_Room *room,
+                               struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_CRYPTO_PublicKey *public_key)
+{
+  struct GNUNET_MESSENGER_Message *transcript = NULL;
+  const struct GNUNET_CRYPTO_PublicKey *pubkey;
+
+  char *original_name;
+
+  if (GNUNET_MESSENGER_KIND_NAME != message->header.kind)
+    goto skip_naming;
+
+  original_name = message->body.name.name;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Apply rule for using handle name in room: %s\n", GNUNET_h2s (
+                &(room->key)));
+
+  const char *handle_name = get_handle_name (room->handle);
+
+  if ((handle_name) && (GNUNET_YES == room->use_handle_name) &&
+      ((! original_name) || (0 == strlen (original_name))))
+  {
+    if (original_name)
+      GNUNET_free (original_name);
+
+    message->body.name.name = GNUNET_strdup (handle_name);
+  }
+
+skip_naming:
+  if (! public_key)
+    goto skip_encryption;
+
+  pubkey = get_handle_pubkey (room->handle);
+
+  if (0 != GNUNET_memcmp (pubkey, public_key))
+    transcript = transcribe_message (message, public_key);
+
+  if (GNUNET_YES != encrypt_message (message, public_key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Sending message aborted: Encryption failed!\n");
+
+    if (transcript)
+      destroy_message (transcript);
+
+    destroy_message (message);
+    return;
+  }
+
+skip_encryption:
+  enqueue_message_to_room (room, message, transcript);
+}
+
+
+void
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room,
+                               const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_MESSENGER_Contact *contact)
+{
+  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;
+  }
+
+  const struct GNUNET_CRYPTO_PublicKey *public_key;
+
+  if (contact)
+  {
+    public_key = get_non_anonymous_key (
+      get_contact_key (contact)
+      );
+
+    if (! public_key)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Sending message aborted: Invalid key!\n");
+      return;
+    }
+  }
+  else
+    public_key = NULL;
+
+  send_message_to_room_with_key (room, copy_message (message), public_key);
+}
+
+
+void
+delete_message_in_room (struct GNUNET_MESSENGER_Room *room,
+                        const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_TIME_Relative delay)
+{
+  struct GNUNET_MESSENGER_Message *message = create_message_delete (hash,
+                                                                    delay);
+
+  if (! message)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Sending deletion aborted: Message creation failed!\n");
+    return;
+  }
+
+  send_message_to_room_with_key (room, message, NULL);
+}
+
+
+void
+GNUNET_MESSENGER_delete_message (struct GNUNET_MESSENGER_Room *room,
+                                 const struct GNUNET_HashCode *hash,
+                                 const struct GNUNET_TIME_Relative delay)
+{
+  if ((! room) || (! hash))
+    return;
+
+  delete_message_in_room (room, hash, delay);
+}
+
+
+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)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Request message (%s)!\n",
+                GNUNET_h2s (hash));
+
+    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(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/service/messenger/messenger_api_cmd_join_room.c b/src/service/messenger/messenger_api_cmd_join_room.c
new file mode 100644
index 000000000..dc0e9a882
--- /dev/null
+++ b/src/service/messenger/messenger_api_cmd_join_room.c
@@ -0,0 +1,181 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2023 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_api_cmd_join_room.c
+ * @brief cmd to join a room in a messenger service.
+ * @author Tobias Frisch
+ */
+
+#include "gnunet_util_lib.h"
+#include "gnunet_core_testing_lib.h"
+#include "gnunet_transport_testing_ng_lib.h"
+#include "gnunet_messenger_service.h"
+#include "messenger-testing-cmds.h"
+
+struct GNUNET_MESSENGER_JoinRoomState
+{
+  char *service_label;
+  char *room_key;
+
+  struct GNUNET_MESSENGER_Room *room;
+};
+
+static void
+join_room_run (void *cls,
+               struct GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_MESSENGER_JoinRoomState *jrs = cls;
+  struct GNUNET_HashCode key;
+
+  if (jrs->room_key)
+    GNUNET_CRYPTO_hash (jrs->room_key, strlen (jrs->room_key), &key);
+  else
+    memset (&key, 0, sizeof(key));
+
+  const struct GNUNET_TESTING_Command *service_cmd;
+  service_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                           jrs->service_label);
+
+  struct GNUNET_MESSENGER_StartServiceState *sss;
+  GNUNET_MESSENGER_get_trait_state (service_cmd, &sss);
+
+  unsigned int peer_index;
+  unsigned int stage_index;
+  struct GNUNET_MESSENGER_RoomState *rs;
+
+  rs = GNUNET_CONTAINER_multihashmap_get (sss->rooms, &key);
+  if (rs)
+    goto skip_room_state;
+
+  rs = GNUNET_MESSENGER_create_room_state (sss->topology);
+  if ((! rs) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (sss->rooms,
+                                                                 &key,
+                                                                 rs,
+                                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testing library failed to create a room state with key '%s'\n",
+                jrs->room_key);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+skip_room_state:
+  peer_index = sss->peer_index;
+  stage_index = sss->stage_index;
+
+  const unsigned int index = stage_index * sss->topology->peer_amount
+                             + peer_index;
+  const struct GNUNET_MESSENGER_TestStage *stage =
+    &(sss->topology->peer_stages[index]);
+
+  unsigned int door_index = stage->door_id;
+
+  if (door_index == 0)
+    door_index = (peer_index + GNUNET_CRYPTO_random_u32 (
+                    GNUNET_CRYPTO_QUALITY_WEAK,
+                    sss->topology->peer_amount - 1
+                    ) + 1) % sss->topology->peer_amount;
+  else
+    door_index = (door_index - 1) % sss->topology->peer_amount;
+
+  struct GNUNET_PeerIdentity *door;
+  door = GNUNET_TESTING_get_peer (door_index, sss->tl_system);
+  if (! door)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testing library failed to get peer identity of index '%u'\n",
+                door_index);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  struct GNUNET_MESSENGER_Room *room;
+  switch (stage->join)
+  {
+  case GNUNET_MESSENGER_STAGE_JOIN_OPEN_ROOM:
+    room = GNUNET_MESSENGER_open_room (sss->msg, &key);
+
+    if (! room)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Testing library failed to open room with key '%s'\n",
+                  jrs->room_key);
+      GNUNET_free (door);
+      GNUNET_TESTING_interpreter_fail (is);
+      return;
+    }
+
+    break;
+  case GNUNET_MESSENGER_STAGE_JOIN_ENTER_ROOM:
+    room = GNUNET_MESSENGER_enter_room (sss->msg, door, &key);
+
+    if (! room)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Testing library failed to enter room with key '%s'\n",
+                  jrs->room_key);
+      GNUNET_free (door);
+      GNUNET_TESTING_interpreter_fail (is);
+      return;
+    }
+
+    break;
+  default:
+    room = NULL;
+    break;
+  }
+
+  jrs->room = room;
+TODO: sss->stage_index++;
+
+  GNUNET_free (door);
+}
+
+
+static void
+join_room_cleanup (void *cls)
+{
+  struct GNUNET_MESSENGER_JoinRoomState *jrs = cls;
+
+  GNUNET_free (jrs->room_key);
+  GNUNET_free (jrs->service_label);
+  GNUNET_free (jrs);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_join_room (const char *label,
+                                const char *service_label,
+                                const char *room_key)
+{
+  struct GNUNET_MESSENGER_JoinRoomState *jrs;
+
+  jrs = GNUNET_new (struct GNUNET_MESSENGER_JoinRoomState);
+  jrs->service_label = GNUNET_strdup (service_label);
+  jrs->room_key = GNUNET_strdup (room_key);
+
+  return GNUNET_TESTING_command_new (jrs,
+                                     label,
+                                     &join_room_run,
+                                     &join_room_cleanup,
+                                     NULL);
+}
diff --git a/src/service/messenger/messenger_api_cmd_start_service.c b/src/service/messenger/messenger_api_cmd_start_service.c
new file mode 100644
index 000000000..f764d31c2
--- /dev/null
+++ b/src/service/messenger/messenger_api_cmd_start_service.c
@@ -0,0 +1,172 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2023--2024 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_api_cmd_start_service.c
+ * @brief cmd to start a messenger service.
+ * @author Tobias Frisch
+ */
+
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_transport_testing_ng_lib.h"
+#include "gnunet_messenger_service.h"
+#include "messenger-testing-cmds.h"
+
+static void
+on_message_cb (void *cls,
+               struct GNUNET_MESSENGER_Room *room,
+               const struct GNUNET_MESSENGER_Contact *sender,
+               const struct GNUNET_MESSENGER_Contact *recipient,
+               const struct GNUNET_MESSENGER_Message *message,
+               const struct GNUNET_HashCode *hash,
+               enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  struct GNUNET_MESSENGER_StartServiceState *sss = cls;
+
+  const struct GNUNET_HashCode *key = GNUNET_MESSENGER_room_get_key (room);
+  struct GNUNET_MESSENGER_RoomState *rs;
+
+  rs = GNUNET_CONTAINER_multihashmap_get (sss->rooms, key);
+  if (! rs)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testing library failed to find room state\n");
+    GNUNET_TESTING_interpreter_fail (sss->is);
+    return;
+  }
+
+  if (GNUNET_MESSENGER_KIND_PEER != message->header.kind)
+    return;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (rs->doors,
+                                                      &(message->body.peer.peer)
+                                                      ,
+                                                      NULL,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testing library failed to register peer identity as found door\n");
+    GNUNET_TESTING_interpreter_fail (sss->is);
+    return;
+  }
+}
+
+
+static void
+start_service_run (void *cls,
+                   struct GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_MESSENGER_StartServiceState *sss = cls;
+
+  sss->is = is;
+
+  const struct GNUNET_TESTING_Command *peer_cmd;
+  peer_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                        sss->peer_label);
+
+  const struct GNUNET_TESTING_StartPeerState *sps;
+  GNUNET_TRANSPORT_TESTING_get_trait_state (peer_cmd, &sps);
+
+  const struct GNUNET_TESTING_Command *system_cmd;
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          sss->system_label);
+
+  const struct GNUNET_TESTING_System *tl_system;
+  GNUNET_TESTING_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  sss->tl_system = tl_system;
+
+  sss->msg = GNUNET_MESSENGER_connect (sps->cfg, NULL, NULL, on_message_cb,
+                                       sss);
+  if (! sss->msg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Testing library failed to connect to messenger service\n");
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  sss->rooms = GNUNET_CONTAINER_multihashmap_create (
+    sss->topology->stage_amount, GNUNET_NO);
+}
+
+
+static void
+start_service_cleanup (void *cls)
+{
+  struct GNUNET_MESSENGER_StartServiceState *sss = cls;
+
+  GNUNET_free (sss->system_label);
+  GNUNET_free (sss->peer_label);
+  GNUNET_free (sss);
+}
+
+
+static enum GNUNET_GenericReturnValue
+start_service_traits (void *cls,
+                      const void **ret,
+                      const char *trait,
+                      unsigned int index)
+{
+  struct GNUNET_MESSENGER_StartServiceState *sss = cls;
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    GNUNET_MESSENGER_make_trait_state ((void *) sss),
+    GNUNET_TESTING_trait_end ()
+  };
+
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_start_service (const char *label,
+                                    const char *peer_label,
+                                    const char *system_label,
+                                    struct GNUNET_MESSENGER_TestStageTopology *
+                                    topology,
+                                    unsigned int peer_index)
+{
+  struct GNUNET_MESSENGER_StartServiceState *sss;
+
+  sss = GNUNET_new (struct GNUNET_MESSENGER_StartServiceState);
+  sss->peer_label = GNUNET_strdup (peer_label);
+  sss->system_label = GNUNET_strdup (system_label);
+  sss->topology = topology;
+
+  sss->is = NULL;
+  sss->tl_system = NULL;
+  sss->msg = NULL;
+  sss->rooms = NULL;
+  sss->peer_index = peer_index;
+  sss->stage_index = 0;
+
+  return GNUNET_TESTING_command_new (sss,
+                                     label,
+                                     &start_service_run,
+                                     &start_service_cleanup,
+                                     &start_service_traits);
+}
diff --git a/src/service/messenger/messenger_api_cmd_stop_service.c b/src/service/messenger/messenger_api_cmd_stop_service.c
new file mode 100644
index 000000000..b10de7661
--- /dev/null
+++ b/src/service/messenger/messenger_api_cmd_stop_service.c
@@ -0,0 +1,95 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2023 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_api_cmd_stop_service.c
+ * @brief cmd to stop a messenger service.
+ * @author Tobias Frisch
+ */
+
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_messenger_service.h"
+#include "messenger-testing-cmds.h"
+
+struct GNUNET_MESSENGER_StopServiceState
+{
+  char *service_label;
+};
+
+static enum GNUNET_GenericReturnValue
+cleanup_rooms_cb (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  struct GNUNET_MESSENGER_RoomState *rs = cls;
+  GNUNET_MESSENGER_destroy_room_state (rs);
+  return GNUNET_YES;
+}
+
+
+static void
+stop_service_run (void *cls,
+                  struct GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_MESSENGER_StopServiceState *stop_ss = cls;
+
+  const struct GNUNET_TESTING_Command *service_cmd;
+  service_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                           stop_ss->
+                                                           service_label);
+
+  struct GNUNET_MESSENGER_StartServiceState *sss;
+  GNUNET_MESSENGER_get_trait_state (service_cmd, &sss);
+
+  GNUNET_MESSENGER_disconnect (sss->msg);
+  sss->msg = NULL;
+
+  GNUNET_CONTAINER_multihashmap_iterate (sss->rooms, cleanup_rooms_cb, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (sss->rooms);
+  sss->rooms = NULL;
+}
+
+
+static void
+stop_service_cleanup (void *cls)
+{
+  struct GNUNET_MESSENGER_StopServiceState *sss = cls;
+
+  GNUNET_free (sss->service_label);
+  GNUNET_free (sss);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_MESSENGER_cmd_stop_service (const char *label,
+                                   const char *service_label)
+{
+  struct GNUNET_MESSENGER_StopServiceState *sss;
+
+  sss = GNUNET_new (struct GNUNET_MESSENGER_StopServiceState);
+  sss->service_label = GNUNET_strdup (service_label);
+
+  return GNUNET_TESTING_command_new (sss,
+                                     label,
+                                     &stop_service_run,
+                                     &stop_service_cleanup,
+                                     NULL);
+}
diff --git a/src/service/messenger/messenger_api_contact.c b/src/service/messenger/messenger_api_contact.c
new file mode 100644
index 000000000..841f72a10
--- /dev/null
+++ b/src/service/messenger/messenger_api_contact.c
@@ -0,0 +1,129 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_contact.h"
+
+struct GNUNET_MESSENGER_Contact*
+create_contact (const struct GNUNET_CRYPTO_PublicKey *key,
+                size_t unique_id)
+{
+  GNUNET_assert (key);
+
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_new (struct
+                                                         GNUNET_MESSENGER_Contact);
+
+  contact->name = NULL;
+  contact->rc = 0;
+  contact->id = unique_id;
+
+  GNUNET_memcpy (&(contact->public_key), key, sizeof(contact->public_key));
+
+  return contact;
+}
+
+
+void
+destroy_contact (struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (contact);
+
+  if (contact->name)
+    GNUNET_free (contact->name);
+
+  GNUNET_free (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;
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (contact);
+
+  return &(contact->public_key);
+}
+
+
+void
+increase_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (contact);
+
+  contact->rc++;
+}
+
+
+enum GNUNET_GenericReturnValue
+decrease_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (contact);
+
+  if (contact->rc > 0)
+    contact->rc--;
+
+  return contact->rc ? GNUNET_NO : GNUNET_YES;
+}
+
+
+size_t
+get_contact_id (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (contact);
+
+  return contact->id;
+}
+
+
+void
+get_context_from_member (const struct GNUNET_HashCode *key,
+                         const struct GNUNET_ShortHashCode *id,
+                         struct GNUNET_HashCode *context)
+{
+  GNUNET_assert ((key) && (id) && (context));
+
+  GNUNET_CRYPTO_hash (id, sizeof(*id), context);
+  GNUNET_CRYPTO_hash_xor (key, context, context);
+}
diff --git a/src/service/messenger/messenger_api_contact.h b/src/service/messenger/messenger_api_contact.h
new file mode 100644
index 000000000..d3bb38e96
--- /dev/null
+++ b/src/service/messenger/messenger_api_contact.h
@@ -0,0 +1,126 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_CONTACT_H
+#define GNUNET_MESSENGER_API_CONTACT_H
+
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_Contact
+{
+  char *name;
+  size_t rc;
+  size_t id;
+
+  struct GNUNET_CRYPTO_PublicKey public_key;
+};
+
+/**
+ * Creates and allocates a new contact with a given public <i>key</i>.
+ *
+ * @param[in] key Public key
+ * @param[in] unique_id Locally unique identifier
+ * @return New contact
+ */
+struct GNUNET_MESSENGER_Contact*
+create_contact (const struct GNUNET_CRYPTO_PublicKey *key,
+                size_t unique_id);
+
+/**
+ * Destroys a contact and frees its memory fully.
+ *
+ * @param[in,out] contact Contact
+ */
+void
+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[in] contact Contact
+ * @return Name of the contact or NULL
+ */
+const char*
+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[in,out] contact Contact
+ * @param[in] name Name
+ */
+void
+set_contact_name (struct GNUNET_MESSENGER_Contact *contact,
+                  const char *name);
+
+/**
+ * Returns the public key of a given <i>contact</i>.
+ *
+ * @param[in] contact Contact
+ * @return Public key of the contact
+ */
+const struct GNUNET_CRYPTO_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Increases the reference counter of a given <i>contact</i> which is zero as default.
+ *
+ * @param[in,out] 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
+ */
+enum GNUNET_GenericReturnValue
+decrease_contact_rc (struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Returns the locally unique identifier of a given <i>contact</i>.
+ *
+ * @param[in] contact contact Contact
+ * @return Locally unique identifier of contact
+ */
+size_t
+get_contact_id (const 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] context 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/service/messenger/messenger_api_contact_store.c b/src/service/messenger/messenger_api_contact_store.c
new file mode 100644
index 000000000..081a8c6e9
--- /dev/null
+++ b/src/service/messenger/messenger_api_contact_store.c
@@ -0,0 +1,218 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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 "gnunet_common.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);
+
+  store->counter = 0;
+}
+
+
+static enum GNUNET_GenericReturnValue
+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_log (GNUNET_ERROR_TYPE_DEBUG, "Clear contact store\n");
+
+  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_CRYPTO_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_CRYPTO_PublicKey *pubkey)
+{
+  GNUNET_assert ((store) && (store->contacts) && (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_CRYPTO_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, ++(store->counter));
+
+  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_CRYPTO_PublicKey *pubkey)
+{
+  GNUNET_assert ((store) && (store->contacts) && (contact) && (pubkey));
+
+  const struct GNUNET_CRYPTO_PublicKey *oldkey = get_contact_key (contact);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (oldkey, sizeof(*oldkey), &hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update contact store entry: %s\n",
+              GNUNET_h2s (&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_CRYPTO_PublicKey *pubkey = get_contact_key (contact);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove contact store entry: %s\n",
+              GNUNET_h2s (&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/service/messenger/messenger_api_contact_store.h b/src/service/messenger/messenger_api_contact_store.h
new file mode 100644
index 000000000..6b61f3e4f
--- /dev/null
+++ b/src/service/messenger/messenger_api_contact_store.h
@@ -0,0 +1,126 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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 "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_Contact;
+
+struct GNUNET_MESSENGER_ContactStore
+{
+  struct GNUNET_CONTAINER_MultiHashMap *anonymous;
+  struct GNUNET_CONTAINER_MultiHashMap *contacts;
+
+  size_t counter;
+};
+
+/**
+ * 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 occurs during allocation
+ * or validation of the contacts key.
+ *
+ * @param[in,out] store Contact store
+ * @param[in] context Member context
+ * @param[in] pubkey Public key
+ */
+struct GNUNET_MESSENGER_Contact*
+get_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
+                   const struct GNUNET_HashCode *context,
+                   const struct GNUNET_CRYPTO_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
+ */
+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_CRYPTO_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/service/messenger/messenger_api_handle.c b/src/service/messenger/messenger_api_handle.c
new file mode 100644
index 000000000..1cf2bccf0
--- /dev/null
+++ b/src/service/messenger/messenger_api_handle.c
@@ -0,0 +1,270 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_handle.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_handle.h"
+
+#include "messenger_api_room.h"
+#include "messenger_api_util.h"
+
+struct GNUNET_MESSENGER_Handle*
+create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg,
+               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;
+  handle->mq = NULL;
+
+  handle->msg_callback = msg_callback;
+  handle->msg_cls = msg_cls;
+
+  handle->name = NULL;
+  handle->key = NULL;
+  handle->pubkey = NULL;
+
+  handle->reconnect_time = GNUNET_TIME_relative_get_zero_ ();
+  handle->reconnect_task = NULL;
+
+  handle->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_contact_store (get_handle_contact_store (handle));
+
+  return handle;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_room (void *cls,
+                      const struct GNUNET_HashCode *key,
+                      void *value)
+{
+  struct GNUNET_MESSENGER_Room *room = value;
+
+  destroy_room (room);
+
+  return GNUNET_YES;
+}
+
+
+void
+destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
+{
+  GNUNET_assert (handle);
+
+  clear_contact_store (get_handle_contact_store (handle));
+
+  if (handle->rooms)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_destroy_room,
+                                           NULL);
+
+    GNUNET_CONTAINER_multihashmap_destroy (handle->rooms);
+  }
+
+  if (handle->reconnect_task)
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+
+  if (handle->mq)
+    GNUNET_MQ_destroy (handle->mq);
+
+  if (handle->name)
+    GNUNET_free (handle->name);
+
+  if (handle->key)
+    GNUNET_free (handle->key);
+
+  if (handle->pubkey)
+    GNUNET_free (handle->pubkey);
+
+  GNUNET_free (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;
+}
+
+
+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_CRYPTO_PrivateKey *key)
+{
+  GNUNET_assert (handle);
+
+  if (! key)
+  {
+    if (handle->key)
+      GNUNET_free (handle->key);
+
+    if (handle->pubkey)
+      GNUNET_free (handle->pubkey);
+
+    handle->key = NULL;
+    handle->pubkey = NULL;
+    return;
+  }
+
+  if (! handle->key)
+    handle->key = GNUNET_new (struct GNUNET_CRYPTO_PrivateKey);
+
+  if (! handle->pubkey)
+    handle->pubkey = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+
+  GNUNET_memcpy (handle->key, key, sizeof(*key));
+  GNUNET_CRYPTO_key_get_public (key, handle->pubkey);
+}
+
+
+const struct GNUNET_CRYPTO_PrivateKey*
+get_handle_key (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  GNUNET_assert (handle);
+
+  if (handle->key)
+    return handle->key;
+
+  return get_anonymous_private_key ();
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+get_handle_pubkey (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  GNUNET_assert (handle);
+
+  if (handle->pubkey)
+    return handle->pubkey;
+
+  return get_anonymous_public_key ();
+}
+
+
+struct GNUNET_MESSENGER_ContactStore*
+get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle)
+{
+  GNUNET_assert (handle);
+
+  return &(handle->contact_store);
+}
+
+
+struct GNUNET_MESSENGER_Contact*
+get_handle_contact (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)
+    return NULL;
+
+  const struct GNUNET_ShortHashCode *contact_id = get_room_sender_id (room);
+
+  if (! contact_id)
+    return NULL;
+
+  struct GNUNET_HashCode context;
+  get_context_from_member (key, contact_id, &context);
+
+  return get_store_contact (get_handle_contact_store (handle), &context,
+                            get_handle_pubkey (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)
+    room->opened = GNUNET_YES;
+}
+
+
+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)
+    add_to_list_tunnels (&(room->entries), door, NULL);
+}
+
+
+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)))
+    destroy_room (room);
+}
+
+
+struct GNUNET_MESSENGER_Room*
+get_handle_room (struct GNUNET_MESSENGER_Handle *handle,
+                 const struct GNUNET_HashCode *key)
+{
+  GNUNET_assert ((handle) && (key));
+
+  return GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
+}
diff --git a/src/service/messenger/messenger_api_handle.h b/src/service/messenger/messenger_api_handle.h
new file mode 100644
index 000000000..1a2763020
--- /dev/null
+++ b/src/service/messenger/messenger_api_handle.h
@@ -0,0 +1,190 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_handle.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_HANDLE_H
+#define GNUNET_MESSENGER_API_HANDLE_H
+
+#include "gnunet_util_lib.h"
+
+#include "gnunet_messenger_service.h"
+
+#include "messenger_api_contact_store.h"
+
+struct GNUNET_MESSENGER_Handle
+{
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  struct GNUNET_MQ_Handle *mq;
+
+  GNUNET_MESSENGER_MessageCallback msg_callback;
+  void *msg_cls;
+
+  char *name;
+  struct GNUNET_CRYPTO_PrivateKey *key;
+  struct GNUNET_CRYPTO_PublicKey *pubkey;
+
+  struct GNUNET_TIME_Relative reconnect_time;
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  struct GNUNET_MESSENGER_ContactStore contact_store;
+
+  struct GNUNET_CONTAINER_MultiHashMap *rooms;
+};
+
+/**
+ * Creates and allocates a new handle using a given configuration and a custom message callback
+ * with a given closure for the client API.
+ *
+ * @param[in] cfg Configuration
+ * @param[in] msg_callback Message callback
+ * @param[in,out] msg_cls Closure
+ * @return New handle
+ */
+struct GNUNET_MESSENGER_Handle*
+create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg,
+               GNUNET_MESSENGER_MessageCallback msg_callback,
+               void *msg_cls);
+
+/**
+ * Destroys a <i>handle</i> and frees its memory fully from the client API.
+ *
+ * @param[in,out] handle Handle
+ */
+void
+destroy_handle (struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Sets the name of a <i>handle</i> to a specific <i>name</i>.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] name New name
+ */
+void
+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[in] handle Handle
+ * @return Name of the handle or NULL
+ */
+const char*
+get_handle_name (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Sets the keypair of a given <i>handle</i> to the keypair of a specific private <i>key</i>.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] key Private key or NULL
+ */
+void
+set_handle_key (struct GNUNET_MESSENGER_Handle *handle,
+                const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
+ * Returns the private key of a given <i>handle</i>.
+ *
+ * @param[in] handle Handle
+ * @return Private key of the handle
+ */
+const struct GNUNET_CRYPTO_PrivateKey*
+get_handle_key (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Returns the public key of a given <i>handle</i>.
+ *
+ * @param[in] handle Handle
+ * @return Public key of the handle
+ */
+const struct GNUNET_CRYPTO_PublicKey*
+get_handle_pubkey (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Returns the used contact store of a given <i>handle</i>.
+ *
+ * @param[in,out] handle Handle
+ * @return Contact store
+ */
+struct GNUNET_MESSENGER_ContactStore*
+get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Returns the contact of a given <i>handle</i> in a room identified by a
+ * given <i>key</i>.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] key Key of room
+ * @return Contact
+ */
+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[in,out] handle Handle
+ * @param[in] key Key of room
+ */
+void
+open_handle_room (struct GNUNET_MESSENGER_Handle *handle,
+                  const struct GNUNET_HashCode *key);
+
+/**
+ * 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[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,
+                      const struct GNUNET_HashCode *key);
+
+/**
+ * Destroys and so implicitly closes a room known to a <i>handle</i> identified by a given <i>key</i>.
+ *
+ * @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);
+
+/**
+ * Returns the room known to a <i>handle</i> identified by a given <i>key</i>.
+ *
+ * @param[in,out] handle handle Handle
+ * @param[in] key Key of room
+ * @return Room or NULL
+ */
+struct GNUNET_MESSENGER_Room*
+get_handle_room (struct GNUNET_MESSENGER_Handle *handle,
+                 const struct GNUNET_HashCode *key);
+
+#endif //GNUNET_MESSENGER_API_HANDLE_H
diff --git a/src/service/messenger/messenger_api_list_tunnels.c b/src/service/messenger/messenger_api_list_tunnels.c
new file mode 100644
index 000000000..bb500233b
--- /dev/null
+++ b/src/service/messenger/messenger_api_list_tunnels.c
@@ -0,0 +1,298 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_list_tunnels.c
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_list_tunnels.h"
+
+void
+init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels)
+{
+  GNUNET_assert (tunnels);
+
+  tunnels->head = NULL;
+  tunnels->tail = NULL;
+}
+
+
+void
+clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels)
+{
+  GNUNET_assert (tunnels);
+
+  struct GNUNET_MESSENGER_ListTunnel *element;
+  for (element = tunnels->head; element;
+       element = remove_from_list_tunnels (tunnels, element))
+
+    tunnels->head = NULL;
+  tunnels->tail = NULL;
+}
+
+
+static int
+compare_list_tunnels (void *cls,
+                      struct GNUNET_MESSENGER_ListTunnel *element0,
+                      struct GNUNET_MESSENGER_ListTunnel *element1)
+{
+  struct GNUNET_PeerIdentity peer0, peer1;
+
+  GNUNET_PEER_resolve (element0->peer, &peer0);
+  GNUNET_PEER_resolve (element1->peer, &peer1);
+
+  return GNUNET_memcmp (&peer0, &peer1);
+}
+
+
+void
+add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                     const struct GNUNET_PeerIdentity *peer,
+                     const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((tunnels) && (peer));
+
+  struct GNUNET_MESSENGER_ListTunnel *element = GNUNET_new (struct
+                                                            GNUNET_MESSENGER_ListTunnel);
+
+  element->peer = GNUNET_PEER_intern (peer);
+  element->hash = hash ? GNUNET_memdup (hash, sizeof (struct GNUNET_HashCode)) :
+                  NULL;
+
+  memset (&(element->connection), 0, sizeof (element->connection));
+
+  GNUNET_CONTAINER_DLL_insert_sorted (struct GNUNET_MESSENGER_ListTunnel,
+                                      compare_list_tunnels, NULL, tunnels->head,
+                                      tunnels->tail, element);
+}
+
+
+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;
+
+  if (index)
+    *index = 0;
+
+  for (element = tunnels->head; element; element = element->next)
+  {
+    GNUNET_PEER_resolve (element->peer, &pid);
+
+    if (0 == GNUNET_memcmp (&pid, peer))
+      return element;
+
+    if (index)
+      (*index) = (*index) + 1;
+  }
+
+  return NULL;
+}
+
+
+struct GNUNET_MESSENGER_ListTunnel*
+find_list_tunnels_alternate (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                             const struct GNUNET_PeerIdentity *peer)
+{
+  GNUNET_assert ((tunnels) && (peer));
+
+  struct GNUNET_MESSENGER_ListTunnel *element;
+  struct GNUNET_PeerIdentity pid;
+
+  for (element = tunnels->head; element; element = element->next)
+  {
+    GNUNET_PEER_resolve (element->peer, &pid);
+
+    if (0 != GNUNET_memcmp (&pid, peer))
+      return element;
+  }
+
+  return NULL;
+}
+
+
+enum GNUNET_GenericReturnValue
+verify_list_tunnels_flag_token (const struct
+                                GNUNET_MESSENGER_ListTunnels *tunnels,
+                                const struct GNUNET_PeerIdentity *peer,
+                                enum GNUNET_MESSENGER_ConnectionFlags flag)
+{
+  GNUNET_assert ((tunnels) && (peer) && (flag));
+
+  struct GNUNET_MESSENGER_ListTunnel *element;
+  struct GNUNET_PeerIdentity pid;
+
+  for (element = tunnels->head; element; element = element->next)
+  {
+    if ((element->connection.flags & flag) != flag)
+      continue;
+
+    GNUNET_PEER_resolve (element->peer, &pid);
+
+    if (0 == GNUNET_memcmp (&pid, peer))
+      return GNUNET_OK;
+  }
+
+  return GNUNET_SYSERR;
+}
+
+
+void
+update_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                        const struct GNUNET_PeerIdentity *peer,
+                        const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((tunnels) && (peer));
+
+  struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (tunnels,
+                                                                   peer,
+                                                                   NULL);
+  if (! element)
+    return;
+
+  if (element->hash)
+  {
+    if (hash)
+      GNUNET_memcpy (element->hash, hash, sizeof(struct GNUNET_HashCode));
+    else
+    {
+      GNUNET_free (element->hash);
+      element->hash = NULL;
+    }
+  }
+  else if (hash)
+    element->hash = GNUNET_memdup (hash, sizeof(struct GNUNET_HashCode));
+}
+
+
+enum GNUNET_GenericReturnValue
+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;
+
+  if ((tunnels->head) && (tunnels->tail))
+    GNUNET_CONTAINER_DLL_remove (tunnels->head, tunnels->tail, element);
+
+  if (element->hash)
+    GNUNET_free (element->hash);
+
+  GNUNET_PEER_change_rc (element->peer, -1);
+  GNUNET_free (element);
+
+  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;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load list of tunnels from path: %s\n",
+              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_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, NULL);
+  } 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));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save list of tunnels to path: %s\n",
+              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/service/messenger/messenger_api_list_tunnels.h b/src/service/messenger/messenger_api_list_tunnels.h
new file mode 100644
index 000000000..e4b709c3b
--- /dev/null
+++ b/src/service/messenger/messenger_api_list_tunnels.h
@@ -0,0 +1,187 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_list_tunnels.h
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_LIST_TUNNELS_H
+#define GNUNET_MESSENGER_API_LIST_TUNNELS_H
+
+#include "gnunet_messenger_service.h"
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_ListTunnel
+{
+  struct GNUNET_MESSENGER_ListTunnel *prev;
+  struct GNUNET_MESSENGER_ListTunnel *next;
+
+  GNUNET_PEER_Id peer;
+  struct GNUNET_HashCode *hash;
+
+  struct GNUNET_MESSENGER_MessageConnection connection;
+};
+
+struct GNUNET_MESSENGER_ListTunnels
+{
+  struct GNUNET_MESSENGER_ListTunnel *head;
+  struct GNUNET_MESSENGER_ListTunnel *tail;
+};
+
+/**
+ * Initializes list of tunnels peer identities as empty list.
+ *
+ * @param[out] tunnels List of tunnels
+ */
+void
+init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
+
+/**
+ * Clears the list of tunnels peer identities.
+ *
+ * @param[in,out] tunnels List of tunnels
+ */
+void
+clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
+
+/**
+ * Adds a specific <i>peer</i> from a tunnel to the end of the list.
+ *
+ * Optionally adds the <i>hash</i> of the peer message from the specific <i>peer</i>.
+ *
+ * @param[in,out] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @param[in] hash Hash of peer message or NULL
+ */
+void
+add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                     const struct GNUNET_PeerIdentity *peer,
+                     const struct GNUNET_HashCode *hash);
+
+/**
+ * Searches linearly through the list of tunnels peer identities for matching a
+ * specific <i>peer</i> identity and returns the matching element of the list.
+ *
+ * If no matching element is found, NULL gets returned.
+ *
+ * If <i>index</i> is not NULL, <i>index</i> will be overridden with the numeric index of
+ * 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[in,out] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @param[out] index Index of found element (optional)
+ * @return Element in the list with matching peer identity
+ */
+struct GNUNET_MESSENGER_ListTunnel*
+find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                   const struct GNUNET_PeerIdentity *peer,
+                   size_t *index);
+
+/**
+ * Searches linearly through the list of tunnels peer identities for matching
+ * against a specific <i>peer</i> identity and returns an element of the list
+ * which does not match it.
+ *
+ * @param[in,out] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @return Element in the list with unmatching peer identity
+ */
+struct GNUNET_MESSENGER_ListTunnel*
+find_list_tunnels_alternate (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                             const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Verifies that a specific tunnel selected by its <i>peer</i> identity in a
+ * list of <i>tunnels</i> is the first in order with a given connection <i>flag</i>.
+ *
+ * @param[in] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @param[in] flag Connection flag mask
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+enum GNUNET_GenericReturnValue
+verify_list_tunnels_flag_token (const struct
+                                GNUNET_MESSENGER_ListTunnels *tunnels,
+                                const struct GNUNET_PeerIdentity *peer,
+                                enum GNUNET_MESSENGER_ConnectionFlags flag);
+
+/**
+ * Updates a specific <i>peer</i> from a tunnel in the list.
+ *
+ * This function exists to add the <i>hash</i> of a newer peer message
+ * from the specific <i>peer</i> to the list element. It can also remove
+ * the hash when NULL is provided as new <i>hash</i> value.
+ *
+ * @param[in,out] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @param[in] hash Hash of peer message or NULL
+ */
+void
+update_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                        const struct GNUNET_PeerIdentity *peer,
+                        const struct GNUNET_HashCode *hash);
+
+/**
+ * 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.
+ *
+ * @param[in,out] tunnels List of tunnels
+ * @param[in] peer Peer identity of tunnel
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
+                       const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Removes a specific <i>element</i> from the list of tunnels peer identities and returns
+ * the next element in the list.
+ *
+ * @param[in,out] tunnels List of tunnels
+ * @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] tunnels List of tunnels
+ * @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] tunnels List of tunnels
+ * @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/service/messenger/messenger_api_message.c b/src/service/messenger/messenger_api_message.c
new file mode 100644
index 000000000..fa281cb37
--- /dev/null
+++ b/src/service/messenger/messenger_api_message.c
@@ -0,0 +1,1380 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_message.c
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_message.h"
+
+#include "gnunet_common.h"
+#include "gnunet_messenger_service.h"
+#include "gnunet_signatures.h"
+
+struct GNUNET_MESSENGER_MessageSignature
+{
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+  struct GNUNET_HashCode hash GNUNET_PACKED;
+};
+
+struct GNUNET_MESSENGER_ShortMessage
+{
+  enum GNUNET_MESSENGER_MessageKind kind;
+  struct GNUNET_MESSENGER_MessageBody body;
+};
+
+struct GNUNET_MESSENGER_Message*
+create_message (enum GNUNET_MESSENGER_MessageKind kind)
+{
+  struct GNUNET_MESSENGER_Message *message = GNUNET_new (struct
+                                                         GNUNET_MESSENGER_Message);
+
+  message->header.kind = kind;
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_NAME:
+    message->body.name.name = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    message->body.text.text = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    message->body.file.uri = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    message->body.privacy.length = 0;
+    message->body.privacy.data = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    message->body.ticket.identifier = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    message->body.transcript.length = 0;
+    message->body.transcript.data = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    message->body.tag.tag = NULL;
+    break;
+  default:
+    break;
+  }
+
+  return message;
+}
+
+
+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));
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_NAME:
+    copy->body.name.name = message->body.name.name? GNUNET_strdup (
+      message->body.name.name) : NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    copy->body.text.text = message->body.text.text? GNUNET_strdup (
+      message->body.text.text) : NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    copy->body.file.uri = message->body.file.uri? GNUNET_strdup (
+      message->body.file.uri) : NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc (
+      copy->body.privacy.length) : NULL;
+
+    if (copy->body.privacy.data)
+      GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data,
+                     copy->body.privacy.length);
+
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    copy->body.ticket.identifier = message->body.ticket.identifier?
+                                   GNUNET_strdup (
+      message->body.ticket.identifier) : NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    copy->body.transcript.data = copy->body.transcript.length ? GNUNET_malloc (
+      copy->body.transcript.length) : NULL;
+
+    if (copy->body.transcript.data)
+      GNUNET_memcpy (copy->body.transcript.data, message->body.transcript.data,
+                     copy->body.transcript.length);
+
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    copy->body.tag.tag = message->body.tag.tag? GNUNET_strdup (
+      message->body.tag.tag) : NULL;
+    break;
+  default:
+    break;
+  }
+
+  return copy;
+}
+
+
+void
+copy_message_header (struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_MESSENGER_MessageHeader *header)
+{
+  GNUNET_assert ((message) && (header));
+
+  enum GNUNET_MESSENGER_MessageKind kind = message->header.kind;
+
+  GNUNET_memcpy (&(message->header), header,
+                 sizeof(struct GNUNET_MESSENGER_MessageHeader));
+
+  message->header.kind = kind;
+}
+
+
+static void
+destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind,
+                      struct GNUNET_MESSENGER_MessageBody *body)
+{
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_NAME:
+    if (body->name.name)
+      GNUNET_free (body->name.name);
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    if (body->text.text)
+      GNUNET_free (body->text.text);
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    if (body->file.uri)
+      GNUNET_free (body->file.uri);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    GNUNET_free (body->privacy.data);
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    if (body->ticket.identifier)
+      GNUNET_free (body->ticket.identifier);
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    GNUNET_free (body->transcript.data);
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    if (body->tag.tag)
+      GNUNET_free (body->tag.tag);
+    break;
+  default:
+    break;
+  }
+}
+
+
+void
+cleanup_message (struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert (message);
+
+  destroy_message_body (message->header.kind, &(message->body));
+}
+
+
+void
+destroy_message (struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert (message);
+
+  destroy_message_body (message->header.kind, &(message->body));
+
+  GNUNET_free (message);
+}
+
+
+enum GNUNET_GenericReturnValue
+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)
+{
+  shortened->kind = message->header.kind;
+
+  GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct
+                                                              GNUNET_MESSENGER_MessageBody));
+}
+
+
+static void
+unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened,
+                      struct GNUNET_MESSENGER_Message *message)
+{
+  destroy_message_body (message->header.kind, &(message->body));
+
+  message->header.kind = shortened->kind;
+
+  GNUNET_memcpy (&(message->body), &(shortened->body),
+                 sizeof(struct GNUNET_MESSENGER_MessageBody));
+}
+
+
+#define member_size(type, member) sizeof(((type*) NULL)->member)
+
+static uint16_t
+get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
+{
+  uint16_t length = 0;
+
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    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);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.id.id);
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer);
+    break;
+  case GNUNET_MESSENGER_KIND_MERGE:
+    length += member_size (struct GNUNET_MESSENGER_Message,
+                           body.merge.previous);
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash);
+    break;
+  case GNUNET_MESSENGER_KIND_INVITE:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door);
+    length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key);
+    break;
+  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 += member_size (struct GNUNET_MESSENGER_Message, body.file.name);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.privacy.key);
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.deletion.hash);
+    length += member_size (struct GNUNET_MESSENGER_Message,
+                           body.deletion.delay);
+    break;
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    length += member_size (struct GNUNET_MESSENGER_Message,
+                           body.connection.amount);
+    length += member_size (struct GNUNET_MESSENGER_Message,
+                           body.connection.flags);
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    length += member_size (struct GNUNET_MESSENGER_Message,
+                           body.transcript.hash);
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    length += member_size (struct GNUNET_MESSENGER_Message, body.tag.hash);
+    break;
+  default:
+    break;
+  }
+
+  return length;
+}
+
+
+typedef uint32_t kind_t;
+
+uint16_t
+get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind,
+                       enum GNUNET_GenericReturnValue include_header)
+{
+  uint16_t length = 0;
+
+  if (GNUNET_YES == include_header)
+  {
+    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 += sizeof(kind_t);
+
+  return length + get_message_body_kind_size (kind);
+}
+
+
+static uint16_t
+get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind,
+                       const struct GNUNET_MESSENGER_MessageBody *body)
+{
+  uint16_t length = 0;
+
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    length += GNUNET_CRYPTO_public_key_get_length (&(body->join.key));
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    length += (body->name.name ? strlen (body->name.name) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    length += GNUNET_CRYPTO_public_key_get_length (&(body->key.key));
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    length += (body->text.text ? strlen (body->text.text) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    length += (body->file.uri ? strlen (body->file.uri) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    length += body->privacy.length;
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    length += (body->ticket.identifier ? strlen (body->ticket.identifier) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    length += GNUNET_CRYPTO_public_key_get_length (&(body->transcript.key));
+    length += body->transcript.length;
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    length += (body->tag.tag ? strlen (body->tag.tag) : 0);
+    break;
+  default:
+    break;
+  }
+
+  return length;
+}
+
+
+uint16_t
+get_message_size (const struct GNUNET_MESSENGER_Message *message,
+                  enum GNUNET_GenericReturnValue include_header)
+{
+  GNUNET_assert (message);
+
+  uint16_t length = 0;
+
+  if (GNUNET_YES == include_header)
+    length += GNUNET_CRYPTO_signature_get_length (
+      &(message->header.signature));
+
+  length += get_message_kind_size (message->header.kind, include_header);
+  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,
+                        enum GNUNET_GenericReturnValue include_body)
+{
+  const uint16_t minimum_size = sizeof(struct GNUNET_HashCode) + sizeof(kind_t);
+
+  if (message)
+    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 minimum_size;
+}
+
+
+static uint16_t
+calc_usual_padding ()
+{
+  uint16_t padding = 0;
+  uint16_t kind_size;
+
+  for (unsigned int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++)
+  {
+    kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i,
+                                       GNUNET_YES);
+
+    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)
+
+#define encode_step_ext(dst, offset, src, size) do { \
+          GNUNET_memcpy (dst + offset, src, size);           \
+          offset += size;                                    \
+} while (0)
+
+#define encode_step(dst, offset, src) do {          \
+          encode_step_ext (dst, offset, src, sizeof(*src)); \
+} while (0)
+
+#define encode_step_key(dst, offset, src, length) do {        \
+          ssize_t result = GNUNET_CRYPTO_write_public_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_CRYPTO_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,
+                     uint16_t length,
+                     char *buffer,
+                     uint16_t offset)
+{
+  uint32_t value0, value1;
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    value0 = GNUNET_htobe32 (body->info.messenger_version);
+
+    encode_step (buffer, offset, &value0);
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    encode_step_key (buffer, offset, &(body->join.key), length);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    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_key (buffer, offset, &(body->key.key), length);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    encode_step (buffer, offset, &(body->peer.peer));
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    encode_step (buffer, offset, &(body->id.id));
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    encode_step (buffer, offset, &(body->miss.peer));
+    break;
+  case GNUNET_MESSENGER_KIND_MERGE:
+    encode_step (buffer, offset, &(body->merge.previous));
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    encode_step (buffer, offset, &(body->request.hash));
+    break;
+  case GNUNET_MESSENGER_KIND_INVITE:
+    encode_step (buffer, offset, &(body->invite.door));
+    encode_step (buffer, offset, &(body->invite.key));
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    if (body->text.text)
+      encode_step_ext (buffer, offset, body->text.text, min (length - offset,
+                                                             strlen (
+                                                               body->text.text))
+                       );
+    break;
+  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, sizeof(body->file.name));
+    if (body->file.uri)
+      encode_step_ext (buffer, offset, body->file.uri, min (length - offset,
+                                                            strlen (
+                                                              body->file.uri)));
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    encode_step (buffer, offset, &(body->privacy.key));
+    encode_step_ext (buffer, offset, body->privacy.data, min (length - offset,
+                                                              body->privacy.
+                                                              length));
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    encode_step (buffer, offset, &(body->deletion.hash));
+    encode_step (buffer, offset, &(body->deletion.delay));
+    break;
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    value0 = GNUNET_htobe32 (body->connection.amount);
+    value1 = GNUNET_htobe32 (body->connection.flags);
+
+    encode_step (buffer, offset, &value0);
+    encode_step (buffer, offset, &value1);
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    encode_step_ext (buffer, offset, body->ticket.identifier,
+                     min (length - offset, strlen (body->ticket.identifier)));
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    encode_step (buffer, offset, &(body->transcript.hash));
+    encode_step_key (buffer, offset, &(body->transcript.key), length);
+    encode_step_ext (buffer, offset, body->transcript.data, min (length
+                                                                 - offset,
+                                                                 body->
+                                                                 transcript.
+                                                                 length));
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    encode_step (buffer, offset, &(body->tag.hash));
+    if (body->tag.tag)
+      encode_step_ext (buffer, offset, body->tag.tag, min (length - offset,
+                                                           strlen (
+                                                             body->tag.tag)));
+    break;
+  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,
+                enum GNUNET_GenericReturnValue include_header)
+{
+  GNUNET_assert ((message) && (buffer));
+
+  uint16_t offset = 0;
+
+  if (GNUNET_YES == include_header)
+    encode_step_signature (buffer, offset, &(message->header.signature),
+                           length);
+
+  const kind_t kind = GNUNET_htobe32 ((kind_t) message->header.kind);
+
+  if (GNUNET_YES == include_header)
+  {
+    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, &kind);
+
+  encode_message_body (message->header.kind, &(message->body),
+                       length, buffer, offset);
+}
+
+
+static void
+encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message,
+                      uint16_t length,
+                      char *buffer)
+{
+  struct GNUNET_HashCode hash;
+  uint16_t offset = sizeof(hash);
+
+  const kind_t kind = GNUNET_htobe32 ((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 { \
+          GNUNET_memcpy (dst, src + offset, size);           \
+          offset += size;                                    \
+} while (0)
+
+#define decode_step(src, offset, dst) do {          \
+          decode_step_ext (src, offset, dst, sizeof(*dst)); \
+} while (0)
+
+#define decode_step_malloc(src, offset, dst, size, zero) do { \
+          dst = GNUNET_malloc (size + zero);                          \
+          if (zero) dst[size] = 0;                                    \
+          decode_step_ext (src, offset, dst, size);                 \
+} while (0)
+
+#define decode_step_key(src, offset, dst, length) do {   \
+          enum GNUNET_GenericReturnValue result;                 \
+          size_t read;                                           \
+          result = GNUNET_CRYPTO_read_public_key_from_buffer (   \
+            src + offset, length - offset, dst, &read            \
+            );                                                     \
+          if (GNUNET_SYSERR == result)                           \
+          GNUNET_break (0);                                    \
+          else                                                   \
+          offset += read;                                      \
+} 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;
+
+  uint32_t value0, value1;
+  switch (*kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    decode_step (buffer, offset, &value0);
+
+    body->info.messenger_version = GNUNET_be32toh (value0);
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    decode_step_key (buffer, offset, &(body->join.key), length);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    if (length > offset)
+      decode_step_malloc (buffer, offset, body->name.name, length - offset, 1);
+    else
+      body->name.name = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    decode_step_key (buffer, offset, &(body->key.key), length);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    decode_step (buffer, offset, &(body->peer.peer));
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    decode_step (buffer, offset, &(body->id.id));
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    decode_step (buffer, offset, &(body->miss.peer));
+    break;
+  case GNUNET_MESSENGER_KIND_MERGE:
+    decode_step (buffer, offset, &(body->merge.previous));
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    decode_step (buffer, offset, &(body->request.hash));
+    break;
+  case GNUNET_MESSENGER_KIND_INVITE:
+    decode_step (buffer, offset, &(body->invite.door));
+    decode_step (buffer, offset, &(body->invite.key));
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    if (length > offset)
+      decode_step_malloc (buffer, offset, body->text.text, length - offset, 1);
+    else
+      body->text.text = NULL;
+    break;
+  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, sizeof(body->file.name));
+    if (length > offset)
+      decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1);
+    else
+      body->file.uri = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    decode_step (buffer, offset, &(body->privacy.key));
+
+    body->privacy.length = (length - offset);
+    decode_step_malloc (buffer, offset, body->privacy.data, length - offset, 0);
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    decode_step (buffer, offset, &(body->deletion.hash));
+    decode_step (buffer, offset, &(body->deletion.delay));
+    break;
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    decode_step (buffer, offset, &value0);
+    decode_step (buffer, offset, &value1);
+
+    body->connection.amount = GNUNET_be32toh (value0);
+    body->connection.flags = GNUNET_be32toh (value1);
+    break;
+  case GNUNET_MESSENGER_KIND_TICKET:
+    if (length > offset)
+      decode_step_malloc (buffer, offset, body->ticket.identifier, length
+                          - offset, 1);
+    else
+      body->ticket.identifier = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    decode_step (buffer, offset, &(body->transcript.hash));
+    decode_step_key (buffer, offset, &(body->transcript.key), length);
+
+    body->transcript.length = (length - offset);
+    decode_step_malloc (buffer, offset, body->transcript.data, length - offset,
+                        0);
+    break;
+  case GNUNET_MESSENGER_KIND_TAG:
+    decode_step (buffer, offset, &(body->tag.hash));
+    if (length > offset)
+      decode_step_malloc (buffer, offset, body->tag.tag, length - offset, 1);
+    else
+      body->tag.tag = NULL;
+    break;
+  default:
+    *kind = GNUNET_MESSENGER_KIND_UNKNOWN;
+    break;
+  }
+
+  return padding;
+}
+
+
+enum GNUNET_GenericReturnValue
+decode_message (struct GNUNET_MESSENGER_Message *message,
+                uint16_t length,
+                const char *buffer,
+                enum GNUNET_GenericReturnValue include_header,
+                uint16_t *padding)
+{
+  GNUNET_assert (
+    (message) &&
+    (buffer) &&
+    (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+                                      include_header))
+    );
+
+  uint16_t offset = 0;
+
+  if (GNUNET_YES == include_header)
+  {
+    ssize_t result = GNUNET_CRYPTO_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,
+                                     include_header))
+    return GNUNET_NO;
+
+  kind_t kind;
+
+  if (GNUNET_YES == include_header)
+  {
+    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, &kind);
+
+  message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (
+    kind);
+
+  if (count < get_message_kind_size (message->header.kind, include_header))
+    return GNUNET_NO;
+
+  const uint16_t result = decode_message_body (&(message->header.kind),
+                                               &(message->body), length, buffer,
+                                               offset);
+
+  if (padding)
+    *padding = result;
+
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message,
+                      uint16_t length,
+                      const char *buffer)
+{
+  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 (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected))
+    return GNUNET_NO;
+
+  kind_t kind;
+
+  decode_step (buffer, offset, &kind);
+
+  message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (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 (const struct GNUNET_MESSENGER_Message *message,
+              uint16_t length,
+              const char *buffer,
+              struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((message) && (buffer) && (hash));
+
+  const ssize_t offset = GNUNET_CRYPTO_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_CRYPTO_PrivateKey *key)
+{
+  GNUNET_assert ((message) && (buffer) && (hash) && (key));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n",
+              GNUNET_h2s (hash));
+
+  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(signature.hash));
+  GNUNET_CRYPTO_sign (key, &signature, &(message->header.signature));
+
+  message->header.signature.type = key->type;
+
+  uint16_t offset = 0;
+  encode_step_signature (buffer, offset, &(message->header.signature), length);
+}
+
+
+void
+sign_message_by_peer (struct GNUNET_MESSENGER_Message *message,
+                      uint16_t length,
+                      char *buffer,
+                      const struct GNUNET_HashCode *hash,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  GNUNET_assert ((message) && (buffer) && (hash) && (cfg));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n",
+              GNUNET_h2s (hash));
+
+  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(signature.hash));
+  GNUNET_CRYPTO_sign_by_peer_identity (cfg, &(signature.purpose),
+                                       &(message->header.signature.
+                                         eddsa_signature));
+
+  message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
+
+  uint16_t offset = 0;
+  encode_step_signature (buffer, offset, &(message->header.signature), length);
+}
+
+
+enum GNUNET_GenericReturnValue
+verify_message (const struct GNUNET_MESSENGER_Message *message,
+                const struct GNUNET_HashCode *hash,
+                const struct GNUNET_CRYPTO_PublicKey *key)
+{
+  GNUNET_assert ((message) && (hash) && (key));
+
+  if (key->type != message->header.signature.type)
+    return GNUNET_SYSERR;
+
+  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(signature.hash));
+
+  return GNUNET_CRYPTO_signature_verify (
+    GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
+    &(message->header.signature), key);
+}
+
+
+enum GNUNET_GenericReturnValue
+verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_PeerIdentity *identity)
+{
+  GNUNET_assert ((message) && (hash) && (identity));
+
+  if (ntohl (GNUNET_PUBLIC_KEY_TYPE_EDDSA) != message->header.signature.type)
+    return GNUNET_SYSERR;
+
+  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(signature.hash));
+
+  return GNUNET_CRYPTO_verify_peer_identity (
+    GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &(signature.purpose),
+    &(message->header.signature.
+      eddsa_signature), identity);
+}
+
+
+enum GNUNET_GenericReturnValue
+encrypt_message (struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_CRYPTO_PublicKey *key)
+{
+  GNUNET_assert ((message) && (key));
+
+  if (GNUNET_YES == is_service_message (message))
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+
+  fold_short_message (message, &shortened);
+
+  const uint16_t length = get_short_message_size (&shortened, GNUNET_YES);
+  const uint16_t padded_length = calc_padded_length (
+    length + GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES
+    );
+
+  message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
+  message->body.privacy.data = GNUNET_malloc (padded_length);
+  message->body.privacy.length = padded_length;
+
+  const uint16_t encoded_length = (
+    padded_length - GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES
+    );
+
+  encode_short_message (&shortened, encoded_length, message->body.privacy.data);
+
+  if (GNUNET_OK != GNUNET_CRYPTO_encrypt (message->body.privacy.data,
+                                          encoded_length,
+                                          key,
+                                          message->body.privacy.data,
+                                          padded_length))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
+
+    unfold_short_message (&shortened, message);
+    return GNUNET_NO;
+  }
+
+  destroy_message_body (shortened.kind, &(shortened.body));
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+decrypt_message (struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_CRYPTO_PrivateKey *key)
+{
+  GNUNET_assert ((message) && (key));
+
+  const uint16_t padded_length = message->body.privacy.length;
+
+  if (padded_length < GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Message length too short to decrypt!\n");
+
+    return GNUNET_NO;
+  }
+
+  const uint16_t encoded_length = (
+    padded_length - GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES
+    );
+
+  if (GNUNET_OK != GNUNET_CRYPTO_decrypt (message->body.privacy.data,
+                                          padded_length,
+                                          key,
+                                          message->body.privacy.data,
+                                          encoded_length))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Decrypting message failed!\n");
+
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+
+  if (GNUNET_YES != decode_short_message (&shortened,
+                                          encoded_length,
+                                          message->body.privacy.data))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Decoding decrypted message failed!\n");
+
+    return GNUNET_NO;
+  }
+
+  unfold_short_message (&shortened, message);
+  return GNUNET_YES;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+transcribe_message (const struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_CRYPTO_PublicKey *key)
+{
+  GNUNET_assert ((message) && (key));
+
+  if (GNUNET_YES == is_service_message (message))
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *transcript = create_message (
+    GNUNET_MESSENGER_KIND_TRANSCRIPT);
+
+  if (! transcript)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Transcribing message failed!\n");
+    return NULL;
+  }
+
+  GNUNET_memcpy (&(transcript->body.transcript.key), key,
+                 sizeof(transcript->body.transcript.key));
+
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+
+  fold_short_message (message, &shortened);
+
+  const uint16_t data_length = get_short_message_size (
+    &shortened, GNUNET_YES);
+
+  transcript->body.transcript.data = GNUNET_malloc (data_length);
+  transcript->body.transcript.length = data_length;
+
+  encode_short_message (&shortened, data_length,
+                        transcript->body.transcript.data);
+
+  return transcript;
+}
+
+
+enum GNUNET_GenericReturnValue
+read_transcript_message (struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert (message);
+
+  if (GNUNET_MESSENGER_KIND_TRANSCRIPT != message->header.kind)
+    return GNUNET_NO;
+
+  const uint16_t data_length = message->body.transcript.length;
+
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+  if (GNUNET_YES != decode_short_message (&shortened,
+                                          data_length,
+                                          message->body.transcript.data))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Decoding decrypted message failed!\n");
+
+    return GNUNET_NO;
+  }
+
+  unfold_short_message (&shortened, message);
+  return GNUNET_YES;
+}
+
+
+struct GNUNET_MQ_Envelope*
+pack_message (struct GNUNET_MESSENGER_Message *message,
+              struct GNUNET_HashCode *hash,
+              const GNUNET_MESSENGER_SignFunction sign,
+              enum GNUNET_MESSENGER_PackMode mode,
+              const void *cls)
+{
+  GNUNET_assert (message);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Packing message kind=%u and sender: %s\n",
+              message->header.kind, GNUNET_sh2s (&(message->header.sender_id)));
+
+  struct GNUNET_MessageHeader *header;
+
+  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, padded_length,
+                               GNUNET_MESSAGE_TYPE_CADET_CLI);
+
+    buffer = (char*) &(header[1]);
+  }
+  else
+  {
+    env = NULL;
+
+    buffer = GNUNET_malloc (padded_length);
+  }
+
+  encode_message (message, padded_length, buffer, GNUNET_YES);
+
+  if (hash)
+  {
+    hash_message (message, length, buffer, hash);
+
+    if (sign)
+      sign (cls, message, length, buffer, hash);
+  }
+
+  if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
+    GNUNET_free (buffer);
+
+  return env;
+}
+
+
+enum GNUNET_GenericReturnValue
+is_peer_message (const struct GNUNET_MESSENGER_Message *message)
+{
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+  case GNUNET_MESSENGER_KIND_PEER:
+  case GNUNET_MESSENGER_KIND_MISS:
+  case GNUNET_MESSENGER_KIND_MERGE:
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    return GNUNET_YES;
+  default:
+    return GNUNET_NO;
+  }
+}
+
+
+enum GNUNET_GenericReturnValue
+is_service_message (const struct GNUNET_MESSENGER_Message *message)
+{
+  if (GNUNET_YES == is_peer_message (message))
+    return GNUNET_YES;
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    return GNUNET_YES; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_JOIN:
+    return GNUNET_YES; // Reserved for member handling only!
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    return GNUNET_YES; // Reserved for member handling only!
+  case GNUNET_MESSENGER_KIND_NAME:
+    return GNUNET_YES; // Reserved for member name handling only!
+  case GNUNET_MESSENGER_KIND_KEY:
+    return GNUNET_YES; // Reserved for member key handling only!
+  case GNUNET_MESSENGER_KIND_PEER:
+    return GNUNET_YES; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_ID:
+    return GNUNET_YES; // Reserved for member id handling only!
+  case GNUNET_MESSENGER_KIND_MISS:
+    return GNUNET_YES; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_MERGE:
+    return GNUNET_YES; // Reserved for peers only!
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    return GNUNET_YES; // Requests should not apply individually! (inefficieny)
+  case GNUNET_MESSENGER_KIND_INVITE:
+    return GNUNET_NO;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    return GNUNET_NO;
+  case GNUNET_MESSENGER_KIND_FILE:
+    return GNUNET_NO;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    return GNUNET_YES; // Prevent duplicate encryption breaking all access!
+  case GNUNET_MESSENGER_KIND_DELETE:
+    return GNUNET_YES; // Deletion should not apply individually! (inefficieny)
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    return GNUNET_YES; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_TICKET:
+    return GNUNET_NO;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    return GNUNET_NO;
+  case GNUNET_MESSENGER_KIND_TAG:
+    return GNUNET_NO;
+  default:
+    return GNUNET_SYSERR;
+  }
+}
+
+
+enum GNUNET_GenericReturnValue
+filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
+{
+  if (GNUNET_YES == is_peer_message (message))
+    return GNUNET_SYSERR; // Requires signature of peer rather than member!
+
+  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_set_key(...) instead!
+  case GNUNET_MESSENGER_KIND_PEER:
+    return GNUNET_SYSERR; // Use #GNUNET_MESSENGER_open_room(...) instead!
+  case GNUNET_MESSENGER_KIND_ID:
+    return GNUNET_NO; // 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_SYSERR; // Reserved for peers only!
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_get_message(...) instead!
+  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_NO; // Use #GNUNET_MESSENGER_delete_message(...) instead!
+  case GNUNET_MESSENGER_KIND_CONNECTION:
+    return GNUNET_SYSERR; // Reserved for connection handling only!
+  case GNUNET_MESSENGER_KIND_TICKET:
+    return GNUNET_YES;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
+  case GNUNET_MESSENGER_KIND_TAG:
+    return GNUNET_YES;
+  default:
+    return GNUNET_SYSERR;
+  }
+}
diff --git a/src/service/messenger/messenger_api_message.h b/src/service/messenger/messenger_api_message.h
new file mode 100644
index 000000000..20b85dc03
--- /dev/null
+++ b/src/service/messenger/messenger_api_message.h
@@ -0,0 +1,351 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_message.h
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_MESSAGE_H
+#define GNUNET_MESSENGER_API_MESSAGE_H
+
+#include "gnunet_util_lib.h"
+
+#include "gnunet_messenger_service.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[in] kind Kind of message
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message (enum GNUNET_MESSENGER_MessageKind kind);
+
+/**
+ * Creates and allocates a copy of a given <i>message</i>.
+ *
+ * @param[in] message Message
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+copy_message (const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Copy message <i>header</i> details from another message to
+ * a given <i>message</i>.
+ *
+ * @param[in,out] message Message
+ * @param[in] header Message header
+ */
+void
+copy_message_header (struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_MESSENGER_MessageHeader *header);
+
+/**
+ * Frees the messages body memory.
+ *
+ * @param[in,out] message Message
+ */
+void
+cleanup_message (struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Destroys a message and frees its memory fully.
+ *
+ * @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
+ */
+enum GNUNET_GenericReturnValue
+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[in] kind Kind of message
+ * @param[in] include_header Flag to include header
+ * @return Minimal size to encode
+ */
+uint16_t
+get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind,
+                       enum GNUNET_GenericReturnValue include_header);
+
+/**
+ * Returns the exact size in bytes to encode a given <i>message</i>.
+ *
+ * @param[in] message Message
+ * @param[in] include_header Flag to include header
+ * @return Size to encode
+ */
+uint16_t
+get_message_size (const struct GNUNET_MESSENGER_Message *message,
+                  enum GNUNET_GenericReturnValue include_header);
+
+/**
+ * Encodes a given <i>message</i> into a <i>buffer</i> of a maximal <i>length</i> in bytes.
+ *
+ * @param[in] message Message
+ * @param[in] length Maximal length to encode
+ * @param[out] buffer Buffer
+ * @param[in] include_header Flag to include header
+ */
+void
+encode_message (const struct GNUNET_MESSENGER_Message *message,
+                uint16_t length,
+                char *buffer,
+                enum GNUNET_GenericReturnValue include_header);
+
+/**
+ * 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.
+ *
+ * On success the function returns #GNUNET_YES.
+ *
+ * @param[out] message Message
+ * @param[in] length Maximal length to decode
+ * @param[in] buffer Buffer
+ * @param[in] include_header Flag to include header
+ * @param[out] padding Padding
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+decode_message (struct GNUNET_MESSENGER_Message *message,
+                uint16_t length,
+                const char *buffer,
+                enum GNUNET_GenericReturnValue include_header,
+                uint16_t *padding);
+
+/**
+ * Calculates a <i>hash</i> of a given <i>buffer</i> with a <i>length</i> in bytes
+ * from a <i>message</i>.
+ *
+ * @param[in] message Message
+ * @param[in] length Length of buffer
+ * @param[in] buffer Buffer
+ * @param[out] hash Hash
+ */
+void
+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 private <i>key</i> and writes
+ * the signature into the <i>buffer</i> as well.
+ *
+ * @param[in,out] message Message
+ * @param[in] length Length of buffer
+ * @param[out] buffer Buffer
+ * @param[in] hash Hash of message
+ * @param[in] key Private key
+ */
+void
+sign_message (struct GNUNET_MESSENGER_Message *message,
+              uint16_t length,
+              char *buffer,
+              const struct GNUNET_HashCode *hash,
+              const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
+ * Signs the <i>hash</i> of a <i>message</i> with the peer identity of a given <i>config</i>
+ * and writes the signature into the <i>buffer</i> as well.
+ *
+ * @param[in,out] message Message
+ * @param[in] length Length of buffer
+ * @param[out] buffer Buffer
+ * @param[in] hash Hash of message
+ * @param[in] cfg Peer configuration
+ */
+void
+sign_message_by_peer (struct GNUNET_MESSENGER_Message *message,
+                      uint16_t length,
+                      char *buffer,
+                      const struct GNUNET_HashCode *hash,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg);
+
+/**
+ * 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.
+ *
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @param[in] key Public key
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+enum GNUNET_GenericReturnValue
+verify_message (const struct GNUNET_MESSENGER_Message *message,
+                const struct GNUNET_HashCode *hash,
+                const struct GNUNET_CRYPTO_PublicKey *key);
+
+/**
+ * Verifies the signature of a given <i>message</i> and its <i>hash</i> with a specific
+ * peer's <i>identity</i>. The function returns #GNUNET_OK if the signature was valid,
+ * otherwise #GNUNET_SYSERR.
+ *
+ * @param[in] message Message
+ * @param[in] hash Hash of message
+ * @param[in] identity Peer identity
+ * @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
+ */
+enum GNUNET_GenericReturnValue
+verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_PeerIdentity *identity);
+
+/**
+ * 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.
+ *
+ * @param[in,out] message Message
+ * @param[in] key Public key
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+encrypt_message (struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_CRYPTO_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.
+ *
+ * @param[in,out] message Message
+ * @param[in] key Private key
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+decrypt_message (struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
+ * Transcribes a <i>message</i> as a new transcript message using a given public
+ * <i>key</i> from the recipient of the encrypted message content.
+ *
+ * @param[in] message Message
+ * @param[in] key Public key
+ * @return Message transcript
+ */
+struct GNUNET_MESSENGER_Message*
+transcribe_message (const struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_CRYPTO_PublicKey *key);
+
+/**
+ * Read the original message from a transcript <i>message</i> and replaces its body
+ * and kind with the inner encrypted message. The function returns #GNUNET_YES if the
+ * operation succeeded, otherwise #GNUNET_NO.
+ *
+ * @param[in,out] transcript Message transcript
+ * @return #GNUNET_YES on success, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+read_transcript_message (struct GNUNET_MESSENGER_Message *message);
+
+typedef void (*GNUNET_MESSENGER_SignFunction)(
+  const void *cls,
+  struct GNUNET_MESSENGER_Message *message,
+  uint16_t length,
+  char *buffer,
+  const struct GNUNET_HashCode *hash
+  );
+
+enum GNUNET_MESSENGER_PackMode
+{
+  GNUNET_MESSENGER_PACK_MODE_ENVELOPE = 0x1,
+  GNUNET_MESSENGER_PACK_MODE_UNKNOWN = 0x0,
+};
+
+/**
+ * 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
+ * will be hashed if <i>hash</i> is not NULL and it will be signed if the <i>sign</i>
+ * function is not NULL.
+ *
+ * @param[out] message Message
+ * @param[out] hash Hash of message
+ * @param[in] sign Function to sign
+ * @param[in] mode Mode of packing
+ * @param[in,out] cls Closure for signing
+ * @return Envelope or NULL
+ */
+struct GNUNET_MQ_Envelope*
+pack_message (struct GNUNET_MESSENGER_Message *message,
+              struct GNUNET_HashCode *hash,
+              const GNUNET_MESSENGER_SignFunction sign,
+              enum GNUNET_MESSENGER_PackMode mode,
+              const void *cls);
+
+/**
+ * Returns whether a specific kind of message can be sent by the service without usage of a
+ * clients private key. The function returns #GNUNET_YES if the kind of message can be signed
+ * via a peer's identity, otherwise #GNUNET_NO.
+ *
+ * @param[in] message Message
+ * @return #GNUNET_YES if sending is allowed, #GNUNET_NO otherwise
+ */
+enum GNUNET_GenericReturnValue
+is_peer_message (const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Returns whether a specific kind of message contains service critical information. That kind
+ * of information should not be encrypted via private messages for example to guarantee the
+ * service to work properly. The function returns #GNUNET_YES if the kind of message needs to
+ * be transferred accessible to all peers and their running service. It returns #GNUNET_NO
+ * if the message can be encrypted to specific subgroups of members without issues. If the kind
+ * of message is unknown it returns #GNUNET_SYSERR.
+ *
+ * @param[in] message Message
+ * @return #GNUNET_YES if encrypting is disallowed, #GNUNET_NO or #GNUNET_SYSERR otherwise
+ */
+enum GNUNET_GenericReturnValue
+is_service_message (const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Returns whether 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
+ * @return #GNUNET_YES if sending is allowed, #GNUNET_NO or #GNUNET_SYSERR otherwise
+ */
+enum GNUNET_GenericReturnValue
+filter_message_sending (const struct GNUNET_MESSENGER_Message *message);
+
+#endif //GNUNET_MESSENGER_API_MESSAGE_H
diff --git a/src/service/messenger/messenger_api_message_control.c b/src/service/messenger/messenger_api_message_control.c
new file mode 100644
index 000000000..e8d0333dc
--- /dev/null
+++ b/src/service/messenger/messenger_api_message_control.c
@@ -0,0 +1,251 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2024 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_message_control.c
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_message_control.h"
+
+#include "gnunet_common.h"
+#include "gnunet_messenger_service.h"
+#include "gnunet_scheduler_lib.h"
+#include "messenger_api_contact.h"
+#include "messenger_api_contact_store.h"
+#include "messenger_api_handle.h"
+#include "messenger_api_message.h"
+#include "messenger_api_room.h"
+
+struct GNUNET_MESSENGER_MessageControl*
+create_message_control (struct GNUNET_MESSENGER_Room *room)
+{
+  GNUNET_assert (room);
+
+  struct GNUNET_MESSENGER_MessageControl *control;
+
+  control = GNUNET_new (struct GNUNET_MESSENGER_MessageControl);
+  control->room = room;
+
+  control->peer_messages = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
+  control->member_messages = GNUNET_CONTAINER_multishortmap_create (8,
+                                                                    GNUNET_NO);
+
+  control->head = NULL;
+  control->tail = NULL;
+
+  return control;
+}
+
+
+void
+destroy_message_control (struct GNUNET_MESSENGER_MessageControl *control)
+{
+  GNUNET_assert (control);
+
+  struct GNUNET_MESSENGER_MessageControlQueue *queue;
+  while (control->head)
+  {
+    queue = control->head;
+
+    if (queue->task)
+      GNUNET_SCHEDULER_cancel (queue->task);
+
+    destroy_message (queue->message);
+
+    GNUNET_CONTAINER_DLL_remove (control->head, control->tail, queue);
+    GNUNET_free (queue);
+  }
+
+  GNUNET_CONTAINER_multishortmap_destroy (control->peer_messages);
+  GNUNET_CONTAINER_multishortmap_destroy (control->member_messages);
+
+  GNUNET_free (control);
+}
+
+
+static void
+enqueue_message_control (struct GNUNET_MESSENGER_MessageControl *control,
+                         const struct GNUNET_HashCode *sender,
+                         const struct GNUNET_HashCode *context,
+                         const struct GNUNET_HashCode *hash,
+                         const struct GNUNET_MESSENGER_Message *message,
+                         enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  GNUNET_assert ((control) && (sender) && (context) && (hash) && (message));
+
+  struct GNUNET_CONTAINER_MultiShortmap *map;
+  if (GNUNET_YES == is_peer_message (message))
+    map = control->peer_messages;
+  else
+    map = control->member_messages;
+
+  struct GNUNET_MESSENGER_MessageControlQueue *queue;
+
+  queue = GNUNET_new (struct GNUNET_MESSENGER_MessageControlQueue);
+  queue->control = control;
+
+  GNUNET_memcpy (&(queue->sender), sender, sizeof (queue->sender));
+  GNUNET_memcpy (&(queue->context), context, sizeof (queue->context));
+  GNUNET_memcpy (&(queue->hash), hash, sizeof (queue->hash));
+
+  queue->message = copy_message (message);
+  queue->flags = flags;
+  queue->task = NULL;
+
+  GNUNET_CONTAINER_DLL_insert (control->head, control->tail, queue);
+
+  GNUNET_CONTAINER_multishortmap_put (map,
+                                      &(message->header.sender_id),
+                                      queue,
+                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+}
+
+
+static void
+handle_message_control (struct GNUNET_MESSENGER_MessageControl *control,
+                        struct GNUNET_MESSENGER_Contact *contact,
+                        const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_MESSENGER_Message *message,
+                        enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  GNUNET_assert ((control) && (hash) && (message));
+
+  handle_room_message (control->room, contact, message, hash, flags);
+
+  if (flags & GNUNET_MESSENGER_FLAG_RECENT)
+    update_room_last_message (control->room, hash);
+
+  callback_room_message (control->room, hash);
+}
+
+
+static void
+task_message_control (void *cls)
+{
+  GNUNET_assert (cls);
+
+  struct GNUNET_MESSENGER_MessageControlQueue *queue = cls;
+  struct GNUNET_MESSENGER_MessageControl *control = queue->control;
+
+  queue->task = NULL;
+
+  struct GNUNET_MESSENGER_Handle *handle = get_room_handle (control->room);
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+    handle);
+
+  struct GNUNET_MESSENGER_Contact *contact = get_store_contact_raw (
+    store, &(queue->context), &(queue->sender));
+
+  struct GNUNET_CONTAINER_MultiShortmap *map;
+  if (GNUNET_YES == is_peer_message (queue->message))
+    map = control->peer_messages;
+  else
+    map = control->member_messages;
+
+  GNUNET_CONTAINER_multishortmap_remove (map,
+                                         &(queue->message->header.sender_id),
+                                         queue);
+
+  GNUNET_CONTAINER_DLL_remove (control->head, control->tail, queue);
+
+  handle_message_control (control,
+                          contact,
+                          &(queue->hash),
+                          queue->message,
+                          queue->flags);
+
+  destroy_message (queue->message);
+
+  GNUNET_free (queue);
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_message_control (void *cls,
+                         const struct GNUNET_ShortHashCode *key,
+                         void *value)
+{
+  GNUNET_assert ((key) && (value));
+
+  struct GNUNET_MESSENGER_MessageControlQueue *queue = value;
+
+  if (queue->task)
+    return GNUNET_YES;
+
+  queue->task = GNUNET_SCHEDULER_add_now (task_message_control, queue);
+  return GNUNET_YES;
+}
+
+
+void
+process_message_control (struct GNUNET_MESSENGER_MessageControl *control,
+                         const struct GNUNET_HashCode *sender,
+                         const struct GNUNET_HashCode *context,
+                         const struct GNUNET_HashCode *hash,
+                         const struct GNUNET_MESSENGER_Message *message,
+                         enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  GNUNET_assert ((control) && (sender) && (context) && (hash) && (message));
+
+  struct GNUNET_MESSENGER_Handle *handle = get_room_handle (control->room);
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+    handle);
+
+  struct GNUNET_MESSENGER_Contact *contact = get_store_contact_raw (
+    store, context, sender);
+
+  if ((! contact) &&
+      (GNUNET_MESSENGER_KIND_JOIN != message->header.kind) &&
+      (GNUNET_MESSENGER_KIND_PEER != message->header.kind))
+    enqueue_message_control (control, sender, context, hash, message, flags);
+  else
+    handle_message_control (control, contact, hash, message, flags);
+
+  struct GNUNET_CONTAINER_MultiShortmap *map = NULL;
+  const struct GNUNET_ShortHashCode *id = &(message->header.sender_id);
+
+  if (GNUNET_YES == is_peer_message (message))
+    map = control->peer_messages;
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    map = control->member_messages;
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    map = control->peer_messages;
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    map = control->member_messages;
+    id = &(message->body.id.id);
+    break;
+  default:
+    break;
+  }
+
+  if (! map)
+    return;
+
+  GNUNET_CONTAINER_multishortmap_get_multiple (map,
+                                               id,
+                                               iterate_message_control,
+                                               NULL);
+}
diff --git a/src/service/messenger/messenger_api_message_control.h b/src/service/messenger/messenger_api_message_control.h
new file mode 100644
index 000000000..a990210f0
--- /dev/null
+++ b/src/service/messenger/messenger_api_message_control.h
@@ -0,0 +1,105 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2024 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_message_control.h
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_MESSAGE_CONTROL_H
+#define GNUNET_MESSENGER_API_MESSAGE_CONTROL_H
+
+#include "gnunet_common.h"
+#include "gnunet_messenger_service.h"
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_Message;
+struct GNUNET_MESSENGER_MessageControl;
+
+struct GNUNET_MESSENGER_MessageControlQueue
+{
+  struct GNUNET_MESSENGER_MessageControl *control;
+
+  struct GNUNET_HashCode sender;
+  struct GNUNET_HashCode context;
+  struct GNUNET_HashCode hash;
+
+  struct GNUNET_MESSENGER_Message *message;
+  enum GNUNET_MESSENGER_MessageFlags flags;
+  struct GNUNET_SCHEDULER_Task *task;
+
+  struct GNUNET_MESSENGER_MessageControlQueue *prev;
+  struct GNUNET_MESSENGER_MessageControlQueue *next;
+};
+
+struct GNUNET_MESSENGER_Room;
+
+struct GNUNET_MESSENGER_MessageControl
+{
+  struct GNUNET_MESSENGER_Room *room;
+
+  struct GNUNET_CONTAINER_MultiShortmap *peer_messages;
+  struct GNUNET_CONTAINER_MultiShortmap *member_messages;
+
+  struct GNUNET_MESSENGER_MessageControlQueue *head;
+  struct GNUNET_MESSENGER_MessageControlQueue *tail;
+};
+
+/**
+ * Creates and allocates a new message control for a <i>room</i> of the client API.
+ *
+ * @param[in,out] room Room
+ * @return New message control
+ */
+struct GNUNET_MESSENGER_MessageControl*
+create_message_control (struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Destroys a message control and frees its memory fully from the client API.
+ *
+ * @param[in,out] control Message control
+ */
+void
+destroy_message_control (struct GNUNET_MESSENGER_MessageControl *control);
+
+/**
+ * Processes a new <i>message</i> with its <i>hash</i> and regarding information about
+ * <i>sender</i>, <i>context</i> and message <i>flags</i> using a selected message
+ * <i>control</i>.
+ *
+ * The message control will ensure order of messages so that senders of messages
+ * can be identified via previously processed messages.
+ *
+ * @param[in,out] control Message control
+ * @param[in] sender Sender hash
+ * @param[in] context Context hash
+ * @param[in] hash Message hash
+ * @param[in] message Message
+ * @param[in] flags Message flags
+ */
+void
+process_message_control (struct GNUNET_MESSENGER_MessageControl *control,
+                         const struct GNUNET_HashCode *sender,
+                         const struct GNUNET_HashCode *context,
+                         const struct GNUNET_HashCode *hash,
+                         const struct GNUNET_MESSENGER_Message *message,
+                         enum GNUNET_MESSENGER_MessageFlags flags);
+
+#endif //GNUNET_MESSENGER_API_MESSAGE_CONTROL_H
\ No newline at end of file
diff --git a/src/service/messenger/messenger_api_message_kind.c b/src/service/messenger/messenger_api_message_kind.c
new file mode 100644
index 000000000..d423c5dda
--- /dev/null
+++ b/src/service/messenger/messenger_api_message_kind.c
@@ -0,0 +1,209 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_message_kind.c
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_message_kind.h"
+
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_Message*
+create_message_join (const struct GNUNET_CRYPTO_PrivateKey *key)
+{
+  if (! key)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_JOIN);
+
+  if (! message)
+    return NULL;
+
+  GNUNET_CRYPTO_key_get_public (key, &(message->body.join.key));
+  return message;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+create_message_leave ()
+{
+  return create_message (GNUNET_MESSENGER_KIND_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)
+    return NULL;
+
+  message->body.name.name = GNUNET_strdup (name);
+  return message;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+create_message_key (const struct GNUNET_CRYPTO_PrivateKey *key)
+{
+  if (! key)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_KEY);
+
+  if (! message)
+    return NULL;
+
+  GNUNET_CRYPTO_key_get_public (key, &(message->body.key.key));
+  return message;
+}
+
+
+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)
+    return NULL;
+
+  GNUNET_memcpy (&(message->body.id.id), unique_id, sizeof(struct
+                                                           GNUNET_ShortHashCode)
+                 );
+
+  return message;
+}
+
+
+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));
+
+  if (0 == GNUNET_CRYPTO_hash_cmp (hash, &zero))
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_REQUEST);
+
+  if (! message)
+    return NULL;
+
+  GNUNET_memcpy (&(message->body.request.hash), hash, sizeof(struct
+                                                             GNUNET_HashCode));
+
+  return message;
+}
+
+
+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)
+    return NULL;
+
+  GNUNET_memcpy (&(message->body.invite.door), door, sizeof(struct
+                                                            GNUNET_PeerIdentity)
+                 );
+  GNUNET_memcpy (&(message->body.invite.key), key, sizeof(struct
+                                                          GNUNET_HashCode));
+
+  return message;
+}
+
+
+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)
+    return NULL;
+
+  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.deletion.hash), hash, sizeof(struct
+                                                              GNUNET_HashCode));
+  message->body.deletion.delay = GNUNET_TIME_relative_hton (delay);
+
+  return message;
+}
+
+
+struct GNUNET_MESSENGER_Message*
+create_message_ticket (const struct GNUNET_RECLAIM_Ticket *ticket)
+{
+  if (! ticket)
+    return NULL;
+
+  struct GNUNET_MESSENGER_Message *message = create_message (
+    GNUNET_MESSENGER_KIND_TICKET);
+
+  if (! message)
+    return NULL;
+
+  message->body.ticket.identifier = GNUNET_strdup (ticket->gns_name);
+
+  return message;
+}
diff --git a/src/service/messenger/messenger_api_message_kind.h b/src/service/messenger/messenger_api_message_kind.h
new file mode 100644
index 000000000..5f4107f61
--- /dev/null
+++ b/src/service/messenger/messenger_api_message_kind.h
@@ -0,0 +1,138 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_message_kind.h
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_MESSAGE_KIND_H
+#define GNUNET_MESSENGER_API_MESSAGE_KIND_H
+
+#include "gnunet_messenger_service.h"
+#include "gnunet_reclaim_service.h"
+#include "gnunet_util_lib.h"
+
+/**
+ * Creates and allocates a new join message containing the clients public <i>key</i>.
+ * (all values are stored as copy)
+ *
+ * @param[in] key Private key
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_join (const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
+ * Creates and allocates a new leave message.
+ *
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+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[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 <i>key</i> to change to derived
+ * from its private counterpart. (all values are stored as copy)
+ *
+ * @param[in] key Private key
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_key (const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
+ * Creates and allocates a new id message containing the unique member id to change to.
+ * (all values are stored as copy)
+ *
+ * @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 request message containing the <i>hash</i> of a missing message.
+ * (all values are stored as copy)
+ *
+ * @param[in] hash Hash of message
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_request (const struct GNUNET_HashCode *hash);
+
+/**
+ * Creates and allocates a new invite message containing the peer identity of an entrance peer
+ * to a room using a given <i>key</i> as shared secret for communication.
+ * (all values are stored as copy)
+ *
+ * @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 <i>text</i> message containing a string representing text.
+ * (all values are stored as copy)
+ *
+ * @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);
+
+/**
+ * Creates and allocates a new ticket message containing the <i>identifier</i> of a ticket to
+ * exchange it with a given audience.
+ * (all values are stored as copy)
+ *
+ * @param[in] identifier Identifier of ticket
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_ticket (const struct GNUNET_RECLAIM_Ticket *ticket);
+
+#endif //GNUNET_MESSENGER_API_MESSAGE_KIND_H
diff --git a/src/service/messenger/messenger_api_queue_messages.c b/src/service/messenger/messenger_api_queue_messages.c
new file mode 100644
index 000000000..33e591da3
--- /dev/null
+++ b/src/service/messenger/messenger_api_queue_messages.c
@@ -0,0 +1,133 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2023--2024 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_queue_messages.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_queue_messages.h"
+
+#include "gnunet_messenger_service.h"
+#include "messenger_api_message.h"
+
+void
+init_queue_messages (struct GNUNET_MESSENGER_QueueMessages *messages)
+{
+  GNUNET_assert (messages);
+
+  messages->head = NULL;
+  messages->tail = NULL;
+}
+
+
+void
+clear_queue_messages (struct GNUNET_MESSENGER_QueueMessages *messages)
+{
+  GNUNET_assert (messages);
+
+  while (messages->head)
+  {
+    struct GNUNET_MESSENGER_QueueMessage *element = messages->head;
+
+    GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+
+    if (element->message)
+      destroy_message (element->message);
+
+    if (element->transcript)
+      destroy_message (element->transcript);
+
+    GNUNET_free (element);
+  }
+
+  messages->head = NULL;
+  messages->tail = NULL;
+}
+
+
+void
+enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
+                     const struct GNUNET_CRYPTO_PrivateKey *sender,
+                     struct GNUNET_MESSENGER_Message *message,
+                     struct GNUNET_MESSENGER_Message *transcript,
+                     enum GNUNET_GenericReturnValue priority)
+{
+  GNUNET_assert ((messages) && (sender) && (message));
+
+  struct GNUNET_MESSENGER_QueueMessage *element = GNUNET_new (struct
+                                                              GNUNET_MESSENGER_QueueMessage);
+
+  if (! element)
+    return;
+
+  element->message = message;
+  element->transcript = transcript;
+
+  GNUNET_memcpy (&(element->sender), sender, sizeof (element->sender));
+
+  if (! element->message)
+  {
+    if (element->transcript)
+      destroy_message (element->transcript);
+
+    GNUNET_free (element);
+    return;
+  }
+
+  if (GNUNET_YES == priority)
+    GNUNET_CONTAINER_DLL_insert (messages->head, messages->tail, element);
+  else
+    GNUNET_CONTAINER_DLL_insert_tail (messages->head, messages->tail, element);
+}
+
+
+struct GNUNET_MESSENGER_Message*
+dequeue_from_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
+                       struct GNUNET_CRYPTO_PrivateKey *sender,
+                       struct GNUNET_MESSENGER_Message **transcript)
+{
+  GNUNET_assert (messages);
+
+  struct GNUNET_MESSENGER_QueueMessage *element = messages->head;
+
+  if (! element)
+  {
+    if (transcript)
+      *transcript = NULL;
+
+    return NULL;
+  }
+
+  struct GNUNET_MESSENGER_Message *message = element->message;
+
+  if (transcript)
+    *transcript = element->transcript;
+  else if (element->transcript)
+    destroy_message (element->transcript);
+
+  GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+
+  if (sender)
+    GNUNET_memcpy (sender, &(element->sender), sizeof (*sender));
+
+  GNUNET_free (element);
+  return message;
+}
diff --git a/src/service/messenger/messenger_api_queue_messages.h b/src/service/messenger/messenger_api_queue_messages.h
new file mode 100644
index 000000000..aeed2e5d9
--- /dev/null
+++ b/src/service/messenger/messenger_api_queue_messages.h
@@ -0,0 +1,94 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2023--2024 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_queue_messages.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_QUEUE_MESSAGES_H
+#define GNUNET_MESSENGER_API_QUEUE_MESSAGES_H
+
+#include "gnunet_util_lib.h"
+
+struct GNUNET_MESSENGER_QueueMessage
+{
+  struct GNUNET_MESSENGER_QueueMessage *prev;
+  struct GNUNET_MESSENGER_QueueMessage *next;
+
+  struct GNUNET_CRYPTO_PrivateKey sender;
+
+  struct GNUNET_MESSENGER_Message *message;
+  struct GNUNET_MESSENGER_Message *transcript;
+};
+
+struct GNUNET_MESSENGER_QueueMessages
+{
+  struct GNUNET_MESSENGER_QueueMessage *head;
+  struct GNUNET_MESSENGER_QueueMessage *tail;
+};
+
+/**
+ * Initializes queue of messages as empty queue.
+ *
+ * @param[out] messages Queue of messages
+ */
+void
+init_queue_messages (struct GNUNET_MESSENGER_QueueMessages *messages);
+
+/**
+ * Clears the queue of messages.
+ *
+ * @param[in,out] messages Queue of messages
+ */
+void
+clear_queue_messages (struct GNUNET_MESSENGER_QueueMessages *messages);
+
+/**
+ * Adds a specific <i>message</i> to the end or the beginning of
+ * the queue depending on its <i>priority</i>.
+ *
+ * @param[in,out] messages Queue of messages
+ * @param[in] sender Private sender key
+ * @param[in] message Message
+ * @param[in] transcript Message transcript
+ * @param[in] priority Whether the message has priority
+ */
+void
+enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
+                     const struct GNUNET_CRYPTO_PrivateKey *sender,
+                     struct GNUNET_MESSENGER_Message *message,
+                     struct GNUNET_MESSENGER_Message *transcript,
+                     enum GNUNET_GenericReturnValue priority);
+
+/**
+ * Remove the message from the front of the queue and returns it.
+ *
+ * @param[in,out] messages Queue of messages
+ * @param[out] sender Private sender key
+ * @param[out] transcript Message transcript
+ * @return Message from front or NULL
+ */
+struct GNUNET_MESSENGER_Message*
+dequeue_from_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
+                       struct GNUNET_CRYPTO_PrivateKey *sender,
+                       struct GNUNET_MESSENGER_Message **transcript);
+
+#endif //GNUNET_MESSENGER_API_QUEUE_MESSAGES_H
diff --git a/src/service/messenger/messenger_api_room.c b/src/service/messenger/messenger_api_room.c
new file mode 100644
index 000000000..cddd43b22
--- /dev/null
+++ b/src/service/messenger/messenger_api_room.c
@@ -0,0 +1,913 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_room.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_room.h"
+
+#include "gnunet_common.h"
+#include "gnunet_messenger_service.h"
+#include "messenger_api_contact_store.h"
+#include "messenger_api_handle.h"
+#include "messenger_api_message.h"
+#include "messenger_api_message_control.h"
+#include <string.h>
+
+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;
+  GNUNET_memcpy (&(room->key), key, sizeof(*key));
+
+  memset (&(room->last_message), 0, sizeof(room->last_message));
+
+  room->opened = GNUNET_NO;
+  room->use_handle_name = GNUNET_YES;
+  room->wait_for_sync = GNUNET_NO;
+
+  room->sender_id = NULL;
+
+  init_list_tunnels (&(room->entries));
+
+  room->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
+  room->links = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_queue_messages (&(room->queue));
+
+  room->control = create_message_control (room);
+
+  return room;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_message (void *cls,
+                         const struct GNUNET_HashCode *key,
+                         void *value)
+{
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry = value;
+
+  destroy_message (entry->message);
+  GNUNET_free (entry);
+
+  return GNUNET_YES;
+}
+
+
+static enum GNUNET_GenericReturnValue
+iterate_destroy_link (void *cls,
+                      const struct GNUNET_HashCode *key,
+                      void *value)
+{
+  struct GNUNET_HashCode *hash = value;
+  GNUNET_free (hash);
+  return GNUNET_YES;
+}
+
+
+void
+destroy_room (struct GNUNET_MESSENGER_Room *room)
+{
+  GNUNET_assert (room);
+
+  destroy_message_control (room->control);
+
+  clear_queue_messages (&(room->queue));
+  clear_list_tunnels (&(room->entries));
+
+  if (room->messages)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (room->messages,
+                                           iterate_destroy_message, NULL);
+
+    GNUNET_CONTAINER_multihashmap_destroy (room->messages);
+  }
+
+  if (room->members)
+    GNUNET_CONTAINER_multishortmap_destroy (room->members);
+
+  if (room->links)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (room->links,
+                                           iterate_destroy_link, NULL);
+
+    GNUNET_CONTAINER_multihashmap_destroy (room->links);
+  }
+
+  if (room->sender_id)
+    GNUNET_free (room->sender_id);
+
+  GNUNET_free (room);
+}
+
+
+enum GNUNET_GenericReturnValue
+is_room_available (const struct GNUNET_MESSENGER_Room *room)
+{
+  GNUNET_assert (room);
+
+  if (! get_room_sender_id (room))
+    return GNUNET_NO;
+
+  if ((GNUNET_YES == room->opened) || (room->entries.head))
+    return GNUNET_YES;
+  else
+    return GNUNET_NO;
+}
+
+
+struct GNUNET_MESSENGER_Handle*
+get_room_handle (struct GNUNET_MESSENGER_Room *room)
+{
+  GNUNET_assert (room);
+
+  return room->handle;
+}
+
+
+const struct GNUNET_ShortHashCode*
+get_room_sender_id (const struct GNUNET_MESSENGER_Room *room)
+{
+  GNUNET_assert (room);
+
+  return room->sender_id;
+}
+
+
+void
+set_room_sender_id (struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert (room);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
+              GNUNET_h2s (&(room->key)));
+
+  if (! id)
+  {
+    if (room->sender_id)
+      GNUNET_free (room->sender_id);
+
+    room->sender_id = NULL;
+    return;
+  }
+
+  if (! room->sender_id)
+    room->sender_id = GNUNET_new (struct GNUNET_ShortHashCode);
+
+  GNUNET_memcpy (room->sender_id, id, sizeof(struct GNUNET_ShortHashCode));
+}
+
+
+const struct GNUNET_MESSENGER_Message*
+get_room_message (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);
+
+  if ((! entry) || (GNUNET_YES != entry->completed))
+    return NULL;
+
+  return entry->message;
+}
+
+
+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);
+
+  if ((! entry) || (GNUNET_YES != entry->completed))
+    return NULL;
+
+  return entry->sender;
+}
+
+
+struct GNUNET_MESSENGER_Contact*
+get_room_recipient (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);
+
+  if ((! entry) || (GNUNET_YES != entry->completed))
+    return NULL;
+
+  return entry->recipient;
+}
+
+
+void
+callback_room_message (struct GNUNET_MESSENGER_Room *room,
+                       const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((room) && (hash));
+
+  struct GNUNET_MESSENGER_Handle *handle = room->handle;
+
+  if (! handle)
+    return;
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
+  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
+
+  if (! entry)
+    return;
+
+  if (handle->msg_callback)
+    handle->msg_callback (handle->msg_cls, room,
+                          entry->sender,
+                          entry->recipient,
+                          entry->message,
+                          hash,
+                          entry->flags);
+
+  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
+    entry->flags ^= GNUNET_MESSENGER_FLAG_UPDATE;
+}
+
+
+static void
+handle_message (struct GNUNET_MESSENGER_Room *room,
+                const struct GNUNET_HashCode *hash,
+                struct GNUNET_MESSENGER_RoomMessageEntry *entry);
+
+
+void
+handle_join_message (struct GNUNET_MESSENGER_Room *room,
+                     const struct GNUNET_HashCode *hash,
+                     struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (! entry->sender)
+  {
+    struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+      room->handle);
+    struct GNUNET_HashCode context;
+
+    get_context_from_member (&(room->key), &(entry->message->header.sender_id),
+                             &context);
+
+    entry->sender = get_store_contact (store, &context,
+                                       &(entry->message->body.join.key));
+  }
+
+  if ((GNUNET_YES != GNUNET_CONTAINER_multishortmap_contains_value (
+         room->members, &(entry->message->header.sender_id), entry->sender)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (room->members,
+                                                        &(entry->message->header
+                                                          .sender_id),
+                                                        entry->sender,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+
+    increase_contact_rc (entry->sender);
+}
+
+
+static void
+handle_leave_message (struct GNUNET_MESSENGER_Room *room,
+                      const struct GNUNET_HashCode *hash,
+                      struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if ((! entry->sender) ||
+      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
+                                                            &(entry->message->
+                                                              header.sender_id),
+                                                            entry->sender)))
+    return;
+
+  if (GNUNET_YES == decrease_contact_rc (entry->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_HashCode *hash,
+                     struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Set rule for using handle name in room: %s\n",
+                GNUNET_h2s (&(room->key)));
+
+    const char *handle_name = get_handle_name (room->handle);
+
+    if ((handle_name) && (0 == strcmp (handle_name,
+                                       entry->message->body.name.name)))
+      room->use_handle_name = GNUNET_YES;
+  }
+
+  if (! entry->sender)
+    return;
+
+  set_contact_name (entry->sender, entry->message->body.name.name);
+}
+
+
+static void
+handle_key_message (struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_HashCode *hash,
+                    struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (! entry->sender)
+    return;
+
+  struct GNUNET_HashCode context;
+  get_context_from_member (&(room->key), &(entry->message->header.sender_id),
+                           &context);
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+    room->handle);
+
+  update_store_contact (store, entry->sender, &context, &context,
+                        &(entry->message->body.key.key));
+}
+
+
+static void
+handle_id_message (struct GNUNET_MESSENGER_Room *room,
+                   const struct GNUNET_HashCode *hash,
+                   struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (GNUNET_MESSENGER_FLAG_SENT & entry->flags)
+    set_room_sender_id (room, &(entry->message->body.id.id));
+
+  if ((! entry->sender) ||
+      (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
+                                                            &(entry->message->
+                                                              header.sender_id),
+                                                            entry->sender)) ||
+      (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (room->members,
+                                                        &(entry->message->body.
+                                                          id.id),
+                                                        entry->sender,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+
+    return;
+
+  struct GNUNET_HashCode context, next_context;
+  get_context_from_member (&(room->key), &(entry->message->header.sender_id),
+                           &context);
+  get_context_from_member (&(room->key), &(entry->message->body.id.id),
+                           &next_context);
+
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+    room->handle);
+
+  update_store_contact (store, entry->sender, &context, &next_context,
+                        get_contact_key (entry->sender));
+}
+
+
+static void
+handle_miss_message (struct GNUNET_MESSENGER_Room *room,
+                     const struct GNUNET_HashCode *hash,
+                     struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (0 == (GNUNET_MESSENGER_FLAG_SENT & entry->flags))
+    return;
+
+  struct GNUNET_MESSENGER_ListTunnel *match = find_list_tunnels (
+    &(room->entries), &(entry->message->body.miss.peer), NULL);
+
+  if (match)
+    remove_from_list_tunnels (&(room->entries), match);
+}
+
+
+static void
+handle_private_message (struct GNUNET_MESSENGER_Room *room,
+                        const struct GNUNET_HashCode *hash,
+                        struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  struct GNUNET_MESSENGER_Message *private_message = copy_message (
+    entry->message);
+
+  if (! private_message)
+    return;
+
+  if (GNUNET_YES != decrypt_message (private_message,
+                                     get_handle_key (room->handle)))
+  {
+    destroy_message (private_message);
+    private_message = NULL;
+  }
+
+  if (! private_message)
+    return;
+
+  destroy_message (entry->message);
+
+  entry->recipient = get_handle_contact (room->handle, &(room->key));
+
+  entry->message = private_message;
+  entry->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
+
+  if ((entry->sender) && (entry->recipient))
+    handle_message (room, hash, entry);
+}
+
+
+extern void
+delete_message_in_room (struct GNUNET_MESSENGER_Room *room,
+                        const struct GNUNET_HashCode *hash,
+                        const struct GNUNET_TIME_Relative delay);
+
+
+static void
+handle_delete_message (struct GNUNET_MESSENGER_Room *room,
+                       const struct GNUNET_HashCode *hash,
+                       struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  const struct GNUNET_HashCode *target_hash =
+    &(entry->message->body.deletion.hash);
+
+  if (get_handle_contact (room->handle, &(room->key)) == entry->sender)
+  {
+    struct GNUNET_TIME_Relative delay;
+    struct GNUNET_TIME_Absolute action;
+
+    delay = GNUNET_TIME_relative_ntoh (entry->message->body.deletion.delay);
+
+    action = GNUNET_TIME_absolute_ntoh (entry->message->header.timestamp);
+    action = GNUNET_TIME_absolute_add (action, delay);
+
+    delay = GNUNET_TIME_absolute_get_difference (GNUNET_TIME_absolute_get (),
+                                                 action);
+
+    link_room_deletion (room, target_hash, delay, delete_message_in_room);
+  }
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *target =
+    GNUNET_CONTAINER_multihashmap_get (room->messages, target_hash);
+
+  if (! target)
+    return;
+
+  if (((target->sender != entry->sender) &&
+       (get_handle_contact (room->handle, &(room->key)) != entry->sender)))
+    return;
+
+  target->flags |= GNUNET_MESSENGER_FLAG_DELETE;
+  callback_room_message (room, target_hash);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->messages,
+                                                          target_hash,
+                                                          target))
+  {
+    destroy_message (target->message);
+    GNUNET_free (target);
+  }
+}
+
+
+static void
+handle_transcript_message (struct GNUNET_MESSENGER_Room *room,
+                           const struct GNUNET_HashCode *hash,
+                           struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  if (get_handle_contact (room->handle, &(room->key)) != entry->sender)
+    return;
+
+  const struct GNUNET_HashCode *original_hash =
+    &(entry->message->body.transcript.hash);
+  struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+    room->handle);
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *original =
+    GNUNET_CONTAINER_multihashmap_get (room->messages, original_hash);
+  struct GNUNET_MESSENGER_Message *original_message;
+
+  if (original)
+    goto read_transcript;
+
+  original = GNUNET_new (struct GNUNET_MESSENGER_RoomMessageEntry);
+
+  if (! original)
+    return;
+
+  original->sender = NULL;
+  original->recipient = NULL;
+
+  original->message = NULL;
+  original->flags = GNUNET_MESSENGER_FLAG_NONE;
+  original->completed = GNUNET_NO;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages,
+                                                      original_hash,
+                                                      original,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    GNUNET_free (original);
+    return;
+  }
+
+read_transcript:
+  original_message = copy_message (entry->message);
+
+  if (! original_message)
+    return;
+
+  if (GNUNET_YES != read_transcript_message (original_message))
+  {
+    destroy_message (original_message);
+    return;
+  }
+
+  original->recipient = get_store_contact (store,
+                                           NULL,
+                                           &(entry->message->body.transcript.key
+                                             ));
+
+  if (original->message)
+  {
+    if (GNUNET_MESSENGER_KIND_PRIVATE == original->message->header.kind)
+      original->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
+
+    copy_message_header (original_message, &(original->message->header));
+    destroy_message (original->message);
+  }
+
+  original->message = original_message;
+
+  link_room_message (room, hash, original_hash);
+  link_room_message (room, original_hash, hash);
+
+  if ((original->sender) && (original->recipient))
+  {
+    original->flags |= GNUNET_MESSENGER_FLAG_UPDATE;
+    handle_message (room, original_hash, original);
+  }
+}
+
+
+static void
+handle_message (struct GNUNET_MESSENGER_Room *room,
+                const struct GNUNET_HashCode *hash,
+                struct GNUNET_MESSENGER_RoomMessageEntry *entry)
+{
+  GNUNET_assert ((room) && (hash) && (entry));
+
+  switch (entry->message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    handle_join_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    handle_leave_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    handle_name_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    handle_key_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    handle_id_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    handle_miss_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    handle_private_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_DELETE:
+    handle_delete_message (room, hash, entry);
+    break;
+  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
+    handle_transcript_message (room, hash, entry);
+    break;
+  default:
+    break;
+  }
+
+  if (entry->flags & GNUNET_MESSENGER_FLAG_UPDATE)
+    callback_room_message (room, hash);
+}
+
+
+void
+handle_room_message (struct GNUNET_MESSENGER_Room *room,
+                     struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash,
+                     enum GNUNET_MESSENGER_MessageFlags flags)
+{
+  GNUNET_assert ((room) && (message) && (hash));
+
+  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
+  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
+
+  if (entry)
+    goto update_entry;
+
+  entry = GNUNET_new (struct GNUNET_MESSENGER_RoomMessageEntry);
+
+  if (! entry)
+    return;
+
+  entry->sender = NULL;
+  entry->recipient = NULL;
+
+  entry->message = NULL;
+  entry->flags = GNUNET_MESSENGER_FLAG_NONE;
+  entry->completed = GNUNET_NO;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash,
+                                                      entry,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    GNUNET_free (entry);
+    return;
+  }
+
+update_entry:
+  entry->sender = sender;
+  entry->flags = flags;
+
+  if (entry->message)
+  {
+    if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
+      entry->flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
+
+    copy_message_header (entry->message, &(message->header));
+  }
+  else
+    entry->message = copy_message (message);
+
+  entry->completed = GNUNET_YES;
+
+  handle_message (room, hash, entry);
+}
+
+
+void
+update_room_last_message (struct GNUNET_MESSENGER_Room *room,
+                          const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert ((room) && (hash));
+
+  GNUNET_memcpy (&(room->last_message), hash, sizeof(room->last_message));
+}
+
+
+struct GNUNET_MESSENGER_MemberCall
+{
+  struct GNUNET_MESSENGER_Room *room;
+  GNUNET_MESSENGER_MemberCallback callback;
+  void *cls;
+};
+
+static enum GNUNET_GenericReturnValue
+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);
+}
+
+
+struct GNUNET_MESSENGER_MemberFind
+{
+  const struct GNUNET_MESSENGER_Contact *contact;
+  enum GNUNET_GenericReturnValue result;
+};
+
+static enum GNUNET_GenericReturnValue
+iterate_find_member (void *cls,
+                     const struct GNUNET_ShortHashCode *key,
+                     void *value)
+{
+  struct GNUNET_MESSENGER_MemberFind *find = cls;
+  struct GNUNET_MESSENGER_Contact *contact = value;
+
+  if (contact == find->contact)
+  {
+    find->result = GNUNET_YES;
+    return GNUNET_NO;
+  }
+
+  return GNUNET_YES;
+}
+
+
+enum GNUNET_GenericReturnValue
+find_room_member (const struct GNUNET_MESSENGER_Room *room,
+                  const struct GNUNET_MESSENGER_Contact *contact)
+{
+  GNUNET_assert (room);
+
+  struct GNUNET_MESSENGER_MemberFind find;
+
+  find.contact = contact;
+  find.result = GNUNET_NO;
+
+  GNUNET_CONTAINER_multishortmap_iterate (room->members, iterate_find_member,
+                                          &find);
+
+  return find.result;
+}
+
+
+static enum GNUNET_GenericReturnValue
+find_linked_hash (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  const struct GNUNET_HashCode **result = cls;
+  struct GNUNET_HashCode *hash = value;
+
+  if (0 == GNUNET_CRYPTO_hash_cmp (hash, *result))
+  {
+    *result = NULL;
+    return GNUNET_NO;
+  }
+
+  return GNUNET_YES;
+}
+
+
+void
+link_room_message (struct GNUNET_MESSENGER_Room *room,
+                   const struct GNUNET_HashCode *hash,
+                   const struct GNUNET_HashCode *other)
+{
+  GNUNET_assert ((room) && (hash) && (other));
+
+  const struct GNUNET_HashCode **result = &other;
+  GNUNET_CONTAINER_multihashmap_get_multiple (room->links, hash,
+                                              find_linked_hash, result);
+
+  if (! *result)
+    return;
+
+  struct GNUNET_HashCode *value = GNUNET_memdup (other, sizeof(struct
+                                                               GNUNET_HashCode))
+  ;
+  if (! value)
+    return;
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->links, hash, value,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
+
+    GNUNET_free (value);
+}
+
+
+struct GNUNET_MESSENGER_RoomLinkDeletionInfo
+{
+  struct GNUNET_MESSENGER_Room *room;
+  struct GNUNET_TIME_Relative delay;
+  GNUNET_MESSENGER_RoomLinkDeletion deletion;
+};
+
+
+static enum GNUNET_GenericReturnValue
+clear_linked_hash (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   void *value)
+{
+  struct GNUNET_HashCode **linked = cls;
+  struct GNUNET_HashCode *hash = value;
+
+  if (0 != GNUNET_CRYPTO_hash_cmp (*linked, hash))
+    return GNUNET_YES;
+
+  *linked = hash;
+  return GNUNET_NO;
+}
+
+
+static enum GNUNET_GenericReturnValue
+delete_linked_hash (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct GNUNET_MESSENGER_RoomLinkDeletionInfo *info = cls;
+  struct GNUNET_HashCode *hash = value;
+
+  struct GNUNET_HashCode key_value;
+  GNUNET_memcpy (&key_value, key, sizeof (key_value));
+
+  struct GNUNET_HashCode *linked = &key_value;
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (info->room->links, hash,
+                                              clear_linked_hash, &linked);
+
+  if ((linked != &key_value) &&
+      (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (info->room->links,
+                                                           hash, linked)))
+    GNUNET_free (linked);
+
+  if (info->deletion)
+    info->deletion (info->room, hash, info->delay);
+
+  GNUNET_free (hash);
+  return GNUNET_YES;
+}
+
+
+void
+link_room_deletion (struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_HashCode *hash,
+                    const struct GNUNET_TIME_Relative delay,
+                    GNUNET_MESSENGER_RoomLinkDeletion deletion)
+{
+  GNUNET_assert ((room) && (hash));
+
+  struct GNUNET_MESSENGER_RoomLinkDeletionInfo info;
+  info.room = room;
+  info.delay = delay;
+  info.deletion = deletion;
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (room->links, hash,
+                                              delete_linked_hash, &info);
+  GNUNET_CONTAINER_multihashmap_remove_all (room->links, hash);
+}
diff --git a/src/service/messenger/messenger_api_room.h b/src/service/messenger/messenger_api_room.h
new file mode 100644
index 000000000..f8460f4e1
--- /dev/null
+++ b/src/service/messenger/messenger_api_room.h
@@ -0,0 +1,270 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_room.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_ROOM_H
+#define GNUNET_MESSENGER_API_ROOM_H
+
+#include "gnunet_common.h"
+#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"
+
+#include "gnunet_messenger_service.h"
+
+#include "messenger_api_handle.h"
+#include "messenger_api_list_tunnels.h"
+#include "messenger_api_contact.h"
+#include "messenger_api_message_control.h"
+#include "messenger_api_queue_messages.h"
+
+struct GNUNET_MESSENGER_RoomMessageEntry
+{
+  struct GNUNET_MESSENGER_Contact *sender;
+  struct GNUNET_MESSENGER_Contact *recipient;
+
+  struct GNUNET_MESSENGER_Message *message;
+  enum GNUNET_MESSENGER_MessageFlags flags;
+  enum GNUNET_GenericReturnValue completed;
+};
+
+struct GNUNET_MESSENGER_Room
+{
+  struct GNUNET_MESSENGER_Handle *handle;
+  struct GNUNET_HashCode key;
+
+  struct GNUNET_HashCode last_message;
+
+  enum GNUNET_GenericReturnValue opened;
+  enum GNUNET_GenericReturnValue use_handle_name;
+  enum GNUNET_GenericReturnValue wait_for_sync;
+
+  struct GNUNET_ShortHashCode *sender_id;
+
+  struct GNUNET_MESSENGER_ListTunnels entries;
+
+  struct GNUNET_CONTAINER_MultiHashMap *messages;
+  struct GNUNET_CONTAINER_MultiShortmap *members;
+  struct GNUNET_CONTAINER_MultiHashMap *links;
+
+  struct GNUNET_MESSENGER_QueueMessages queue;
+
+  struct GNUNET_MESSENGER_MessageControl *control;
+};
+
+typedef void (*GNUNET_MESSENGER_RoomLinkDeletion) (struct
+                                                   GNUNET_MESSENGER_Room *room,
+                                                   const struct
+                                                   GNUNET_HashCode *hash,
+                                                   const struct
+                                                   GNUNET_TIME_Relative delay);
+
+/**
+ * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i> for the client API.
+ *
+ * @param[in,out] handle Handle
+ * @param[in] key Key of room
+ * @return New room
+ */
+struct GNUNET_MESSENGER_Room*
+create_room (struct GNUNET_MESSENGER_Handle *handle,
+             const struct GNUNET_HashCode *key);
+
+/**
+ * Destroys a room and frees its memory fully from the client API.
+ *
+ * @param[in,out] room Room
+ */
+void
+destroy_room (struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Checks whether a room is available to send messages.
+ *
+ * @param[in] room Room
+ * @return GNUNET_YES if the room is available, otherwise GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+is_room_available (const struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Returns the messenger handle of the <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @return Messenger handle or NULL
+ */
+struct GNUNET_MESSENGER_Handle*
+get_room_handle (struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Returns the member id of the <i>room</i>'s sender.
+ *
+ * @param[in] room Room
+ * @return Member id or NULL
+ */
+const struct GNUNET_ShortHashCode*
+get_room_sender_id (const struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Sets the member id of the <i>room</i>'s sender to a specific <i>id</i> or NULL.
+ *
+ * @param[in,out] room Room
+ * @param[in] id Member id or NULL
+ */
+void
+set_room_sender_id (struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_ShortHashCode *id);
+
+/**
+ * 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[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);
+
+/**
+ * Returns a messages recipient locally stored from a map for a given <i>hash</i> in a <i>room</i>. If no
+ * matching message is found or the message has not been privately received, NULL gets returned.
+ *
+ * @param[in] room Room
+ * @param[in] hash Hash of message
+ * @return Contact of recipient or NULL
+ */
+struct GNUNET_MESSENGER_Contact*
+get_room_recipient (const struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_HashCode *hash);
+
+/**
+ * Executes the message callback for a given <i>hash</i> in a <i>room</i>.
+ *
+ * @param[in,out] room Room
+ * @param[in] hash Hash of message
+ */
+void
+callback_room_message (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.
+ *
+ * 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
+ * @param[in] flags Flags of message
+ */
+void
+handle_room_message (struct GNUNET_MESSENGER_Room *room,
+                     struct GNUNET_MESSENGER_Contact *sender,
+                     const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash,
+                     enum GNUNET_MESSENGER_MessageFlags flags);
+
+/**
+ * Updates the last message <i>hash</i> of a <i>room</i> for the client API so that new messages can
+ * point to the latest message hash while sending.
+ *
+ * @param[in,out] room Room
+ * @param[in] hash Hash of message
+ */
+void
+update_room_last_message (struct GNUNET_MESSENGER_Room *room,
+                          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);
+
+/**
+ * Checks through all members of a given <i>room</i> if a specific <i>contact</i> is found and
+ * returns a result depending on that.
+ *
+ * @param[in] room Room
+ * @param[in] contact
+ * @return #GNUNET_YES if found, otherwise #GNUNET_NO
+ */
+enum GNUNET_GenericReturnValue
+find_room_member (const struct GNUNET_MESSENGER_Room *room,
+                  const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Links a message identified by its <i>hash</i> inside a given <i>room</i> with another
+ * message identified by its <i>other</i> hash. Linked messages will be deleted automatically,
+ * if any linked message to it gets deleted.
+ *
+ * @param[in,out] room Room
+ * @param[in] hash Hash of message
+ * @param[in] other Hash of other message
+ */
+void
+link_room_message (struct GNUNET_MESSENGER_Room *room,
+                   const struct GNUNET_HashCode *hash,
+                   const struct GNUNET_HashCode *other);
+
+/**
+ * Delete all remaining links to a certain message identified by its <i>hash</i> inside a given
+ * <i>room</i> and cause a <i>deletion</i> process to all of the linked messages.
+ *
+ * @param[in,out] room Room
+ * @param[in] hash Hash of message
+ * @param[in] delay Delay for linked deletion
+ * @param[in] deletion Function called for each linked deletion
+ */
+void
+link_room_deletion (struct GNUNET_MESSENGER_Room *room,
+                    const struct GNUNET_HashCode *hash,
+                    const struct GNUNET_TIME_Relative delay,
+                    GNUNET_MESSENGER_RoomLinkDeletion deletion);
+
+#endif //GNUNET_MESSENGER_API_ROOM_H
diff --git a/src/service/messenger/messenger_api_traits.c b/src/service/messenger/messenger_api_traits.c
new file mode 100644
index 000000000..b6affc90d
--- /dev/null
+++ b/src/service/messenger/messenger_api_traits.c
@@ -0,0 +1,29 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2023--2024 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_api_traits.c
+ * @brief testing lib for messenger service
+ * @author Tobias Frisch
+ */
+
+#include "messenger-testing-cmds.h"
+
+GNUNET_MESSENGER_SIMPLE_TRAITS (GNUNET_MESSENGER_MAKE_IMPL_SIMPLE_TRAIT)
diff --git a/src/service/messenger/messenger_api_util.c b/src/service/messenger/messenger_api_util.c
new file mode 100644
index 000000000..1d38f87a1
--- /dev/null
+++ b/src/service/messenger/messenger_api_util.c
@@ -0,0 +1,129 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_util.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_util.h"
+
+#include "gnunet_identity_service.h"
+#include "gnunet_messenger_service.h"
+
+static void
+callback_close_channel (void *cls)
+{
+  struct GNUNET_CADET_Channel *channel = cls;
+
+  if (channel)
+    GNUNET_CADET_channel_destroy (channel);
+}
+
+
+void
+delayed_disconnect_channel (struct GNUNET_CADET_Channel *channel)
+{
+  GNUNET_assert (channel);
+
+  GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (),
+                                              GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                              callback_close_channel, channel);
+}
+
+
+enum GNUNET_GenericReturnValue
+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
+  {
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, id, sizeof(struct
+                                                                         GNUNET_ShortHashCode));
+
+    if ((members) && (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
+                        members, id)))
+      counter--;
+    else
+      break;
+  }
+  while (counter > 0);
+
+  if (counter)
+    return GNUNET_YES;
+
+  return GNUNET_NO;
+}
+
+
+const struct GNUNET_CRYPTO_PrivateKey*
+get_anonymous_private_key ()
+{
+  const struct GNUNET_IDENTITY_Ego *ego = GNUNET_IDENTITY_ego_get_anonymous ();
+  return GNUNET_IDENTITY_ego_get_private_key (ego);
+}
+
+
+const struct GNUNET_CRYPTO_PublicKey*
+get_anonymous_public_key ()
+{
+  static struct GNUNET_CRYPTO_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;
+}
+
+
+void
+convert_messenger_key_to_port (const struct GNUNET_HashCode *key,
+                               struct GNUNET_HashCode *port)
+{
+  static uint32_t version_value = 0;
+  static struct GNUNET_HashCode version;
+
+  if (! version_value)
+  {
+    version_value = (uint32_t) (GNUNET_MESSENGER_VERSION);
+    version_value = ((version_value >> 16) & 0xFFFF);
+    version_value = GNUNET_htole32 (version_value);
+    GNUNET_CRYPTO_hash (&version_value, sizeof(version_value), &version);
+  }
+
+  GNUNET_CRYPTO_hash_sum (key, &version, port);
+}
+
+
+void
+convert_peer_identity_to_id (const struct GNUNET_PeerIdentity *identity,
+                             struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_memcpy (id, identity, sizeof(struct GNUNET_ShortHashCode));
+}
diff --git a/src/service/messenger/messenger_api_util.h b/src/service/messenger/messenger_api_util.h
new file mode 100644
index 000000000..877491c93
--- /dev/null
+++ b/src/service/messenger/messenger_api_util.h
@@ -0,0 +1,95 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2024 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_util.h
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_UTIL_H
+#define GNUNET_SERVICE_MESSENGER_UTIL_H
+
+#include "gnunet_cadet_service.h"
+#include "gnunet_util_lib.h"
+
+/**
+ * Starts an urgent task to close a CADET channel asynchronously.
+ *
+ * @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.
+ *
+ * @param[out] id New member id
+ * @param[in] members Map of member ids
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure
+ */
+enum GNUNET_GenericReturnValue
+generate_free_member_id (struct GNUNET_ShortHashCode *id,
+                         const struct GNUNET_CONTAINER_MultiShortmap *members);
+
+/**
+ * Returns the private identity key of #GNUNET_IDENTITY_ego_get_anonymous() without
+ * recalculating it every time.
+ *
+ * @return anonymous private key
+ */
+const struct GNUNET_CRYPTO_PrivateKey*
+get_anonymous_private_key ();
+
+/**
+ * Returns the public identity key of #GNUNET_IDENTITY_ego_get_anonymous() without
+ * recalculating it every time.
+ *
+ * @return anonymous public key
+ */
+const struct GNUNET_CRYPTO_PublicKey*
+get_anonymous_public_key ();
+
+/**
+ * Converts a Messenger service key of a room to the specific port which
+ * gets used for the CADET channels.
+ *
+ * The port includes upper bits of the #GNUNET_MESSENGER_VERSION to
+ * reduce the chance of incompatible connections.
+ *
+ * @param[in] key Messenger service room key
+ * @param[out] port CADET service port
+ */
+void
+convert_messenger_key_to_port (const struct GNUNET_HashCode *key,
+                               struct GNUNET_HashCode *port);
+
+/**
+ * Converts a peers identity to a short hash code which can be used
+ * as id to refer to a peer via sender id as attached in messages.
+ *
+ * @param[in] identity Peer identity
+ * @param[out] id Short peer id
+ */
+void
+convert_peer_identity_to_id (const struct GNUNET_PeerIdentity *identity,
+                             struct GNUNET_ShortHashCode *id);
+
+#endif //GNUNET_SERVICE_MESSENGER_UTIL_H
diff --git a/src/service/messenger/test_messenger.c b/src/service/messenger/test_messenger.c
new file mode 100644
index 000000000..4f7a51e34
--- /dev/null
+++ b/src/service/messenger/test_messenger.c
@@ -0,0 +1,218 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include <stdio.h>
+#include "gnunet_util_lib.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)
+
+#define TESTER_NAME "tester"
+
+static int status = 1;
+
+static struct GNUNET_SCHEDULER_Task *die_task = NULL;
+static struct GNUNET_SCHEDULER_Task *op_task = NULL;
+static struct GNUNET_SCHEDULER_Task *it_task = NULL;
+
+struct GNUNET_MESSENGER_Handle *messenger = NULL;
+
+static struct GNUNET_CRYPTO_PrivateKey identity;
+
+static void
+end (void *cls)
+{
+  die_task = NULL;
+
+  if (it_task)
+  {
+    GNUNET_SCHEDULER_cancel (it_task);
+    it_task = NULL;
+  }
+
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  if (messenger)
+  {
+    GNUNET_MESSENGER_disconnect (messenger);
+    messenger = NULL;
+  }
+
+  GNUNET_CRYPTO_private_key_clear (&identity);
+  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 int identity_counter = 0;
+
+/**
+ * Function called when an identity is retrieved.
+ *
+ * @param cls Closure
+ * @param handle Handle of messenger service
+ */
+static void
+on_iteration (void *cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+  it_task = NULL;
+
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  const char *name = GNUNET_MESSENGER_get_name (handle);
+
+  if ((! name) || (0 != strcmp (name, TESTER_NAME)))
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "name");
+    return;
+  }
+
+  const struct GNUNET_CRYPTO_PublicKey *key = GNUNET_MESSENGER_get_key (
+    handle);
+
+  struct GNUNET_CRYPTO_PublicKey pubkey;
+  GNUNET_CRYPTO_key_get_public (&identity, &pubkey);
+
+  if (((! identity_counter) && (key)) || ((identity_counter) && ((! key) ||
+                                                                 (0 !=
+                                                                  GNUNET_memcmp (
+                                                                    key,
+                                                                    &pubkey)))))
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "key");
+    return;
+  }
+
+  if (identity_counter)
+  {
+    GNUNET_MESSENGER_disconnect (handle);
+
+    op_task = NULL;
+    messenger = NULL;
+
+    if (die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+
+    die_task = GNUNET_SCHEDULER_add_now (&end, NULL);
+    return;
+  }
+
+  GNUNET_MESSENGER_set_key (handle, &identity);
+  identity_counter++;
+
+  it_task = GNUNET_SCHEDULER_add_now (&on_iteration, handle);
+}
+
+
+/**
+ * Main function for testcase.
+ *
+ * @param cls Closure
+ * @param cfg Configuration
+ * @param peer Peer for testing
+ */
+static void
+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, NULL, NULL, NULL);
+
+  identity.type = htonl (GNUNET_PUBLIC_KEY_TYPE_ECDSA);
+  GNUNET_CRYPTO_ecdsa_key_create (&(identity.ecdsa_key));
+
+  if (messenger)
+    it_task = GNUNET_SCHEDULER_add_now (&on_iteration, messenger);
+}
+
+
+/**
+ * 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 (0 != GNUNET_TESTING_peer_run ("test-messenger", "test_messenger_api.conf",
+                                    &run, NULL))
+    return 1;
+
+  return status;
+}
diff --git a/src/service/messenger/test_messenger_anonymous.c b/src/service/messenger/test_messenger_anonymous.c
new file mode 100644
index 000000000..5f77cca53
--- /dev/null
+++ b/src/service/messenger/test_messenger_anonymous.c
@@ -0,0 +1,190 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020--2023 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_anonymous.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+
+#include <stdio.h>
+#include "gnunet_util_lib.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 struct GNUNET_SCHEDULER_Task *it_task = NULL;
+
+struct GNUNET_MESSENGER_Handle *messenger = NULL;
+
+static void
+end (void *cls)
+{
+  die_task = NULL;
+
+  if (it_task)
+  {
+    GNUNET_SCHEDULER_cancel (it_task);
+    it_task = NULL;
+  }
+
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  if (messenger)
+  {
+    GNUNET_MESSENGER_disconnect (messenger);
+    messenger = NULL;
+  }
+
+  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;
+}
+
+
+/**
+ * Function called when an identity is retrieved.
+ *
+ * @param cls Closure
+ * @param handle Handle of messenger service
+ */
+static void
+on_iteration (void *cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  it_task = NULL;
+
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  const char *name = GNUNET_MESSENGER_get_name (handle);
+
+  if (NULL != name)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "name-anonymous");
+    return;
+  }
+
+  const struct GNUNET_CRYPTO_PublicKey *key = GNUNET_MESSENGER_get_key (
+    handle);
+
+  if (key)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "key-anonymous");
+    return;
+  }
+
+  GNUNET_MESSENGER_disconnect (handle);
+
+  messenger = NULL;
+
+  if (die_task)
+    GNUNET_SCHEDULER_cancel (die_task);
+
+  die_task = GNUNET_SCHEDULER_add_now (&end, NULL);
+}
+
+
+/**
+ * Main function for testcase.
+ *
+ * @param cls Closure
+ * @param cfg Configuration
+ * @param peer Peer for testing
+ */
+static void
+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, NULL, NULL, NULL);
+
+  if (messenger)
+    it_task = GNUNET_SCHEDULER_add_now (&on_iteration, messenger);
+}
+
+
+/**
+ * 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 (0 != GNUNET_TESTING_peer_run ("test-messenger", "test_messenger_api.conf",
+                                    &run, NULL))
+    return 1;
+
+  return status;
+}
diff --git a/src/service/messenger/test_messenger_api.conf b/src/service/messenger/test_messenger_api.conf
new file mode 100644
index 000000000..c6c7ea2d3
--- /dev/null
+++ b/src/service/messenger/test_messenger_api.conf
@@ -0,0 +1,49 @@
+@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
+
+[messenger]
+START_ON_DEMAND = YES
+MESSENGER_AUTO_CONNECTING = NO
+MESSENGER_AUTO_ROUTING = NO
+
+[nat]
+ENABLE_UPNP = NO
+RETURN_LOCAL_ADDRESSES = YES
+IMMEDIATE_START = NO
\ No newline at end of file
diff --git a/src/service/messenger/test_messenger_plugin_cmd_simple_join.c b/src/service/messenger/test_messenger_plugin_cmd_simple_join.c
new file mode 100644
index 000000000..4f50e4c06
--- /dev/null
+++ b/src/service/messenger/test_messenger_plugin_cmd_simple_join.c
@@ -0,0 +1,400 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2023 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 test_messenger_plugin_cmd_simple_join.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author Tobias Frisch
+ */
+
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "gnunet_transport_core_service.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_core_service.h"
+#include "gnunet_core_testing_lib.h"
+#include "gnunet_transport_testing_ng_lib.h"
+#include "messenger-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+#define MAX_RECEIVED 1000
+
+#define MESSAGE_SIZE 65000
+
+static struct GNUNET_TESTING_Command block_script;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Command start_peer;
+
+static struct GNUNET_TESTING_Command start_service;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+struct TestState
+{
+  /**
+   * Callback to write messages to the master loop.
+   *
+   */
+  GNUNET_TESTING_cmd_helper_write_cb write_message;
+
+  /**
+   * Callback to notify the helper test case has finished.
+   */
+  GNUNET_TESTING_cmd_helper_finish_cb finished_cb;
+
+  /**
+   * The name for a specific test environment directory.
+   *
+   */
+  char *testdir;
+
+  /**
+   * The name for the configuration file of the specific node.
+   *
+   */
+  char *cfgname;
+
+  /**
+   * The complete topology information.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+
+  struct GNUNET_MESSENGER_TestStageTopology *chat_topology;
+};
+
+struct Sender
+{
+  /**
+   * Number of received messages from sender.
+   */
+  unsigned long long num_received;
+
+  /**
+   * Sample mean time the message traveled.
+   */
+  struct GNUNET_TIME_Relative mean_time;
+
+  /**
+   * Time the first message was send.
+   */
+  struct GNUNET_TIME_Absolute time_first;
+};
+
+
+struct GNUNET_TESTING_BarrierList*
+get_waiting_for_barriers ()
+{
+  struct GNUNET_TESTING_BarrierList*barriers;
+  struct GNUNET_TESTING_BarrierListEntry *ble;
+
+  barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "ready-to-connect";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "test-case-finished";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+  return barriers;
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_MESSENGER_destroy_topo (ts->chat_topology);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+static void
+child_completed_callback (void *cls,
+                          enum GNUNET_OS_ProcessStatusType type,
+                          long unsigned int exit_code)
+{
+
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ * @param topology_data A file name for the file containing the topology configuration, or a string containing
+ *        the topology configuration.
+ * @param read_file If read_file is GNUNET_YES this string is the filename for the topology configuration,
+ *        if read_file is GNUNET_NO the string contains the topology configuration.
+ * @param finish_cb Callback function which writes a message from the helper process running on a netjail
+ *                  node to the master process * signaling that the test case running on the netjail node finished.
+ * @return Returns the struct GNUNET_TESTING_Interpreter of the command loop running on this netjail node.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  struct GNUNET_MESSENGER_TestStageTopology *chat_topology;
+  unsigned int sscanf_ret = 0;
+  char **argv = NULL;
+  int argc = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_script = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-script");
+  connect_peers = GNUNET_CORE_cmd_connect_peers ("connect-peers",
+                                                 "start-peer",
+                                                 "system-create",
+                                                 num,
+                                                 topology,
+                                                 0,
+                                                 GNUNET_NO,
+                                                 NULL);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_messenger_api.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  start_peer = GNUNET_TESTING_cmd_start_peer ("start-peer",
+                                              "system-create",
+                                              num,
+                                              node_ip,
+                                              ts->cfgname,
+                                              GNUNET_NO);
+
+  const struct GNUNET_MESSENGER_TestStage stages[4] = {
+    GNUNET_MESSENGER_create_stage_open_room (),
+    GNUNET_MESSENGER_create_stage_open_room (),
+    GNUNET_MESSENGER_create_stage_enter_room (2),
+    GNUNET_MESSENGER_create_stage_enter_room (1)
+  };
+
+  chat_topology = GNUNET_MESSENGER_create_topo (2, 2, stages);
+  ts->chat_topology = chat_topology;
+
+  start_service = GNUNET_MESSENGER_cmd_start_service ("start-messenger",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      chat_topology,
+                                                      num);
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    start_peer,
+    GNUNET_TESTING_cmd_barrier_reached ("ready-to-connect-reached",
+                                        "ready-to-connect",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    connect_peers,
+    GNUNET_TESTING_cmd_exec_bash_script ("script",
+                                         "block.sh",
+                                         argv,
+                                         argc,
+                                         &child_completed_callback),
+    block_script,
+    start_service,
+    GNUNET_MESSENGER_cmd_join_room ("join-room-1",
+                                    "start-messenger",
+                                    "test-room"),
+    GNUNET_MESSENGER_cmd_join_room ("join-room-2",
+                                    "start-messenger",
+                                    "test-room"),
+    GNUNET_MESSENGER_cmd_stop_service ("stop-messenger",
+                                       "start-messenger"),
+    GNUNET_TESTING_cmd_barrier_reached ("test-case-finished-reached",
+                                        "test-case-finished",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    GNUNET_TESTING_cmd_stop_peer ("stop-peer",
+                                  "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_messenger_plugin_cmd_simple_join_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-join",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_messenger_plugin_cmd_simple_join_init
+ * @return NULL
+ */
+void *
+libgnunet_test_messenger_plugin_cmd_simple_join_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/messenger/test_messenger_start_testcase.sh b/src/service/messenger/test_messenger_start_testcase.sh
new file mode 100755
index 000000000..29788638e
--- /dev/null
+++ b/src/service/messenger/test_messenger_start_testcase.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+read -p "Test case configuration to use:" conf
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+START_WITH_CONFIG=/usr/local/lib/gnunet/libexec/test_testing_start_with_config
+if [ ! -f /usr/local/lib/gnunet/libexec/test_testing_start_with_config ]; then
+  START_WITH_CONFIG=/usr/lib/gnunet/libexec/test_testing_start_with_config
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; $START_WITH_CONFIG $conf"
\ No newline at end of file