54 files changed, 10277 insertions, 14 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index f98cb96df..d8a869acb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -11,7 +11,8 @@ endif
 
 if HAVE_EXPERIMENTAL
  EXP_DIR = \
-  rps
+  rps \
+  messenger
   #abd FTBFS
 if HAVE_ABE
  EXP_DIR += \
diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c
index d44e8da96..64c088923 100644
--- a/src/identity/identity_api.c
+++ b/src/identity/identity_api.c
@@ -1138,11 +1138,11 @@ GNUNET_IDENTITY_signature_verify_ (uint32_t purpose,
 
 
 ssize_t
-GNUNET_IDENTITY_public_key_encrypt (const void *block,
-                                    size_t size,
-                                    const struct GNUNET_IDENTITY_PublicKey *pub,
-                                    struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
-                                    void *result)
+GNUNET_IDENTITY_encrypt (const void *block,
+                         size_t size,
+                         const struct GNUNET_IDENTITY_PublicKey *pub,
+                         struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
+                         void *result)
 {
   struct GNUNET_CRYPTO_EcdhePrivateKey pk;
   GNUNET_CRYPTO_ecdhe_key_create (&pk);
@@ -1177,13 +1177,11 @@ GNUNET_IDENTITY_public_key_encrypt (const void *block,
 
 
 ssize_t
-GNUNET_IDENTITY_private_key_decrypt (const void *block,
-                                     size_t size,
-                                     const struct
-                                     GNUNET_IDENTITY_PrivateKey *priv,
-                                     const struct
-                                     GNUNET_CRYPTO_EcdhePublicKey *ecc,
-                                     void *result)
+GNUNET_IDENTITY_decrypt (const void *block,
+                         size_t size,
+                         const struct GNUNET_IDENTITY_PrivateKey *priv,
+                         const struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
+                         void *result)
 {
   struct GNUNET_HashCode hash;
   switch (ntohl (priv->type))
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index 202abb7ac..fc3d745a6 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -62,6 +62,7 @@ gnunetinclude_HEADERS = \
   gnunet_json_lib.h \
   gnunet_load_lib.h \
   gnunet_cadet_service.h \
+  gnunet_messenger_service.h \
   gnunet_mhd_compat.h \
   gnunet_microphone_lib.h \
   gnunet_mst_lib.h \
diff --git a/src/include/gnunet_messenger_service.h b/src/include/gnunet_messenger_service.h
new file mode 100644
index 000000000..8f5315c30
--- /dev/null
+++ b/src/include/gnunet_messenger_service.h
@@ -0,0 +1,436 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ *
+ * @file
+ * MESSENGER service; manages decentralized chat groups
+ *
+ * @defgroup messenger  MESSENGER service
+ * Instant messaging based on the CADET subsystem
+ *
+ * @{
+ */
+
+#ifndef GNUNET_MESSENGER_SERVICE_H
+#define GNUNET_MESSENGER_SERVICE_H
+
+#ifdef __cplusplus
+extern "C" {
+#if 0 /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include "platform.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_mq_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define GNUNET_MESSENGER_SERVICE_NAME "messenger"
+
+/**
+ * Opaque handle to the messenger
+ */
+struct GNUNET_MESSENGER_Handle;
+
+/**
+ * Opaque handle to a room
+ */
+struct GNUNET_MESSENGER_Room;
+
+/**
+ * Opaque handle to a contact
+ */
+struct GNUNET_MESSENGER_Contact;
+
+/**
+ * Enum for the different supported kinds of messages
+ */
+enum GNUNET_MESSENGER_MessageKind
+{
+  GNUNET_MESSENGER_KIND_INFO = 1,
+
+  GNUNET_MESSENGER_KIND_JOIN = 2,
+  GNUNET_MESSENGER_KIND_LEAVE = 3,
+
+  GNUNET_MESSENGER_KIND_NAME = 4,
+  GNUNET_MESSENGER_KIND_KEY = 5,
+  GNUNET_MESSENGER_KIND_PEER = 6,
+  GNUNET_MESSENGER_KIND_ID = 7,
+
+  GNUNET_MESSENGER_KIND_MISS = 8,
+  GNUNET_MESSENGER_KIND_MERGE = 9,
+  GNUNET_MESSENGER_KIND_REQUEST = 10,
+
+  GNUNET_MESSENGER_KIND_INVITE = 11,
+  GNUNET_MESSENGER_KIND_TEXT = 12,
+  GNUNET_MESSENGER_KIND_FILE = 13,
+
+  GNUNET_MESSENGER_KIND_PRIVATE = 14,
+
+  GNUNET_MESSENGER_KIND_UNKNOWN = 0
+}__attribute__((__packed__));
+
+/**
+ * Get the name of a message <i>kind</i>.
+ *
+ * @param kind Kind of a message
+ * @return Name of that kind
+ */
+const char*
+GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind);
+
+struct GNUNET_MESSENGER_MessageHeader
+{
+  struct GNUNET_IDENTITY_Signature signature;
+
+  struct GNUNET_TIME_AbsoluteNBO timestamp;
+
+  struct GNUNET_ShortHashCode sender_id;
+  struct GNUNET_HashCode previous;
+
+  enum GNUNET_MESSENGER_MessageKind kind;
+};
+
+struct GNUNET_MESSENGER_MessageInfo
+{
+  struct GNUNET_IDENTITY_PublicKey host_key;
+  struct GNUNET_ShortHashCode unique_id;
+};
+
+struct GNUNET_MESSENGER_MessageJoin
+{
+  struct GNUNET_IDENTITY_PublicKey key;
+};
+
+struct GNUNET_MESSENGER_MessageLeave
+{
+};
+
+struct GNUNET_MESSENGER_MessageName
+{
+  char *name;
+};
+
+struct GNUNET_MESSENGER_MessageKey
+{
+  struct GNUNET_IDENTITY_PublicKey key;
+};
+
+struct GNUNET_MESSENGER_MessagePeer
+{
+  struct GNUNET_PeerIdentity peer;
+};
+
+struct GNUNET_MESSENGER_MessageId
+{
+  struct GNUNET_ShortHashCode id;
+};
+
+struct GNUNET_MESSENGER_MessageMiss
+{
+  struct GNUNET_PeerIdentity peer;
+};
+
+struct GNUNET_MESSENGER_MessageMerge
+{
+  struct GNUNET_HashCode previous;
+};
+
+struct GNUNET_MESSENGER_MessageRequest
+{
+  struct GNUNET_HashCode hash;
+};
+
+struct GNUNET_MESSENGER_MessageInvite
+{
+  struct GNUNET_PeerIdentity door;
+  struct GNUNET_HashCode key;
+};
+
+struct GNUNET_MESSENGER_MessageText
+{
+  char *text;
+};
+
+struct GNUNET_MESSENGER_MessageFile
+{
+  struct GNUNET_CRYPTO_SymmetricSessionKey key;
+  struct GNUNET_HashCode hash;
+  char name[NAME_MAX];
+  char *uri;
+};
+
+struct GNUNET_MESSENGER_MessagePrivate
+{
+  struct GNUNET_CRYPTO_EcdhePublicKey key;
+
+  uint16_t length;
+  char *data;
+};
+
+struct GNUNET_MESSENGER_MessageBody
+{
+  union
+  {
+    struct GNUNET_MESSENGER_MessageInfo info;
+
+    struct GNUNET_MESSENGER_MessageJoin join;
+    struct GNUNET_MESSENGER_MessageLeave leave;
+
+    struct GNUNET_MESSENGER_MessageName name;
+    struct GNUNET_MESSENGER_MessageKey key;
+    struct GNUNET_MESSENGER_MessagePeer peer;
+    struct GNUNET_MESSENGER_MessageId id;
+
+    struct GNUNET_MESSENGER_MessageMiss miss;
+    struct GNUNET_MESSENGER_MessageMerge merge;
+    struct GNUNET_MESSENGER_MessageRequest request;
+
+    struct GNUNET_MESSENGER_MessageInvite invite;
+    struct GNUNET_MESSENGER_MessageText text;
+    struct GNUNET_MESSENGER_MessageFile file;
+
+    struct GNUNET_MESSENGER_MessagePrivate private;
+  };
+};
+
+/**
+ * Struct to a message
+ */
+struct GNUNET_MESSENGER_Message
+{
+  struct GNUNET_MESSENGER_MessageHeader header;
+  struct GNUNET_MESSENGER_MessageBody body;
+};
+
+/**
+ * Method called whenever the EGO of a <i>handle</i> changes or if the first connection fails
+ * to load a valid EGO and the anonymous keypair will be used instead.
+ *
+ * @param cls Closure from <i>GNUNET_MESSENGER_connect</i>
+ * @param handle Messenger handle
+ */
+typedef void
+(*GNUNET_MESSENGER_IdentityCallback) (void *cls, struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Method called whenever a message is sent or received from a <i>room</i>.
+ *
+ * @param cls Closure from <i>GNUNET_MESSENGER_connect</i>
+ * @param room Room handle
+ * @param message Newly received or sent message
+ * @param hash Hash identifying the message
+ */
+typedef void
+(*GNUNET_MESSENGER_MessageCallback) (void *cls, const struct GNUNET_MESSENGER_Room *room,
+                                     const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Set up a handle for the messenger related functions and connects to all necessary services. It will look up the ego
+ * key identified by its <i>name</i> and use it for signing all messages from the handle.
+ *
+ * @param cfg Configuration to use
+ * @param name Name to look up an ego or NULL to stay anonymous
+ * @param identity_callback Function called when the EGO of the handle changes
+ * @param identity_cls Closure for the <i>identity_callback</i> handler
+ * @param msg_callback Function called when a new message is sent or received
+ * @param msg_cls Closure for the <i>msg_callback</i> handler
+ * @return Messenger handle to use, NULL on error
+ */
+struct GNUNET_MESSENGER_Handle*
+GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name,
+                          GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls,
+                          GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls);
+
+/**
+ * Update a handle of the messenger to use a different ego key and replace the old one with a newly generated one. All
+ * participated rooms get informed about the key renewal. The handle requires a set name for this function to work and
+ * it needs to be unused by other egos.
+ *
+ * Keep in mind that this will fully delete the old ego key (if any is used) even if any other service wants to use it
+ * as default.
+ *
+ * @param handle Messenger handle to use
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+int
+GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Disconnect all of the messengers used services and clears up its used memory.
+ *
+ * @param handle Messenger handle to use
+ */
+void
+GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Get the name (if specified, otherwise NULL) used by the messenger.
+ *
+ * @param handle Messenger handle to use
+ * @return Name used by the messenger or NULL
+ */
+const char*
+GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Set the name for the messenger. This will rename the currently used ego and move all stored files related to the current
+ * name to its new directory. If anything fails during this process the function returns GNUNET_NO and the name for
+ * the messenger won't change as specified.
+ *
+ * @param handle Messenger handle to use
+ * @param name Name for the messenger to change to
+ * @return GNUNET_YES on success, GNUNET_NO on failure and GNUNET_SYSERR if <i>handle</i> is NULL
+ */
+int
+GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name);
+
+/**
+ * Get the public key used by the messenger.
+ *
+ * @param handle Messenger handle to use
+ * @return Used ego's public key
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Open a room to send and receive messages. The room will use the specified <i>key</i> as port for the underlying cadet
+ * service. Opening a room results in opening the port for incoming connections as possible <b>door</b>.
+ *
+ * Notice that there can only be one room related to a specific <i>key</i>. So trying to open two rooms with the same
+ * <i>key</i> will result in opening the room once but returning the handle both times because the room stays open.
+ *
+ * You can also open a room after entering it through a <b>door</b> using <i>GNUNET_MESSENGER_entry_room(...)</i>. This
+ * will notify all entered <b>doors</b> to list you as new <b>door</b>.
+ *
+ * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
+ *
+ * @param handle Messenger handle to use
+ * @param key Hash identifying the port
+ * @return Room handle, NULL on error
+ */
+struct GNUNET_MESSENGER_Room*
+GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
+
+/**
+ * Enter a room to send and receive messages through a <b>door</b> opened using <i>GNUNET_MESSENGER_open_room(...)</i>.
+ *
+ * Notice that there can only be one room related to a specific <i>key</i>. So trying to enter two rooms with the same
+ * <i>key</i> will result in entering the room once but returning the handle both times because the room stays entered.
+ * You can however enter a room through multiple <b>doors</b> in parallel which results in connecting both ends. But
+ * entering the room through the same <b>door</b> won't have any effect after the first time.
+ *
+ * You can also enter a room through a <b>door</b> after opening it using <i>GNUNET_MESSENGER_open_room(...)</i>. But the
+ * <b>door</b> may not be your own peer identity.
+ *
+ * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
+ *
+ * @param handle Messenger handle to use
+ * @param door Peer identity of an open <b>door</b>
+ * @param key Hash identifying the port
+ * @return Room handle, NULL on error
+ */
+struct GNUNET_MESSENGER_Room*
+GNUNET_MESSENGER_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
+                             const struct GNUNET_HashCode *key);
+
+/**
+ * Close a room which was entered, opened or both in various order and variety. Closing a room will destroy all connections
+ * from your peer to another and the other way around.
+ *
+ * ( After a member closes a <b>door</b>, all members entered through that specific <b>door</b> have to use another one
+ * or open the room on their own. )
+ *
+ * @param room Room handle
+ */
+void
+GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Get the contact of a member in a <i>room</i> identified by their <i>id</i>.
+ *
+ * Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.
+ *
+ * @param room Room handle
+ * @param id Hash identifying a member
+ * @return Contact handle, NULL if <i>id</i> is not in use
+ */
+struct GNUNET_MESSENGER_Contact*
+GNUNET_MESSENGER_get_member (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Get the name used by the <i>contact</i>.
+ *
+ * @param contact Contact handle
+ * @return Name of <i>contact</i> or NULL
+ */
+const char*
+GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Get the public key used by the <i>contact</i>.
+ *
+ * @param contact Contact handle
+ * @return Public key of the ego used by <i>contact</i>
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Send a <i>message</i> into a </i>room</i>. If you opened the <i>room</i> all entered members will receive the
+ * <i>message</i>. If you entered the <i>room</i> through a <b>door</b> all so entered <b>doors</b> will receive the
+ * <i>message</i> as well. All members receiving the <i>message</i> will also propagate this <i>message</i> recursively
+ * as long as the <i>message</i> is unknown to them.
+ *
+ * Notice that all messages sent and received are also stored and can be propagated to new members entering the room.
+ *
+ * @param room Room handle
+ * @param message New message to send
+ */
+void
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Get the message in a <i>room</i> identified by its <i>hash</i>.
+ *
+ * @param room Room handle
+ * @param hash Hash identifying a message
+ * @return Message struct or NULL if no message with that hash is known
+ */
+const struct GNUNET_MESSENGER_Message*
+GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
+
+#if 0 /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif //GNUNET_MESSENGER_SERVICE_H
+
+/** @} *//* end of group */
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index d9821ffe8..3bdebeb50 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2001--2018 GNUnet e.V.
+     Copyright (C) 2001--2020 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -20,6 +20,7 @@
 
 /**
  * @author Christian Grothoff
+ * @author Tobias Frisch
  *
  * @file
  * Constants for network protocols
@@ -3518,6 +3519,46 @@ extern "C" {
 #define GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_RESULT 1501
 
 
+/*********************************************************************************/
+/**********************************  MESSENGER  **********************************/
+/*********************************************************************************/
+/* MESSENGER: message types 1600-1629
+ * 1600-1609 Connection-level Messages
+ * 1610-1619 Room-level Messages
+ */
+
+/*********************************  Connection  **********************************/
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE 1600
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE 1601
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY 1602
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME 1603
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME 1604
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY 1605
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID 1606
+
+/************************************  Room  *************************************/
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN 1610
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY 1611
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE 1612
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE 1614
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE 1615
+
+#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE 1616
+
+/*********************************************************************************/
+
 /**
  * Type used to match 'all' message types.
  */
diff --git a/src/messenger/.gitignore b/src/messenger/.gitignore
new file mode 100644
index 000000000..9de3fb304
--- /dev/null
+++ b/src/messenger/.gitignore
@@ -0,0 +1,4 @@
+gnunet-service-messenger
+gnunet-messenger
+test_messenger_api
+test_messenger_anonymous
diff --git a/src/messenger/Makefile.am b/src/messenger/Makefile.am
new file mode 100644
index 000000000..ebe08290e
--- /dev/null
+++ b/src/messenger/Makefile.am
@@ -0,0 +1,131 @@
+# 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)
+
+bin_PROGRAMS = \
+ gnunet-messenger
+
+lib_LTLIBRARIES = \
+  libgnunetmessenger_common.la \
+  libgnunetmessenger.la \
+  $(EXP_LIB)
+
+libgnunetmessenger_common_la_SOURCES = \
+  messenger_api_ego.h \
+  messenger_api_message.c messenger_api_message.h \
+  messenger_api_list_tunnels.c messenger_api_list_tunnels.h
+libgnunetmessenger_common_la_LIBADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  $(XLIB) \
+  $(LTLIBINTL)
+libgnunetmessenger_common_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+libgnunetmessenger_la_SOURCES = \
+  messenger_api.c \
+  messenger_api_contact.c messenger_api_contact.h \
+  messenger_api_handle.c messenger_api_handle.h \
+  messenger_api_room.c messenger_api_room.h
+libgnunetmessenger_la_LIBADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  libgnunetmessenger_common.la \
+  $(XLIB) \
+  $(LTLIBINTL)
+libgnunetmessenger_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+gnunet_messenger_SOURCES = \
+ gnunet-messenger.c
+gnunet_messenger_LDADD = \
+ libgnunetmessenger_common.la \
+ libgnunetmessenger.la \
+ $(top_builddir)/src/util/libgnunetutil.la
+gnunet_messenger_LDFLAGS = \
+  $(GN_LIBINTL)
+
+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_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_store.c gnunet-service-messenger_message_store.h \
+  gnunet-service-messenger_basement.c gnunet-service-messenger_basement.h \
+  gnunet-service-messenger_contact.c gnunet-service-messenger_contact.h \
+  gnunet-service-messenger_handle.c gnunet-service-messenger_handle.h \
+  gnunet-service-messenger_room.c gnunet-service-messenger_room.h \
+  gnunet-service-messenger_tunnel.c gnunet-service-messenger_tunnel.h \
+  gnunet-service-messenger_util.c gnunet-service-messenger_util.h
+gnunet_service_messenger_LDADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  libgnunetmessenger_common.la \
+  libgnunetmessenger.la \
+  $(GN_LIBINTL)
+
+check_PROGRAMS = \
+  test_messenger_api \
+  test_messenger_anonymous \
+  test_messenger_comm0
+
+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)
+endif
+
+test_messenger_api_SOURCES = \
+  test_messenger.c
+test_messenger_api_LDADD = \
+  libgnunetmessenger_common.la \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+
+test_messenger_anonymous_SOURCES = \
+  test_messenger_anonymous.c
+test_messenger_anonymous_LDADD = \
+  libgnunetmessenger_common.la \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+
+test_messenger_comm0_SOURCES = \
+  test_messenger_comm0.c
+test_messenger_comm0_LDADD = \
+  libgnunetmessenger_common.la \
+  libgnunetmessenger.la \
+  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testbed-logger/libgnunettestbedlogger.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la
+
+EXTRA_DIST = \
+  test_messenger_api.conf
diff --git a/src/messenger/gnunet-messenger.c b/src/messenger/gnunet-messenger.c
new file mode 100644
index 000000000..579e5c3ad
--- /dev/null
+++ b/src/messenger/gnunet-messenger.c
@@ -0,0 +1,306 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-messenger.c
+ * @brief Print information about messenger groups.
+ */
+
+#include <stdio.h>
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_messenger_service.h"
+
+struct GNUNET_MESSENGER_Handle *messenger;
+
+/**
+ * Function called whenever a message is received or sent.
+ *
+ * @param cls Closure
+ * @param room Room
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+on_message (void *cls, const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+            const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Contact *sender = GNUNET_MESSENGER_get_member (room, &(message->header.sender_id));
+
+  const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
+
+  if (!sender_name)
+    sender_name = "anonymous";
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    {
+      printf ("* '%s' joined the room! [ %u %u %u %u ]\n", sender_name, message->body.join.key.ecdsa_key.q_y[0],
+              message->body.join.key.ecdsa_key.q_y[1], message->body.join.key.ecdsa_key.q_y[2],
+              message->body.join.key.ecdsa_key.q_y[3]);
+      break;
+    }
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    {
+      printf ("* '%s' leaves the room!\n", sender_name);
+      break;
+    }
+  case GNUNET_MESSENGER_KIND_PEER:
+    {
+      printf ("* '%s' opened the room on: %s\n", sender_name, GNUNET_i2s_full (&(message->body.peer.peer)));
+      break;
+    }
+  case GNUNET_MESSENGER_KIND_TEXT:
+    {
+      printf ("* '%s' says: \"%s\"\n", sender_name, message->body.text.text);
+      break;
+    }
+  default:
+    {
+      break;
+    }
+  }
+}
+
+struct GNUNET_SCHEDULER_Task *read_task;
+
+/**
+ * Task to shut down this application.
+ *
+ * @param cls Closure
+ */
+static void
+shutdown_hook (void *cls)
+{
+  struct GNUNET_MESSENGER_Room *room = cls;
+
+  if (read_task)
+    GNUNET_SCHEDULER_cancel (read_task);
+
+  if (room)
+    GNUNET_MESSENGER_close_room (room);
+
+  if (messenger)
+    GNUNET_MESSENGER_disconnect (messenger);
+}
+
+static void
+listen_stdio (void *cls);
+
+#define MAX_BUFFER_SIZE 60000
+
+/**
+ * Task run in stdio mode, after some data is available at stdin.
+ *
+ * @param cls Closure
+ */
+static void
+read_stdio (void *cls)
+{
+  read_task = NULL;
+
+  char buffer[MAX_BUFFER_SIZE];
+  ssize_t length;
+
+  length = read (0, buffer, MAX_BUFFER_SIZE);
+
+  if ((length <= 0) || (length >= MAX_BUFFER_SIZE))
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  if (buffer[length - 1] == '\n')
+    buffer[length - 1] = '\0';
+  else
+    buffer[length] = '\0';
+
+  struct GNUNET_MESSENGER_Room *room = cls;
+
+  struct GNUNET_MESSENGER_Message message;
+  message.header.kind = GNUNET_MESSENGER_KIND_TEXT;
+  message.body.text.text = buffer;
+
+  GNUNET_MESSENGER_send_message (room, &message);
+
+  read_task = GNUNET_SCHEDULER_add_now (listen_stdio, cls);
+}
+
+/**
+ * Wait for input on STDIO and send it out over the #ch.
+ *
+ * @param cls Closure
+ */
+static void
+listen_stdio (void *cls)
+{
+  read_task = NULL;
+
+  struct GNUNET_NETWORK_FDSet *rs = GNUNET_NETWORK_fdset_create ();
+
+  GNUNET_NETWORK_fdset_set_native (rs, 0);
+
+  read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+  GNUNET_TIME_UNIT_FOREVER_REL,
+                                           rs,
+                                           NULL,
+                                           &read_stdio, cls);
+
+  GNUNET_NETWORK_fdset_destroy (rs);
+}
+
+/**
+ * Initial task to startup application.
+ *
+ * @param cls Closure
+ */
+static void
+idle (void *cls)
+{
+  struct GNUNET_MESSENGER_Room *room = cls;
+
+  printf ("* You joined the room.\n");
+
+  read_task = GNUNET_SCHEDULER_add_now (listen_stdio, room);
+}
+
+char *door_id;
+char *ego_name;
+char *room_key;
+
+struct GNUNET_SCHEDULER_Task *shutdown_task;
+
+/**
+ * Function called when an identity is retrieved.
+ *
+ * @param cls Closure
+ * @param handle Handle of messenger service
+ */
+static void
+on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
+{
+  struct GNUNET_HashCode key;
+  memset (&key, 0, sizeof(key));
+
+  if (room_key)
+    GNUNET_CRYPTO_hash (room_key, strlen (room_key), &key);
+
+  struct GNUNET_PeerIdentity *door = NULL;
+
+  if (door_id)
+  {
+    door = GNUNET_new(struct GNUNET_PeerIdentity);
+
+    if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (door_id, strlen (door_id), &(door->public_key)))
+    {
+      GNUNET_free(door);
+      door = NULL;
+    }
+  }
+
+  const char *name = GNUNET_MESSENGER_get_name (handle);
+
+  if (!name)
+    name = "anonymous";
+
+  printf ("* Welcome to the messenger, '%s'!\n", name);
+
+  struct GNUNET_MESSENGER_Room *room;
+
+  if (door)
+  {
+    printf ("* You try to entry a room...\n");
+
+    room = GNUNET_MESSENGER_entry_room (messenger, door, &key);
+  }
+  else
+  {
+    printf ("* You try to open a room...\n");
+
+    room = GNUNET_MESSENGER_open_room (messenger, &key);
+  }
+
+  GNUNET_SCHEDULER_cancel (shutdown_task);
+
+  shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, room);
+
+  if (!room)
+    GNUNET_SCHEDULER_shutdown ();
+  else
+    GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (), GNUNET_SCHEDULER_PRIORITY_IDLE, idle,
+                                                room);
+}
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls, char *const*args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  messenger = GNUNET_MESSENGER_connect (cfg, ego_name, &on_identity, NULL, &on_message, NULL);
+
+  shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, NULL);
+}
+
+/**
+ * The main function to obtain messenger information.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char **argv)
+{
+  const char *description = "Open and connect to rooms using the MESSENGER to chat.";
+
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_string ('d',
+                                 "door",
+                                 "PEERIDENTITY",
+                                 "peer identity to entry into the room",
+                                 &door_id),
+    GNUNET_GETOPT_option_string ('e',
+                                 "ego",
+                                 "IDENTITY",
+                                 "identity to use for messaging",
+                                 &ego_name),
+    GNUNET_GETOPT_option_string ('r',
+                                 "room",
+                                 "ROOMKEY",
+                                 "key of the room to connect to",
+                                 &room_key),
+    GNUNET_GETOPT_OPTION_END };
+
+  return (GNUNET_OK == GNUNET_PROGRAM_run (argc,
+                                           argv,
+                                           "gnunet-messenger\0",
+                                           gettext_noop(description),
+                                           options,
+                                           &run,
+                                           NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
+}
diff --git a/src/messenger/gnunet-service-messenger.c b/src/messenger/gnunet-service-messenger.c
new file mode 100644
index 000000000..2c92305c4
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger.c
@@ -0,0 +1,306 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger.h"
+
+#include "gnunet-service-messenger_service.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 int
+check_create (void *cls, const struct GNUNET_MESSENGER_CreateMessage *msg)
+{
+  GNUNET_MQ_check_zero_termination(msg);
+  return GNUNET_OK;
+}
+
+static void
+handle_create (void *cls, const struct GNUNET_MESSENGER_CreateMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  const char *name = ((const char*) msg) + sizeof(*msg);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle created with name: %s\n", name);
+
+  setup_handle_name (msg_client->handle, strlen (name) > 0? name : NULL);
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+static void
+handle_update (void *cls, const struct GNUNET_MESSENGER_UpdateMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  if (GNUNET_OK != update_handle (msg_client->handle))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Name is required to update key!\n");
+
+  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_SERVICE_client_drop (msg_client->client);
+}
+
+static int
+check_set_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
+{
+  GNUNET_MQ_check_zero_termination(msg);
+  return GNUNET_OK;
+}
+
+static void
+handle_set_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  const char *name = ((const char*) msg) + sizeof(*msg);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handles name is now: %s\n", name);
+
+  if (GNUNET_YES != set_handle_name (msg_client->handle, name))
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No valid name: %s\n", name);
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+static void
+handle_room_open (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening room: %s\n",
+             GNUNET_h2s (&(msg->key)));
+
+  if (GNUNET_YES == open_handle_room (msg_client->handle, &(msg->key)))
+  {
+    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+
+    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(msg->key));
+    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 void
+handle_room_entry (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entering room: %s, %s\n",
+             GNUNET_h2s (&(msg->key)), GNUNET_i2s (&(msg->door)));
+
+  if (GNUNET_YES == entry_handle_room (msg_client->handle, &(msg->door), &(msg->key)))
+  {
+    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+
+    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(msg->door));
+    GNUNET_memcpy(&(response->key), &(msg->key), sizeof(msg->key));
+    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_handle_room (msg_client->handle, &(msg->key)))
+  {
+    const struct GNUNET_ShortHashCode* member_id = get_handle_member_id(msg_client->handle, &(msg->key));
+
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closing room with member id: %s\n",
+               GNUNET_sh2s (member_id));
+
+    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(msg->key));
+    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 int
+check_send_message (void *cls, const struct GNUNET_MESSENGER_SendMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size) - sizeof(msg->header);
+
+  if (full_length < sizeof(msg->key))
+    return GNUNET_NO;
+
+  const uint16_t length = full_length - sizeof(msg->key);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+
+  if (GNUNET_YES != decode_message (&message, length, buffer))
+    return GNUNET_NO;
+
+  return GNUNET_OK;
+}
+
+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 *buffer = ((const char*) msg) + sizeof(*msg);
+
+  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+  decode_message (&message, length, buffer);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending message: %s to %s\n",
+             GNUNET_MESSENGER_name_of_kind (message.header.kind),
+             GNUNET_h2s (key));
+
+  if (GNUNET_YES != send_handle_message (msg_client->handle, key, &message))
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message failed: %s to %s\n",
+               GNUNET_MESSENGER_name_of_kind (message.header.kind),
+               GNUNET_h2s (key));
+
+  GNUNET_SERVICE_client_continue (msg_client->client);
+}
+
+static void
+handle_get_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
+{
+  struct GNUNET_MESSENGER_Client *msg_client = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Requesting message from room: %s\n",
+             GNUNET_h2s (&(msg->key)));
+
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (messenger, &(msg->key));
+
+  if (room)
+    get_room_message (room, msg_client->handle, &(msg->hash), GNUNET_YES);
+  else
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Room not found: %s\n",
+               GNUNET_h2s (&(msg->key)));
+
+  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 cls closure
+ * @param config configuration to use
+ * @param service the initialized service
+ */
+static void
+run (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service)
+{
+  messenger = create_service (config, service);
+
+  if ((!messenger) || (!messenger->cadet) || (!messenger->identity))
+    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_var_size( create, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE, struct GNUNET_MESSENGER_CreateMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( update, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE, struct GNUNET_MESSENGER_UpdateMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( destroy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY, struct GNUNET_MESSENGER_DestroyMessage, NULL ),
+    GNUNET_MQ_hd_var_size( set_name, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME, struct GNUNET_MESSENGER_NameMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( room_open, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, struct GNUNET_MESSENGER_RoomMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( room_entry, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, struct GNUNET_MESSENGER_RoomMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( room_close, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, struct GNUNET_MESSENGER_RoomMessage, NULL ),
+    GNUNET_MQ_hd_var_size( send_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE, struct GNUNET_MESSENGER_SendMessage, NULL ),
+    GNUNET_MQ_hd_fixed_size( get_message, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, struct GNUNET_MESSENGER_RecvMessage, NULL ),
+    GNUNET_MQ_handler_end());
diff --git a/src/messenger/gnunet-service-messenger.h b/src/messenger/gnunet-service-messenger.h
new file mode 100644
index 000000000..85a1d2549
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger.h
@@ -0,0 +1,121 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_H
+#define GNUNET_SERVICE_MESSENGER_H
+
+#include "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_mq_lib.h"
+#include "gnunet_peer_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_util_lib.h"
+
+/**
+ * Message to create a handle for a client
+ */
+struct GNUNET_MESSENGER_CreateMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message to update the handle (its EGO key) for a client
+ */
+struct GNUNET_MESSENGER_UpdateMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message to destroy the handle for a client
+ */
+struct GNUNET_MESSENGER_DestroyMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message to receive the current name of a handle
+ */
+struct GNUNET_MESSENGER_NameMessage
+{
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message to receive the current public key of a handle
+ */
+struct GNUNET_MESSENGER_KeyMessage
+{
+  struct GNUNET_MessageHeader header;
+  struct GNUNET_IDENTITY_PublicKey pubkey;
+};
+
+/**
+ * General message to confirm interaction with a room
+ */
+struct GNUNET_MESSENGER_RoomMessage
+{
+  struct GNUNET_MessageHeader header;
+
+  struct GNUNET_PeerIdentity door;
+  struct GNUNET_HashCode key;
+};
+
+/**
+ * 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;
+};
+
+/**
+ * Message to send something into a room
+ */
+struct GNUNET_MESSENGER_SendMessage
+{
+  struct GNUNET_MessageHeader header;
+  struct GNUNET_HashCode key;
+};
+
+/**
+ * Message to receive something from a room
+ */
+struct GNUNET_MESSENGER_RecvMessage
+{
+  struct GNUNET_MessageHeader header;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode hash;
+};
+
+#endif //GNUNET_SERVICE_MESSENGER_H
diff --git a/src/messenger/gnunet-service-messenger_basement.c b/src/messenger/gnunet-service-messenger_basement.c
new file mode 100644
index 000000000..190cf2de5
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_basement.c
@@ -0,0 +1,58 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_basement.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_basement.h"
+
+size_t
+count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels *tunnels)
+{
+  const struct GNUNET_MESSENGER_ListTunnel *element;
+  size_t count = 0;
+
+  for (element = tunnels->head; element; element = element->next)
+    count++;
+
+  return count;
+}
+
+int
+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;
+}
+
+int
+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/messenger/gnunet-service-messenger_basement.h b/src/messenger/gnunet-service-messenger_basement.h
new file mode 100644
index 000000000..0a1a9b126
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_basement.h
@@ -0,0 +1,66 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_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 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 count Count of peers
+ * @param src Source index
+ * @param dst Destination index
+ * @return GNUNET_YES or GNUNET_NO based on topologic requirement
+ */
+int
+should_connect_tunnel_to (size_t count, size_t src, size_t dst);
+
+/**
+ * Returns GNUNET_YES or GNUNET_NO to determine if the peers of index <i>src</i> and
+ * index <i>dst</i> should be connected in any direction to construct a complete
+ * basement with a given <i>count</i> of peers.
+ *
+ * @param count Count of peers
+ * @param src Source index
+ * @param dst Destination index
+ * @return GNUNET_YES or GNUNET_NO based on topologic requirement
+ */
+int
+required_connection_between (size_t count, size_t src, size_t dst);
+
+#endif //GNUNET_SERVICE_MESSENGER_BASEMENT_H
diff --git a/src/messenger/gnunet-service-messenger_contact.c b/src/messenger/gnunet-service-messenger_contact.c
new file mode 100644
index 000000000..1ec125402
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_contact.c
@@ -0,0 +1,96 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_contact.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_contact.h"
+
+struct GNUNET_MESSENGER_SrvContact*
+create_contact (const struct GNUNET_IDENTITY_PublicKey *key)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_new(struct GNUNET_MESSENGER_SrvContact);
+
+  contact->name = NULL;
+  contact->rc = 0;
+
+  GNUNET_memcpy(&(contact->public_key), key, sizeof(contact->public_key));
+
+  return contact;
+}
+
+void
+destroy_contact (struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  if (contact->name)
+    GNUNET_free(contact->name);
+
+  GNUNET_free(contact);
+}
+
+const char*
+get_contact_name (const struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  return contact->name;
+}
+
+void
+set_contact_name (struct GNUNET_MESSENGER_SrvContact *contact, const char *name)
+{
+  GNUNET_assert(name);
+
+  if (contact->name)
+    GNUNET_free(contact->name);
+
+  contact->name = GNUNET_strdup(name);
+}
+
+const struct GNUNET_IDENTITY_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  return &(contact->public_key);
+}
+
+void
+increase_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  contact->rc++;
+}
+
+int
+decrease_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  if (contact->rc > 0)
+    contact->rc--;
+
+  return contact->rc ? GNUNET_NO : GNUNET_YES;
+}
+
+const struct GNUNET_HashCode*
+get_contact_id_from_key (const struct GNUNET_MESSENGER_SrvContact *contact)
+{
+  static struct GNUNET_HashCode id;
+
+  GNUNET_CRYPTO_hash (&(contact->public_key), sizeof(contact->public_key), &id);
+
+  return &id;
+}
diff --git a/src/messenger/gnunet-service-messenger_contact.h b/src/messenger/gnunet-service-messenger_contact.h
new file mode 100644
index 000000000..4a4f8bf0f
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_contact.h
@@ -0,0 +1,112 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_contact.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_CONTACT_H
+#define GNUNET_SERVICE_MESSENGER_CONTACT_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+
+struct GNUNET_MESSENGER_SrvContact
+{
+  char *name;
+  size_t rc;
+
+  struct GNUNET_IDENTITY_PublicKey public_key;
+};
+
+/**
+ * Creates and allocates a new contact with a given public <i>key</i> from an EGO.
+ *
+ * @param key Public key
+ * @return New contact
+ */
+struct GNUNET_MESSENGER_SrvContact*
+create_contact (const struct GNUNET_IDENTITY_PublicKey *key);
+
+/**
+ * Destroys a contact and frees its memory fully.
+ *
+ * @param contact Contact
+ */
+void
+destroy_contact (struct GNUNET_MESSENGER_SrvContact *contact);
+
+/**
+ * Returns the current name of a given <i>contact</i> or NULL if no valid name was assigned yet.
+ *
+ * @param contact Contact
+ * @return Name of the contact or NULL
+ */
+const char*
+get_contact_name (const struct GNUNET_MESSENGER_SrvContact *contact);
+
+/**
+ * Changes the current name of a given <i>contact</i> by copying it from the parameter <i>name</i>.
+ *
+ * @param contact Contact
+ * @param name Valid name (may not be NULL!)
+ */
+void
+set_contact_name (struct GNUNET_MESSENGER_SrvContact *contact, const char *name);
+
+/**
+ * Returns the public key of a given <i>contact</i>.
+ *
+ * @param contact Contact
+ * @return Public key of the contact
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_SrvContact *contact);
+
+/**
+ * Increases the reference counter of a given <i>contact</i> which is zero as default.
+ *
+ * @param contact Contact
+ */
+void
+increase_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact);
+
+/**
+ * Decreases the reference counter if possible (can not underflow!) of a given <i>contact</i>
+ * and returns GNUNET_YES if the counter is equal to zero, otherwise GNUNET_NO.
+ *
+ * @param contact Contact
+ * @return GNUNET_YES or GNUNET_NO depending on the reference counter
+ */
+int
+decrease_contact_rc (struct GNUNET_MESSENGER_SrvContact *contact);
+
+/**
+ * Returns the resulting hashcode of the public key from a given <i>contact</i>.
+ *
+ * @param contact Contact
+ * @return Hash of the contacts public key
+ */
+const struct GNUNET_HashCode*
+get_contact_id_from_key (const struct GNUNET_MESSENGER_SrvContact *contact);
+
+#endif //GNUNET_SERVICE_MESSENGER_CONTACT_H
diff --git a/src/messenger/gnunet-service-messenger_handle.c b/src/messenger/gnunet-service-messenger_handle.c
new file mode 100644
index 000000000..38ad6fbb4
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_handle.c
@@ -0,0 +1,503 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_handle.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_handle.h"
+
+#include "gnunet-service-messenger.h"
+#include "gnunet-service-messenger_message_kind.h"
+
+struct GNUNET_MESSENGER_SrvHandle*
+create_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct GNUNET_MESSENGER_SrvHandle);
+
+  handle->service = service;
+  handle->mq = mq;
+
+  handle->name = NULL;
+
+  handle->operation = NULL;
+
+  handle->ego = NULL;
+
+  handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  return handle;
+}
+
+int
+iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  GNUNET_free(value);
+
+  return GNUNET_YES;
+}
+
+void
+destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  if (handle->service->dir)
+   save_handle_configuration(handle);
+
+  if (handle->operation)
+    GNUNET_IDENTITY_cancel (handle->operation);
+
+  if (handle->name)
+    GNUNET_free(handle->name);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_free_member_ids, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);
+
+  GNUNET_free(handle);
+}
+
+void
+get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **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 int
+create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_ShortHashCode *random_id = generate_service_new_member_id (handle->service, key);
+
+  if (!random_id)
+    return GNUNET_NO;
+
+  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_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
+{
+  return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
+}
+
+void
+change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                         const struct GNUNET_ShortHashCode *unique_id)
+{
+  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
+
+  if (member_id)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Changed a member id (%s) for room (%s) ",
+               GNUNET_sh2s(member_id), GNUNET_h2s(key));
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "into (%s).\n",
+               GNUNET_sh2s(unique_id));
+
+    GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
+
+    struct GNUNET_MESSENGER_MemberMessage *msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+
+    GNUNET_memcpy(&(msg->key), key, sizeof(*key));
+    GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
+
+    GNUNET_MQ_send (handle->mq, env);
+  }
+  else
+  {
+    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);
+  }
+}
+
+static void
+change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+{
+  if (handle->name)
+    GNUNET_free(handle->name);
+
+  handle->name = name ? GNUNET_strdup(name) : NULL;
+
+  const uint16_t name_len = handle->name ? strlen (handle->name) : 0;
+
+  struct GNUNET_MESSENGER_NameMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME);
+
+  char *extra = ((char*) msg) + sizeof(*msg);
+
+  if (name_len)
+    GNUNET_memcpy(extra, handle->name, name_len);
+
+  extra[name_len] = '\0';
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+static void
+change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Ego *ego)
+{
+  handle->ego = ego;
+
+  ego = get_handle_ego(handle);
+
+  struct GNUNET_MESSENGER_KeyMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);
+
+  GNUNET_memcpy(&(msg->pubkey), &(ego->pub), sizeof(ego->pub));
+
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+struct GNUNET_MESSENGER_Ego*
+get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  static struct GNUNET_MESSENGER_Ego anonymous;
+  static int read_keys = 0;
+
+  if (handle->ego)
+    return handle->ego;
+
+  if (!read_keys)
+  {
+    struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous ();
+    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key(ego), sizeof(anonymous.priv));
+    GNUNET_IDENTITY_ego_get_public_key(ego, &(anonymous.pub));
+    read_keys = 1;
+  }
+
+  return &anonymous;
+}
+
+void
+setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+{
+  change_handle_name (handle, name);
+  change_handle_ego (handle, handle->name? lookup_service_ego(handle->service, handle->name) : NULL);
+
+  if (handle->service->dir)
+   load_handle_configuration(handle);
+}
+
+struct GNUNET_MESSENGER_MessageHandle
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_Message *message;
+};
+
+static int
+iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
+
+  send_handle_message (msg_handle->handle, key, msg_handle->message);
+
+  return GNUNET_YES;
+}
+
+static void
+callback_ego_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *emsg)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+
+  handle->operation = NULL;
+
+  if (emsg)
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", emsg);
+
+  if (key)
+  {
+    struct GNUNET_MESSENGER_MessageHandle msg_handle;
+
+    msg_handle.handle = handle;
+    msg_handle.message = create_message_key (key);
+
+    GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
+
+    destroy_message (msg_handle.message);
+
+    update_service_ego(handle->service, handle->name, key);
+
+    change_handle_ego (handle, lookup_service_ego(handle->service, handle->name));
+  }
+}
+
+int
+update_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert(handle);
+
+  if (!handle->name)
+    return GNUNET_SYSERR;
+
+  struct GNUNET_MESSENGER_Ego *ego = lookup_service_ego(handle->service, handle->name);
+
+  if (!ego)
+    handle->operation = GNUNET_IDENTITY_create (handle->service->identity, handle->name, NULL,
+                                                GNUNET_IDENTITY_TYPE_ECDSA, callback_ego_create, handle);
+  else
+    change_handle_ego (handle, ego);
+
+  return GNUNET_OK;
+}
+
+int
+set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+{
+  GNUNET_assert(handle);
+
+  if ((name) && (lookup_service_ego(handle->service, name)))
+    return GNUNET_NO;
+
+  struct GNUNET_IDENTITY_Operation *operation = handle->operation;
+
+  if (handle->name)
+    handle->operation = GNUNET_IDENTITY_rename (handle->service->identity, handle->name, name, NULL, NULL);
+
+  char *old_dir;
+  get_handle_data_subdir (handle, handle->name, &old_dir);
+
+  char *new_dir;
+  get_handle_data_subdir (handle, name, &new_dir);
+
+  int result = 0;
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (old_dir, GNUNET_YES))
+  {
+    GNUNET_DISK_directory_create_for_file (new_dir);
+
+    result = rename (old_dir, new_dir);
+  }
+  else if (GNUNET_YES == GNUNET_DISK_directory_test (new_dir, GNUNET_NO))
+    result = -1;
+
+  if (0 == result)
+  {
+    struct GNUNET_MESSENGER_MessageHandle msg_handle;
+
+    msg_handle.handle = handle;
+    msg_handle.message = create_message_name (name);
+
+    GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
+
+    destroy_message (msg_handle.message);
+
+    change_handle_name (handle, name);
+
+    if (operation)
+      GNUNET_IDENTITY_cancel (operation);
+  }
+  else
+  {
+    if (handle->operation)
+    {
+      GNUNET_IDENTITY_cancel (handle->operation);
+
+      handle->operation = operation;
+    }
+  }
+
+  GNUNET_free(old_dir);
+  GNUNET_free(new_dir);
+
+  return (result == 0 ? GNUNET_OK : GNUNET_NO);
+}
+
+int
+open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
+{
+  if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
+    return GNUNET_NO;
+
+  return open_service_room (handle->service, handle, key);
+}
+
+int
+entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door,
+                   const struct GNUNET_HashCode *key)
+{
+  if ((!get_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);
+}
+
+int
+close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
+{
+  if (!get_handle_member_id (handle, key))
+    return GNUNET_NO;
+
+  return close_service_room (handle->service, handle, key);
+}
+
+int
+send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                     struct GNUNET_MESSENGER_Message *message)
+{
+  const struct GNUNET_ShortHashCode *id = get_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;
+  }
+
+  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_HashCode hash;
+
+  GNUNET_memcpy(&(message->header.sender_id), id, sizeof(*id));
+
+  send_room_message (room, handle, message, &hash);
+  return GNUNET_YES;
+}
+
+static int callback_scan_for_rooms(void* cls, const char *filename) {
+  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
+
+  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+
+  if ((GNUNET_YES == GNUNET_DISK_file_test(filename)) &&
+      (GNUNET_OK == GNUNET_CONFIGURATION_parse(cfg, filename)))
+  {
+    struct GNUNET_HashCode key;
+    struct GNUNET_ShortHashCode member_id;
+
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "key", &key, sizeof(key))) &&
+        (GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "member_id", &member_id, sizeof(member_id))))
+      change_handle_member_id(handle, &key, &member_id);
+  }
+
+  GNUNET_CONFIGURATION_destroy(cfg);
+  return GNUNET_OK;
+}
+
+void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle) {
+  char* id_dir;
+  get_handle_data_subdir(handle, handle->name, &id_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_YES))
+  {
+    char* scan_dir;
+    GNUNET_asprintf(&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+
+    if (GNUNET_OK == GNUNET_DISK_directory_test(scan_dir, GNUNET_YES))
+      GNUNET_DISK_directory_scan(scan_dir, callback_scan_for_rooms, handle);
+
+    GNUNET_free(scan_dir);
+  }
+
+  GNUNET_free(id_dir);
+}
+
+static int
+iterate_save_rooms(void* cls, const struct GNUNET_HashCode* key, void* value)
+{
+  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
+  struct GNUNET_ShortHashCode* member_id = value;
+
+  char* id_dir;
+  get_handle_data_subdir(handle, handle->name, &id_dir);
+
+  char* filename;
+  GNUNET_asprintf(&filename, "%s%s%c%s.cfg",
+                  id_dir, "rooms", DIR_SEPARATOR,
+                  GNUNET_h2s(key));
+
+  GNUNET_free(id_dir);
+
+  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+
+  char* key_data = GNUNET_STRINGS_data_to_string_alloc(key, sizeof(*key));
+
+  if (key_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "key", key_data);
+
+    GNUNET_free(key_data);
+  }
+
+  char* member_id_data = GNUNET_STRINGS_data_to_string_alloc(member_id, sizeof(*member_id));
+
+  if (member_id_data)
+  {
+    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "member_id", member_id_data);
+
+    GNUNET_free(member_id_data);
+  }
+
+  GNUNET_CONFIGURATION_write(cfg, filename);
+  GNUNET_CONFIGURATION_destroy(cfg);
+
+  GNUNET_free(filename);
+
+  return GNUNET_YES;
+}
+
+void save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  char* id_dir;
+  get_handle_data_subdir(handle, handle->name, &id_dir);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_NO)) ||
+      (GNUNET_OK == GNUNET_DISK_directory_create(id_dir)))
+  {
+    char* save_dir;
+    GNUNET_asprintf(&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+
+    if ((GNUNET_YES == GNUNET_DISK_directory_test(save_dir, GNUNET_NO)) ||
+        (GNUNET_OK == GNUNET_DISK_directory_create(save_dir)))
+      GNUNET_CONTAINER_multihashmap_iterate(handle->member_ids, iterate_save_rooms, handle);
+
+    GNUNET_free(save_dir);
+  }
+
+  GNUNET_free(id_dir);
+}
diff --git a/src/messenger/gnunet-service-messenger_handle.h b/src/messenger/gnunet-service-messenger_handle.h
new file mode 100644
index 000000000..81cf377a8
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_handle.h
@@ -0,0 +1,216 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_handle.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_HANDLE_H
+#define GNUNET_SERVICE_MESSENGER_HANDLE_H
+
+#include "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_peer_lib.h"
+#include "gnunet_mq_lib.h"
+
+#include "gnunet-service-messenger_service.h"
+
+#include "messenger_api_ego.h"
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_SrvHandle
+{
+  struct GNUNET_MESSENGER_Service *service;
+  struct GNUNET_MQ_Handle *mq;
+
+  char *name;
+
+  struct GNUNET_IDENTITY_Operation *operation;
+
+  struct GNUNET_MESSENGER_Ego *ego;
+
+  struct GNUNET_CONTAINER_MultiHashMap *member_ids;
+};
+
+/**
+ * Creates and allocates a new handle related to a <i>service</i> and using a given <i>mq</i> (message queue).
+ *
+ * @param service MESSENGER Service
+ * @param mq Message queue
+ * @return New handle
+ */
+struct GNUNET_MESSENGER_SrvHandle*
+create_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq);
+
+/**
+ * Destroys a handle and frees its memory fully.
+ *
+ * @param handle Handle
+ */
+void
+destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Writes the path of the directory for a given <i>handle</i> using a specific <i>name</i> to the parameter
+ * <i>dir</i>. This directory will be used to store data regarding the handle and its messages.
+ *
+ * @param handle Handle
+ * @param name Potential name of the handle
+ * @param dir[out] Path to store data
+ */
+void
+get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir);
+
+/**
+ * Returns the member id of a given <i>handle</i> in a specific <i>room</i>.
+ *
+ * If the handle is not a member of the specific <i>room</i>, NULL gets returned.
+ *
+ * @param handle Handle
+ * @param key Key of a room
+ * @return Member id or NULL
+ */
+const struct GNUNET_ShortHashCode*
+get_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
+
+/**
+ * Changes the member id of a given <i>handle</i> in a specific <i>room</i> to match a <i>unique_id</i>.
+ *
+ * The client connected to the <i>handle</i> will be informed afterwards automatically.
+ *
+ * @param handle Handle
+ * @param key Key of a room
+ * @param unique_id Unique member id
+ */
+void
+change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                         const struct GNUNET_ShortHashCode *unique_id);
+
+/**
+ * Returns the EGO used by a given <i>handle</i>.
+ *
+ * @param handle Handle
+ * @return EGO keypair
+ */
+struct GNUNET_MESSENGER_Ego*
+get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Tries to set the name and EGO key of a <i>handle</i> initially by looking up a specific <i>name</i>.
+ *
+ * @param handle Handle
+ * @param name Name (optionally: valid EGO name)
+ */
+void
+setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name);
+
+/**
+ * Tries to change the keypair of an EGO of a <i>handle</i> under the same name and informs all rooms
+ * about the change automatically.
+ *
+ * @param handle Handle
+ * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ */
+int
+update_handle (struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Tries to rename the handle which implies renaming the EGO its using and moving all related data into
+ * the directory fitting to the changed <i>name</i>.
+ *
+ * The client connected to the <i>handle</i> will be informed afterwards automatically.
+ *
+ * @param handle Handle
+ * @param name New name
+ * @return GNUNET_OK on success, otherwise GNUNET_NO
+ */
+int
+set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name);
+
+/**
+ * Makes a given <i>handle</i> a member of the room using a specific <i>key</i> and opens the
+ * room from the handles service.
+ *
+ * @param handle Handle
+ * @param key Key of a room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+open_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 handle Handle
+ * @param door Peer identity
+ * @param key Key of a room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door,
+                   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 handle Handle
+ * @param key Key of a room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
+
+/**
+ * Sends a <i>message</i> from a given <i>handle</i> to the room using a specific <i>key</i>.
+ *
+ * @param handle Handle
+ * @param key Key of a room
+ * @param message Message
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                     struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Loads member ids and other potential configuration from a given <i>handle</i> which
+ * depends on the given name the <i>handle</i> uses.
+ *
+ * @param handle Handle
+ */
+void
+load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Saves member ids and other potential configuration from a given <i>handle</i> which
+ * depends on the given name the <i>handle</i> uses.
+ *
+ * @param handle Handle
+ */
+void
+save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle);
+
+#endif //GNUNET_SERVICE_MESSENGER_HANDLE_H
diff --git a/src/messenger/gnunet-service-messenger_list_handles.c b/src/messenger/gnunet-service-messenger_list_handles.c
new file mode 100644
index 000000000..16a160dea
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_list_handles.c
@@ -0,0 +1,95 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_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_handle (element->handle);
+    GNUNET_free(element);
+  }
+
+  handles->head = NULL;
+  handles->tail = NULL;
+}
+
+void
+add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *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);
+}
+
+int
+remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *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;
+}
+
+void*
+find_list_handle_by_member (struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_ListHandle *element;
+
+  for (element = handles->head; element; element = element->next)
+    if (get_handle_member_id ((struct GNUNET_MESSENGER_SrvHandle*) element->handle, key))
+      return element->handle;
+
+  return NULL;
+}
diff --git a/src/messenger/gnunet-service-messenger_list_handles.h b/src/messenger/gnunet-service-messenger_list_handles.h
new file mode 100644
index 000000000..fe92cc58a
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_list_handles.h
@@ -0,0 +1,96 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_list_handles.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
+#define GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_container_lib.h"
+
+struct GNUNET_MESSENGER_ListHandle
+{
+  struct GNUNET_MESSENGER_ListHandle *prev;
+  struct GNUNET_MESSENGER_ListHandle *next;
+
+  void *handle;
+};
+
+struct GNUNET_MESSENGER_ListHandles
+{
+  struct GNUNET_MESSENGER_ListHandle *head;
+  struct GNUNET_MESSENGER_ListHandle *tail;
+};
+
+/**
+ * Initializes list of handles as empty list.
+ *
+ * @param handles List of handles
+ */
+void
+init_list_handles (struct GNUNET_MESSENGER_ListHandles *handles);
+
+/**
+ * Destroys remaining handles and clears the list.
+ *
+ * @param 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 handles List of handles
+ * @param handle Handle
+ */
+void
+add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle);
+
+/**
+ * Removes the first entry matching with a specific <i>handle</i> from the list and
+ * returns GNUNET_YES on success or GNUNET_NO on failure.
+ *
+ * @param handles List of handles
+ * @param handle Handle
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles, void *handle);
+
+/**
+ * Searches linearly through the list of handles for members of a specific room
+ * which is identified by a given <i>key</i>.
+ *
+ * If no handle is found which is a current member, NULL gets returned.
+ *
+ * @param handles List of handles
+ * @param key Common key of a room
+ * @return First handle which is a current member
+ */
+void*
+find_list_handle_by_member (struct GNUNET_MESSENGER_ListHandles *handles, const struct GNUNET_HashCode *key);
+
+#endif //GNUNET_SERVICE_MESSENGER_LIST_HANDLES_H
diff --git a/src/messenger/gnunet-service-messenger_list_messages.c b/src/messenger/gnunet-service-messenger_list_messages.c
new file mode 100644
index 000000000..c4f1f7043
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_list_messages.c
@@ -0,0 +1,76 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_list_messages.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_list_messages.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)
+{
+  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
+remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *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;
+    }
+}
diff --git a/src/messenger/gnunet-service-messenger_list_messages.h b/src/messenger/gnunet-service-messenger_list_messages.h
new file mode 100644
index 000000000..266c30ec6
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_list_messages.h
@@ -0,0 +1,81 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_list_messages.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
+#define GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_container_lib.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 messages List of hashes
+ */
+void
+init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages);
+
+/**
+ * Clears the list of message hashes.
+ *
+ * @param 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 messages List of hashes
+ * @param hash Hash of message
+ */
+void
+add_to_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash);
+
+/**
+ * Removes the first entry with a matching <i>hash</i> from the list.
+ *
+ * @param messages List of hashes
+ * @param hash Hash of message
+ */
+void
+remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_LIST_MESSAGES_H
diff --git a/src/messenger/gnunet-service-messenger_message_handle.c b/src/messenger/gnunet-service-messenger_message_handle.c
new file mode 100644
index 000000000..1652435c8
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_handle.c
@@ -0,0 +1,130 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_handle.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_handle.h"
+
+void
+handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
+
+  if (!contact)
+    add_room_contact (room, &(message->header.sender_id), &(message->body.join.key));
+
+  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+
+  if (!info)
+  {
+    info = GNUNET_new(struct GNUNET_MESSENGER_MemberInfo);
+
+    info->access = GNUNET_MESSENGER_MEMBER_UNKNOWN;
+    init_list_messages (&(info->session_messages));
+  }
+  else
+    clear_list_messages (&(info->session_messages));
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_put (room->member_infos, &(message->header.sender_id), info,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    add_to_list_messages (&(info->session_messages), hash);
+}
+
+void
+handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+
+  if (info)
+    clear_list_messages (&(info->session_messages));
+}
+
+void
+handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
+
+  if (contact)
+    set_contact_name (contact, message->body.name.name);
+
+  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+
+  if (info)
+    add_to_list_messages (&(info->session_messages), hash);
+}
+
+void
+handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = get_room_contact (room, &(message->header.sender_id));
+
+  if (contact)
+    swap_service_contact_by_pubkey (room->service, contact, &(message->body.key.key));
+
+  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+
+  if (info)
+    add_to_list_messages (&(info->session_messages), hash);
+}
+
+void
+handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  if (GNUNET_NO == contains_list_tunnels (&(room->basement), &(message->body.peer.peer)))
+    add_to_list_tunnels (&(room->basement), &(message->body.peer.peer));
+
+  if (room->peer_message)
+    rebuild_room_basement_structure (room);
+}
+
+void
+handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_MemberInfo *info = get_room_member_info (room, &(message->header.sender_id));
+
+  if (info)
+    add_to_list_messages (&(info->session_messages), hash);
+
+  switch_room_member_id (room, &(message->header.sender_id), &(message->body.id.id), hash);
+}
+
+void
+handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (&(room->basement), &(message->body.peer.peer), NULL);
+
+  if (!element)
+    return;
+
+  remove_from_list_tunnels (&(room->basement), element);
+
+  if (room->peer_message)
+    rebuild_room_basement_structure (room);
+}
diff --git a/src/messenger/gnunet-service-messenger_message_handle.h b/src/messenger/gnunet-service-messenger_message_handle.h
new file mode 100644
index 000000000..d091e1d11
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_handle.h
@@ -0,0 +1,128 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_handle.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+
+#include "gnunet-service-messenger_message_kind.h"
+
+#include "gnunet-service-messenger_tunnel.h"
+#include "messenger_api_message.h"
+
+/**
+ * Handles a received or sent join message to make changes of current member information.
+ * (add matching member and clear member info)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message JOIN-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent leave message to make changes of current member information.
+ * (remove matching member and clear member info)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message LEAVE-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent name message to rename a current member.
+ * (change name of matching member)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message NAME-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent key message to change the key of a member and rearrange the contacts accordingly.
+ * (move the member in the contacts and change its key)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message KEY-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent peer message to make changes of the basement in the room.
+ * (add a new peer to the basement and restructure connections based on updated list of peers)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message PEER-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent id message to change a members id.
+ * (change id of matching member)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message ID-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received or sent miss message to drop a peer from the basement in the room.
+ * (remove a peer from the basement and restructure connections based on updated list of peers)
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving/sending connection (may be NULL)
+ * @param message MISS-Message
+ * @param hash Hash of the message
+ */
+void
+handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                     struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_HANDLE_H
diff --git a/src/messenger/gnunet-service-messenger_message_kind.c b/src/messenger/gnunet-service-messenger_message_kind.c
new file mode 100644
index 000000000..9c829fe09
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_kind.c
@@ -0,0 +1,192 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_kind.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_kind.h"
+#include "gnunet-service-messenger_util.h"
+
+struct GNUNET_MESSENGER_Message*
+create_message_info (struct GNUNET_MESSENGER_Ego *ego, struct GNUNET_CONTAINER_MultiShortmap *members)
+{
+  struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_INFO);
+
+  if (!message)
+    return NULL;
+
+  GNUNET_memcpy(&(message->body.info.host_key), &(ego->pub), sizeof(ego->pub));
+
+  if (GNUNET_YES == generate_free_member_id (&(message->body.info.unique_id), members))
+    return message;
+  else
+  {
+    destroy_message (message);
+    return NULL;
+  }
+}
+
+struct GNUNET_MESSENGER_Message*
+create_message_join (struct GNUNET_MESSENGER_Ego *ego)
+{
+  struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_JOIN);
+
+  if (!message)
+    return NULL;
+
+  GNUNET_memcpy(&(message->body.join.key), &(ego->pub), sizeof(ego->pub));
+
+  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)
+{
+  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_IDENTITY_PrivateKey *key)
+{
+  struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_KEY);
+
+  if (!message)
+    return NULL;
+
+  GNUNET_IDENTITY_key_get_public (key, &(message->body.key.key));
+  return message;
+}
+
+struct GNUNET_MESSENGER_Message*
+create_message_peer (const struct GNUNET_MESSENGER_Service *service)
+{
+  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_id (const struct GNUNET_ShortHashCode *unique_id)
+{
+  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_miss (const struct GNUNET_PeerIdentity *peer)
+{
+  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)
+{
+  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_request (const struct GNUNET_HashCode *hash)
+{
+  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)
+{
+  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)
+{
+  struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_TEXT);
+
+  if (!message)
+    return NULL;
+
+  message->body.text.text = GNUNET_strdup(text);
+  return message;
+}
diff --git a/src/messenger/gnunet-service-messenger_message_kind.h b/src/messenger/gnunet-service-messenger_message_kind.h
new file mode 100644
index 000000000..dd89d0b2f
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_kind.h
@@ -0,0 +1,160 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_kind.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
+
+#include "platform.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+
+#include "messenger_api_message.h"
+#include "gnunet-service-messenger_service.h"
+#include "messenger_api_ego.h"
+
+/**
+ * Creates and allocates a new info message containing the hosts public key and a newly generated unique member id.
+ * (all values are stored as copy)
+ *
+ * @param ego EGO of the host
+ * @param members Map of all assigned member ids
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_info (struct GNUNET_MESSENGER_Ego *ego, struct GNUNET_CONTAINER_MultiShortmap *members);
+
+/**
+ * Creates and allocates a new join message containing the clients public key.
+ * (all values are stored as copy)
+ *
+ * @param ego EGO of the client
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_join (struct GNUNET_MESSENGER_Ego *ego);
+
+/**
+ * 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 name New name
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_name (const char *name);
+
+/**
+ * Creates and allocates a new key message containing the public key to change to derived
+ * from its private counterpart. (all values are stored as copy)
+ *
+ * @param key Private key of EGO
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key);
+
+/**
+ * Creates and allocates a new peer message containing a services peer identity.
+ * (all values are stored as copy)
+ *
+ * @param service Service
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_peer (const struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Creates and allocates a new id message containing the unique member id to change to.
+ * (all values are stored as copy)
+ *
+ * @param unique_id Unique member id
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_id (const struct GNUNET_ShortHashCode *unique_id);
+
+/**
+ * Creates and allocates a new miss message containing the missing peer identity.
+ * (all values are stored as copy)
+ *
+ * @param peer Missing peer identity
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_miss (const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Creates and allocates a new merge message containing the hash of a second previous message
+ * besides the regular previous message mentioned in a messages header.
+ * (all values are stored as copy)
+ *
+ * @param previous Hash of message
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_merge (const struct GNUNET_HashCode *previous);
+
+/**
+ * Creates and allocates a new request message containing the hash of a missing message.
+ * (all values are stored as copy)
+ *
+ * @param 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 door Peer identity
+ * @param key Shared secret of a room
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_invite (const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key);
+
+/**
+ * Creates and allocates a new text message containing a string representing text.
+ * (all values are stored as copy)
+ *
+ * @param text Text
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+create_message_text (const char *text);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_KIND_H
diff --git a/src/messenger/gnunet-service-messenger_message_recv.c b/src/messenger/gnunet-service-messenger_message_recv.c
new file mode 100644
index 000000000..aa28a36ea
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_recv.c
@@ -0,0 +1,204 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_recv.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_recv.h"
+#include "gnunet-service-messenger_message_handle.h"
+
+void
+recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  int conflict = GNUNET_CONTAINER_multishortmap_contains (room->members, &(message->body.info.unique_id));
+
+  if (GNUNET_NO == conflict)
+  {
+    struct GNUNET_MESSENGER_Message *sync_message = create_message_id (&(message->body.info.unique_id));
+    struct GNUNET_HashCode sync_hash;
+
+    send_room_message_ext (room, room->host, sync_message, &sync_hash, tunnel);
+    destroy_message (sync_message);
+
+    switch_room_member_id (room, get_room_host_id (room), &(message->body.info.unique_id), NULL);
+
+    change_room_host_id (room, &(message->body.info.unique_id));
+  }
+
+  if (!tunnel->contact_id)
+    tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+  GNUNET_memcpy(tunnel->contact_id, &(message->header.sender_id), sizeof(struct GNUNET_ShortHashCode));
+
+  struct GNUNET_ShortHashCode original_id;
+
+  if (GNUNET_YES == conflict)
+  {
+    GNUNET_memcpy(&original_id, get_room_host_id (room), sizeof(struct GNUNET_ShortHashCode));
+
+    change_room_host_id (room, &(message->body.info.unique_id));
+  }
+
+  {
+    struct GNUNET_MESSENGER_Message *join_message = create_message_join (room->host->ego);
+    struct GNUNET_HashCode join_hash;
+
+    send_tunnel_message (tunnel, room->host, join_message, &join_hash);
+    destroy_message (join_message);
+  }
+
+  if ((GNUNET_YES == conflict) && (0 != GNUNET_memcmp(&original_id, get_room_host_id (room))))
+  {
+    struct GNUNET_MESSENGER_Message *sync_message = create_message_id (&original_id);
+    struct GNUNET_HashCode sync_hash;
+
+    send_tunnel_message (tunnel, room->host, sync_message, &sync_hash);
+    destroy_message (sync_message);
+  }
+}
+
+struct GNUNET_MESSENGER_MemberInfoSpread
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
+};
+
+static int
+iterate_send_member_infos (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberInfo *info = value;
+  struct GNUNET_MESSENGER_MemberInfoSpread *spread = cls;
+
+  struct GNUNET_MESSENGER_ListMessage *element = info->session_messages.head;
+
+  while (element)
+  {
+    const struct GNUNET_MESSENGER_Message *message = get_room_message (spread->room, spread->room->host,
+                                                                       &(element->hash), GNUNET_NO);
+
+    if (message)
+      forward_tunnel_message (spread->tunnel, message, &(element->hash));
+
+    element = element->next;
+  }
+
+  return GNUNET_YES;
+}
+
+void
+recv_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_Message *info_msg = get_room_message (room, room->host, &(message->header.previous),
+                                                                      GNUNET_NO);
+
+  if ((info_msg) && (0 == GNUNET_memcmp(&(info_msg->header.sender_id), get_room_host_id (room)))
+      && (GNUNET_MESSENGER_KIND_INFO == info_msg->header.kind))
+  {
+    struct GNUNET_MESSENGER_MemberInfoSpread spread;
+
+    spread.room = room;
+
+    if ((tunnel) && (tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, &(message->header.sender_id))))
+      spread.tunnel = tunnel;
+    else
+      spread.tunnel = find_room_tunnel_to (room, &(message->header.sender_id));
+
+    if (spread.tunnel)
+      GNUNET_CONTAINER_multishortmap_iterate (room->member_infos, iterate_send_member_infos, &spread);
+  }
+
+  handle_message_join (room, tunnel, message, hash);
+}
+
+void
+recv_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  handle_message_leave (room, tunnel, message, hash);
+}
+
+void
+recv_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  handle_message_name (room, tunnel, message, hash);
+}
+
+void
+recv_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                  struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  handle_message_key (room, tunnel, message, hash);
+}
+
+void
+recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   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(struct GNUNET_HashCode));
+
+    if (!tunnel->contact_id)
+      tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+    GNUNET_memcpy(tunnel->contact_id, &(message->header.sender_id), sizeof(struct GNUNET_ShortHashCode));
+  }
+
+  handle_message_peer (room, tunnel, message, hash);
+}
+
+void
+recv_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                 struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  if ((tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, &(message->header.sender_id))))
+    GNUNET_memcpy(tunnel->contact_id, &(message->body.id.id), sizeof(struct GNUNET_ShortHashCode));
+
+  handle_message_id (room, tunnel, message, hash);
+}
+
+void
+recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  handle_message_miss (room, tunnel, message, hash);
+}
+
+void
+recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, room->host, &(message->body.request.hash),
+                                                                 GNUNET_NO);
+
+  if (msg)
+    forward_tunnel_message (tunnel, msg, &(message->body.request.hash));
+}
diff --git a/src/messenger/gnunet-service-messenger_message_recv.h b/src/messenger/gnunet-service-messenger_message_recv.h
new file mode 100644
index 000000000..245612cb0
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_recv.h
@@ -0,0 +1,159 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_recv.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+
+#include "gnunet-service-messenger_tunnel.h"
+#include "messenger_api_message.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 room Room of the message
+ * @param tunnel Receiving connection
+ * @param message INFO-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received join message to forward all member information to the new member if the message was
+ * the direct reaction to a previous info message from this peer.
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message JOIN-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received leave message.
+ * @see handle_message_leave()
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message LEAVE-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received name message.
+ * @see handle_message_name()
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message NAME-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received key message.
+ * @see handle_message_key()
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message KEY-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                  struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received peer message to link it to its origin tunnel if the peer identity matches.
+ * (the peer message and the member id can potentially be linked to the tunnel)
+ *
+ * TODO: This handling will only check the one given tunnel!
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message PEER-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received id message to change the tunnels linked member id if necessary.
+ * (the tunnels linked member id will be changed if the sender id is matching)
+ *
+ * TODO: This handling will only check the one given tunnel!
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message ID-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                 struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received miss message.
+ * @see handle_message_miss()
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message MISS-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                   struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a received request message by checking for the requested message and forwarding it back
+ * if the message was found.
+ * (this can also cause this peer to send a new request instead of only forwarding the received one)
+ *
+ * TODO: Requests can cause exponentially more requests!
+ *
+ * @param room Room of the message
+ * @param tunnel Receiving connection
+ * @param message REQUEST-Message
+ * @param hash Hash of the message
+ */
+void
+recv_message_request (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_RECV_H
diff --git a/src/messenger/gnunet-service-messenger_message_send.c b/src/messenger/gnunet-service-messenger_message_send.c
new file mode 100644
index 000000000..86cf9b888
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_send.c
@@ -0,0 +1,118 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_send.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_message_send.h"
+#include "gnunet-service-messenger_message_handle.h"
+
+void
+send_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  if (!tunnel->contact_id)
+  {
+    tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+    GNUNET_memcpy(tunnel->contact_id, &(message->body.info.unique_id), sizeof(struct GNUNET_ShortHashCode));
+  }
+  else
+  {
+    disconnect_tunnel (tunnel);
+  }
+}
+
+void
+send_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  handle_message_join (room, tunnel, message, hash);
+
+  if (room->peer_message)
+  {
+    const struct GNUNET_MESSENGER_Message *peer_message = get_room_message (room, handle, room->peer_message,
+                                                                            GNUNET_NO);
+
+    if ((peer_message) && (tunnel))
+    {
+      forward_tunnel_message (tunnel, peer_message, room->peer_message);
+    }
+  }
+}
+
+void
+send_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash)
+{
+  handle_message_leave (room, tunnel, message, hash);
+}
+
+void
+send_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  handle_message_name (room, tunnel, message, hash);
+}
+
+void
+send_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                  struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                  const struct GNUNET_HashCode *hash)
+{
+  handle_message_key (room, tunnel, message, hash);
+}
+
+void
+send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  if (!room->peer_message)
+  {
+    room->peer_message = GNUNET_new(struct GNUNET_HashCode);
+  }
+
+  GNUNET_memcpy(room->peer_message, hash, sizeof(struct GNUNET_HashCode));
+
+  handle_message_peer (room, tunnel, message, hash);
+}
+
+void
+send_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                 struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_HashCode *hash)
+{
+  handle_message_id (room, tunnel, message, hash);
+}
+
+void
+send_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  handle_message_miss (room, tunnel, message, hash);
+}
diff --git a/src/messenger/gnunet-service-messenger_message_send.h b/src/messenger/gnunet-service-messenger_message_send.h
new file mode 100644
index 000000000..c1096205a
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_send.h
@@ -0,0 +1,155 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_send.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+
+#include "gnunet-service-messenger_tunnel.h"
+#include "messenger_api_message.h"
+
+/**
+ * Handles a sent info message to setup a tunnels linked member id.
+ * (if a tunnel has already got a member id linked to it, the connection will be closed)
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message INFO-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent join message to ensure growth of the decentralized room structure.
+ * (if the service provides a peer message for this room currently, it will be forwarded)
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message JOIN-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_join (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent leave message.
+ * @see handle_message_leave()
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message LEAVE-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_leave (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent name message.
+ * @see handle_message_name()
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message NAME-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_name (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent key message.
+ * @see handle_message_key()
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message KEY-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_key (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                  struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                  const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent peer message to update the rooms peer message of this service.
+ * (a set peer message indicates this service being a part of the decentralized room structure)
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message PEER-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent id message.
+ * @see handle_message_id()
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message ID-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_id (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                 struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                 const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a sent miss message.
+ * @see handle_message_miss()
+ *
+ * @param room Room of the message
+ * @param handle Sending handle
+ * @param tunnel Sending connection (may be NULL)
+ * @param message MISS-Message
+ * @param hash Hash of the message
+ */
+void
+send_message_miss (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_SEND_H
diff --git a/src/messenger/gnunet-service-messenger_message_store.c b/src/messenger/gnunet-service-messenger_message_store.c
new file mode 100644
index 000000000..5933d6390
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_store.c
@@ -0,0 +1,282 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_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)
+{
+  store->storage_messages = NULL;
+
+  store->entries = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  store->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+}
+
+static int
+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 int
+iterate_destroy_messages (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Message *message = value;
+
+  destroy_message (message);
+
+  return GNUNET_YES;
+}
+
+void
+clear_message_store (struct GNUNET_MESSENGER_MessageStore *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_destroy (store->entries);
+  GNUNET_CONTAINER_multihashmap_destroy (store->messages);
+}
+
+struct GNUNET_MESSENGER_MessageEntryStorage
+{
+  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_MessageEntry entry;
+};
+
+void
+load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *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_READ, permission);
+  else
+    store->storage_messages = NULL;
+
+  GNUNET_free(filename);
+
+  if (!store->storage_messages)
+    return;
+
+  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+    goto free_filename;
+
+  struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ, permission);
+
+  if (!entries)
+    goto free_filename;
+
+  struct GNUNET_MESSENGER_MessageEntryStorage storage;
+  struct GNUNET_MESSENGER_MessageEntry *entry;
+
+  do
+  {
+    entry = GNUNET_new(struct GNUNET_MESSENGER_MessageEntry);
+
+    if (GNUNET_DISK_file_read (entries, &storage, sizeof(storage)) == sizeof(storage))
+    {
+      GNUNET_memcpy(entry, &(storage.entry), sizeof(*entry));
+
+      if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->entries, &(storage.hash), entry,
+                                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+        GNUNET_free(entry);
+    }
+    else
+    {
+      GNUNET_free(entry);
+
+      entry = NULL;
+    }
+  }
+  while (entry);
+
+  GNUNET_DISK_file_close (entries);
+
+free_filename:
+  GNUNET_free(filename);
+}
+
+struct GNUNET_MESSENGER_MessageSave
+{
+  struct GNUNET_MESSENGER_MessageStore *store;
+
+  struct GNUNET_DISK_FileHandle *storage_entries;
+};
+
+static int
+iterate_save_messages (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MessageSave *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);
+  storage.entry.offset = GNUNET_DISK_file_seek (save->store->storage_messages, 0, GNUNET_DISK_SEEK_END);
+
+  if ((GNUNET_SYSERR == storage.entry.offset) ||
+      (sizeof(storage) != GNUNET_DISK_file_write (save->storage_entries, &storage, sizeof(storage))))
+    return GNUNET_YES;
+
+  char *buffer = GNUNET_malloc(storage.entry.length);
+
+  encode_message (message, storage.entry.length, buffer);
+
+  GNUNET_DISK_file_write (save->store->storage_messages, buffer, storage.entry.length);
+
+  GNUNET_free(buffer);
+
+  return GNUNET_YES;
+}
+
+void
+save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
+{
+  struct GNUNET_MESSENGER_MessageSave save;
+
+  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+
+  char *filename;
+  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
+
+  save.store = store;
+  save.storage_entries = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
+
+  GNUNET_free(filename);
+
+  if (!save.storage_entries)
+    return;
+
+  if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage_entries, 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_entries);
+  }
+
+close_entries:
+  GNUNET_DISK_file_close (save.storage_entries);
+}
+
+int
+contains_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *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)
+{
+  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 (GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length) != entry->length)
+    goto free_buffer;
+
+
+  message = create_message (GNUNET_MESSENGER_KIND_UNKNOWN);
+
+  if ((GNUNET_YES != decode_message (message, entry->length, buffer)) || (GNUNET_OK
+      != GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  {
+    destroy_message (message);
+
+    message = NULL;
+
+    GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry);
+  }
+
+free_buffer:
+  GNUNET_free(buffer);
+
+  return message;
+}
+
+int
+put_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
+                   struct GNUNET_MESSENGER_Message *message)
+{
+  return GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+}
diff --git a/src/messenger/gnunet-service-messenger_message_store.h b/src/messenger/gnunet-service-messenger_message_store.h
new file mode 100644
index 000000000..e58459b21
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_message_store.h
@@ -0,0 +1,120 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_message_store.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
+#define GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
+
+#include "platform.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_disk_lib.h"
+
+struct GNUNET_MESSENGER_MessageEntry
+{
+  off_t offset;
+  uint16_t length;
+};
+
+struct GNUNET_MESSENGER_MessageStore
+{
+  struct GNUNET_DISK_FileHandle *storage_messages;
+
+  struct GNUNET_CONTAINER_MultiHashMap *entries;
+  struct GNUNET_CONTAINER_MultiHashMap *messages;
+};
+
+/**
+ * Initializes a message store as fully empty.
+ *
+ * @param store Message store
+ */
+void
+init_message_store (struct GNUNET_MESSENGER_MessageStore *store);
+
+/**
+ * Clears a message store, wipes its content and deallocates its memory.
+ *
+ * @param store Message store
+ */
+void
+clear_message_store (struct GNUNET_MESSENGER_MessageStore *store);
+
+/**
+ * Loads messages from a directory into a message store.
+ *
+ * @param store Message store
+ * @param directory Path to a directory
+ */
+void
+load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory);
+
+/**
+ * Saves messages from a message store into a directory.
+ *
+ * @param store Message store
+ * @param directory Path to a directory
+ */
+void
+save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory);
+
+/**
+ * Checks if a message matching a given <i>hash</i> is stored in a message store. The function returns
+ * GNUNET_YES if a match is found, GNUNET_NO otherwise.
+ *
+ * The message has not to be loaded from disk into memory for this check!
+ *
+ * @param store Message store
+ * @param hash Hash of message
+ * @return GNUNET_YES on match, otherwise GNUNET_NO
+ */
+int
+contains_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash);
+
+/**
+ * Returns the message from a message store matching a given <i>hash</i>. If no matching message is found,
+ * NULL gets returned.
+ *
+ * This function requires the message to be loaded into memory!
+ * @see contains_store_message()
+ *
+ * @param store Message store
+ * @param 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);
+
+/**
+ * Stores a message into the message store. The result indicates if the operation was successful.
+ *
+ * @param store Message store
+ * @param hash Hash of message
+ * @param message Message
+ * @return GNUNET_OK on success, otherwise GNUNET_NO
+ */
+int
+put_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash,
+                   struct GNUNET_MESSENGER_Message *message);
+
+#endif //GNUNET_SERVICE_MESSENGER_MESSAGE_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_room.c b/src/messenger/gnunet-service-messenger_room.c
new file mode 100644
index 000000000..7383e1d20
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_room.c
@@ -0,0 +1,1051 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_room.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_room.h"
+
+#include "gnunet-service-messenger_message_kind.h"
+
+#include "gnunet-service-messenger_service.h"
+#include "gnunet-service-messenger_util.h"
+
+static void
+idle_request_room_messages (void *cls);
+
+struct GNUNET_MESSENGER_SrvRoom*
+create_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);
+  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
+  room->member_infos = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
+
+  init_message_store (&(room->store));
+  room->requested = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_list_tunnels (&(room->basement));
+  init_list_messages (&(room->last_messages));
+
+  room->peer_message = NULL;
+
+  init_list_messages (&(room->handling));
+  room->idle = NULL;
+
+  room->strict_access = GNUNET_NO;
+
+  if (room->service->dir)
+    load_service_room_and_messages (room->service, room);
+
+  room->idle = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
+
+  return room;
+}
+
+static int
+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 int
+iterate_clear_members (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = value;
+
+  if (GNUNET_YES == decrease_contact_rc (contact))
+  {
+    struct GNUNET_MESSENGER_SrvRoom *room = cls;
+
+    const struct GNUNET_HashCode *id = get_contact_id_from_key (contact);
+
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->service->contacts, id, contact))
+      destroy_contact (contact);
+  }
+
+  return GNUNET_YES;
+}
+
+static int
+iterate_destroy_member_infos (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MemberInfo *info = value;
+
+  clear_list_messages (&(info->session_messages));
+
+  GNUNET_free(info);
+  return GNUNET_YES;
+}
+
+void
+destroy_room (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert(room);
+
+  if (room->idle)
+  {
+    GNUNET_SCHEDULER_cancel (room->idle);
+
+    room->idle = NULL;
+  }
+
+  if (room->port)
+    GNUNET_CADET_close_port (room->port);
+
+  merge_room_last_messages (room, room->host);
+
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_destroy_tunnels,
+  NULL);
+
+  handle_room_messages (room);
+
+  if (room->service->dir)
+    save_service_room_and_messages (room->service, room);
+
+  GNUNET_CONTAINER_multishortmap_iterate (room->members, iterate_clear_members, room);
+  GNUNET_CONTAINER_multishortmap_iterate (room->member_infos, iterate_destroy_member_infos, NULL);
+
+  clear_message_store (&(room->store));
+
+  GNUNET_CONTAINER_multihashmap_destroy (room->requested);
+
+  GNUNET_CONTAINER_multipeermap_destroy (room->tunnels);
+  GNUNET_CONTAINER_multishortmap_destroy (room->members);
+  GNUNET_CONTAINER_multishortmap_destroy (room->member_infos);
+
+  clear_list_tunnels (&(room->basement));
+  clear_list_messages (&(room->last_messages));
+
+  if (room->peer_message)
+    GNUNET_free(room->peer_message);
+
+  GNUNET_free(room);
+}
+
+struct GNUNET_MESSENGER_SrvContact*
+get_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert((room) && (room->members));
+
+  return GNUNET_CONTAINER_multishortmap_get (room->members, id);
+}
+
+void
+add_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id,
+                  const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = get_service_contact_by_pubkey (room->service, pubkey);
+
+  if (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (room->members, id, contact,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    increase_contact_rc (contact);
+}
+
+struct GNUNET_MESSENGER_MemberInfo*
+get_room_member_info (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id)
+{
+  GNUNET_assert((room) && (room->member_infos));
+
+  return GNUNET_CONTAINER_multishortmap_get (room->member_infos, id);
+}
+
+struct GNUNET_ShortHashCode*
+generate_room_member_id (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  struct GNUNET_ShortHashCode *unique_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+  GNUNET_assert(room);
+
+  if (GNUNET_YES == generate_free_member_id (unique_id, room->members))
+    return unique_id;
+  else
+  {
+    GNUNET_free(unique_id);
+    return NULL;
+  }
+}
+
+const struct GNUNET_ShortHashCode*
+get_room_host_id (const struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  GNUNET_assert(room);
+
+  return get_handle_member_id (room->host, &(room->key));
+}
+
+void
+change_room_host_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *unique_id)
+{
+  GNUNET_assert(room);
+
+  change_handle_member_id (room->host, &(room->key), unique_id);
+}
+
+static int
+send_room_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  if (!handle)
+    return GNUNET_NO;
+
+  merge_room_last_messages (room, handle);
+
+  if (!is_tunnel_connected (tunnel))
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_info (get_handle_ego(handle), room->members);
+
+  if (!message)
+    return GNUNET_NO;
+
+  if ((tunnel->peer_message) && (tunnel->contact_id))
+  {
+    GNUNET_memcpy(&(message->body.info.unique_id), &(tunnel->contact_id), sizeof(struct GNUNET_ShortHashCode));
+    GNUNET_free(tunnel->contact_id);
+
+    tunnel->contact_id = NULL;
+  }
+
+  struct GNUNET_HashCode hash;
+
+  send_tunnel_message (tunnel, handle, message, &hash);
+  destroy_message (message);
+
+  if (tunnel->contact_id)
+  {
+    GNUNET_free(tunnel->contact_id);
+
+    tunnel->contact_id = NULL;
+  }
+
+  return GNUNET_YES;
+}
+
+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 = GNUNET_CONTAINER_multipeermap_get (room->tunnels, source);
+
+  if (tunnel)
+  {
+    if (GNUNET_YES == bind_tunnel (tunnel, channel))
+    {
+      if (GNUNET_YES == send_room_info (room, room->host, tunnel))
+        return tunnel;
+      else
+      {
+        disconnect_tunnel (tunnel);
+        return NULL;
+      }
+    }
+    else
+    {
+      delayed_disconnect_channel (channel);
+      return NULL;
+    }
+  }
+  else
+  {
+    tunnel = create_tunnel (room, source);
+
+    if ((GNUNET_YES == bind_tunnel (tunnel, channel)) && (GNUNET_OK
+        == GNUNET_CONTAINER_multipeermap_put (room->tunnels, source, tunnel,
+                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    {
+      if (GNUNET_YES == send_room_info (room, room->host, tunnel))
+        return tunnel;
+      else
+      {
+        GNUNET_CONTAINER_multipeermap_remove (room->tunnels, source, tunnel);
+
+        disconnect_tunnel (tunnel);
+        destroy_tunnel (tunnel);
+        return NULL;
+      }
+    }
+    else
+    {
+      tunnel->channel = NULL;
+      destroy_tunnel (tunnel);
+
+      delayed_disconnect_channel (channel);
+      return NULL;
+    }
+  }
+}
+
+static int
+join_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+           const struct GNUNET_ShortHashCode *member_id)
+{
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s(get_room_key(room)), GNUNET_sh2s(member_id));
+
+  struct GNUNET_MESSENGER_Message *message = create_message_join (get_handle_ego(handle));
+
+  if (!message)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Your join message could not be created!\n");
+
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_HashCode hash;
+
+  send_room_message (room, handle, message, &hash);
+  destroy_message (message);
+
+  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_new(struct GNUNET_MESSENGER_MemberInfo);
+
+  info->access = GNUNET_MESSENGER_MEMBER_ALLOWED;
+  init_list_messages (&(info->session_messages));
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_put (room->member_infos, member_id, info,
+                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+  {
+    change_handle_member_id (handle, &(room->key), member_id);
+
+    add_to_list_messages (&(info->session_messages), &hash);
+    return GNUNET_YES;
+  }
+  else
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Your member information could not be registered!\n");
+
+    GNUNET_free(info);
+    return GNUNET_NO;
+  }
+}
+
+static int
+join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, &(room->key));
+
+  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, member_id);
+
+  if ((!info) && (GNUNET_NO == join_room (room, handle, member_id)))
+    return GNUNET_NO;
+
+  return GNUNET_YES;
+}
+
+extern int
+check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header);
+extern void
+handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header);
+
+extern void
+callback_tunnel_disconnect (void *cls, const struct GNUNET_CADET_Channel *channel);
+
+int
+open_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  if (room->port)
+    return join_room_locally (room, handle);
+
+  struct GNUNET_CADET_Handle *cadet = get_room_cadet (room);
+  struct GNUNET_HashCode *key = get_room_key (room);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
+                                                                       struct GNUNET_MessageHeader, NULL),
+                                                 GNUNET_MQ_handler_end() };
+
+  room->port = GNUNET_CADET_open_port (cadet, key, callback_room_connect, room, NULL,
+                                       callback_tunnel_disconnect, handlers);
+
+  const struct GNUNET_ShortHashCode *member_id = get_handle_member_id (handle, &(room->key));
+
+  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, member_id);
+
+  if ((!info) && (GNUNET_NO == join_room (room, handle, member_id)) && (room->port))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not join the room, therefore it keeps closed!\n");
+
+    GNUNET_CADET_close_port (room->port);
+    room->port = NULL;
+
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MESSENGER_Message *message = create_message_peer (room->service);
+
+  if (message)
+  {
+    struct GNUNET_HashCode hash;
+
+    send_room_message (room, handle, message, &hash);
+    destroy_message (message);
+  }
+
+  return (room->port ? GNUNET_YES : GNUNET_NO);
+}
+
+int
+entry_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+               const struct GNUNET_PeerIdentity *door)
+{
+  if (room->peer_message)
+  {
+    const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, handle, room->peer_message, GNUNET_NO);
+
+    if (0 == GNUNET_memcmp(&(msg->body.peer.peer), door))
+      return join_room_locally (room, handle);
+  }
+
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, door);
+
+  if (tunnel)
+  {
+    switch (connect_tunnel (tunnel))
+    {
+    case GNUNET_YES:
+      return GNUNET_YES;
+    case GNUNET_NO:
+      return join_room_locally (room, handle);
+    default:
+      return GNUNET_NO;
+    }
+  }
+
+  tunnel = create_tunnel (room, door);
+
+  if ((GNUNET_YES == connect_tunnel (tunnel)) &&
+      (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (room->tunnels, door, tunnel,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    return GNUNET_YES;
+  else
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not connect to that door!\n");
+
+    destroy_tunnel (tunnel);
+    return GNUNET_NO;
+  }
+}
+
+struct GNUNET_MESSENGER_SrvTunnelFinder
+{
+  const struct GNUNET_ShortHashCode *needle;
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
+};
+
+static int
+iterate_find_tunnel (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
+  struct GNUNET_MESSENGER_SrvTunnelFinder *finder = cls;
+
+  if ((tunnel->contact_id) && (0 == GNUNET_memcmp(tunnel->contact_id, finder->needle)))
+  {
+    finder->tunnel = tunnel;
+    return GNUNET_NO;
+  }
+
+  return GNUNET_YES;
+}
+
+struct GNUNET_MESSENGER_SrvTunnel*
+find_room_tunnel_to (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *contact_id)
+{
+  struct GNUNET_MESSENGER_SrvTunnelFinder finder;
+
+  finder.needle = contact_id;
+  finder.tunnel = NULL;
+
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_find_tunnel, &finder);
+
+  return finder.tunnel;
+}
+
+struct GNUNET_MQ_Envelope*
+pack_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, int mode)
+{
+  message->header.timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
+
+  const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, &(room->key));
+
+  GNUNET_assert(id);
+
+  GNUNET_memcpy(&(message->header.sender_id), id, sizeof(struct GNUNET_ShortHashCode));
+
+  if (room->last_messages.head)
+    GNUNET_memcpy(&(message->header.previous), &(room->last_messages.head->hash), sizeof(struct GNUNET_HashCode));
+  else
+    memset (&(message->header.previous), 0, sizeof(struct GNUNET_HashCode));
+
+  return pack_message (message, hash, get_handle_ego (handle), mode);
+}
+
+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;
+  int packed;
+};
+
+static int
+iterate_send_room_message (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
+
+  if ((!is_tunnel_connected (tunnel)) || (!tunnel->contact_id))
+    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_room_message (closure->room, closure->handle, closure->message, closure->hash,
+    GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+
+    if (env)
+    {
+      closure->message = copy_message (closure->message);
+      closure->packed = GNUNET_YES;
+    }
+  }
+  else
+  {
+    env = pack_message (closure->message, NULL, NULL,
+    GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+  }
+
+  if (env)
+    send_tunnel_envelope (tunnel, closure->handle, env, closure->message, closure->hash);
+
+  return GNUNET_YES;
+}
+
+void
+callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+void
+send_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_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) && (closure.message == message))
+  {
+    pack_room_message (room, handle, message, hash,
+    GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+
+    callback_room_sent (room, handle, NULL, copy_message (message), hash);
+  }
+}
+
+void
+send_room_message_ext (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
+                       struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  struct GNUNET_MESSENGER_ClosureSendRoom closure;
+
+  closure.room = room;
+  closure.handle = handle;
+  closure.exclude = tunnel;
+  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) && (closure.message == message))
+  {
+    pack_room_message (room, handle, message, hash,
+    GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+
+    callback_room_sent (room, handle, NULL, copy_message (message), hash);
+  }
+}
+
+void
+forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_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 = copy_message (message);
+  closure.hash = &message_hash;
+  closure.packed = GNUNET_YES;
+
+  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_send_room_message, &closure);
+}
+
+void
+merge_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  if (!handle)
+    return;
+
+  if (!room->last_messages.head)
+    return;
+
+  while (room->last_messages.head != room->last_messages.tail)
+  {
+    struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.tail;
+
+    struct GNUNET_MESSENGER_Message *message = create_message_merge (&(element->hash));
+
+    if (message)
+    {
+      struct GNUNET_HashCode hash;
+
+      send_room_message (room, handle, message, &hash);
+      destroy_message (message);
+    }
+
+    if (element->prev)
+      GNUNET_CONTAINER_DLL_remove(room->last_messages.head, room->last_messages.tail, element);
+  }
+}
+
+struct GNUNET_CADET_Handle*
+get_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  return room->service->cadet;
+}
+
+struct GNUNET_HashCode*
+get_room_key (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  return &(room->key);
+}
+
+const struct GNUNET_MESSENGER_SrvTunnel*
+get_room_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
+}
+
+const struct GNUNET_MESSENGER_Message*
+get_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                  const struct GNUNET_HashCode *hash, int request)
+{
+  const struct GNUNET_MESSENGER_Message *message = get_store_message (&(room->store), hash);
+
+  if ((message) || (!handle) || (GNUNET_YES != request)
+      || (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->requested, hash)))
+    return message;
+
+  struct GNUNET_MESSENGER_Message *request_msg = create_message_request (hash);
+
+  if (request_msg)
+  {
+    if (GNUNET_CONTAINER_multihashmap_put (room->requested, hash, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST) == GNUNET_OK)
+    {
+      struct GNUNET_HashCode request_hash;
+
+      send_room_message (room, handle, request_msg, &request_hash);
+    }
+
+    destroy_message (request_msg);
+  }
+
+  return message;
+}
+
+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;
+
+  GNUNET_PEER_resolve (tunnel->peer, &identity);
+
+  if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
+  {
+    struct GNUNET_MESSENGER_Message *message = create_message_miss (&identity);
+
+    if (message)
+    {
+      struct GNUNET_HashCode hash;
+
+      send_room_message (room, room->host, message, &hash);
+      destroy_message (message);
+    }
+  }
+}
+
+int
+callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room, void *cls,
+                              struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
+{
+  if (GNUNET_MESSENGER_KIND_UNKNOWN == message->header.kind)
+    return GNUNET_SYSERR;
+
+  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
+                                                                                    &(message->header.sender_id));
+
+  if (!contact)
+  {
+    if (GNUNET_MESSENGER_KIND_INFO == message->header.kind)
+      contact = get_service_contact_by_pubkey (room->service, &(message->body.info.host_key));
+    else if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
+      contact = get_service_contact_by_pubkey (room->service, &(message->body.join.key));
+  }
+
+  if ((!contact) || (GNUNET_SYSERR == verify_message (message, hash, get_contact_key (contact))))
+    return GNUNET_SYSERR;
+
+  if (GNUNET_YES == room->strict_access)
+  {
+    struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos,
+                                                                                   &(message->header.sender_id));
+
+    if ((info) && (GNUNET_MESSENGER_MEMBER_BLOCKED == info->access))
+      return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_YES == contains_store_message (&(room->store), hash))
+    return GNUNET_NO;
+
+  return GNUNET_YES;
+}
+
+static void
+search_room_for_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_Message *message = get_room_message (room, room->host, hash, GNUNET_YES);
+
+  if (!message)
+    return;
+
+  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
+    search_room_for_message (room, &(message->body.merge.previous));
+
+  search_room_for_message (room, &(message->header.previous));
+}
+
+static void
+idle_request_room_messages (void *cls)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = cls;
+
+  room->idle = NULL;
+
+  struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.head;
+
+  while (element)
+  {
+    search_room_for_message (room, &(element->hash));
+
+    element = element->next;
+  }
+
+  merge_room_last_messages (room, room->host);
+
+  room->idle = GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_second_ (),
+                                                           GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages,
+                                                           cls);
+}
+
+void
+update_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_ListMessage *element = room->last_messages.head;
+  struct GNUNET_MESSENGER_ListMessage *merging = NULL;
+
+  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
+  {
+    merging = room->last_messages.head;
+
+    while (merging)
+    {
+      if (0 == GNUNET_CRYPTO_hash_cmp (&(merging->hash), &(message->body.merge.previous)))
+        break;
+
+      merging = merging->next;
+    }
+
+    if (merging)
+      element = merging->next;
+  }
+
+  while (element)
+  {
+    if (0 == GNUNET_CRYPTO_hash_cmp (&(element->hash), &(message->header.previous)))
+      break;
+
+    element = element->next;
+  }
+
+  if ((merging) && (!element))
+  {
+    element = merging;
+    merging = NULL;
+  }
+
+  if (element)
+  {
+    GNUNET_memcpy(&(element->hash), hash, sizeof(struct GNUNET_HashCode));
+
+    if (merging)
+      GNUNET_CONTAINER_DLL_remove(room->last_messages.head, room->last_messages.tail, merging);
+  }
+  else
+    add_to_list_messages (&(room->last_messages), hash);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (room->requested, hash))
+    GNUNET_CONTAINER_multihashmap_remove_all (room->requested, hash);
+}
+
+void
+switch_room_member_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *old_id,
+                       const struct GNUNET_ShortHashCode *new_id, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multishortmap_get (room->members, old_id);
+
+  if ((contact) && (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (room->members, old_id, contact)))
+    GNUNET_CONTAINER_multishortmap_put (room->members, new_id, contact,
+                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+
+  struct GNUNET_MESSENGER_MemberInfo *info = GNUNET_CONTAINER_multishortmap_get (room->member_infos, old_id);
+
+  if ((!info) || (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->member_infos, old_id, contact))
+      || (GNUNET_YES != GNUNET_CONTAINER_multishortmap_put (room->member_infos, new_id, contact,
+                                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    return;
+
+  if (hash)
+    add_to_list_messages (&(info->session_messages), hash);
+}
+
+void
+rebuild_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  struct GNUNET_PeerIdentity peer;
+  size_t src;
+
+  if ((GNUNET_OK != get_service_peer_identity (room->service, &peer)) || (!find_list_tunnels (&(room->basement), &peer,
+                                                                                              &src)))
+    return;
+
+  size_t count = count_of_tunnels (&(room->basement));
+
+  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++;
+  }
+}
+
+void
+handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  while (room->handling.head)
+  {
+    struct GNUNET_MESSENGER_ListMessage *element = room->handling.head;
+
+    const struct GNUNET_MESSENGER_Message *msg = get_room_message (room, room->host, &(element->hash), GNUNET_NO);
+
+    if (msg)
+      handle_service_message (room->service, room, msg, &(element->hash));
+
+    GNUNET_CONTAINER_DLL_remove(room->handling.head, room->handling.tail, element);
+    GNUNET_free(element);
+  }
+}
+
+#include "gnunet-service-messenger_message_recv.h"
+
+void
+callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (GNUNET_OK != put_store_message (&(room->store), hash, message))
+    return;
+
+  update_room_last_messages (room, message, hash);
+
+  if (GNUNET_MESSENGER_KIND_INFO != message->header.kind)
+    forward_room_message (room, tunnel, message, hash);
+
+  const int start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
+
+  add_to_list_messages (&(room->handling), hash);
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    recv_message_info (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    recv_message_join (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    recv_message_leave (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    recv_message_name (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    recv_message_key (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_PEER:
+    recv_message_peer (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    recv_message_id (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    recv_message_miss (room, tunnel, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_REQUEST:
+    recv_message_request (room, tunnel, message, hash);
+    break;
+  default:
+    break;
+  }
+
+  if (GNUNET_YES == start_handle)
+    handle_room_messages (room);
+}
+
+#include "gnunet-service-messenger_message_send.h"
+
+void
+callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_Message *old_message = get_room_message (room, handle, hash, GNUNET_NO);
+
+  if ((old_message) || (GNUNET_OK != put_store_message (&(room->store), hash, message)))
+  {
+    if (old_message != message)
+      GNUNET_free(message);
+  }
+  else
+  {
+    struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls; // may be NULL
+
+    update_room_last_messages (room, message, hash);
+
+    const int start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
+
+    add_to_list_messages (&(room->handling), hash);
+
+    switch (message->header.kind)
+    {
+    case GNUNET_MESSENGER_KIND_INFO:
+      send_message_info (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_JOIN:
+      send_message_join (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_LEAVE:
+      send_message_leave (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_NAME:
+      send_message_name (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_KEY:
+      send_message_key (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_PEER:
+      send_message_peer (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_ID:
+      send_message_id (room, handle, tunnel, message, hash);
+      break;
+    case GNUNET_MESSENGER_KIND_MISS:
+      send_message_miss (room, handle, tunnel, message, hash);
+      break;
+    default:
+      break;
+    }
+
+    if (GNUNET_YES == start_handle)
+      handle_room_messages (room);
+  }
+}
diff --git a/src/messenger/gnunet-service-messenger_room.h b/src/messenger/gnunet-service-messenger_room.h
new file mode 100644
index 000000000..36c9e8cf5
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_room.h
@@ -0,0 +1,378 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_room.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_ROOM_H
+#define GNUNET_SERVICE_MESSENGER_ROOM_H
+
+#include "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_mq_lib.h"
+
+#include "gnunet-service-messenger_contact.h"
+
+#include "gnunet_messenger_service.h"
+#include "gnunet-service-messenger_basement.h"
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_tunnel.h"
+
+#include "gnunet-service-messenger_list_messages.h"
+#include "messenger_api_list_tunnels.h"
+
+#include "gnunet-service-messenger_message_store.h"
+#include "messenger_api_ego.h"
+
+enum GNUNET_MESSENGER_MemberAccess
+{
+  GNUNET_MESSENGER_MEMBER_ALLOWED = 1,
+  GNUNET_MESSENGER_MEMBER_BLOCKED = 1,
+
+  GNUNET_MESSENGER_MEMBER_UNKNOWN = 0
+};
+
+struct GNUNET_MESSENGER_MemberInfo
+{
+  enum GNUNET_MESSENGER_MemberAccess access;
+
+  struct GNUNET_MESSENGER_ListMessages session_messages;
+};
+
+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_CONTAINER_MultiShortmap *members;
+  struct GNUNET_CONTAINER_MultiShortmap *member_infos;
+
+  struct GNUNET_MESSENGER_MessageStore store;
+  struct GNUNET_CONTAINER_MultiHashMap *requested;
+
+  struct GNUNET_MESSENGER_ListTunnels basement;
+  struct GNUNET_MESSENGER_ListMessages last_messages;
+
+  struct GNUNET_HashCode *peer_message;
+
+  struct GNUNET_MESSENGER_ListMessages handling;
+  struct GNUNET_SCHEDULER_Task *idle;
+
+  int strict_access;
+};
+
+/**
+ * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i>.
+ *
+ * @param handle Handle
+ * @param key Key of room
+ * @return New room
+ */
+struct GNUNET_MESSENGER_SrvRoom*
+create_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key);
+
+/**
+ * Destroys a room and frees its memory fully.
+ *
+ * @param room Room
+ */
+void
+destroy_room (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the contact of a member in a <i>room</i> identified by a given <i>id</i>. If the <i>room</i>
+ * does not contain a member with the given <i>id</i>, NULL gets returned.
+ *
+ * @param room Room
+ * @param id Member id
+ * @return Contact or NULL
+ */
+struct GNUNET_MESSENGER_SrvContact*
+get_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Adds a contact from the service to a <i>room</i> under a specific <i>id</i> with a given public key.
+ *
+ * @param room Room
+ * @param id Member id
+ * @param pubkey Public key of EGO
+ */
+void
+add_room_contact (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id,
+                  const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Returns the member information of a member in a <i>room</i> identified by a given <i>id</i>. If the <i>room</i>
+ * does not contain a member with the given <i>id</i>, NULL gets returned.
+ *
+ * @param room Room
+ * @param id Member id
+ * @return Member information or NULL
+ */
+struct GNUNET_MESSENGER_MemberInfo*
+get_room_member_info (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *id);
+
+/**
+ * Tries to generate and allocate a new unique member id checking all current members for possible
+ * duplicates. If the function fails, NULL gets returned.
+ *
+ * @param room Room
+ * @return New member id or NULL
+ */
+struct GNUNET_ShortHashCode*
+generate_room_member_id (const struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the member id of the member representing the handle currently hosting this <i>room</i>.
+ *
+ * @param room Room
+ * @return Host member id or NULL
+ */
+const struct GNUNET_ShortHashCode*
+get_room_host_id (const struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Changes the member id of the member representing the handle currently hosting this <i>room</i>.
+ *
+ * @param room Room
+ * @param unique_id Unique member id
+ */
+void
+change_room_host_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *unique_id);
+
+/**
+ * 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 guranteed to be open for incoming connections.
+ *
+ * @param room Room
+ * @param handle Handle
+ * @return GNUNET_YES on success, GNUNET_NO on failure.
+ */
+int
+open_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 room Room
+ * @param handle Handle
+ * @param door Peer identity
+ * @return GNUNET_YES on success, GNUNET_NO on failure.
+ */
+int
+entry_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+               const struct GNUNET_PeerIdentity *door);
+
+/**
+ * Returns a tunnel granting a direct connection to a specific member in a <i>room</i>. The member gets identified
+ * by an <i>id</i>. If no tunnel has been linked to the selected id, NULL gets returned.
+ *
+ * @param room Room
+ * @param contact_id Member id
+ * @return Tunnel to the member or NULL
+ */
+struct GNUNET_MESSENGER_SrvTunnel*
+find_room_tunnel_to (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *contact_id);
+
+/**
+ * Packs a <i>message</i> depending on the selected <i>mode</i> into a newly allocated envelope. It will set the
+ * timestamp of the message, the sender id and the previous messages hash automatically before packing. The message
+ * will be signed by the handles EGO.
+ *
+ * If the optional <i>hash</i> parameter is a valid pointer, its value will be overriden by the signed messages hash.
+ *
+ * If <i>mode</i> is set to GNUNET_MESSENGER_PACK_MODE_ENVELOPE, the function returns a valid envelope to send
+ * through a message queue, otherwise NULL.
+ *
+ * @param room Room
+ * @param handle Handle
+ * @param message Message
+ * @param[out] hash Hash of message
+ * @param mode Packing mode
+ * @return New envelope or NULL
+ */
+struct GNUNET_MQ_Envelope*
+pack_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, int 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.
+ *
+ * @param room Room
+ * @param handle Handle
+ * @param message Message
+ * @param[out] hash Hash of message
+ */
+void
+send_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash);
+
+/**
+ * Sends a <i>message</i> from a given <i>handle</i> into a <i>room</i> excluding one specific <i>tunnel</i>.
+ * The <i>hash</i> parameter will be updated with the hash-value resulting from the sent message.
+ *
+ * The function handles packing the message automatically and will call linked message-events locally even if
+ * the message won't be sent to another peer.
+ *
+ * @param room Room
+ * @param handle Handle
+ * @param message Message
+ * @param[out] hash Hash of message
+ * @param tunnel Tunnel
+ */
+void
+send_room_message_ext (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                       struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
+                       struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Forwards a <i>message</i> with a given <i>hash</i> to a specific <i>tunnel</i> inside of a <i>room</i>.
+ *
+ * @param room Room
+ * @param tunnel Tunnel
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+forward_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel,
+                      const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Reduces all current forks inside of the message history of a <i>room</i> to one remaining last message
+ * by merging them down. All merge messages will be sent from a given <i>handle</i>.
+ *
+ * @param room Room
+ * @param handle Handle
+ */
+void
+merge_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle);
+
+/**
+ * Returns the CADET handle from a rooms service.
+ *
+ * @param room Room
+ * @return CADET handle
+ */
+struct GNUNET_CADET_Handle*
+get_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns the shared secret you need to access a <i>room</i>.
+ *
+ * @param room Room
+ * @return Shared secret
+ */
+struct GNUNET_HashCode*
+get_room_key (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Returns a tunnel inside of a <i>room</i> leading towards a given <i>peer</i> if such a tunnel exists,
+ * otherwise NULL.
+ *
+ * @param room Room
+ * @param peer Peer identity
+ * @return Tunnel or NULL
+ */
+const struct GNUNET_MESSENGER_SrvTunnel*
+get_room_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Returns a message from a <i>room</i> identified by a given <i>hash</i>. If no matching message is
+ * found and <i>request</i> is set to GNUNET_YES, the <i>handle</i> will request the missing message
+ * automatically.
+ *
+ * The function uses the optimized check for a message via its hash from the message store.
+ * @see contains_store_message()
+ *
+ * If a message is missing independent of the following request, NULL gets returned instead of the
+ * matching message.
+ *
+ * @param room Room
+ * @param handle Handle
+ * @param hash Hash of message
+ * @param request Flag to request a message
+ * @return Message or NULL
+ */
+const struct GNUNET_MESSENGER_Message*
+get_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle,
+                  const struct GNUNET_HashCode *hash, int request);
+
+/**
+ * Updates the last messages of a <i>room</i> by replacing them if the previous hash of a given <i>message</i>
+ * matches with one of the latest messages.
+ *
+ * @param room Room
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+update_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message,
+                           const struct GNUNET_HashCode *hash);
+
+/**
+ * Changes an id of a current member from an old id to a new one and adds optionally the <i>hash</i> of an
+ * id message to the members information.
+ *
+ * @param room Room
+ * @param old_id Old member id
+ * @param new_id New member id
+ * @param hash Hash of id message
+ */
+void
+switch_room_member_id (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *old_id,
+                       const struct GNUNET_ShortHashCode *new_id, const struct GNUNET_HashCode *hash);
+
+/**
+ * Rebuilds the decentralized structure for a <i>room</i> by ensuring all required connections are made
+ * depending on the amount of peers and this peers index in the list of them.
+ *
+ * @param room Room
+ */
+void
+rebuild_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Handles all queued up messages of a room to handle in correct order.
+ *
+ * @param room Room
+ */
+void
+handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room);
+
+#endif //GNUNET_SERVICE_MESSENGER_ROOM_H
diff --git a/src/messenger/gnunet-service-messenger_service.c b/src/messenger/gnunet-service-messenger_service.c
new file mode 100644
index 000000000..963314fd8
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_service.c
@@ -0,0 +1,516 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_service.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_service.h"
+
+#include "gnunet-service-messenger_message_kind.h"
+
+#include "gnunet-service-messenger.h"
+#include "gnunet-service-messenger_util.h"
+
+static void
+callback_shutdown_service (void *cls)
+{
+  struct GNUNET_MESSENGER_Service *service = cls;
+
+  if (service)
+  {
+    service->shutdown = NULL;
+
+    destroy_service (service);
+  }
+}
+
+static void
+callback_update_ego (void *cls,
+                     struct GNUNET_IDENTITY_Ego *ego,
+                     void **ctx,
+                     const char *identifier)
+{
+  if ((!ego) || (!identifier))
+    return;
+
+  struct GNUNET_MESSENGER_Service *service = cls;
+
+  update_service_ego(service, identifier, GNUNET_IDENTITY_ego_get_private_key(ego));
+}
+
+struct GNUNET_MESSENGER_Service*
+create_service (const struct GNUNET_CONFIGURATION_Handle *config, struct GNUNET_SERVICE_Handle *service_handle)
+{
+  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->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->cadet = GNUNET_CADET_connect (service->config);
+  service->identity = GNUNET_IDENTITY_connect (service->config, &callback_update_ego, service);
+
+  service->egos = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  init_list_handles (&(service->handles));
+
+  service->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  service->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  return service;
+}
+
+static int
+iterate_destroy_egos (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Ego *ego = value;
+  GNUNET_free(ego);
+  return GNUNET_YES;
+}
+
+static int
+iterate_destroy_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = value;
+  destroy_room (room);
+  return GNUNET_YES;
+}
+
+static int
+iterate_destroy_contacts (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_SrvContact *contact = value;
+  destroy_contact (contact);
+  return GNUNET_YES;
+}
+
+void
+destroy_service (struct GNUNET_MESSENGER_Service *service)
+{
+  if (service->shutdown)
+  {
+    GNUNET_SCHEDULER_cancel (service->shutdown);
+
+    service->shutdown = NULL;
+  }
+
+  GNUNET_CONTAINER_multihashmap_iterate (service->egos, iterate_destroy_egos, NULL);
+
+  clear_list_handles (&(service->handles));
+
+  GNUNET_CONTAINER_multihashmap_iterate (service->rooms, iterate_destroy_rooms, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (service->contacts, iterate_destroy_contacts, NULL);
+
+  GNUNET_CONTAINER_multihashmap_destroy (service->egos);
+  GNUNET_CONTAINER_multihashmap_destroy (service->rooms);
+  GNUNET_CONTAINER_multihashmap_destroy (service->contacts);
+
+  if (service->cadet)
+  {
+    GNUNET_CADET_disconnect (service->cadet);
+
+    service->cadet = NULL;
+  }
+
+  if (service->identity)
+  {
+    GNUNET_IDENTITY_disconnect (service->identity);
+
+    service->identity = NULL;
+  }
+
+  if (service->dir)
+  {
+    GNUNET_free(service->dir);
+
+    service->dir = NULL;
+  }
+
+  GNUNET_SERVICE_shutdown (service->service);
+
+  GNUNET_free(service);
+}
+
+struct GNUNET_MESSENGER_Ego*
+lookup_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier)
+{
+  GNUNET_assert(identifier);
+
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash(identifier, strlen(identifier), &hash);
+  return GNUNET_CONTAINER_multihashmap_get(service->egos, &hash);
+}
+
+void
+update_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier,
+                    const struct GNUNET_IDENTITY_PrivateKey* key)
+{
+  GNUNET_assert((identifier) && (key));
+
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash(identifier, strlen(identifier), &hash);
+
+  struct GNUNET_MESSENGER_Ego* ego = GNUNET_CONTAINER_multihashmap_get(service->egos, &hash);
+
+  if (!ego)
+  {
+    ego = GNUNET_new(struct GNUNET_MESSENGER_Ego);
+    GNUNET_CONTAINER_multihashmap_put(service->egos, &hash, ego, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+
+  GNUNET_memcpy(&(ego->priv), key, sizeof(*key));
+
+  if (GNUNET_OK != GNUNET_IDENTITY_key_get_public(key, &(ego->pub)))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating invalid ego key failed!\n");
+}
+
+struct GNUNET_MESSENGER_SrvHandle*
+add_service_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = create_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)
+{
+  if (!handle)
+    return;
+
+  if (GNUNET_YES == remove_list_handle (&(service->handles), handle))
+    destroy_handle (handle);
+}
+
+int
+get_service_peer_identity (const struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CRYPTO_get_peer_identity (service->config, peer);
+}
+
+struct GNUNET_MESSENGER_SrvContact*
+get_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+  struct GNUNET_MESSENGER_SrvContact *contact = GNUNET_CONTAINER_multihashmap_get (service->contacts, &hash);
+
+  if (contact)
+    return contact;
+
+  contact = create_contact (pubkey);
+
+  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->contacts, &hash, contact,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    return contact;
+
+  destroy_contact (contact);
+  return NULL;
+}
+
+void
+swap_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvContact *contact,
+                                const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  const struct GNUNET_HashCode *hash = get_contact_id_from_key (contact);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (service->contacts, hash, contact))
+  {
+    GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
+
+    hash = get_contact_id_from_key (contact);
+
+    GNUNET_CONTAINER_multihashmap_put (service->contacts, hash, contact,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+}
+
+struct GNUNET_ShortHashCode*
+generate_service_new_member_id (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
+
+  if (room)
+  {
+    return generate_room_member_id (room);
+  }
+  else
+  {
+    struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
+    generate_free_member_id (random_id, NULL);
+    return random_id;
+  }
+}
+
+struct GNUNET_MESSENGER_SrvRoom*
+get_service_room (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
+{
+  return GNUNET_CONTAINER_multihashmap_get (service->rooms, key);
+}
+
+int
+open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
+
+  if (room)
+    return open_room (room, handle);
+
+  room = create_room (handle, key);
+
+  if ((GNUNET_YES == open_room (room, handle)) && (GNUNET_OK
+      == GNUNET_CONTAINER_multihashmap_put (service->rooms, key, room, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    return GNUNET_YES;
+
+  destroy_room (room);
+  return GNUNET_NO;
+}
+
+int
+entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
+
+  if (room)
+  {
+    if (GNUNET_YES == entry_room_at (room, handle, door))
+      return GNUNET_YES;
+    else
+      return GNUNET_NO;
+  }
+
+  room = create_room (handle, key);
+
+  if ((GNUNET_YES == entry_room_at (room, handle, door)) && (GNUNET_OK
+      == GNUNET_CONTAINER_multihashmap_put (service->rooms, key, room, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  {
+    return GNUNET_YES;
+  }
+  else
+  {
+    destroy_room (room);
+    return GNUNET_NO;
+  }
+
+}
+
+int
+close_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
+
+  if (!room)
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_Message *message = create_message_leave ();
+
+  if (message)
+  {
+    struct GNUNET_HashCode hash;
+
+    send_room_message (room, handle, message, &hash);
+    destroy_message (message);
+  }
+
+  const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, key);
+
+  GNUNET_assert(id);
+
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (handle->member_ids, key, id))
+    return GNUNET_NO;
+
+  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_room (room);
+      return GNUNET_YES;
+    }
+    else
+      return GNUNET_NO;
+  }
+
+  if (room->host == handle)
+    room->host = member_handle;
+
+  return GNUNET_YES;
+}
+
+static void
+get_room_data_subdir (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
+{
+  GNUNET_asprintf (dir, "%s%s%c%s%c", service->dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (&(room->key)), DIR_SEPARATOR);
+}
+
+void
+load_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  char *room_dir;
+  get_room_data_subdir (service, room, &room_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
+  {
+    load_message_store (&room->store, room_dir);
+
+    char *config_file;
+    GNUNET_asprintf (&config_file, "%s%s", room_dir, "room.cfg");
+
+    struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+    if ((GNUNET_YES == GNUNET_DISK_file_test (config_file)) && (GNUNET_OK
+        == GNUNET_CONFIGURATION_parse (cfg, config_file)))
+    {
+      unsigned long long access;
+
+      if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "room", "access-rule", &access))
+        room->strict_access = (int) (access);
+
+      char *message_string;
+
+      if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "room", "last-message", &message_string)) && (message_string))
+      {
+        struct GNUNET_HashCode hash;
+
+        GNUNET_CRYPTO_hash_from_string(message_string, &hash);
+
+        const struct GNUNET_MESSENGER_Message *message = get_room_message (room, room->host, &hash, GNUNET_NO);
+
+        if (message)
+          update_room_last_messages (room, message, &hash);
+
+        GNUNET_free(message_string);
+      }
+    }
+
+    GNUNET_CONFIGURATION_destroy (cfg);
+
+    GNUNET_free(config_file);
+  }
+
+  GNUNET_free(room_dir);
+}
+
+void
+save_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room)
+{
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (service->rooms, &(room->key)))
+  {
+    return;
+  }
+
+  char *room_dir;
+  get_room_data_subdir (service, room, &room_dir);
+
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) || (GNUNET_OK
+      == GNUNET_DISK_directory_create (room_dir)))
+  {
+    save_message_store (&room->store, room_dir);
+
+    char *config_file;
+    GNUNET_asprintf (&config_file, "%s%s", room_dir, "room.cfg");
+
+    struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
+
+    GNUNET_CONFIGURATION_set_value_number (cfg, "room", "access-rule", room->strict_access);
+
+    if (room->last_messages.head)
+      GNUNET_CONFIGURATION_set_value_string (cfg, "room", "last-message",
+                                             GNUNET_h2s_full (&(room->last_messages.head->hash)));
+
+    GNUNET_CONFIGURATION_write (cfg, config_file);
+    GNUNET_CONFIGURATION_destroy (cfg);
+
+    GNUNET_free(config_file);
+  }
+
+  GNUNET_free(room_dir);
+}
+
+void
+handle_service_message (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
+
+  const uint16_t length = get_message_size (message);
+
+  while (element)
+  {
+    struct GNUNET_MESSENGER_SrvHandle *handle = (struct GNUNET_MESSENGER_SrvHandle*) element->handle;
+
+    if ((handle->mq) && (get_handle_member_id (handle, &(room->key))))
+    {
+      struct GNUNET_MESSENGER_RecvMessage *msg;
+      struct GNUNET_MQ_Envelope *env;
+
+      env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
+
+      GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+      GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
+
+      char *buffer = ((char*) msg) + sizeof(*msg);
+      encode_message (message, length, buffer);
+
+      GNUNET_MQ_send (handle->mq, env);
+    }
+
+    element = element->next;
+  }
+}
diff --git a/src/messenger/gnunet-service-messenger_service.h b/src/messenger/gnunet-service-messenger_service.h
new file mode 100644
index 000000000..246c74771
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_service.h
@@ -0,0 +1,259 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_service.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_SERVICE_H
+#define GNUNET_SERVICE_MESSENGER_SERVICE_H
+
+#include "platform.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_identity_service.h"
+
+#include "messenger_api_ego.h"
+
+#include "gnunet-service-messenger_list_handles.h"
+
+#include "gnunet-service-messenger_contact.h"
+#include "gnunet-service-messenger_room.h"
+
+struct GNUNET_MESSENGER_Service
+{
+  const struct GNUNET_CONFIGURATION_Handle *config;
+  struct GNUNET_SERVICE_Handle *service;
+
+  struct GNUNET_SCHEDULER_Task *shutdown;
+
+  char *dir;
+
+  struct GNUNET_CADET_Handle *cadet;
+  struct GNUNET_IDENTITY_Handle *identity;
+
+  struct GNUNET_CONTAINER_MultiHashMap *egos;
+
+  struct GNUNET_MESSENGER_ListHandles handles;
+
+  struct GNUNET_CONTAINER_MultiHashMap *contacts;
+  struct GNUNET_CONTAINER_MultiHashMap *rooms;
+};
+
+/**
+ * Creates and allocates a new service using a given <i>config</i> and a GNUnet service handle.
+ *
+ * @param config Configuration
+ * @param service_handle GNUnet service handle
+ * @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 service Service
+ */
+void
+destroy_service (struct GNUNET_MESSENGER_Service *service);
+
+/**
+ * Lookups an EGO which was registered to a <i>service</i> under
+ * a specific <i>identifier</i>.
+ *
+ * @param service Service
+ * @param identifier Identifier string
+ * @return EGO or NULL
+ */
+struct GNUNET_MESSENGER_Ego*
+lookup_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier);
+
+/**
+ * Updates the registration of an EGO to a <i>service</i> under
+ * a specific <i>identifier</i> with a new <i>key</i>.
+ *
+ * @param service Service
+ * @param identifier Identifier string
+ * @param key Private EGO key
+ */
+void
+update_service_ego (struct GNUNET_MESSENGER_Service *service, const char *identifier,
+                    const struct GNUNET_IDENTITY_PrivateKey* key);
+
+/**
+ * Creates and adds a new handle to a <i>service</i> using a given message queue.
+ *
+ * @param service Service
+ * @param 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 service Service
+ * @param 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 service Service
+ * @param[out] peer Peer identity
+ * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ */
+int
+get_service_peer_identity (const struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Returns a contact of a <i>service</i> identified by a given public key. If no matching contact exists,
+ * it will tried to create one with the specific public key. If the function still fails to do so,
+ * NULL gets returned.
+ *
+ * @param service Service
+ * @param pubkey Public key of EGO
+ * @return Contact
+ */
+struct GNUNET_MESSENGER_SrvContact*
+get_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Changes the public key for a <i>contact</i> known to a <i>service</i> to a specific public key and
+ * updates local map entries to access the contact by its updated key.
+ *
+ * @param service Service
+ * @param contact Contact
+ * @param pubkey Public key of EGO
+ */
+void
+swap_service_contact_by_pubkey (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvContact *contact,
+                                const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Tries to generate and allocate a new unique member id for a given room of a service identified by its <i>key</i>.
+ * If the generation fails caused by too many tries of duplicates, it returns NULL.
+ *
+ * @param service Service
+ * @param key Key of room
+ * @return Newly generated member id or NULL
+ */
+struct GNUNET_ShortHashCode*
+generate_service_new_member_id (struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key);
+
+/**
+ * Returns the room identified by a given <i>key</i> for a <i>service</i>. If the service doesn't know any room
+ * using the given key, NULL gets returned.
+ *
+ * @param service Service
+ * @param key Key of room
+ * @return Room or NULL
+ */
+struct GNUNET_MESSENGER_SrvRoom*
+get_service_room (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 service Service
+ * @param handle Handle
+ * @param key Key of room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+open_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                   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 service Service
+ * @param handle Handle
+ * @param door Peer identity
+ * @param key Key of room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+entry_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    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 service Service
+ * @param handle Handle
+ * @param key Key of room
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+close_service_room (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle,
+                    const struct GNUNET_HashCode *key);
+
+/**
+ * Loads the local configuration for a given <i>room</i> of a <i>service</i> which contains the last messages hash
+ * and the ruleset for general access of new members.
+ *
+ * @param service Service
+ * @param room Room
+ */
+void
+load_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Saves the configuration for a given <i>room</i> of a <i>service</i> which contains the last messages hash
+ * and the ruleset for general access of new members locally.
+ *
+ * @param service Service
+ * @param room Room
+ */
+void
+save_service_room_and_messages (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room);
+
+/**
+ * Sends a received or sent <i>message</i> with a given <i>hash</i> to each handle of a <i>service</i> which
+ * is currently member of a specific <i>room</i> for handling it in the client API.
+ *
+ * @param service Service
+ * @param room Room
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+handle_service_message (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room,
+                        const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_SERVICE_MESSENGER_SERVICE_H
diff --git a/src/messenger/gnunet-service-messenger_tunnel.c b/src/messenger/gnunet-service-messenger_tunnel.c
new file mode 100644
index 000000000..df9e5c4c7
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_tunnel.c
@@ -0,0 +1,300 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_tunnel.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_tunnel.h"
+
+#include "gnunet-service-messenger_handle.h"
+#include "gnunet-service-messenger_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->contact_id = NULL;
+
+  tunnel->peer_message = NULL;
+  tunnel->last_message = NULL;
+
+  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->contact_id)
+    GNUNET_free(tunnel->contact_id);
+
+  if (tunnel->peer_message)
+    GNUNET_free(tunnel->peer_message);
+
+  if (tunnel->last_message)
+    GNUNET_free(tunnel->last_message);
+
+  GNUNET_free(tunnel);
+}
+
+int
+bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel)
+{
+  GNUNET_assert(tunnel);
+
+  if (tunnel->channel)
+  {
+    if (tunnel->contact_id)
+      return GNUNET_NO;
+
+    delayed_disconnect_channel (tunnel->channel);
+  }
+
+  tunnel->channel = channel;
+
+  return GNUNET_YES;
+}
+
+extern void
+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 int
+callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room, void *cls,
+                              struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash);
+
+int
+check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  if (!tunnel)
+    return GNUNET_NO;
+
+  const uint16_t length = ntohs (header->size) - sizeof(*header);
+  const char *buffer = (const char*) &header[1];
+
+  struct GNUNET_MESSENGER_Message message;
+
+  if (length < sizeof(message.header))
+    return GNUNET_NO;
+
+  if (GNUNET_YES != decode_message (&message, length, buffer))
+    return GNUNET_NO;
+
+  struct GNUNET_HashCode hash;
+  hash_message (length, buffer, &hash);
+
+  int result = callback_verify_room_message (tunnel->room, cls, &message, &hash);
+
+  if (GNUNET_MESSENGER_KIND_PEER == message.header.kind)
+  {
+    struct GNUNET_PeerIdentity identity;
+
+    GNUNET_PEER_resolve (tunnel->peer, &identity);
+
+    if (0 == GNUNET_memcmp(&(message.body.peer.peer), &(identity)))
+    {
+      if (tunnel->contact_id)
+      {
+        if (0 != GNUNET_memcmp(tunnel->contact_id, &(message.header.sender_id)))
+          result = GNUNET_SYSERR;
+      }
+      else
+      {
+        tunnel->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+        GNUNET_memcpy(tunnel->contact_id, &(message.header.sender_id), sizeof(struct GNUNET_ShortHashCode));
+      }
+    }
+  }
+
+  return (result == GNUNET_YES ? GNUNET_OK : GNUNET_NO);
+}
+
+extern void
+callback_room_recv (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash);
+
+void
+handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
+
+  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;
+
+  decode_message (&message, length, buffer);
+  hash_message (length, buffer, &hash);
+
+  if (tunnel)
+  {
+    if (!tunnel->last_message)
+      tunnel->last_message = GNUNET_new(struct GNUNET_HashCode);
+
+    GNUNET_memcpy(tunnel->last_message, &hash, sizeof(struct GNUNET_HashCode));
+
+    callback_room_recv (tunnel->room, cls, copy_message (&message), &hash);
+  }
+
+  GNUNET_CADET_receive_done (tunnel->channel);
+}
+
+int
+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_room_cadet (tunnel->room);
+  struct GNUNET_HashCode *key = get_room_key (tunnel->room);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
+                                                                       struct GNUNET_MessageHeader, NULL),
+                                                 GNUNET_MQ_handler_end() };
+
+  tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, key, NULL, callback_tunnel_disconnect, handlers);
+
+  return GNUNET_YES;
+}
+
+void
+disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  if (tunnel->channel)
+  {
+    delayed_disconnect_channel (tunnel->channel);
+
+    tunnel->channel = NULL;
+  }
+}
+
+int
+is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
+}
+
+struct GNUNET_MESSENGER_MessageSent
+{
+  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
+  struct GNUNET_HashCode hash;
+};
+
+extern void
+callback_room_sent (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, void *cls,
+                    struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+static void
+callback_tunnel_sent (void *cls)
+{
+  struct GNUNET_MESSENGER_MessageSent *sent = cls;
+
+  if (sent->tunnel)
+  {
+    if (!sent->tunnel->last_message)
+      sent->tunnel->last_message = GNUNET_new(struct GNUNET_HashCode);
+
+    GNUNET_memcpy(sent->tunnel->last_message, &(sent->hash), sizeof(struct GNUNET_HashCode));
+  }
+
+  GNUNET_free(sent);
+}
+
+void
+send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MQ_Envelope *env,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  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);
+
+  callback_room_sent (tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle, tunnel, message, hash);
+}
+
+void
+send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message,
+                     struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MQ_Envelope *env = pack_room_message (tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
+                                                      message, hash,
+                                                      GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+
+  if (env)
+    send_tunnel_envelope (tunnel, handle, env, copy_message (message), hash);
+}
+
+void
+forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message,
+                        const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Message *clone = copy_message (message);
+  struct GNUNET_MQ_Envelope *env = pack_message (clone, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+
+  if (env)
+    send_tunnel_envelope (tunnel, NULL, env, clone, hash);
+}
+
+const struct GNUNET_HashCode*
+get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
+{
+  return tunnel->peer_message;
+}
diff --git a/src/messenger/gnunet-service-messenger_tunnel.h b/src/messenger/gnunet-service-messenger_tunnel.h
new file mode 100644
index 000000000..e6efb226d
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_tunnel.h
@@ -0,0 +1,155 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_tunnel.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_TUNNEL_H
+#define GNUNET_SERVICE_MESSENGER_TUNNEL_H
+
+#include "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_peer_lib.h"
+#include "gnunet_crypto_lib.h"
+
+#include "gnunet-service-messenger_room.h"
+
+struct GNUNET_MESSENGER_SrvTunnel
+{
+  struct GNUNET_MESSENGER_SrvRoom *room;
+  struct GNUNET_CADET_Channel *channel;
+
+  GNUNET_PEER_Id peer;
+  struct GNUNET_ShortHashCode *contact_id;
+
+  struct GNUNET_HashCode *peer_message;
+  struct GNUNET_HashCode *last_message;
+};
+
+/**
+ * Creates and allocates a tunnel of a <i>room</i> to a specific peer identity.
+ *
+ * @param room Room
+ * @param 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 tunnel
+ */
+void
+destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Binds a CADET <i>channel</i> to a <i>tunnel</i> on returns GNUNET_YES only if
+ * the bounds channel was replaced successfully, otherwise GNUNET_NO gets returned.
+ *
+ * @param tunnel Tunnel
+ * @param channel CADET channel
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+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 tunnel Tunnel
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Disconnects and unbinds a channel from a <i>tunnel</i>. The actual disconnection
+ * will be asynchronous.
+ *
+ * @param tunnel Tunnel
+ */
+void
+disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Returns the status of a currently bound channel of a <i>tunnel</i>.
+ *
+ * @param tunnel Tunnel
+ * @return GNUNET_YES or GNUNET_NO
+ */
+int
+is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+/**
+ * Sends an envelope containing a <i>message</i> with a given <i>hash</i> through
+ * a <i>tunnel</i> by a given <i>handle</i>.
+ *
+ * @param tunnel Tunnel
+ * @param handle Handle
+ * @param env Envelope
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MQ_Envelope *env,
+                      struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash);
+
+/**
+ * Sends a <i>message</i> by packing it automatically into an envelope and passing it
+ * through the <i>tunnel</i>. The used <i>handle</i> will sign the message and
+ * the <i>hash</i> will be calculated and stored.
+ *
+ * @param tunnel Tunnel
+ * @param handle Handle
+ * @param[out] message Message
+ * @param[out] hash Hash of message
+ */
+void
+send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message,
+                     struct GNUNET_HashCode *hash);
+
+/**
+ * Forwards a given <i>message</i> with a known <i>hash</i> through a <i>tunnel</i>.
+ *
+ * @param tunnel Tunnel
+ * @param message Message
+ * @param hash Hash of message
+ */
+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 tunnel Tunnel
+ * @return Hash of peer message or NULL
+ */
+const struct GNUNET_HashCode*
+get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel);
+
+#endif //GNUNET_SERVICE_MESSENGER_TUNNEL_H
diff --git a/src/messenger/gnunet-service-messenger_util.c b/src/messenger/gnunet-service-messenger_util.c
new file mode 100644
index 000000000..94fc9469d
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_util.c
@@ -0,0 +1,64 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_util.c
+ * @brief GNUnet MESSENGER service
+ */
+
+#include "gnunet-service-messenger_util.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_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_ (), GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                              callback_close_channel, channel);
+}
+
+int
+generate_free_member_id (struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
+{
+  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;
+}
diff --git a/src/messenger/gnunet-service-messenger_util.h b/src/messenger/gnunet-service-messenger_util.h
new file mode 100644
index 000000000..20f8f0afe
--- /dev/null
+++ b/src/messenger/gnunet-service-messenger_util.h
@@ -0,0 +1,53 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/gnunet-service-messenger_util.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_SERVICE_MESSENGER_UTIL_H
+#define GNUNET_SERVICE_MESSENGER_UTIL_H
+
+#include "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+
+/**
+ * Starts an urgent task to close a CADET channel asynchronously.
+ *
+ * @param 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 members Map of member ids
+ * @return GNUNET_YES on success, GNUNET_NO on failure
+ */
+int
+generate_free_member_id (struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members);
+
+#endif //GNUNET_SERVICE_MESSENGER_UTIL_H
diff --git a/src/messenger/messenger.conf.in b/src/messenger/messenger.conf.in
new file mode 100644
index 000000000..59e11b166
--- /dev/null
+++ b/src/messenger/messenger.conf.in
@@ -0,0 +1,13 @@
+[messenger]
+START_ON_DEMAND = YES
+PORT = 2097
+HOSTNAME = localhost
+BINARY = gnunet-service-messenger
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_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/
\ No newline at end of file
diff --git a/src/messenger/messenger_api.c b/src/messenger/messenger_api.c
new file mode 100644
index 000000000..6401b18d7
--- /dev/null
+++ b/src/messenger/messenger_api.c
@@ -0,0 +1,568 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "gnunet_messenger_service.h"
+
+#include "gnunet-service-messenger.h"
+
+#include "messenger_api_handle.h"
+#include "messenger_api_message.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";
+  default:
+    return "UNKNOWN";
+  }
+}
+
+static int
+check_get_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
+{
+  GNUNET_MQ_check_zero_termination(msg);
+  return GNUNET_OK;
+}
+
+static void
+handle_get_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const char *name = ((const char*) msg) + sizeof(*msg);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set name of handle: %s\n", name);
+
+  set_handle_name (handle, strlen(name) > 0? name : NULL);
+}
+
+static void
+handle_get_key (void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
+{
+  struct GNUNET_MESSENGER_Handle *handle = cls;
+
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = &(msg->pubkey);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set key of handle: %s\n", GNUNET_IDENTITY_public_key_to_string (pubkey));
+
+  set_handle_key (handle, pubkey);
+
+  if (handle->identity_callback)
+    handle->identity_callback (handle->identity_cls, handle);
+}
+
+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);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set id of handle in room: %s\n", GNUNET_h2s (key));
+
+  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
+
+  if (room)
+  {
+    if (!room->contact_id)
+      room->contact_id = GNUNET_new(struct GNUNET_ShortHashCode);
+
+    GNUNET_memcpy(room->contact_id, id, sizeof(*id));
+  }
+}
+
+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);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
+
+  open_handle_room (handle, key);
+}
+
+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);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entered room: %s\n", GNUNET_h2s (key));
+
+  entry_handle_room_at (handle, door, key);
+}
+
+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);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closed room: %s\n", GNUNET_h2s (key));
+
+  close_handle_room (handle, key);
+}
+
+static int
+check_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
+{
+  const uint16_t full_length = ntohs (msg->header.size) - sizeof(msg->header);
+
+  if (full_length < sizeof(msg->hash))
+    return GNUNET_NO;
+
+  const uint16_t length = full_length - sizeof(msg->hash);
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+
+  if (length < sizeof(message.header))
+    return GNUNET_NO;
+
+  if (GNUNET_YES != decode_message (&message, length, buffer))
+    return GNUNET_NO;
+
+  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 *hash = &(msg->hash);
+
+  const char *buffer = ((const char*) msg) + sizeof(*msg);
+
+  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
+
+  struct GNUNET_MESSENGER_Message message;
+  decode_message (&message, length, buffer);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n", GNUNET_MESSENGER_name_of_kind (message.header.kind));
+
+  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
+
+  if (room)
+  {
+    handle_room_message (room, &message, hash);
+
+    if (handle->msg_callback)
+      handle->msg_callback (handle->msg_cls, room, &message, hash);
+  }
+  else
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MESSENGER ERROR: Room not found\n");
+}
+
+static void
+reconnect (struct GNUNET_MESSENGER_Handle *handle);
+
+static void
+send_open_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
+{
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+static void
+send_entry_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room,
+                 const struct GNUNET_PeerIdentity *door)
+{
+  struct GNUNET_MESSENGER_RoomMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
+  GNUNET_memcpy(&(msg->door), door, sizeof(*door));
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_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;
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+  GNUNET_MQ_send (handle->mq, env);
+}
+
+static int
+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_entry_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)
+  ;
+
+  reconnect (handle);
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_reset_room, handle);
+}
+
+static int
+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_DEBUG, "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_var_size(
+      get_name, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME, struct GNUNET_MESSENGER_NameMessage, handle),
+                                                       GNUNET_MQ_hd_fixed_size(
+                                                           get_key, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY,
+                                                           struct GNUNET_MESSENGER_KeyMessage, handle),
+                                                       GNUNET_MQ_hd_fixed_size(
+                                                           member_id,
+                                                           GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
+                                                           struct GNUNET_MESSENGER_MemberMessage, handle),
+                                                       GNUNET_MQ_hd_fixed_size(room_open,
+                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
+                                                                               struct GNUNET_MESSENGER_RoomMessage,
+                                                                               handle),
+                                                       GNUNET_MQ_hd_fixed_size(room_entry,
+                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
+                                                                               struct GNUNET_MESSENGER_RoomMessage,
+                                                                               handle),
+                                                       GNUNET_MQ_hd_fixed_size(room_close,
+                                                                               GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
+                                                                               struct GNUNET_MESSENGER_RoomMessage,
+                                                                               handle),
+                                                       GNUNET_MQ_hd_var_size(
+                                                           recv_message,
+                                                           GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
+                                                           struct GNUNET_MESSENGER_RecvMessage, handle),
+                                                       GNUNET_MQ_handler_end() };
+
+  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
+  GNUNET_MESSENGER_SERVICE_NAME,
+                                      handlers, &callback_mq_error, handle);
+}
+
+struct GNUNET_MESSENGER_Handle*
+GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name,
+                          GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls,
+                          GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, identity_callback, identity_cls, msg_callback, msg_cls);
+
+  reconnect (handle);
+
+  if (handle->mq)
+  {
+    const uint16_t name_len = name ? strlen (name) : 0;
+
+    struct GNUNET_MESSENGER_CreateMessage *msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
+
+    char *extra = ((char*) msg) + sizeof(*msg);
+
+    if (name_len)
+      GNUNET_memcpy(extra, name, name_len);
+
+    extra[name_len] = '\0';
+
+    GNUNET_MQ_send (handle->mq, env);
+    return handle;
+  }
+  else
+  {
+    destroy_handle (handle);
+    return NULL;
+  }
+}
+
+int
+GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle)
+{
+  if ((!handle) || (!get_handle_name(handle)))
+    return GNUNET_SYSERR;
+
+  struct GNUNET_MESSENGER_UpdateMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE);
+  GNUNET_MQ_send (handle->mq, env);
+  return GNUNET_OK;
+}
+
+void
+GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (!handle)
+    return;
+
+  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);
+}
+
+const char*
+GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (!handle)
+    return NULL;
+
+  return get_handle_name (handle);
+}
+
+int
+GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
+{
+  if (!handle)
+    return GNUNET_SYSERR;
+
+  const uint16_t name_len = name ? strlen (name) : 0;
+
+  struct GNUNET_MESSENGER_NameMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME);
+
+  char *extra = ((char*) msg) + sizeof(*msg);
+
+  if (name_len)
+    GNUNET_memcpy(extra, name, name_len);
+
+  extra[name_len] = '\0';
+
+  GNUNET_MQ_send (handle->mq, env);
+  return GNUNET_YES;
+}
+
+const struct GNUNET_IDENTITY_PublicKey*
+GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (!handle)
+    return NULL;
+
+  return get_handle_key (handle);
+}
+
+struct GNUNET_MESSENGER_Room*
+GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
+{
+  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_entry_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
+                             const struct GNUNET_HashCode *key)
+{
+  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_entry_room (handle, room, door);
+  return room;
+}
+
+void
+GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
+{
+  send_close_room (room->handle, room);
+}
+
+struct GNUNET_MESSENGER_Contact*
+GNUNET_MESSENGER_get_member (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_ShortHashCode *id)
+{
+  return GNUNET_CONTAINER_multishortmap_get (room->members, id);
+}
+
+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_IDENTITY_PublicKey*
+GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  if (!contact)
+    return NULL;
+
+  return get_contact_key (contact);
+}
+
+void
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message)
+{
+  const uint16_t length = get_message_size (message);
+
+  struct GNUNET_MESSENGER_SendMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE);
+
+  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+
+  char *buffer = ((char*) msg) + sizeof(*msg);
+  encode_message (message, length, buffer);
+
+  GNUNET_MQ_send (room->handle->mq, env);
+}
+
+const struct GNUNET_MESSENGER_Message*
+GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
+{
+  const struct GNUNET_MESSENGER_Message *message = get_room_message (room, hash);
+
+  if (!message)
+  {
+    struct GNUNET_MESSENGER_RecvMessage *msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
+    GNUNET_memcpy(&(msg->key), &(room->key), sizeof(room->key));
+    GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
+    GNUNET_MQ_send (room->handle->mq, env);
+  }
+
+  return message;
+}
diff --git a/src/messenger/messenger_api_contact.c b/src/messenger/messenger_api_contact.c
new file mode 100644
index 000000000..9a242aa00
--- /dev/null
+++ b/src/messenger/messenger_api_contact.c
@@ -0,0 +1,78 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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_IDENTITY_PublicKey *key)
+{
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_new(struct GNUNET_MESSENGER_Contact);
+
+  contact->name = NULL;
+
+  GNUNET_memcpy(&(contact->public_key), key, sizeof(contact->public_key));
+
+  return contact;
+}
+
+void
+destroy_contact (struct GNUNET_MESSENGER_Contact *contact)
+{
+  if (contact->name)
+    GNUNET_free(contact->name);
+
+  GNUNET_free(contact);
+}
+
+const char*
+get_contact_name (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  return contact->name;
+}
+
+void
+set_contact_name (struct GNUNET_MESSENGER_Contact *contact, const char *name)
+{
+  if (contact->name)
+    GNUNET_free(contact->name);
+
+  contact->name = name? GNUNET_strdup(name) : NULL;
+}
+
+const struct GNUNET_IDENTITY_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  return &(contact->public_key);
+}
+
+const struct GNUNET_HashCode*
+get_contact_id_from_key (const struct GNUNET_MESSENGER_Contact *contact)
+{
+  static struct GNUNET_HashCode id;
+
+  GNUNET_CRYPTO_hash (&(contact->public_key), sizeof(contact->public_key), &id);
+
+  return &id;
+}
diff --git a/src/messenger/messenger_api_contact.h b/src/messenger/messenger_api_contact.h
new file mode 100644
index 000000000..0673b9b85
--- /dev/null
+++ b/src/messenger/messenger_api_contact.h
@@ -0,0 +1,93 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+
+struct GNUNET_MESSENGER_Contact
+{
+  char *name;
+
+  struct GNUNET_IDENTITY_PublicKey public_key;
+};
+
+/**
+ * Creates and allocates a new contact with a given public <i>key</i> from an EGO.
+ *
+ * @param key Public key
+ * @return New contact
+ */
+struct GNUNET_MESSENGER_Contact*
+create_contact (const struct GNUNET_IDENTITY_PublicKey *key);
+
+/**
+ * Destroys a contact and frees its memory fully.
+ *
+ * @param contact Contact
+ */
+void
+destroy_contact (struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Returns the current name of a given <i>contact</i> or NULL if no valid name was assigned yet.
+ *
+ * @param contact Contact
+ * @return Name of the contact or NULL
+ */
+const char*
+get_contact_name (const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Changes the current name of a given <i>contact</i> by copying it from the parameter <i>name</i>.
+ *
+ * @param contact Contact
+ * @param name Valid name (may not be NULL!)
+ */
+void
+set_contact_name (struct GNUNET_MESSENGER_Contact *contact, const char *name);
+
+/**
+ * Returns the public key of a given <i>contact</i>.
+ *
+ * @param contact Contact
+ * @return Public key of the contact
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+get_contact_key (const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Returns the resulting hashcode of the public key from a given <i>contact</i>.
+ *
+ * @param contact Contact
+ * @return Hash of the contacts public key
+ */
+const struct GNUNET_HashCode*
+get_contact_id_from_key (const struct GNUNET_MESSENGER_Contact *contact);
+
+#endif //GNUNET_MESSENGER_API_CONTACT_H
diff --git a/src/messenger/messenger_api_ego.h b/src/messenger/messenger_api_ego.h
new file mode 100644
index 000000000..c60eeac50
--- /dev/null
+++ b/src/messenger/messenger_api_ego.h
@@ -0,0 +1,38 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_ego.h
+ * @brief GNUnet MESSENGER service
+ */
+
+#ifndef GNUNET_MESSENGER_API_EGO_H
+#define GNUNET_MESSENGER_API_EGO_H
+
+#include "platform.h"
+#include "gnunet_identity_service.h"
+
+struct GNUNET_MESSENGER_Ego
+{
+  struct GNUNET_IDENTITY_PrivateKey priv;
+  struct GNUNET_IDENTITY_PublicKey pub;
+};
+
+#endif //GNUNET_MESSENGER_API_EGO_H
diff --git a/src/messenger/messenger_api_handle.c b/src/messenger/messenger_api_handle.c
new file mode 100644
index 000000000..20ef77254
--- /dev/null
+++ b/src/messenger/messenger_api_handle.c
@@ -0,0 +1,213 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_handle.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_handle.h"
+
+struct GNUNET_MESSENGER_Handle*
+create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_IdentityCallback identity_callback,
+               void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
+{
+  struct GNUNET_MESSENGER_Handle *handle = GNUNET_new(struct GNUNET_MESSENGER_Handle);
+
+  handle->cfg = cfg;
+  handle->mq = NULL;
+
+  handle->identity_callback = identity_callback;
+  handle->identity_cls = identity_cls;
+
+  handle->msg_callback = msg_callback;
+  handle->msg_cls = msg_cls;
+
+  handle->name = 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);
+  handle->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  return handle;
+}
+
+static int
+iterate_destroy_room (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Room *room = value;
+
+  destroy_room (room);
+
+  return GNUNET_YES;
+}
+
+static int
+iterate_destroy_contact (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Contact *contact = value;
+
+  destroy_contact (contact);
+
+  return GNUNET_YES;
+}
+
+void
+destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
+{
+  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->pubkey)
+    GNUNET_free(handle->pubkey);
+
+  if (handle->rooms)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_destroy_room, NULL);
+
+    GNUNET_CONTAINER_multihashmap_destroy (handle->rooms);
+  }
+
+  if (handle->contacts)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (handle->contacts, iterate_destroy_contact, NULL);
+
+    GNUNET_CONTAINER_multihashmap_destroy (handle->contacts);
+  }
+
+  GNUNET_free(handle->name);
+}
+
+void
+set_handle_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
+{
+  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)
+{
+  return handle->name;
+}
+
+void
+set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  if (!handle->pubkey)
+    handle->pubkey = GNUNET_new(struct GNUNET_IDENTITY_PublicKey);
+
+  GNUNET_memcpy(handle->pubkey, pubkey, sizeof(*pubkey));
+}
+
+const struct GNUNET_IDENTITY_PublicKey*
+get_handle_key (const struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (!handle->pubkey)
+  {
+    struct GNUNET_IDENTITY_Ego *anonymous = GNUNET_IDENTITY_ego_get_anonymous ();
+    static struct GNUNET_IDENTITY_PublicKey pubkey;
+
+    GNUNET_IDENTITY_ego_get_public_key (anonymous, &pubkey);
+
+    return &pubkey;
+  }
+
+  return handle->pubkey;
+}
+
+struct GNUNET_MESSENGER_Contact*
+get_handle_contact_by_pubkey (const struct GNUNET_MESSENGER_Handle *handle,
+                              const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
+
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multihashmap_get (handle->contacts, &hash);
+
+  if (contact)
+    return contact;
+
+  contact = create_contact (pubkey);
+
+  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (handle->contacts, &hash, contact,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    return contact;
+
+  destroy_contact (contact);
+  return NULL;
+}
+
+void
+swap_handle_contact_by_pubkey (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Contact *contact,
+                               const struct GNUNET_IDENTITY_PublicKey *pubkey)
+{
+  const struct GNUNET_HashCode *hash = get_contact_id_from_key (contact);
+
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (handle->contacts, hash, contact))
+  {
+    GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
+
+    hash = get_contact_id_from_key (contact);
+
+    GNUNET_CONTAINER_multihashmap_put (handle->contacts, hash, contact,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+}
+
+void
+open_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *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)
+{
+  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
+
+  if (room)
+    add_to_list_tunnels (&(room->entries), door);
+}
+
+void
+close_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *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);
+}
diff --git a/src/messenger/messenger_api_handle.h b/src/messenger/messenger_api_handle.h
new file mode 100644
index 000000000..d6cde0106
--- /dev/null
+++ b/src/messenger/messenger_api_handle.h
@@ -0,0 +1,174 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 "platform.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_peer_lib.h"
+
+#include "gnunet_messenger_service.h"
+
+#include "messenger_api_contact.h"
+#include "messenger_api_room.h"
+
+struct GNUNET_MESSENGER_Handle
+{
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  struct GNUNET_MQ_Handle *mq;
+
+  GNUNET_MESSENGER_IdentityCallback identity_callback;
+  void *identity_cls;
+
+  GNUNET_MESSENGER_MessageCallback msg_callback;
+  void *msg_cls;
+
+  char *name;
+  struct GNUNET_IDENTITY_PublicKey *pubkey;
+
+  struct GNUNET_TIME_Relative reconnect_time;
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  struct GNUNET_CONTAINER_MultiHashMap *rooms;
+  struct GNUNET_CONTAINER_MultiHashMap *contacts;
+};
+
+/**
+ * Creates and allocates a new handle using a given configuration and a custom message callback
+ * with a given closure for the client API.
+ *
+ * @param cfg Configuration
+ * @param msg_callback Message callback
+ * @param msg_cls Closure
+ * @return New handle
+ */
+struct GNUNET_MESSENGER_Handle*
+create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_IdentityCallback identity_callback,
+               void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls);
+
+/**
+ * Destroys a <i>handle</i> and frees its memory fully from the client API.
+ *
+ * @param 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 handle Handle
+ * @param 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 handle Handle
+ * @return Name of the handle or NULL
+ */
+const char*
+get_handle_name (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Sets the public key of a given <i>handle</i> to a specific public key.
+ *
+ * @param handle Handle
+ * @param pubkey Public key
+ */
+void
+set_handle_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Returns the public key of a given <i>handle</i>.
+ *
+ * @param handle Handle
+ * @return Public key of the handle
+ */
+const struct GNUNET_IDENTITY_PublicKey*
+get_handle_key (const struct GNUNET_MESSENGER_Handle *handle);
+
+/**
+ * Returns a contact known to a <i>handle</i> identified by a given public key. If not matching
+ * contact is found, NULL gets returned.
+ *
+ * @param handle Handle
+ * @param pubkey Public key of EGO
+ * @return Contact or NULL
+ */
+struct GNUNET_MESSENGER_Contact*
+get_handle_contact_by_pubkey (const struct GNUNET_MESSENGER_Handle *handle,
+                              const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Changes the public key for a <i>contact</i> known to a <i>handle</i> to a specific public key and
+ * updates local map entries to access the contact by its updated key.
+ *
+ * @param handle Handle
+ * @param contact Contact
+ * @param pubkey Public key of EGO
+ */
+void
+swap_handle_contact_by_pubkey (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Contact *contact,
+                               const struct GNUNET_IDENTITY_PublicKey *pubkey);
+
+/**
+ * Marks a room known to a <i>handle</i> identified by a given <i>key</i> as open.
+ *
+ * @param handle Handle
+ * @param key Key of room
+ */
+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 handle Handle
+ * @param door Peer identity
+ * @param 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 handle Handle
+ * @param key Key of room
+ */
+void
+close_handle_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
+
+#endif //GNUNET_MESSENGER_API_HANDLE_H
diff --git a/src/messenger/messenger_api_list_tunnels.c b/src/messenger/messenger_api_list_tunnels.c
new file mode 100644
index 000000000..13d8c1906
--- /dev/null
+++ b/src/messenger/messenger_api_list_tunnels.c
@@ -0,0 +1,112 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 = tunnels->head)
+  {
+    GNUNET_CONTAINER_DLL_remove(tunnels->head, tunnels->tail, element);
+    GNUNET_PEER_change_rc (element->peer, -1);
+    GNUNET_free(element);
+  }
+
+  tunnels->head = NULL;
+  tunnels->tail = NULL;
+}
+
+static int
+compare_list_tunnels (void *cls, struct GNUNET_MESSENGER_ListTunnel *element0,
+                      struct GNUNET_MESSENGER_ListTunnel *element1)
+{
+  return ((int) element0->peer) - ((int) element1->peer);
+}
+
+void
+add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_MESSENGER_ListTunnel *element = GNUNET_new(struct GNUNET_MESSENGER_ListTunnel);
+
+  element->peer = GNUNET_PEER_intern (peer);
+
+  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)
+{
+  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;
+}
+
+int
+contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *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)
+{
+  struct GNUNET_MESSENGER_ListTunnel *next = element->next;
+
+  GNUNET_CONTAINER_DLL_remove(tunnels->head, tunnels->tail, element);
+  GNUNET_PEER_change_rc (element->peer, -1);
+  GNUNET_free(element);
+
+  return next;
+}
diff --git a/src/messenger/messenger_api_list_tunnels.h b/src/messenger/messenger_api_list_tunnels.h
new file mode 100644
index 000000000..0240fceb8
--- /dev/null
+++ b/src/messenger/messenger_api_list_tunnels.h
@@ -0,0 +1,112 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 "platform.h"
+#include "gnunet_peer_lib.h"
+#include "gnunet_container_lib.h"
+
+struct GNUNET_MESSENGER_ListTunnel
+{
+  struct GNUNET_MESSENGER_ListTunnel *prev;
+  struct GNUNET_MESSENGER_ListTunnel *next;
+
+  GNUNET_PEER_Id peer;
+};
+
+struct GNUNET_MESSENGER_ListTunnels
+{
+  struct GNUNET_MESSENGER_ListTunnel *head;
+  struct GNUNET_MESSENGER_ListTunnel *tail;
+};
+
+/**
+ * Initializes list of tunnels peer identities as empty list.
+ *
+ * @param tunnels List of peer identities
+ */
+void
+init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
+
+/**
+ * Clears the list of tunnels peer identities.
+ *
+ * @param tunnels List of peer identities
+ */
+void
+clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels);
+
+/**
+ * Adds a specific <i>peer</i> from a tunnel to the end of the list.
+ *
+ * @param tunnels List of peer identities
+ * @param peer Peer identity of tunnel
+ */
+void
+add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * 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 overriden 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 tunnels List of peer identities
+ * @param 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);
+
+/**
+ * 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 tunnels List of peer identities
+ * @param peer Peer identity of tunnel
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Removes a specific <i>element</i> from the list of tunnels peer identities and returns
+ * the next element in the list.
+ *
+ * @param tunnels List of peer identities
+ * @param element Element of the list
+ * @return Next element in the list
+ */
+struct GNUNET_MESSENGER_ListTunnel*
+remove_from_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element);
+
+#endif //GNUNET_MESSENGER_API_LIST_TUNNELS_H
diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c
new file mode 100644
index 000000000..fdab60eef
--- /dev/null
+++ b/src/messenger/messenger_api_message.c
@@ -0,0 +1,602 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_message.c
+ * @brief messenger api: client and service implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_MessageSignature
+{
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+  struct GNUNET_HashCode hash;
+};
+
+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.private.length = 0;
+    message->body.private.data = NULL;
+    break;
+  default:
+    break;
+  }
+
+  return message;
+}
+
+struct GNUNET_MESSENGER_Message*
+copy_message (const struct GNUNET_MESSENGER_Message *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 = GNUNET_strdup(message->body.name.name);
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    copy->body.text.text = GNUNET_strdup(message->body.text.text);
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    copy->body.file.uri = GNUNET_strdup(message->body.file.uri);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    copy->body.private.data = copy->body.private.length ? GNUNET_malloc(copy->body.private.length) : NULL;
+
+    if (copy->body.private.data)
+    {
+      GNUNET_memcpy(copy->body.private.data, message->body.private.data, copy->body.private.length);
+    }
+
+    break;
+  default:
+    break;
+  }
+
+  return copy;
+}
+
+static void
+destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, struct GNUNET_MESSENGER_MessageBody *body)
+{
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_NAME:
+    GNUNET_free(body->name.name);
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    GNUNET_free(body->text.text);
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    GNUNET_free(body->file.uri);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    GNUNET_free(body->private.data);
+    break;
+  default:
+    break;
+  }
+}
+
+void
+destroy_message (struct GNUNET_MESSENGER_Message *message)
+{
+  destroy_message_body (message->header.kind, &(message->body));
+
+  GNUNET_free(message);
+}
+
+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.host_key);
+    length += member_size(struct GNUNET_MESSENGER_Message, body.info.unique_id);
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    length += member_size(struct GNUNET_MESSENGER_Message, body.join.key);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    length += member_size(struct GNUNET_MESSENGER_Message, body.key.key);
+    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_TEXT:
+    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 += NAME_MAX;
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    length += member_size(struct GNUNET_MESSENGER_Message, body.private.key);
+    break;
+  default:
+    break;
+  }
+
+  return length;
+}
+
+uint16_t
+get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
+{
+  uint16_t length = 0;
+
+  length += member_size(struct GNUNET_MESSENGER_Message, header.signature);
+  length += member_size(struct GNUNET_MESSENGER_Message, header.timestamp);
+  length += member_size(struct GNUNET_MESSENGER_Message, header.sender_id);
+  length += member_size(struct GNUNET_MESSENGER_Message, header.previous);
+  length += member_size(struct GNUNET_MESSENGER_Message, header.kind);
+
+  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_NAME:
+    length += (body->name.name? strlen (body->name.name) : 0);
+    break;
+  case GNUNET_MESSENGER_KIND_TEXT:
+    length += strlen (body->text.text);
+    break;
+  case GNUNET_MESSENGER_KIND_FILE:
+    length += strlen (body->file.uri);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    length += body->private.length;
+    break;
+  default:
+    break;
+  }
+
+  return length;
+}
+
+uint16_t
+get_message_size (const struct GNUNET_MESSENGER_Message *message)
+{
+  return get_message_kind_size (message->header.kind) + get_message_body_size (message->header.kind, &(message->body));
+}
+
+static uint16_t
+get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message)
+{
+  if (message)
+    return sizeof(message->kind) + get_message_body_kind_size (message->kind)
+           + get_message_body_size (message->kind, &(message->body));
+  else
+    return sizeof(message->kind);
+}
+
+#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)
+
+static void
+encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody *body,
+                     uint16_t length, char *buffer, uint16_t offset)
+{
+  switch (kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    encode_step(buffer, offset, &(body->info.host_key));
+    encode_step(buffer, offset, &(body->info.unique_id));
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    encode_step(buffer, offset, &(body->join.key));
+    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(buffer, offset, &(body->key.key));
+    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:
+    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, NAME_MAX);
+    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->private.key));
+    encode_step_ext(buffer, offset, body->private.data, min(length - offset, body->private.length));
+    break;
+  default:
+    break;
+  }
+}
+
+void
+encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer)
+{
+  uint16_t offset = 0;
+
+  encode_step(buffer, offset, &(message->header.signature));
+  encode_step(buffer, offset, &(message->header.timestamp));
+  encode_step(buffer, offset, &(message->header.sender_id));
+  encode_step(buffer, offset, &(message->header.previous));
+  encode_step(buffer, offset, &(message->header.kind));
+
+  encode_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)
+{
+  uint16_t offset = 0;
+
+  encode_step(buffer, offset, &(message->kind));
+
+  encode_message_body (message->kind, &(message->body), length, buffer, offset);
+}
+
+#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)
+
+static void
+decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, struct GNUNET_MESSENGER_MessageBody *body,
+                     uint16_t length, const char *buffer, uint16_t offset)
+{
+  switch (*kind)
+  {
+  case GNUNET_MESSENGER_KIND_INFO:
+    decode_step(buffer, offset, &(body->info.host_key));
+    decode_step(buffer, offset, &(body->info.unique_id));
+    break;
+  case GNUNET_MESSENGER_KIND_JOIN:
+    decode_step(buffer, offset, &(body->join.key));
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    if (length - offset > 0)
+      decode_step_malloc(buffer, offset, body->name.name, length - offset, 1);
+    else
+      body->name.name = NULL;
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    decode_step(buffer, offset, &(body->key.key));
+    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:
+    decode_step_malloc(buffer, offset, body->text.text, length - offset, 1);
+    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, NAME_MAX);
+    decode_step_malloc(buffer, offset, body->file.uri, length - offset, 1);
+    break;
+  case GNUNET_MESSENGER_KIND_PRIVATE:
+    decode_step(buffer, offset, &(body->private.key));
+
+    body->private.length = (length - offset);
+    decode_step_malloc(buffer, offset, body->private.data, length - offset, 0);
+    break;
+  default:
+    *kind = GNUNET_MESSENGER_KIND_UNKNOWN;
+    break;
+  }
+}
+
+int
+decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer)
+{
+  uint16_t offset = 0;
+
+  if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN))
+    return GNUNET_NO;
+
+  decode_step(buffer, offset, &(message->header.signature));
+  decode_step(buffer, offset, &(message->header.timestamp));
+  decode_step(buffer, offset, &(message->header.sender_id));
+  decode_step(buffer, offset, &(message->header.previous));
+  decode_step(buffer, offset, &(message->header.kind));
+
+  if (length < get_message_kind_size (message->header.kind))
+    return GNUNET_NO;
+
+  decode_message_body (&(message->header.kind), &(message->body), length, buffer, offset);
+
+  return GNUNET_YES;
+}
+
+static int
+decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, uint16_t length, const char *buffer)
+{
+  uint16_t offset = 0;
+
+  if (length < get_short_message_size (NULL))
+    return GNUNET_NO;
+
+  decode_step(buffer, offset, &(message->kind));
+
+  if (length < get_short_message_size (message))
+    return GNUNET_NO;
+
+  decode_message_body (&(message->kind), &(message->body), length, buffer, offset);
+
+  return GNUNET_YES;
+}
+
+void
+hash_message (uint16_t length, const char *buffer, struct GNUNET_HashCode *hash)
+{
+  GNUNET_CRYPTO_hash (buffer + sizeof(struct GNUNET_CRYPTO_EcdsaSignature),
+                      length - sizeof(struct GNUNET_CRYPTO_EcdsaSignature), hash);
+}
+
+void
+sign_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
+              const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_Ego *ego)
+{
+  struct GNUNET_MESSENGER_MessageSignature signature;
+
+  signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
+  signature.purpose.size = htonl (sizeof(signature));
+
+  GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+
+  GNUNET_IDENTITY_sign(&(ego->priv), &signature, &(message->header.signature));
+  GNUNET_memcpy(buffer, &(message->header.signature), sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
+}
+
+int
+verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
+                const struct GNUNET_IDENTITY_PublicKey *key)
+{
+  struct GNUNET_MESSENGER_MessageSignature signature;
+
+  signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
+  signature.purpose.size = htonl (sizeof(signature));
+
+  GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+
+  return GNUNET_IDENTITY_signature_verify(GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
+                                          &(message->header.signature), key);
+}
+
+int
+encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PublicKey *key)
+{
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+
+  fold_short_message (message, &shortened);
+
+  const uint16_t length = get_short_message_size (&shortened);
+
+  message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
+  message->body.private.data = GNUNET_malloc(length);
+
+  encode_short_message (&shortened, length, message->body.private.data);
+
+  if (GNUNET_IDENTITY_encrypt (message->body.private.data, length, key, &(message->body.private.key),
+                               message->body.private.data)
+      == length)
+  {
+    destroy_message_body (shortened.kind, &(shortened.body));
+    return GNUNET_YES;
+  }
+  else
+  {
+    unfold_short_message (&shortened, message);
+    return GNUNET_NO;
+  }
+}
+
+int
+decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key)
+{
+  if (message->body.private.length != GNUNET_IDENTITY_decrypt (message->body.private.data,
+                                                               message->body.private.length, key,
+                                                               &(message->body.private.key),
+                                                               message->body.private.data))
+    return GNUNET_NO;
+
+  struct GNUNET_MESSENGER_ShortMessage shortened;
+
+  if (GNUNET_YES != decode_short_message (&shortened, message->body.private.length, message->body.private.data))
+    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 struct GNUNET_MESSENGER_Ego *ego, int mode)
+{
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packing message: %u\n", message->header.kind);
+
+  struct GNUNET_MessageHeader *header;
+
+  uint16_t length = get_message_size (message);
+
+  struct GNUNET_MQ_Envelope *env;
+  char *buffer;
+
+  if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
+  {
+    env = GNUNET_MQ_msg_extra(header, length, GNUNET_MESSAGE_TYPE_CADET_CLI);
+
+    buffer = (char*) &(header[1]);
+  }
+  else
+  {
+    env = NULL;
+
+    buffer = GNUNET_malloc(length);
+  }
+
+  encode_message (message, length, buffer);
+
+  if (hash)
+  {
+    hash_message (length, buffer, hash);
+
+    if (ego)
+      sign_message (message, length, buffer, hash, ego);
+  }
+
+  if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
+    GNUNET_free(buffer);
+
+  return env;
+}
diff --git a/src/messenger/messenger_api_message.h b/src/messenger/messenger_api_message.h
new file mode 100644
index 000000000..0f0a97e9c
--- /dev/null
+++ b/src/messenger/messenger_api_message.h
@@ -0,0 +1,190 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_mq_lib.h"
+#include "gnunet_signatures.h"
+
+#include "gnunet_messenger_service.h"
+
+#include "messenger_api_ego.h"
+
+/**
+ * Creates and allocates a new message with a specific <i>kind</i>.
+ *
+ * @param 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 message Message
+ * @return New message
+ */
+struct GNUNET_MESSENGER_Message*
+copy_message (const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Destroys a message and frees its memory fully.
+ *
+ * @param message Message
+ */
+void
+destroy_message (struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Returns the minimal size in bytes to encode a message of a specific <i>kind</i>.
+ *
+ * @param kind Kind of message
+ * @return Minimal size to encode
+ */
+uint16_t
+get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind);
+
+/**
+ * Returns the exact size in bytes to encode a given <i>message</i>.
+ *
+ * @param message Message
+ * @return Size to encode
+ */
+uint16_t
+get_message_size (const struct GNUNET_MESSENGER_Message *message);
+
+/**
+ * Encodes a given <i>message</i> into a <i>buffer</i> of a maximal <i>length</i> in bytes.
+ *
+ * @param message Message
+ * @param length Maximal length to encode
+ * @param[out] buffer Buffer
+ */
+void
+encode_message (const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer);
+
+/**
+ * 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 length Maximal length to decode
+ * @param buffer Buffer
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer);
+
+/**
+ * Calculates a <i>hash</i> of a given <i>buffer</i> of a <i>length</i> in bytes.
+ *
+ * @param length Length of buffer
+ * @param buffer Buffer
+ * @param[out] hash Hash
+ */
+void
+hash_message (uint16_t length, const char *buffer, struct GNUNET_HashCode *hash);
+
+/**
+ * Signs the <i>hash</i> of a <i>message</i> with a given <i>ego</i> and writes the signature
+ * into the <i>buffer</i> as well.
+ *
+ * @param[out] message Message
+ * @param length Length of buffer
+ * @param[out] buffer Buffer
+ * @param hash Hash of message
+ * @param ego EGO
+ */
+void
+sign_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer,
+              const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_Ego *ego);
+
+/**
+ * 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 message Message
+ * @param hash Hash of message
+ * @param key Public key of EGO
+ * @return GNUNET_OK on success, otherwise GNUNET_SYSERR
+ */
+int
+verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash,
+                const struct GNUNET_IDENTITY_PublicKey *key);
+
+/**
+ * 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 message Message
+ * @param key Public key of EGO
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PublicKey *key);
+
+/**
+ * Decrypts a private <i>message</i> using a given private <i>key</i> and replaces its body
+ * and kind with the inner encrypted message. The function returns GNUNET_YES if the
+ * operation succeeded, otherwise GNUNET_NO.
+ *
+ * @param message Message
+ * @param key Private key of EGO
+ * @return GNUNET_YES on success, otherwise GNUNET_NO
+ */
+int
+decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key);
+
+#define GNUNET_MESSENGER_PACK_MODE_ENVELOPE 0x1
+#define 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>ego</i> is
+ * not NULL.
+ *
+ * @param[out] message Message
+ * @param[out] hash Hash of message
+ * @param ego EGO to sign
+ * @param mode Mode of packing
+ * @return Envelope or NULL
+ */
+struct GNUNET_MQ_Envelope*
+pack_message (struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash,
+              const struct GNUNET_MESSENGER_Ego *ego, int mode);
+
+#endif //GNUNET_MESSENGER_API_MESSAGE_H
diff --git a/src/messenger/messenger_api_room.c b/src/messenger/messenger_api_room.c
new file mode 100644
index 000000000..5fedf1a78
--- /dev/null
+++ b/src/messenger/messenger_api_room.c
@@ -0,0 +1,189 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/messenger_api_room.c
+ * @brief messenger api: client implementation of GNUnet MESSENGER service
+ */
+
+#include "messenger_api_room.h"
+
+#include "messenger_api_handle.h"
+
+struct GNUNET_MESSENGER_Room*
+create_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_MESSENGER_Room *room = GNUNET_new(struct GNUNET_MESSENGER_Room);
+
+  room->handle = handle;
+  GNUNET_memcpy(&(room->key), key, sizeof(*key));
+
+  room->opened = GNUNET_NO;
+  room->contact_id = NULL;
+
+  room->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
+
+  init_list_tunnels (&(room->entries));
+
+  room->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+
+  return room;
+}
+
+static int
+iterate_destroy_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_Message *message = value;
+
+  destroy_message (message);
+
+  return GNUNET_YES;
+}
+
+void
+destroy_room (struct GNUNET_MESSENGER_Room *room)
+{
+  if (room->members)
+    GNUNET_CONTAINER_multishortmap_destroy (room->members);
+
+  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->contact_id)
+    GNUNET_free(room->contact_id);
+
+  GNUNET_free(room);
+}
+
+const struct GNUNET_MESSENGER_Message*
+get_room_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
+{
+  return GNUNET_CONTAINER_multihashmap_get (room->messages, hash);
+}
+
+static void
+handle_join_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Contact *contact = get_handle_contact_by_pubkey (room->handle, &(message->body.join.key));
+
+  if (contact)
+    GNUNET_CONTAINER_multishortmap_put (room->members, &(message->header.sender_id), contact,
+                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+}
+
+static void
+handle_leave_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                      const struct GNUNET_HashCode *hash)
+{
+  GNUNET_CONTAINER_multishortmap_remove_all (room->members, &(message->header.sender_id));
+}
+
+static void
+handle_name_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
+                                                                                 &(message->header.sender_id));
+
+  if (contact)
+    set_contact_name (contact, message->body.name.name);
+}
+
+static void
+handle_key_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                    const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
+                                                                                 &(message->header.sender_id));
+
+  if (contact)
+    swap_handle_contact_by_pubkey (room->handle, contact, &(message->body.key.key));
+}
+
+static void
+handle_id_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                   const struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multishortmap_get (room->members,
+                                                                                 &(message->header.sender_id));
+
+  if ((contact) && (GNUNET_OK
+      == GNUNET_CONTAINER_multishortmap_put (room->members, &(message->body.id.id), contact,
+                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+    GNUNET_CONTAINER_multishortmap_remove (room->members, &(message->header.sender_id), contact);
+}
+
+static void
+handle_miss_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  if ((room->contact_id) && (0 == GNUNET_memcmp(&(message->header.sender_id), room->contact_id)))
+  {
+    struct GNUNET_MESSENGER_ListTunnel *match = find_list_tunnels (&(room->entries), &(message->body.miss.peer), NULL);
+
+    if (match)
+      remove_from_list_tunnels (&(room->entries), match);
+  }
+}
+
+void
+handle_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash)
+{
+  if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->messages, hash))
+    return;
+
+  switch (message->header.kind)
+  {
+  case GNUNET_MESSENGER_KIND_JOIN:
+    handle_join_message (room, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_LEAVE:
+    handle_leave_message (room, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_NAME:
+    handle_name_message (room, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_KEY:
+    handle_key_message (room, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_ID:
+    handle_id_message (room, message, hash);
+    break;
+  case GNUNET_MESSENGER_KIND_MISS:
+    handle_miss_message (room, message, hash);
+    break;
+  default:
+    break;
+  }
+
+  struct GNUNET_MESSENGER_Message *clone = copy_message (message);
+
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash, clone,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    destroy_message (clone);
+}
diff --git a/src/messenger/messenger_api_room.h b/src/messenger/messenger_api_room.h
new file mode 100644
index 000000000..0038128d8
--- /dev/null
+++ b/src/messenger/messenger_api_room.h
@@ -0,0 +1,95 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/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 "platform.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+
+#include "gnunet_messenger_service.h"
+
+#include "messenger_api_list_tunnels.h"
+#include "messenger_api_contact.h"
+#include "messenger_api_message.h"
+
+struct GNUNET_MESSENGER_Room
+{
+  struct GNUNET_MESSENGER_Handle *handle;
+  struct GNUNET_HashCode key;
+
+  int opened;
+
+  struct GNUNET_ShortHashCode *contact_id;
+
+  struct GNUNET_CONTAINER_MultiShortmap *members;
+  struct GNUNET_MESSENGER_ListTunnels entries;
+
+  struct GNUNET_CONTAINER_MultiHashMap *messages;
+};
+
+/**
+ * Creates and allocates a new room for a <i>handle</i> with a given <i>key</i> for the client API.
+ *
+ * @param handle Handle
+ * @param key Key of room
+ * @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 room Room
+ */
+void
+destroy_room (struct GNUNET_MESSENGER_Room *room);
+
+/**
+ * Returns a message locally stored from a map for a given <i>hash</i> in a <i>room</i>. If no matching
+ * message is found, NULL gets returned.
+ *
+ * @param room Room
+ * @param hash Hash of message
+ * @return Message or NULL
+ */
+const struct GNUNET_MESSENGER_Message*
+get_room_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
+
+/**
+ * Handles a <i>message</i> with a given <i>hash</i> in a <i>room</i> for the client API to update
+ * members and its information. The function also stores the message in map locally for access afterwards.
+ *
+ * @param room Room
+ * @param message Message
+ * @param hash Hash of message
+ */
+void
+handle_room_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+                     const struct GNUNET_HashCode *hash);
+
+#endif //GNUNET_MESSENGER_API_ROOM_H
diff --git a/src/messenger/test_messenger.c b/src/messenger/test_messenger.c
new file mode 100644
index 000000000..b42dfe6d9
--- /dev/null
+++ b/src/messenger/test_messenger.c
@@ -0,0 +1,187 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+#include <stdio.h>
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_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;
+
+struct GNUNET_MESSENGER_Handle *messenger = NULL;
+
+static void
+end (void *cls)
+{
+  die_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;
+}
+
+static int identity_counter = 0;
+
+/**
+ * Function called when an identity is retrieved.
+ *
+ * @param cls Closure
+ * @param handle Handle of messenger service
+ */
+static void
+on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
+{
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  const char* name = GNUNET_MESSENGER_get_name(handle);
+
+  if (0 != strcmp(name, TESTER_NAME))
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "name");
+    return;
+  }
+
+  struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous();
+  struct GNUNET_IDENTITY_PublicKey anonymous_key;
+
+  GNUNET_IDENTITY_ego_get_public_key(ego, &anonymous_key);
+
+  const struct GNUNET_IDENTITY_PublicKey* key = GNUNET_MESSENGER_get_key(handle);
+
+  if (((!identity_counter) && (0 != GNUNET_memcmp(key, (&anonymous_key)))) ||
+      ((identity_counter) && (0 == GNUNET_memcmp(key, (&anonymous_key)))))
+  {
+    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_update(messenger);
+  identity_counter++;
+}
+
+/**
+ * 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, &on_identity, NULL, NULL, NULL);
+}
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main(int argc, char **argv)
+{
+  if (0 != GNUNET_TESTING_peer_run("test-messenger",
+                                   "test_messenger_api.conf",
+                                   &run, NULL))
+    return 1;
+
+  return status;
+}
diff --git a/src/messenger/test_messenger_anonymous.c b/src/messenger/test_messenger_anonymous.c
new file mode 100644
index 000000000..e2057acc4
--- /dev/null
+++ b/src/messenger/test_messenger_anonymous.c
@@ -0,0 +1,179 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_anonymous.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+#include <stdio.h>
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_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;
+
+struct GNUNET_MESSENGER_Handle *messenger = NULL;
+
+static void
+end (void *cls)
+{
+  die_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_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
+{
+  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;
+  }
+
+  if (GNUNET_SYSERR != GNUNET_MESSENGER_update(handle))
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "update-fail");
+    return;
+  }
+
+  struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous();
+  struct GNUNET_IDENTITY_PublicKey anonymous_key;
+
+  GNUNET_IDENTITY_ego_get_public_key(ego, &anonymous_key);
+
+  const struct GNUNET_IDENTITY_PublicKey* key = GNUNET_MESSENGER_get_key(handle);
+
+  if (0 != GNUNET_memcmp(key, (&anonymous_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, &on_identity, NULL, NULL, NULL);
+}
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main(int argc, char **argv)
+{
+  if (0 != GNUNET_TESTING_peer_run("test-messenger",
+                                   "test_messenger_api.conf",
+                                   &run, NULL))
+    return 1;
+
+  return status;
+}
diff --git a/src/messenger/test_messenger_comm0.c b/src/messenger/test_messenger_comm0.c
new file mode 100644
index 000000000..631b5b2c9
--- /dev/null
+++ b/src/messenger/test_messenger_comm0.c
@@ -0,0 +1,252 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2020 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file messenger/test_messenger_comm0.c
+ * @author Tobias Frisch
+ * @brief Test for the messenger service using cadet API.
+ */
+#include <stdio.h>
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testbed_logger_service.h"
+#include "gnunet_testbed_service.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_messenger_service.h"
+
+/**
+ * How long until we really give up on a particular testcase portion?
+ */
+#define TOTAL_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                     60)
+
+/**
+ * How long until we give up on any particular operation (and retry)?
+ */
+#define BASE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+
+static int status = 1;
+
+static struct GNUNET_SCHEDULER_Task *die_task = NULL;
+static struct GNUNET_SCHEDULER_Task *op_task = NULL;
+
+static void
+end (void *cls)
+{
+  die_task = NULL;
+
+  if (op_task)
+  {
+    GNUNET_SCHEDULER_cancel (op_task);
+    op_task = NULL;
+  }
+
+  GNUNET_SCHEDULER_shutdown ();
+  status = 0;
+}
+
+
+static void
+end_badly (void *cls)
+{
+  fprintf (stderr, "Testcase failed (timeout).\n");
+
+  end (NULL);
+  status = 1;
+}
+
+static void
+end_operation (void *cls)
+{
+  op_task = NULL;
+
+  fprintf (stderr, "Testcase failed (operation: '%s').\n", cls? (const char*) cls : "unknown");
+
+  if (die_task)
+    GNUNET_SCHEDULER_cancel (die_task);
+
+  end (NULL);
+  status = 1;
+}
+
+static void
+end_error (void *cls)
+{
+  op_task = NULL;
+
+  fprintf (stderr, "Testcase failed (error: '%s').\n", cls? (const char*) cls : "unknown");
+  GNUNET_free(cls);
+
+  if (die_task)
+    GNUNET_SCHEDULER_cancel (die_task);
+
+  end (NULL);
+  status = 1;
+}
+
+/**
+ * Function called whenever a message is received or sent.
+ *
+ * @param cls Closure
+ * @param room Room
+ * @param message Message
+ * @param hash Hash of message
+ */
+static void
+on_message (void *cls, const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
+            const struct GNUNET_HashCode *hash)
+{
+  // TODO
+}
+
+/**
+ * Function called when an identity is retrieved.
+ *
+ * @param cls Closure
+ * @param handle Handle of messenger service
+ */
+static void
+on_identity (void *cls, struct GNUNET_MESSENGER_Handle *handle)
+{
+  // TODO
+}
+
+static void
+on_peer (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
+         const struct GNUNET_TESTBED_PeerInformation *pinfo,
+         const char *emsg)
+{
+  if (emsg)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_error, GNUNET_strdup(emsg));
+    return;
+  }
+
+  if (pinfo->pit != GNUNET_TESTBED_PIT_CONFIGURATION)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "config");
+    return;
+  }
+
+  struct GNUNET_MESSENGER_Handle *handle;
+  struct GNUNET_MESSENGER_Room *room;
+
+  fprintf (stderr, "MSG: connect\n");
+
+  handle = GNUNET_MESSENGER_connect(pinfo->result.cfg, "tester", &on_identity, NULL, &on_message, NULL);
+
+  struct GNUNET_HashCode hash;
+  GNUNET_CRYPTO_hash("test", 4, &hash);
+
+  fprintf (stderr, "MSG: open\n");
+
+  room = GNUNET_MESSENGER_open_room(handle, &hash);
+
+  fprintf (stderr, "MSG: close\n");
+
+  GNUNET_MESSENGER_close_room(room);
+
+  fprintf (stderr, "MSG: disconnect\n");
+
+  GNUNET_MESSENGER_disconnect(handle);
+
+  GNUNET_TESTBED_operation_done(op);
+
+}
+
+/**
+ * Main function for a peer of the testcase.
+ *
+ * @param cls Closure
+ * @param event Information about the event
+ */
+static void
+run (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
+{
+  if (GNUNET_TESTBED_ET_PEER_START != event->type)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "start");
+    return;
+  }
+
+  GNUNET_TESTBED_peer_get_information(event->details.peer_start.peer,
+                                      GNUNET_TESTBED_PIT_CONFIGURATION,
+                                      on_peer, event->details.peer_start.peer);
+
+  fprintf (stderr, "MSG: barrier\n");
+
+  GNUNET_TESTBED_barrier_wait("exit", NULL, NULL);
+
+  fprintf (stderr, "MSG: exit\n");
+}
+
+static void
+exit_status (void *cls, const char *name,
+             struct GNUNET_TESTBED_Barrier *barrier,
+             enum GNUNET_TESTBED_BarrierStatus status,
+             const char *emsg)
+{
+  if (emsg)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_error, GNUNET_strdup(emsg));
+    return;
+  }
+
+  if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status)
+  {
+    op_task = GNUNET_SCHEDULER_add_now (&end_operation, "exit");
+    return;
+  }
+  else if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED == status)
+    GNUNET_SCHEDULER_add_now(&end, NULL);
+}
+
+static void
+init (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers,
+      struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded,
+      unsigned int links_failed)
+{
+  die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT, &end_badly, NULL);
+
+  struct GNUNET_TESTBED_Controller *controller;
+
+  controller = GNUNET_TESTBED_run_get_controller_handle(h);
+
+  GNUNET_TESTBED_barrier_init(controller, "exit", num_peers, exit_status, NULL);
+}
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main(int argc, char **argv)
+{
+  if (GNUNET_OK != GNUNET_TESTBED_test_run("test-messenger-comm0",
+                                           "test_messenger_api.conf",
+                                           2, 0,
+                                           &run, NULL,
+                                           &init, NULL))
+    return 1;
+
+  return status;
+}