Merge branch 'master' of ssh://git.gnunet.org/gnunet

15 files changed, 426 insertions, 122 deletions

diff --git a/src/curl/curl.c b/src/curl/curl.c
index 71672c780..30c2f8c01 100644
--- a/src/curl/curl.c
+++ b/src/curl/curl.c
@@ -368,7 +368,8 @@ download_cb (char *bufptr,
     db->eno = ENOMEM;
     return 0;   /* signals an error to curl */
   }
-  db->buf = GNUNET_realloc (db->buf, db->buf_size + msize);
+  db->buf = GNUNET_realloc (db->buf,
+                            db->buf_size + msize);
   buf = db->buf + db->buf_size;
   GNUNET_memcpy (buf, bufptr, msize);
   db->buf_size += msize;
@@ -421,7 +422,8 @@ setup_job_headers (struct GNUNET_CURL_Context *ctx,
           &scope.scope_id,
           sizeof(struct GNUNET_AsyncScopeId));
       GNUNET_assert (NULL != aid_header);
-      GNUNET_assert (NULL != curl_slist_append (all_headers, aid_header));
+      GNUNET_assert (NULL != curl_slist_append (all_headers,
+                                                aid_header));
       GNUNET_free (aid_header);
     }
   }
@@ -455,12 +457,25 @@ setup_job (CURL *eh,
   job = GNUNET_new (struct GNUNET_CURL_Job);
   job->job_headers = all_headers;
 
-  if ((CURLE_OK != curl_easy_setopt (eh, CURLOPT_PRIVATE, job)) ||
-      (CURLE_OK !=
-       curl_easy_setopt (eh, CURLOPT_WRITEFUNCTION, &download_cb)) ||
-      (CURLE_OK != curl_easy_setopt (eh, CURLOPT_WRITEDATA, &job->db)) ||
-      (CURLE_OK != curl_easy_setopt (eh, CURLOPT_SHARE, ctx->share)) ||
-      (CURLM_OK != curl_multi_add_handle (ctx->multi, eh)))
+  if ( (CURLE_OK !=
+        curl_easy_setopt (eh,
+                          CURLOPT_PRIVATE,
+                          job)) ||
+       (CURLE_OK !=
+        curl_easy_setopt (eh,
+                          CURLOPT_WRITEFUNCTION,
+                          &download_cb)) ||
+       (CURLE_OK !=
+        curl_easy_setopt (eh,
+                          CURLOPT_WRITEDATA,
+                          &job->db)) ||
+       (CURLE_OK !=
+        curl_easy_setopt (eh,
+                          CURLOPT_SHARE,
+                          ctx->share)) ||
+       (CURLM_OK !=
+        curl_multi_add_handle (ctx->multi,
+                               eh)) )
   {
     GNUNET_break (0);
     GNUNET_free (job);
@@ -683,9 +698,12 @@ GNUNET_CURL_job_cancel (struct GNUNET_CURL_Job *job)
 {
   struct GNUNET_CURL_Context *ctx = job->ctx;
 
-  GNUNET_CONTAINER_DLL_remove (ctx->jobs_head, ctx->jobs_tail, job);
+  GNUNET_CONTAINER_DLL_remove (ctx->jobs_head,
+                               ctx->jobs_tail,
+                               job);
   GNUNET_break (CURLM_OK ==
-                curl_multi_remove_handle (ctx->multi, job->easy_handle));
+                curl_multi_remove_handle (ctx->multi,
+                                          job->easy_handle));
   curl_easy_cleanup (job->easy_handle);
   GNUNET_free (job->db.buf);
   curl_slist_free_all (job->job_headers);
@@ -831,7 +849,8 @@ enum GNUNET_GenericReturnValue
 GNUNET_CURL_append_header (struct GNUNET_CURL_Context *ctx,
                            const char *header)
 {
-  ctx->common_headers = curl_slist_append (ctx->common_headers, header);
+  ctx->common_headers = curl_slist_append (ctx->common_headers,
+                                           header);
   if (NULL == ctx->common_headers)
     return GNUNET_SYSERR;
 
@@ -854,40 +873,46 @@ do_benchmark (CURLMsg *cmsg)
   uint64_t bytes_sent = 0;
   uint64_t bytes_received = 0;
 
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_TOTAL_TIME,
-                                               &total_as_double));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_TOTAL_TIME,
+                                   &total_as_double));
   total.rel_value_us = total_as_double * 1000 * 1000;
 
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_EFFECTIVE_URL,
-                                               &url));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_EFFECTIVE_URL,
+                                   &url));
 
   /* HEADER_SIZE + SIZE_DOWNLOAD_T is hopefully the total
      number of bytes received, not clear from curl docs. */
 
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_HEADER_SIZE,
-                                               &size_long));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_HEADER_SIZE,
+                                   &size_long));
   bytes_received += size_long;
 
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_SIZE_DOWNLOAD_T,
-                                               &size_curl));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_SIZE_DOWNLOAD_T,
+                                   &size_curl));
   bytes_received += size_curl;
 
   /* REQUEST_SIZE + SIZE_UPLOAD_T is hopefully the total number of bytes
      sent, again docs are not completely clear. */
 
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_REQUEST_SIZE,
-                                               &size_long));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_REQUEST_SIZE,
+                                   &size_long));
   bytes_sent += size_long;
 
   /* We obtain this value to check an invariant, but never use it otherwise. */
