8 files changed, 289 insertions, 7 deletions

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;
+}