-  GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                               CURLINFO_SIZE_UPLOAD_T,
-                                               &size_curl));
+  GNUNET_break (CURLE_OK ==
+                curl_easy_getinfo (cmsg->easy_handle,
+                                   CURLINFO_SIZE_UPLOAD_T,
+                                   &size_curl));
 
   /* CURLINFO_SIZE_UPLOAD_T <= CURLINFO_REQUEST_SIZE should
      be an invariant.
@@ -900,8 +925,10 @@ do_benchmark (CURLMsg *cmsg)
 
   urd = get_url_benchmark_data (url, (unsigned int) response_code);
   urd->count++;
-  urd->time = GNUNET_TIME_relative_add (urd->time, total);
-  urd->time_max = GNUNET_TIME_relative_max (total, urd->time_max);
+  urd->time = GNUNET_TIME_relative_add (urd->time,
+                                        total);
+  urd->time_max = GNUNET_TIME_relative_max (total,
+                                            urd->time_max);
   urd->bytes_sent += bytes_sent;
   urd->bytes_received += bytes_received;
 }
@@ -929,7 +956,8 @@ GNUNET_CURL_perform2 (struct GNUNET_CURL_Context *ctx,
 
   (void) curl_multi_perform (ctx->multi,
                              &n_running);
-  while (NULL != (cmsg = curl_multi_info_read (ctx->multi, &n_completed)))
+  while (NULL != (cmsg = curl_multi_info_read (ctx->multi,
+                                               &n_completed)))
   {
     struct GNUNET_CURL_Job *job;
     long response_code;
@@ -937,9 +965,10 @@ GNUNET_CURL_perform2 (struct GNUNET_CURL_Context *ctx,
 
     /* Only documented return value is CURLMSG_DONE */
     GNUNET_break (CURLMSG_DONE == cmsg->msg);
-    GNUNET_assert (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
-                                                  CURLINFO_PRIVATE,
-                                                  (char **) &job));
+    GNUNET_assert (CURLE_OK ==
+                   curl_easy_getinfo (cmsg->easy_handle,
+                                      CURLINFO_PRIVATE,
+                                      (char **) &job));
     GNUNET_assert (job->ctx == ctx);
     response_code = 0;
     if (NULL != job->jcc_raw)
@@ -1027,14 +1056,17 @@ GNUNET_CURL_get_select_info (struct GNUNET_CURL_Context *ctx,
   int m;
 
   m = -1;
-  GNUNET_assert (CURLM_OK == curl_multi_fdset (ctx->multi,
-                                               read_fd_set,
-                                               write_fd_set,
-                                               except_fd_set,
-                                               &m));
+  GNUNET_assert (CURLM_OK ==
+                 curl_multi_fdset (ctx->multi,
+                                   read_fd_set,
+                                   write_fd_set,
+                                   except_fd_set,
+                                   &m));
   to = *timeout;
   *max_fd = GNUNET_MAX (m, *max_fd);
-  GNUNET_assert (CURLM_OK == curl_multi_timeout (ctx->multi, &to));
+  GNUNET_assert (CURLM_OK ==
+                 curl_multi_timeout (ctx->multi,
+                                     &to));
 
   /* Only if what we got back from curl is smaller than what we
      already had (-1 == infinity!), then update timeout */
@@ -1079,7 +1111,9 @@ GNUNET_CURL_constructor__ (void)
 
   if (CURLE_OK != (ret = curl_global_init (CURL_GLOBAL_DEFAULT)))
   {
-    CURL_STRERROR (GNUNET_ERROR_TYPE_ERROR, "curl_global_init", ret);
+    CURL_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+                   "curl_global_init",
+                   ret);
     curl_fail = 1;
   }
 }
diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c
index 22371f91a..08a975e65 100644
--- a/src/identity/identity_api.c
+++ b/src/identity/identity_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2013, 2016 GNUnet e.V.
+     Copyright (C) 2013, 2016, 2021 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -1020,7 +1020,9 @@ GNUNET_IDENTITY_write_key_to_buffer (const struct
     return -1;
   if (length < 0)
     return -2;
-  GNUNET_memcpy (buffer, key, length);
+  GNUNET_memcpy (buffer, &(key->type), sizeof (key->type));
+  GNUNET_memcpy (buffer + sizeof (key->type), &(key->ecdsa_key), length
+                 - sizeof (key->type));
   return length;
 }
 
diff --git a/src/include/gnu_name_system_record_types.h b/src/include/gnu_name_system_record_types.h
index b2cf45dc8..22b2c472e 100644
--- a/src/include/gnu_name_system_record_types.h
+++ b/src/include/gnu_name_system_record_types.h
@@ -127,6 +127,16 @@ extern "C" {
  */
 #define GNUNET_GNSRECORD_TYPE_EDKEY 65556
 
+/**
+ * Encoding for Robust Immutable Storage (ERIS) binary read capability
+ */
+#define GNUNET_GNSRECORD_TYPE_ERIS_READ_CAPABILITY 65557
+
+/**
+ * Record type to share an entry of a messenger room
+ */
+#define GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY 65558
+
 
 #if 0 /* keep Emacsens' auto-indent happy */
 {
diff --git a/src/include/gnunet_messenger_service.h b/src/include/gnunet_messenger_service.h
index b54567aa7..96d48b411 100644
--- a/src/include/gnunet_messenger_service.h
+++ b/src/include/gnunet_messenger_service.h
@@ -75,6 +75,27 @@ struct GNUNET_MESSENGER_Room;
  */
 struct GNUNET_MESSENGER_Contact;
 
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * A room entry record specifies which peer is hosting a given room and
+ * may also specify the key to enter it.
+ */
+struct GNUNET_MESSENGER_RoomEntryRecord
+{
+  /**
+   * The peer identity of an open door to a room.
+   */
+  struct GNUNET_PeerIdentity door;
+
+  /**
+   * The hash identifying the port of the room.
+   */
+  struct GNUNET_HashCode key;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
 /**
  * Enum for the different supported kinds of messages
  */
diff --git a/src/include/gnunet_network_lib.h b/src/include/gnunet_network_lib.h
index 97ab64add..ff1e853f5 100644
--- a/src/include/gnunet_network_lib.h
+++ b/src/include/gnunet_network_lib.h
@@ -78,7 +78,7 @@ struct GNUNET_NETWORK_FDSet
  * @param pf protocol family to test (PF_INET, PF_INET6, PF_UNIX)
  * @return #GNUNET_OK if the PF is supported
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_test_pf (int pf);
 
 
@@ -154,7 +154,7 @@ GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,
  * @param address_len length of @a address
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
                             const struct sockaddr *address,
                             socklen_t address_len);
@@ -165,7 +165,7 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
  * @param desc socket to close
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc);
 
 
@@ -186,7 +186,7 @@ GNUNET_NETWORK_socket_free_memory_only_ (struct GNUNET_NETWORK_Handle *desc);
  * @param address_len of @a address
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
                                const struct sockaddr *address,
                                socklen_t address_len);
@@ -202,7 +202,7 @@ GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
  * @param optlen length of optval
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
                                   int level,
                                   int optname,
@@ -217,7 +217,7 @@ GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
  * @param backlog length of the listen queue
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
                               int backlog);
 
@@ -339,7 +339,7 @@ GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
  * @param how type of shutdown
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
                                 int how);
 
@@ -353,7 +353,7 @@ GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
  * @param desc socket
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_disable_corking (struct GNUNET_NETWORK_Handle *desc);
 
 
diff --git a/src/messenger/Makefile.am b/src/messenger/Makefile.am
index 3fc532e7e..4be11f3aa 100644
--- a/src/messenger/Makefile.am
+++ b/src/messenger/Makefile.am
@@ -10,6 +10,19 @@ pkgcfgdir= $(pkgdatadir)/config.d/
 
 libexecdir= $(pkglibdir)/libexec/
 
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_gnsrecord_messenger.la
+
+
+libgnunet_plugin_gnsrecord_messenger_la_SOURCES = \
+  plugin_gnsrecord_messenger.c
+libgnunet_plugin_gnsrecord_messenger_la_LIBADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_gnsrecord_messenger_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
 pkgcfg_DATA = \
   messenger.conf
 
diff --git a/src/messenger/gnunet-service-messenger.c b/src/messenger/gnunet-service-messenger.c
index 989157ceb..a994e16ee 100644
--- a/src/messenger/gnunet-service-messenger.c
+++ b/src/messenger/gnunet-service-messenger.c
@@ -227,10 +227,10 @@ check_for_message:
   if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer, GNUNET_NO, NULL))
     return GNUNET_NO;
 
-  if (GNUNET_YES != filter_message_sending(&message))
-    return GNUNET_NO;
+  const int allowed = filter_message_sending(&message);
 
-  return GNUNET_OK;
+  cleanup_message(&message);
+  return GNUNET_YES == allowed? GNUNET_OK : GNUNET_NO;
 }
 
 static void
@@ -278,6 +278,8 @@ handle_send_message (void *cls,
                GNUNET_MESSENGER_name_of_kind (message.header.kind), GNUNET_h2s (key));
 
 end_handling:
+  cleanup_message(&message);
+
   GNUNET_SERVICE_client_continue (msg_client->client);
 }
 
diff --git a/src/messenger/gnunet-service-messenger_tunnel.c b/src/messenger/gnunet-service-messenger_tunnel.c
index fdd6429e6..c21f298b3 100644
--- a/src/messenger/gnunet-service-messenger_tunnel.c
+++ b/src/messenger/gnunet-service-messenger_tunnel.c
@@ -176,6 +176,9 @@ handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
 {
   struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
+  if (!tunnel)
+    return;
+
   const uint16_t length = ntohs (header->size) - sizeof(*header);
   const char *buffer = (const char*) &header[1];
 
@@ -190,9 +193,6 @@ handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
              GNUNET_MESSENGER_name_of_kind(message.header.kind));
 
-  if (!tunnel)
-    return;
-
   const int new_message = update_room_message (
       tunnel->room, copy_message (&message), &hash
   );
@@ -226,6 +226,8 @@ handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
   }
 
 receive_done:
+  cleanup_message(&message);
+
   GNUNET_CADET_receive_done (tunnel->channel);
 }
 
diff --git a/src/messenger/messenger.conf.in b/src/messenger/messenger.conf.in
index 59e11b166..6b54550ea 100644
--- a/src/messenger/messenger.conf.in
+++ b/src/messenger/messenger.conf.in
@@ -1,5 +1,6 @@
 [messenger]
 START_ON_DEMAND = YES
+RUN_PER_USER = YES
 PORT = 2097
 HOSTNAME = localhost
 BINARY = gnunet-service-messenger
diff --git a/src/messenger/messenger_api.c b/src/messenger/messenger_api.c
index ef6244e19..81a02e858 100644
--- a/src/messenger/messenger_api.c
+++ b/src/messenger/messenger_api.c
@@ -214,6 +214,7 @@ check_recv_message (void *cls,
   if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
     return GNUNET_NO;
 
+  cleanup_message(&message);
   return GNUNET_OK;
 }
 
@@ -254,11 +255,15 @@ handle_recv_message (void *cls,
 
     handle_room_message (room, contact, &message, hash);
 
+    const struct GNUNET_MESSENGER_Message *stored_message = get_room_message(room, hash);
+
     if (handle->msg_callback)
-      handle->msg_callback (handle->msg_cls, room, contact, &message, hash, flags);
+      handle->msg_callback (handle->msg_cls, room, contact, stored_message, hash, flags);
   }
   else
     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Room not found\n");
+
+  cleanup_message(&message);
 }
 
 static void
diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c
index 05bf654fb..4e64cc22f 100644
--- a/src/messenger/messenger_api_message.c
+++ b/src/messenger/messenger_api_message.c
@@ -126,6 +126,14 @@ destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind,
 }
 
 void
+cleanup_message (struct GNUNET_MESSENGER_Message *message)
+{
+  GNUNET_assert(message);
+
+  destroy_message_body (message->header.kind, &(message->body));
+}
+
+void
 destroy_message (struct GNUNET_MESSENGER_Message *message)
 {
   GNUNET_assert(message);
diff --git a/src/messenger/messenger_api_message.h b/src/messenger/messenger_api_message.h
index 6aebf4014..21161c134 100644
--- a/src/messenger/messenger_api_message.h
+++ b/src/messenger/messenger_api_message.h
@@ -62,6 +62,14 @@ struct GNUNET_MESSENGER_Message*
 copy_message (const struct GNUNET_MESSENGER_Message *message);
 
 /**
+ * Frees the messages body memory.
+ *
+ * @param[in/out] message Message
+ */
+void
+cleanup_message (struct GNUNET_MESSENGER_Message *message);
+
+/**
  * Destroys a message and frees its memory fully.
  *
  * @param[in/out] message Message
diff --git a/src/messenger/plugin_gnsrecord_messenger.c b/src/messenger/plugin_gnsrecord_messenger.c
new file mode 100644
index 000000000..2219f0bde
--- /dev/null
+++ b/src/messenger/plugin_gnsrecord_messenger.c
@@ -0,0 +1,243 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+   SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @author Tobias Frisch
+ * @file src/messenger/plugin_gnsrecord_messenger.c
+ * @brief Plugin to provide the API for useful GNS records to improve
+ *        the usability of the messenger service.
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_messenger_service.h"
+#include "gnunet_gnsrecord_plugin.h"
+
+
+/**
+ * Convert the 'value' of a record to a string.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param data value in binary encoding
+ * @param data_size number of bytes in @a data
+ * @return NULL on error, otherwise human-readable representation of the value
+ */
+static char *
+messenger_value_to_string (void *cls,
+                           uint32_t type,
+                           const void *data,
+                           size_t data_size)
+{
+  (void) cls;
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY:
+    {
+      if (data_size != sizeof(struct GNUNET_MESSENGER_RoomEntryRecord))
+      {
+        GNUNET_break_op (0);
+        return NULL;
+      }
+
+      const struct GNUNET_MESSENGER_RoomEntryRecord *record = data;
+
+      char *door = GNUNET_CRYPTO_eddsa_public_key_to_string (&(record->door.public_key));
+      char *key = GNUNET_STRINGS_data_to_string_alloc (&(record->key), sizeof(struct GNUNET_HashCode));
+
+      char *ret;
+      GNUNET_asprintf (&ret, "%s-%s", door, key);
+      GNUNET_free (key);
+      GNUNET_free (door);
+      return ret;
+    }
+
+  default:
+    return NULL;
+  }
+}
+
+
+/**
+ * Convert human-readable version of a 'value' of a record to the binary
+ * representation.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param s human-readable string
+ * @param data set to value in binary encoding (will be allocated)
+ * @param data_size set to number of bytes in @a data
+ * @return #GNUNET_OK on success
+ */
+static int
+messenger_string_to_value (void *cls,
+                           uint32_t type,
+                           const char *s,
+                           void **data,
+                           size_t *data_size)
+{
+  (void) cls;
+  if (NULL == s)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY:
+    {
+      char key [103];
+      const char *dash;
+      struct GNUNET_PeerIdentity door;
+
+      if ((NULL == (dash = strchr (s, '-'))) ||
+          (1 != sscanf (s, "%103s-", key)) ||
+          (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
+                                                                    strlen (dash + 1),
+                                                                    &(door.public_key))))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
+                    s);
+        return GNUNET_SYSERR;
+      }
+
+      struct GNUNET_MESSENGER_RoomEntryRecord *record = GNUNET_new (
+          struct GNUNET_MESSENGER_RoomEntryRecord
+      );
+
+      if (GNUNET_OK != GNUNET_STRINGS_string_to_data (key,
+                                                      strlen (key),
+                                                      &(record->key),
+                                                      sizeof(struct GNUNET_HashCode)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
+                    s);
+        GNUNET_free (record);
+        return GNUNET_SYSERR;
+      }
+
+      record->door = door;
+      *data = record;
+      *data_size = sizeof(struct GNUNET_MESSENGER_RoomEntryRecord);
+      return GNUNET_OK;
+    }
+
+  default:
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Mapping of record type numbers to human-readable
+ * record type names.
+ */
+static struct
+{
+  const char *name;
+  uint32_t number;
+} name_map[] = {
+  { "MESSENGER_ROOM_ENTRY", GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY },
+  { NULL, UINT32_MAX }
+};
+
+
+/**
+ * Convert a type name (e.g. "AAAA") to the corresponding number.
+ *
+ * @param cls closure, unused
+ * @param gns_typename name to convert
+ * @return corresponding number, UINT32_MAX on error
+ */
+static uint32_t
+messenger_typename_to_number (void *cls,
+                              const char *gns_typename)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (0 != strcasecmp (gns_typename, name_map[i].name)))
+    i++;
+  return name_map[i].number;
+}
+
+
+/**
+ * Convert a type number to the corresponding type string (e.g. 1 to "A")
+ *
+ * @param cls closure, unused
+ * @param type number of a type to convert
+ * @return corresponding typestring, NULL on error
+ */
+static const char *
+messenger_number_to_typename (void *cls,
+                              uint32_t type)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (type != name_map[i].number))
+    i++;
+  return name_map[i].name;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_plugin_gnsrecord_messenger_init (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api;
+
+  (void) cls;
+  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api->value_to_string = &messenger_value_to_string;
+  api->string_to_value = &messenger_string_to_value;
+  api->typename_to_number = &messenger_typename_to_number;
+  api->number_to_typename = &messenger_number_to_typename;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_plugin_gnsrecord_messenger_done (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
diff --git a/src/pq/pq_event.c b/src/pq/pq_event.c
index 79a2e80c6..283e4569c 100644
--- a/src/pq/pq_event.c
+++ b/src/pq/pq_event.c
@@ -420,6 +420,7 @@ GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db,
                         void *cb_cls)
 {
   struct GNUNET_DB_EventHandler *eh;
+  bool sub;
 
   eh = GNUNET_new (struct GNUNET_DB_EventHandler);
   eh->db = db;
@@ -427,6 +428,9 @@ GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db,
             &eh->sh);
   eh->cb = cb;
   eh->cb_cls = cb_cls;
+  sub = (NULL ==
+         GNUNET_CONTAINER_multishortmap_get (db->channel_map,
+                                             &eh->sh));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multishortmap_put (db->channel_map,
                                                      &eh->sh,
@@ -439,9 +443,10 @@ GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db,
     scheduler_fd_cb (db,
                      PQsocket (db->conn));
   }
-  manage_subscribe (db,
-                    "LISTEN X",
-                    eh);
+  if (sub)
+    manage_subscribe (db,
+                      "LISTEN X",
+                      eh);
   eh->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                    &event_timeout,
                                                    eh);
@@ -458,9 +463,12 @@ GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh)
                  GNUNET_CONTAINER_multishortmap_remove (db->channel_map,
                                                         &eh->sh,
                                                         eh));
-  manage_subscribe (db,
-                    "UNLISTEN X",
-                    eh);
+  if (NULL ==
+      GNUNET_CONTAINER_multishortmap_get (db->channel_map,
+                                          &eh->sh))
+    manage_subscribe (db,
+                      "UNLISTEN X",
+                      eh);
   if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
diff --git a/src/util/network.c b/src/util/network.c
index 014701e02..688c37665 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -75,13 +75,7 @@ struct GNUNET_NETWORK_Handle
 };
 
 
-/**
- * Test if the given protocol family is supported by this system.
- *
- * @param pf protocol family to test (PF_INET, PF_INET6, PF_UNIX)
- * @return #GNUNET_OK if the PF is supported
- */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_test_pf (int pf)
 {
   static int cache_v4 = -1;
@@ -145,15 +139,6 @@ GNUNET_NETWORK_test_pf (int pf)
 }
 
 
-/**
- * Given a unixpath that is too long (larger than UNIX_PATH_MAX),
- * shorten it to an acceptable length while keeping it unique
- * and making sure it remains a valid filename (if possible).
- *
- * @param unixpath long path, will be freed (or same pointer returned
- *        with moved 0-termination).
- * @return shortened unixpath, NULL on error
- */
 char *
 GNUNET_NETWORK_shorten_unixpath (char *unixpath)
 {
@@ -189,15 +174,6 @@ GNUNET_NETWORK_shorten_unixpath (char *unixpath)
 }
 
 
-/**
- * If services crash, they can leave a unix domain socket file on the
- * disk. This needs to be manually removed, because otherwise both
- * bind() and connect() for the respective address will fail.  In this
- * function, we test if such a left-over file exists, and if so,
- * remove it (unless there is a listening service at the address).
- *
- * @param un unix domain socket address to check
- */
 void
 GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
 {
@@ -244,14 +220,7 @@ GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
 #endif
 
 
-/**
- * Set if a socket should use blocking or non-blocking IO.
- *
- * @param fd socket
- * @param doBlock blocking mode
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
- */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,
                                     int doBlock)
 {
@@ -418,14 +387,6 @@ initialize_network_handle (struct GNUNET_NETWORK_Handle *h,
 }
 
 
-/**
- * accept a new connection on a socket
- *
- * @param desc bound socket
- * @param address address of the connecting peer, may be NULL
- * @param address_len length of @a address
- * @return client socket
- */
 struct GNUNET_NETWORK_Handle *
 GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
                               struct sockaddr *address,
@@ -473,15 +434,7 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
 }
 
 
-/**
- * Bind a socket to a particular address.
- *
- * @param desc socket to bind
- * @param address address to be bound
- * @param address_len length of @a address
- * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
- */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
                             const struct sockaddr *address,
                             socklen_t address_len)
@@ -550,13 +503,7 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
 }
 
 
-/**
- * Close a socket
- *
- * @param desc socket
- * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
- */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
 {
   int ret;