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

73 files changed, 11647 insertions, 3542 deletions

diff --git a/src/plugin/Makefile.am b/src/plugin/Makefile.am
index 1a1ecffa7..78e06fd63 100644
--- a/src/plugin/Makefile.am
+++ b/src/plugin/Makefile.am
@@ -1,10 +1,16 @@
 SUBDIRS = \
         block \
+        dns \
         gnsrecord \
-        dhtu \
+        peerstore \
+        datacache \
+        datastore \
         namecache \
         namestore \
+        dht \
         revocation \
+        regex \
         gns \
         fs \
-        reclaim
+        reclaim \
+        messenger
diff --git a/src/plugin/datacache/Makefile.am b/src/plugin/datacache/Makefile.am
new file mode 100644
index 000000000..b9ae06975
--- /dev/null
+++ b/src/plugin/datacache/Makefile.am
@@ -0,0 +1,76 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+sqldir = $(prefix)/share/gnunet/sql/
+
+sql_DATA = \
+  datacache-0001.sql \
+  datacache-drop.sql
+
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIBS = -lgcov
+endif
+
+if HAVE_SQLITE
+  SQLITE_PLUGIN = libgnunet_plugin_datacache_sqlite.la
+endif
+if HAVE_POSTGRESQL
+  POSTGRES_PLUGIN = libgnunet_plugin_datacache_postgres.la
+endif
+
+plugin_LTLIBRARIES = \
+  $(SQLITE_PLUGIN) \
+  $(POSTGRES_PLUGIN) \
+  libgnunet_plugin_datacache_heap.la
+
+# Real plugins should of course go into
+# plugin_LTLIBRARIES
+noinst_LTLIBRARIES = \
+  libgnunet_plugin_datacache_template.la
+
+
+libgnunet_plugin_datacache_sqlite_la_SOURCES = \
+  plugin_datacache_sqlite.c
+libgnunet_plugin_datacache_sqlite_la_LIBADD = \
+  $(top_builddir)/src/lib/sq/libgnunetsq.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lsqlite3 \
+  $(LTLIBINTL)
+libgnunet_plugin_datacache_sqlite_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_plugin_datacache_heap_la_SOURCES = \
+  plugin_datacache_heap.c
+libgnunet_plugin_datacache_heap_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
+  $(LTLIBINTL)
+libgnunet_plugin_datacache_heap_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_plugin_datacache_postgres_la_SOURCES = \
+  plugin_datacache_postgres.c
+libgnunet_plugin_datacache_postgres_la_LIBADD = \
+  $(top_builddir)/src/lib/pq/libgnunetpq.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_PLUGIN_LDFLAGS) -lpq
+libgnunet_plugin_datacache_postgres_la_CPPFLAGS = \
+ $(POSTGRESQL_CPPFLAGS) $(AM_CPPFLAGS)
+libgnunet_plugin_datacache_postgres_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS) $(POSTGRESQL_LDFLAGS)
+
+libgnunet_plugin_datacache_template_la_SOURCES = \
+  plugin_datacache_template.c
+libgnunet_plugin_datacache_template_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
+  $(LTLIBINTL)
+libgnunet_plugin_datacache_template_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+EXTRA_DIST = \
+ $(sql_DATA)
diff --git a/src/plugin/datacache/datacache-0001.sql b/src/plugin/datacache/datacache-0001.sql
new file mode 100644
index 000000000..6567de3c2
--- /dev/null
+++ b/src/plugin/datacache/datacache-0001.sql
@@ -0,0 +1,48 @@
+--
+-- This file is part of GNUnet
+-- Copyright (C) 2014--2022 GNUnet e.V.
+--
+-- GNUnet is free software; you can redistribute it and/or modify it under the
+-- terms of the GNU General Public License as published by the Free Software
+-- Foundation; either version 3, 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 General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License along with
+-- GNUnet; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+--
+
+-- Everything in one big transaction
+BEGIN;
+
+-- Check patch versioning is in place.
+SELECT _v.register_patch('datacache-0001', NULL, NULL);
+
+-------------------- Schema ----------------------------
+
+CREATE SCHEMA datacache;
+COMMENT ON SCHEMA datacache IS 'gnunet-datacache data';
+
+SET search_path TO datacache;
+
+CREATE TABLE IF NOT EXISTS gn180dc (
+  oid BIGINT GENERATED BY DEFAULT AS IDENTITY,
+  type INT4 NOT NULL,
+  ro INT4 NOT NULL,
+  prox INT4 NOT NULL,
+  expiration_time INT8 NOT NULL,
+  key BYTEA NOT NULL CHECK(LENGTH(key)=64),
+  trunc BYTEA NOT NULL CHECK(LENGTH(trunc)=32),
+  value BYTEA NOT NULL,
+  path BYTEA DEFAULT NULL);
+
+CREATE INDEX IF NOT EXISTS idx_oid
+  ON gn180dc (oid);
+CREATE INDEX IF NOT EXISTS idx_key
+  ON gn180dc (key);
+CREATE INDEX IF NOT EXISTS idx_dt
+  ON gn180dc (expiration_time);
+
+COMMIT;
diff --git a/src/plugin/datacache/datacache-drop.sql b/src/plugin/datacache/datacache-drop.sql
new file mode 100644
index 000000000..2dd84bca8
--- /dev/null
+++ b/src/plugin/datacache/datacache-drop.sql
@@ -0,0 +1,25 @@
+--
+-- This file is part of GNUnet
+-- Copyright (C) 2014--2022 GNUnet e.V.
+--
+-- GNUnet is free software; you can redistribute it and/or modify it under the
+-- terms of the GNU General Public License as published by the Free Software
+-- Foundation; either version 3, 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 General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License along with
+-- GNUnet; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+--
+
+-- Everything in one big transaction
+BEGIN;
+
+
+SELECT _v.unregister_patch('datacache-0001');
+
+DROP SCHEMA datacache CASCADE;
+
+COMMIT;
diff --git a/src/plugin/datacache/meson.build b/src/plugin/datacache/meson.build
new file mode 100644
index 000000000..3c9e7d330
--- /dev/null
+++ b/src/plugin/datacache/meson.build
@@ -0,0 +1,30 @@
+install_data ('datacache-0001.sql',
+              'datacache-drop.sql',
+               install_dir: get_option('datadir')/'gnunet'/'sql')
+
+shared_module('gnunet_plugin_datacache_sqlite',
+        ['plugin_datacache_sqlite.c'],
+        dependencies: [libgnunetutil_dep,
+                       sqlite_dep,
+                       libgnunetsq_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+shared_module('gnunet_plugin_datacache_heap',
+        ['plugin_datacache_heap.c'],
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+if pq_dep.found()
+  shared_module('gnunet_plugin_datacache_postgres',
+          ['plugin_datacache_postgres.c'],
+          dependencies: [libgnunetutil_dep,
+                         pq_dep,
+                         libgnunetpq_dep],
+          include_directories: [incdir, configuration_inc],
+          install: true,
+          install_dir: get_option('libdir')/'gnunet')
+endif
diff --git a/src/plugin/datacache/plugin_datacache_heap.c b/src/plugin/datacache/plugin_datacache_heap.c
new file mode 100644
index 000000000..0dd8e47f8
--- /dev/null
+++ b/src/plugin/datacache/plugin_datacache_heap.c
@@ -0,0 +1,530 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2012, 2015, 2022 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 datacache/plugin_datacache_heap.c
+ * @brief heap-only implementation of a database backend for the datacache
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_datacache_plugin.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "datacache-heap", __VA_ARGS__)
+
+#define LOG_STRERROR_FILE(kind, op, fn) GNUNET_log_from_strerror_file (kind, \
+                                                                       "datacache-heap", \
+                                                                       op, fn)
+
+#define NUM_HEAPS 24
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATACACHE_PluginEnvironment *env;
+
+  /**
+   * Our hash map.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *map;
+
+  /**
+   * Heaps sorted by distance.
+   */
+  struct GNUNET_CONTAINER_Heap *heaps[NUM_HEAPS];
+};
+
+
+/**
+ * Entry in the hash map.
+ */
+struct Value
+{
+  /**
+   * Block data.
+   */
+  struct GNUNET_DATACACHE_Block block;
+
+  /**
+   * Corresponding node in the heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *hn;
+
+  /**
+   * Put path as a non-const pointer.
+   */
+  struct GNUNET_DHT_PathElement *put_path;
+
+  /**
+   * How close is the hash to us? Determines which heap we are in!
+   */
+  uint32_t distance;
+
+};
+
+
+#define OVERHEAD (sizeof(struct Value) + 64)
+
+
+/**
+ * Closure for #put_cb().
+ */
+struct PutContext
+{
+  /**
+   * Block data.
+   */
+  const struct GNUNET_DATACACHE_Block *block;
+
+  /**
+   * Value to set to true if an equivalent block was found.
+   */
+  bool found;
+};
+
+
+/**
+ * Function called during PUT to detect if an equivalent block
+ * already exists.
+ *
+ * @param cls the `struct PutContext`
+ * @param key the key for the value(s)
+ * @param value an existing value
+ * @return #GNUNET_YES if not found (to continue to iterate)
+ */
+static enum GNUNET_GenericReturnValue
+put_cb (void *cls,
+        const struct GNUNET_HashCode *key,
+        void *value)
+{
+  struct PutContext *put_ctx = cls;
+  struct Value *val = value;
+
+  if ((val->block.data_size == put_ctx->block->data_size) &&
+      (val->block.type == put_ctx->block->type) &&
+      (0 == memcmp (val->block.data,
+                    put_ctx->block->data,
+                    put_ctx->block->data_size)))
+  {
+    put_ctx->found = true;
+    val->block.expiration_time
+      = GNUNET_TIME_absolute_max (val->block.expiration_time,
+                                  put_ctx->block->expiration_time);
+    /* replace old path with new path */
+    GNUNET_free (val->put_path);
+    val->put_path = GNUNET_memdup (put_ctx->block->put_path,
+                                   put_ctx->block->put_path_length
+                                   * sizeof (struct GNUNET_DHT_PathElement));
+    val->block.put_path = val->put_path;
+    val->block.put_path_length = put_ctx->block->put_path_length;
+    GNUNET_CONTAINER_heap_update_cost (val->hn,
+                                       val->block.expiration_time.abs_value_us);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got same value for key %s and type %u (size %u vs %u)\n",
+                GNUNET_h2s (key),
+                (unsigned int) val->block.type,
+                (unsigned int) val->block.data_size,
+                (unsigned int) put_ctx->block->data_size);
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param xor_distance how close is @a key to our PID?
+ * @param block data to store
+ * @return 0 if duplicate, -1 on error, number of bytes used otherwise
+ */
+static ssize_t
+heap_plugin_put (void *cls,
+                 uint32_t xor_distance,
+                 const struct GNUNET_DATACACHE_Block *block)
+{
+  struct Plugin *plugin = cls;
+  struct Value *val;
+  struct PutContext put_ctx = {
+    .block = block,
+    .found = false
+  };
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Storing %u bytes under key %s with path length %u\n",
+              (unsigned int) block->data_size,
+              GNUNET_h2s (&block->key),
+              block->put_path_length);
+  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->map,
+                                              &block->key,
+                                              &put_cb,
+                                              &put_ctx);
+  if (GNUNET_YES == put_ctx.found)
+    return 0;
+  val = GNUNET_malloc (sizeof(struct Value)
+                       + block->data_size);
+  GNUNET_memcpy (&val[1],
+                 block->data,
+                 block->data_size);
+  val->block = *block;
+  val->block.data = &val[1];
+  if (xor_distance >= NUM_HEAPS)
+    val->distance = NUM_HEAPS - 1;
+  else
+    val->distance = xor_distance;
+  if (0 != block->put_path_length)
+  {
+    val->put_path
+      = GNUNET_memdup (block->put_path,
+                       block->put_path_length
+                       * sizeof (struct GNUNET_DHT_PathElement));
+    val->block.put_path = val->put_path;
+  }
+  (void) GNUNET_CONTAINER_multihashmap_put (plugin->map,
+                                            &val->block.key,
+                                            val,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  val->hn = GNUNET_CONTAINER_heap_insert (
+    plugin->heaps[val->distance],
+    val,
+    val->block.expiration_time.abs_value_us);
+  return val->block.data_size + OVERHEAD;
+}
+
+
+/**
+ * Closure for #get_cb().
+ */
+struct GetContext
+{
+  /**
+   * Function to call for each result.
+   */
+  GNUNET_DATACACHE_Iterator iter;
+
+  /**
+   * Closure for @e iter.
+   */
+  void *iter_cls;
+
+  /**
+   * Number of results found.
+   */
+  unsigned int cnt;
+
+  /**
+   * Block type requested.
+   */
+  enum GNUNET_BLOCK_Type type;
+};
+
+
+/**
+ * Function called during GET to find matching blocks.
+ * Only matches by type.
+ *
+ * @param cls the `struct GetContext`
+ * @param key the key for the value(s)
+ * @param value an existing value
+ * @return #GNUNET_YES to continue to iterate
+ */
+static enum GNUNET_GenericReturnValue
+get_cb (void *cls,
+        const struct GNUNET_HashCode *key,
+        void *value)
+{
+  struct GetContext *get_ctx = cls;
+  struct Value *val = value;
+  enum GNUNET_GenericReturnValue ret;
+
+  if ( (get_ctx->type != val->block.type) &&
+       (GNUNET_BLOCK_TYPE_ANY != get_ctx->type) )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Result for key %s does not match block type %d\n",
+                GNUNET_h2s (key),
+                get_ctx->type);
+    return GNUNET_OK;
+  }
+  if (GNUNET_TIME_absolute_is_past (val->block.expiration_time))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Result for key %s is expired\n",
+                GNUNET_h2s (key));
+    return GNUNET_OK;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Found result for key %s\n",
+              GNUNET_h2s (key));
+  if (NULL != get_ctx->iter)
+    ret = get_ctx->iter (get_ctx->iter_cls,
+                         &val->block);
+  else
+    ret = GNUNET_YES;
+  get_ctx->cnt++;
+  return ret;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+heap_plugin_get (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 enum GNUNET_BLOCK_Type type,
+                 GNUNET_DATACACHE_Iterator iter,
+                 void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GetContext get_ctx;
+
+  get_ctx.type = type;
+  get_ctx.iter = iter;
+  get_ctx.iter_cls = iter_cls;
+  get_ctx.cnt = 0;
+  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->map,
+                                              key,
+                                              &get_cb,
+                                              &get_ctx);
+  return get_ctx.cnt;
+}
+
+
+/**
+ * Delete the entry with the lowest expiration value
+ * from the datacache right now.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+heap_plugin_del (void *cls)
+{
+  struct Plugin *plugin = cls;
+  struct Value *val;
+
+  for (unsigned int i = 0; i < NUM_HEAPS; i++)
+  {
+    val = GNUNET_CONTAINER_heap_remove_root (plugin->heaps[i]);
+    if (NULL != val)
+      break;
+  }
+  if (NULL == val)
+    return GNUNET_SYSERR;
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (plugin->map,
+                                                       &val->block.key,
+                                                       val));
+  plugin->env->delete_notify (plugin->env->cls,
+                              &val->block.key,
+                              val->block.data_size + OVERHEAD);
+  GNUNET_free (val->put_path);
+  GNUNET_free (val);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Closure for #find_closest().
+ */
+struct GetClosestContext
+{
+  struct Value **values;
+
+  const struct GNUNET_HashCode *key;
+
+  enum GNUNET_BLOCK_Type type;
+
+  unsigned int num_results;
+
+};
+
+
+static enum GNUNET_GenericReturnValue
+find_closest (void *cls,
+              const struct GNUNET_HashCode *key,
+              void *value)
+{
+  struct GetClosestContext *gcc = cls;
+  struct Value *val = value;
+  unsigned int j;
+
+  if (1 != GNUNET_CRYPTO_hash_cmp (key,
+                                   gcc->key))
+    return GNUNET_OK; /* useless */
+  if ( (val->block.type != gcc->type) &&
+       (GNUNET_BLOCK_TYPE_ANY != gcc->type) )
+    return GNUNET_OK; /* useless */
+  j = gcc->num_results;
+  for (unsigned int i = 0; i < gcc->num_results; i++)
+  {
+    if (NULL == gcc->values[i])
+    {
+      j = i;
+      break;
+    }
+    if (1 ==
+        GNUNET_CRYPTO_hash_cmp (&gcc->values[i]->block.key,
+                                key))
+    {
+      j = i;
+      break;
+    }
+  }
+  if (j == gcc->num_results)
+    return GNUNET_OK;
+  gcc->values[j] = val;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterate over the results that are "close" to a particular key in
+ * the datacache.  "close" is defined as numerically larger than @a
+ * key (when interpreted as a circular address space), with small
+ * distance.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param key area of the keyspace to look into
+ * @param type desired block type for the replies
+ * @param num_results number of results that should be returned to @a iter
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+heap_plugin_get_closest (void *cls,
+                         const struct GNUNET_HashCode *key,
+                         enum GNUNET_BLOCK_Type type,
+                         unsigned int num_results,
+                         GNUNET_DATACACHE_Iterator iter,
+                         void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  struct Value *values[num_results];
+  struct GetClosestContext gcc = {
+    .values = values,
+    .type = type,
+    .num_results = num_results * 2,
+    .key = key
+  };
+
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->map,
+                                         &find_closest,
+                                         &gcc);
+  for (unsigned int i = 0; i < num_results * 2; i++)
+  {
+    if (NULL == values[i])
+      return i;
+    if ( (NULL != iter) &&
+         (GNUNET_SYSERR ==
+          iter (iter_cls,
+                &values[i]->block)) )
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Ending iteration (client error)\n");
+      return i;
+    }
+  }
+  return num_results * 2;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironmnet`)
+ * @return the plugin's closure (our `struct Plugin`)
+ */
+void *
+libgnunet_plugin_datacache_heap_init (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
+  struct GNUNET_DATACACHE_PluginFunctions *api;
+  struct Plugin *plugin;
+
+  plugin = GNUNET_new (struct Plugin);
+  plugin->map = GNUNET_CONTAINER_multihashmap_create (1024,   /* FIXME: base on quota! */
+                                                      GNUNET_YES);
+  for (unsigned int i = 0; i < NUM_HEAPS; i++)
+    plugin->heaps[i] = GNUNET_CONTAINER_heap_create (
+      GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  plugin->env = env;
+  api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions);
+  api->cls = plugin;
+  api->get = &heap_plugin_get;
+  api->put = &heap_plugin_put;
+  api->del = &heap_plugin_del;
+  api->get_closest = &heap_plugin_get_closest;
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       _ ("Heap datacache running\n"));
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our "struct Plugin")
+ * @return NULL
+ */
+void *
+libgnunet_plugin_datacache_heap_done (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+  struct Value *val;
+
+  for (unsigned int i = 0; i < NUM_HEAPS; i++)
+  {
+    while (NULL != (val = GNUNET_CONTAINER_heap_remove_root (plugin->heaps[i])))
+    {
+      GNUNET_assert (GNUNET_YES ==
+                     GNUNET_CONTAINER_multihashmap_remove (plugin->map,
+                                                           &val->block.key,
+                                                           val));
+      GNUNET_free (val->put_path);
+      GNUNET_free (val);
+    }
+    GNUNET_CONTAINER_heap_destroy (plugin->heaps[i]);
+  }
+  GNUNET_CONTAINER_multihashmap_destroy (plugin->map);
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datacache_heap.c */
diff --git a/src/plugin/datacache/plugin_datacache_postgres.c b/src/plugin/datacache/plugin_datacache_postgres.c
new file mode 100644
index 000000000..8bfd04aea
--- /dev/null
+++ b/src/plugin/datacache/plugin_datacache_postgres.c
@@ -0,0 +1,616 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2006, 2009, 2010, 2012, 2015, 2017, 2018, 2022 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 datacache/plugin_datacache_postgres.c
+ * @brief postgres for an implementation of a database backend for the datacache
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_pq_lib.h"
+#include "gnunet_datacache_plugin.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "datacache-postgres", __VA_ARGS__)
+
+/**
+ * Per-entry overhead estimate
+ */
+#define OVERHEAD (sizeof(struct GNUNET_HashCode) + 24)
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATACACHE_PluginEnvironment *env;
+
+  /**
+   * Native Postgres database handle.
+   */
+  struct GNUNET_PQ_Context *dbh;
+
+  /**
+   * Number of key-value pairs in the database.
+   */
+  unsigned int num_items;
+};
+
+
+/**
+ * @brief Get a database handle
+ *
+ * @param plugin global context
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+init_connection (struct Plugin *plugin)
+{
+  struct GNUNET_PQ_PreparedStatement ps[] = {
+    GNUNET_PQ_make_prepare ("getkt",
+                            "SELECT expiration_time,type,ro,value,trunc,path"
+                            " FROM datacache.gn180dc"
+                            " WHERE key=$1 AND type=$2 AND expiration_time >= $3"),
+    GNUNET_PQ_make_prepare ("getk",
+                            "SELECT expiration_time,type,ro,value,trunc,path"
+                            " FROM datacache.gn180dc"
+                            " WHERE key=$1 AND expiration_time >= $2"),
+    GNUNET_PQ_make_prepare ("getex",
+                            "SELECT LENGTH(value) AS len,oid,key"
+                            " FROM datacache.gn180dc"
+                            " WHERE expiration_time < $1"
+                            " ORDER BY expiration_time ASC LIMIT 1"),
+    GNUNET_PQ_make_prepare ("getm",
+                            "SELECT LENGTH(value) AS len,oid,key"
+                            " FROM datacache.gn180dc"
+                            " ORDER BY prox ASC, expiration_time ASC LIMIT 1"),
+    GNUNET_PQ_make_prepare ("get_closest",
+                            "(SELECT expiration_time,type,ro,value,trunc,path,key"
+                            " FROM datacache.gn180dc"
+                            " WHERE key >= $1"
+                            "   AND expiration_time >= $2"
+                            "   AND ( (type = $3) OR ( 0 = $3) )"
+                            " ORDER BY key ASC"
+                            " LIMIT $4)"
+                            " UNION "
+                            "(SELECT expiration_time,type,ro,value,trunc,path,key"
+                            " FROM datacache.gn180dc"
+                            " WHERE key <= $1"
+                            "   AND expiration_time >= $2"
+                            "   AND ( (type = $3) OR ( 0 = $3) )"
+                            " ORDER BY key DESC"
+                            " LIMIT $4)"),
+    GNUNET_PQ_make_prepare ("delrow",
+                            "DELETE FROM datacache.gn180dc"
+                            " WHERE oid=$1"),
+    GNUNET_PQ_make_prepare ("put",
+                            "INSERT INTO datacache.gn180dc"
+                            " (type, ro, prox, expiration_time, key, value, trunc, path) "
+                            "VALUES ($1, $2, $3, $4, $5, $6, $7, $8)"),
+    GNUNET_PQ_PREPARED_STATEMENT_END
+  };
+
+  plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->env->cfg,
+                                            "datacache-postgres",
+                                            "datacache-",
+                                            NULL,
+                                            ps);
+  if (NULL == plugin->dbh)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param prox proximity of @a key to my PID
+ * @param block data to store
+ * @return 0 if duplicate, -1 on error, number of bytes used otherwise
+ */
+static ssize_t
+postgres_plugin_put (void *cls,
+                     uint32_t prox,
+                     const struct GNUNET_DATACACHE_Block *block)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = (uint32_t) block->type;
+  uint32_t ro32 = (uint32_t) block->type;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_uint32 (&type32),
+    GNUNET_PQ_query_param_uint32 (&ro32),
+    GNUNET_PQ_query_param_uint32 (&prox),
+    GNUNET_PQ_query_param_absolute_time (&block->expiration_time),
+    GNUNET_PQ_query_param_auto_from_type (&block->key),
+    GNUNET_PQ_query_param_fixed_size (block->data,
+                                      block->data_size),
+    GNUNET_PQ_query_param_auto_from_type (&block->trunc_peer),
+    (0 == block->put_path_length)
+    ? GNUNET_PQ_query_param_null ()
+    : GNUNET_PQ_query_param_fixed_size (
+      block->put_path,
+      block->put_path_length
+      * sizeof(struct GNUNET_DHT_PathElement)),
+    GNUNET_PQ_query_param_end
+  };
+  enum GNUNET_DB_QueryStatus ret;
+
+  ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                            "put",
+                                            params);
+  if (0 > ret)
+    return -1;
+  plugin->num_items++;
+  return block->data_size + OVERHEAD;
+}
+
+
+/**
+ * Closure for #handle_results.
+ */
+struct HandleResultContext
+{
+  /**
+   * Function to call on each result, may be NULL.
+   */
+  GNUNET_DATACACHE_Iterator iter;
+
+  /**
+   * Closure for @e iter.
+   */
+  void *iter_cls;
+
+  /**
+   * Key used.
+   */
+  const struct GNUNET_HashCode *key;
+};
+
+
+/**
+ * Function to be called with the results of a SELECT statement
+ * that has returned @a num_results results.  Parse the result
+ * and call the callback given in @a cls
+ *
+ * @param cls closure of type `struct HandleResultContext`
+ * @param result the postgres result
+ * @param num_results the number of results in @a result
+ */
+static void
+handle_results (void *cls,
+                PGresult *result,
+                unsigned int num_results)
+{
+  struct HandleResultContext *hrc = cls;
+
+  for (unsigned int i = 0; i < num_results; i++)
+  {
+    uint32_t type32;
+    uint32_t bro32;
+    void *data;
+    struct GNUNET_DATACACHE_Block block;
+    void *path = NULL;
+    size_t path_size = 0;
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_absolute_time ("expiration_time",
+                                           &block.expiration_time),
+      GNUNET_PQ_result_spec_uint32 ("type",
+                                    &type32),
+      GNUNET_PQ_result_spec_uint32 ("ro",
+                                    &bro32),
+      GNUNET_PQ_result_spec_variable_size ("value",
+                                           &data,
+                                           &block.data_size),
+      GNUNET_PQ_result_spec_auto_from_type ("trunc",
+                                            &block.trunc_peer),
+      GNUNET_PQ_result_spec_allow_null (
+        GNUNET_PQ_result_spec_variable_size ("path",
+                                             &path,
+                                             &path_size),
+        NULL),
+      GNUNET_PQ_result_spec_end
+    };
+
+    if (GNUNET_YES !=
+        GNUNET_PQ_extract_result (result,
+                                  rs,
+                                  i))
+    {
+      GNUNET_break (0);
+      return;
+    }
+    if (0 != (path_size % sizeof(struct GNUNET_DHT_PathElement)))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length
+      = path_size / sizeof (struct GNUNET_DHT_PathElement);
+    block.type = (enum GNUNET_BLOCK_Type) type32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    block.key = *hrc->key;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found result of size %u bytes and type %u in database\n",
+         (unsigned int) block.data_size,
+         (unsigned int) block.type);
+    if ( (NULL != hrc->iter) &&
+         (GNUNET_SYSERR ==
+          hrc->iter (hrc->iter_cls,
+                     &block)) )
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Ending iteration (client error)\n");
+      GNUNET_PQ_cleanup_result (rs);
+      return;
+    }
+    GNUNET_PQ_cleanup_result (rs);
+  }
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key key to look for
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+postgres_plugin_get (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     enum GNUNET_BLOCK_Type type,
+                     GNUNET_DATACACHE_Iterator iter,
+                     void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = (uint32_t) type;
+  struct GNUNET_TIME_Absolute now = { 0 };
+  struct GNUNET_PQ_QueryParam paramk[] = {
+    GNUNET_PQ_query_param_auto_from_type (key),
+    GNUNET_PQ_query_param_absolute_time (&now),
+    GNUNET_PQ_query_param_end
+  };
+  struct GNUNET_PQ_QueryParam paramkt[] = {
+    GNUNET_PQ_query_param_auto_from_type (key),
+    GNUNET_PQ_query_param_uint32 (&type32),
+    GNUNET_PQ_query_param_absolute_time (&now),
+    GNUNET_PQ_query_param_end
+  };
+  enum GNUNET_DB_QueryStatus res;
+  struct HandleResultContext hr_ctx;
+
+  now = GNUNET_TIME_absolute_get ();
+  hr_ctx.iter = iter;
+  hr_ctx.iter_cls = iter_cls;
+  hr_ctx.key = key;
+  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                              (0 == type) ? "getk" : "getkt",
+                                              (0 == type) ? paramk : paramkt,
+                                              &handle_results,
+                                              &hr_ctx);
+  if (res < 0)
+    return 0;
+  return res;
+}
+
+
+/**
+ * Delete the entry with the lowest expiration value
+ * from the datacache right now.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+postgres_plugin_del (void *cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PQ_QueryParam pempty[] = {
+    GNUNET_PQ_query_param_end
+  };
+  uint32_t size;
+  uint64_t oid;
+  struct GNUNET_HashCode key;
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint32 ("len",
+                                  &size),
+    GNUNET_PQ_result_spec_uint64 ("oid",
+                                  &oid),
+    GNUNET_PQ_result_spec_auto_from_type ("key",
+                                          &key),
+    GNUNET_PQ_result_spec_end
+  };
+  enum GNUNET_DB_QueryStatus res;
+  struct GNUNET_PQ_QueryParam dparam[] = {
+    GNUNET_PQ_query_param_uint64 (&oid),
+    GNUNET_PQ_query_param_end
+  };
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_PQ_QueryParam xparam[] = {
+    GNUNET_PQ_query_param_absolute_time (&now),
+    GNUNET_PQ_query_param_end
+  };
+
+  now = GNUNET_TIME_absolute_get ();
+  res = GNUNET_PQ_eval_prepared_singleton_select (plugin->dbh,
+                                                  "getex",
+                                                  xparam,
+                                                  rs);
+  if (0 >= res)
+    res = GNUNET_PQ_eval_prepared_singleton_select (plugin->dbh,
+                                                    "getm",
+                                                    pempty,
+                                                    rs);
+  if (0 > res)
+    return GNUNET_SYSERR;
+  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
+  {
+    /* no result */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Ending iteration (no more results)\n");
+    return 0;
+  }
+  res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                            "delrow",
+                                            dparam);
+  if (0 > res)
+  {
+    GNUNET_PQ_cleanup_result (rs);
+    return GNUNET_SYSERR;
+  }
+  plugin->num_items--;
+  plugin->env->delete_notify (plugin->env->cls,
+                              &key,
+                              size + OVERHEAD);
+  GNUNET_PQ_cleanup_result (rs);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Closure for #extract_result_cb.
+ */
+struct ExtractResultContext
+{
+  /**
+   * Function to call for each result found.
+   */
+  GNUNET_DATACACHE_Iterator iter;
+
+  /**
+   * Closure for @e iter.
+   */
+  void *iter_cls;
+};
+
+
+/**
+ * Function to be called with the results of a SELECT statement
+ * that has returned @a num_results results.  Calls the `iter`
+ * from @a cls for each result.
+ *
+ * @param cls closure with the `struct ExtractResultContext`
+ * @param result the postgres result
+ * @param num_results the number of results in @a result
+ */
+static void
+extract_result_cb (void *cls,
+                   PGresult *result,
+                   unsigned int num_results)
+{
+  struct ExtractResultContext *erc = cls;
+
+  if (NULL == erc->iter)
+    return;
+  for (unsigned int i = 0; i < num_results; i++)
+  {
+    uint32_t type32;
+    uint32_t bro32;
+    struct GNUNET_DATACACHE_Block block;
+    void *data;
+    void *path;
+    size_t path_size;
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_absolute_time ("expiration_time",
+                                           &block.expiration_time),
+      GNUNET_PQ_result_spec_uint32 ("type",
+                                    &type32),
+      GNUNET_PQ_result_spec_uint32 ("ro",
+                                    &bro32),
+      GNUNET_PQ_result_spec_variable_size ("value",
+                                           &data,
+                                           &block.data_size),
+      GNUNET_PQ_result_spec_auto_from_type ("trunc",
+                                            &block.trunc_peer),
+      GNUNET_PQ_result_spec_variable_size ("path",
+                                           &path,
+                                           &path_size),
+      GNUNET_PQ_result_spec_auto_from_type ("key",
+                                            &block.key),
+      GNUNET_PQ_result_spec_end
+    };
+
+    if (GNUNET_YES !=
+        GNUNET_PQ_extract_result (result,
+                                  rs,
+                                  i))
+    {
+      GNUNET_break (0);
+      return;
+    }
+    if (0 != (path_size % sizeof(struct GNUNET_DHT_PathElement)))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.type = (enum GNUNET_BLOCK_Type) type32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof (struct GNUNET_DHT_PathElement);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found result of size %u bytes and type %u in database\n",
+         (unsigned int) block.data_size,
+         (unsigned int) block.type);
+    if ( (NULL != erc->iter) &&
+         (GNUNET_SYSERR ==
+          erc->iter (erc->iter_cls,
+                     &block)) )
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Ending iteration (client error)\n");
+      GNUNET_PQ_cleanup_result (rs);
+      break;
+    }
+    GNUNET_PQ_cleanup_result (rs);
+  }
+}
+
+
+/**
+ * Iterate over the results that are "close" to a particular key in
+ * the datacache.  "close" is defined as numerically larger than @a
+ * key (when interpreted as a circular address space), with small
+ * distance.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param key area of the keyspace to look into
+ * @param type desired block type for the replies
+ * @param num_results number of results that should be returned to @a iter
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+postgres_plugin_get_closest (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             enum GNUNET_BLOCK_Type type,
+                             unsigned int num_results,
+                             GNUNET_DATACACHE_Iterator iter,
+                             void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t num_results32 = (uint32_t) num_results;
+  uint32_t type32 = (uint32_t) type;
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (key),
+    GNUNET_PQ_query_param_absolute_time (&now),
+    GNUNET_PQ_query_param_uint32 (&type32),
+    GNUNET_PQ_query_param_uint32 (&num_results32),
+    GNUNET_PQ_query_param_end
+  };
+  enum GNUNET_DB_QueryStatus res;
+  struct ExtractResultContext erc;
+
+  erc.iter = iter;
+  erc.iter_cls = iter_cls;
+  now = GNUNET_TIME_absolute_get ();
+  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                              "get_closest",
+                                              params,
+                                              &extract_result_cb,
+                                              &erc);
+  if (0 > res)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Ending iteration (postgres error)\n");
+    return 0;
+  }
+  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
+  {
+    /* no result */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Ending iteration (no more results)\n");
+    return 0;
+  }
+  return res;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironmnet`)
+ * @return the plugin's closure (our `struct Plugin`)
+ */
+void *
+libgnunet_plugin_datacache_postgres_init (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
+  struct GNUNET_DATACACHE_PluginFunctions *api;
+  struct Plugin *plugin;
+
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+
+  if (GNUNET_OK != init_connection (plugin))
+  {
+    GNUNET_free (plugin);
+    return NULL;
+  }
+
+  api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions);
+  api->cls = plugin;
+  api->get = &postgres_plugin_get;
+  api->put = &postgres_plugin_put;
+  api->del = &postgres_plugin_del;
+  api->get_closest = &postgres_plugin_get_closest;
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Postgres datacache running\n");
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return NULL
+ */
+void *
+libgnunet_plugin_datacache_postgres_done (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_PQ_exec_sql (plugin->dbh,
+                                    "datacache-drop"));
+  GNUNET_PQ_disconnect (plugin->dbh);
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datacache_postgres.c */
diff --git a/src/plugin/datacache/plugin_datacache_sqlite.c b/src/plugin/datacache/plugin_datacache_sqlite.c
new file mode 100644
index 000000000..1c6f24a82
--- /dev/null
+++ b/src/plugin/datacache/plugin_datacache_sqlite.c
@@ -0,0 +1,1063 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2006, 2009, 2015, 2022 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 datacache/plugin_datacache_sqlite.c
+ * @brief sqlite for an implementation of a database backend for the datacache
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_datacache_plugin.h"
+#include "gnunet_sq_lib.h"
+#include <sqlite3.h>
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "datacache-sqlite", __VA_ARGS__)
+
+#define LOG_STRERROR_FILE(kind, op, fn) \
+  GNUNET_log_from_strerror_file (kind, "datacache-sqlite", op, fn)
+
+
+/**
+ * How much overhead do we assume per entry in the
+ * datacache?
+ */
+#define OVERHEAD (sizeof(struct GNUNET_HashCode) + 36)
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATACACHE_PluginEnvironment *env;
+
+  /**
+   * Handle to the sqlite database.
+   */
+  sqlite3 *dbh;
+
+  /**
+   * Filename used for the DB.
+   */
+  char *fn;
+
+  /**
+   * Prepared statement for #sqlite_plugin_put.
+   */
+  sqlite3_stmt *insert_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
+  sqlite3_stmt *get_count_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
+  sqlite3_stmt *get_count_any_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
+  sqlite3_stmt *get_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get.
+   */
+  sqlite3_stmt *get_any_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_del.
+   */
+  sqlite3_stmt *del_select_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_del.
+   */
+  sqlite3_stmt *del_expired_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_del.
+   */
+  sqlite3_stmt *del_stmt;
+
+  /**
+   * Prepared statement for #sqlite_plugin_get_closest.
+   */
+  sqlite3_stmt *get_closest_stmt;
+
+  /**
+   * Number of key-value pairs in the database.
+   */
+  unsigned int num_items;
+};
+
+
+/**
+ * Log an error message at log-level @a level that indicates
+ * a failure of the command @a cmd with the error from the database @a db
+ *
+ * @param db database handle
+ * @param level log level
+ * @param cmd failed command
+ */
+#define LOG_SQLITE(db, level, cmd)                    \
+  do                                                  \
+  {                                                   \
+    LOG (level,                                       \
+         _ ("`%s' failed at %s:%d with error: %s\n"), \
+         cmd,                                         \
+         __FILE__,                                    \
+         __LINE__,                                    \
+         sqlite3_errmsg (db));                        \
+  } while (0)
+
+
+/**
+ * Execute SQL statement.
+ *
+ * @param db database handle
+ * @param cmd SQL command to execute
+ */
+#define SQLITE3_EXEC(db, cmd)                                   \
+  do                                                            \
+  {                                                             \
+    emsg = NULL;                                                \
+    if (SQLITE_OK !=                                            \
+        sqlite3_exec (db, cmd, NULL, NULL, &emsg))              \
+    {                                                           \
+      LOG (GNUNET_ERROR_TYPE_ERROR,                             \
+           _ ("`%s' failed at %s:%d with error: %s\n"),         \
+           "sqlite3_exec",                                      \
+           __FILE__,                                            \
+           __LINE__,                                            \
+           emsg);                                               \
+      sqlite3_free (emsg);                                      \
+    }                                                           \
+  } while (0)
+
+
+/**
+ * @brief Prepare a SQL statement
+ *
+ * @param dbh database handle
+ * @param zSql SQL statement text
+ * @param[out] ppStmt set to the prepared statement
+ * @return 0 on success
+ */
+static int
+sq_prepare (sqlite3 *dbh,
+            const char *zSql, /* SQL statement, UTF-8 encoded */
+            sqlite3_stmt **ppStmt)
+{ /* OUT: Statement handle */
+  char *dummy;
+
+  return sqlite3_prepare (dbh,
+                          zSql,
+                          strlen (zSql),
+                          ppStmt,
+                          (const char **) &dummy);
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param xor_distance how close is @a key to our PID?
+ * @param block data to store
+ * @return 0 if duplicate, -1 on error, number of bytes used otherwise
+ */
+static ssize_t
+sqlite_plugin_put (void *cls,
+                   uint32_t xor_distance,
+                   const struct GNUNET_DATACACHE_Block *block)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = (uint32_t) block->type;
+  uint32_t ro32 = (uint32_t) block->ro;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_uint32 (&ro32),
+    GNUNET_SQ_query_param_absolute_time (&block->expiration_time),
+    GNUNET_SQ_query_param_auto_from_type (&block->key),
+    GNUNET_SQ_query_param_uint32 (&xor_distance),
+    GNUNET_SQ_query_param_fixed_size (block->data,
+                                      block->data_size),
+    GNUNET_SQ_query_param_fixed_size (block->put_path,
+                                      block->put_path_length
+                                      * sizeof(struct GNUNET_DHT_PathElement)),
+    GNUNET_SQ_query_param_auto_from_type (&block->trunc_peer),
+    GNUNET_SQ_query_param_end
+  };
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing PUT of %u bytes with key `%s' and expiration %s\n",
+       (unsigned int) block->data_size,
+       GNUNET_h2s (&block->key),
+       GNUNET_STRINGS_relative_time_to_string (
+         GNUNET_TIME_absolute_get_remaining (
+           block->expiration_time),
+         GNUNET_YES));
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->insert_stmt,
+                      params))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_bind_xxx");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->insert_stmt);
+    return -1;
+  }
+  if (SQLITE_DONE !=
+      sqlite3_step (plugin->insert_stmt))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->insert_stmt);
+    return -1;
+  }
+  plugin->num_items++;
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->insert_stmt);
+  return block->data_size + OVERHEAD;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+get_any (void *cls,
+         const struct GNUNET_HashCode *key,
+         GNUNET_DATACACHE_Iterator iter,
+         void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_TIME_Absolute now;
+  unsigned int cnt;
+  uint32_t off;
+  uint32_t btype32;
+  uint32_t bro32;
+  unsigned int total;
+  struct GNUNET_DATACACHE_Block block;
+  void *path;
+  void *data;
+  size_t path_size;
+  struct GNUNET_SQ_QueryParam params_count[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam params_select[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_uint32 (&off),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_auto_from_type (&block.trunc_peer),
+    GNUNET_SQ_result_spec_uint32 (&btype32),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_end
+  };
+
+  now = GNUNET_TIME_absolute_get ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing GET for key `%s'\n",
+       GNUNET_h2s (key));
+
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->get_count_any_stmt,
+                      params_count))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_bind_xxx");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_any_stmt);
+    return 0;
+  }
+  if (SQLITE_ROW !=
+      sqlite3_step (plugin->get_count_any_stmt))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_any_stmt);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No content found when processing GET for key `%s'\n",
+         GNUNET_h2s (key));
+    return 0;
+  }
+  total = sqlite3_column_int (plugin->get_count_any_stmt,
+                              0);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_count_any_stmt);
+  if ( (0 == total) ||
+       (NULL == iter) )
+  {
+    if (0 == total)
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "No content found when processing GET for key `%s'\n",
+           GNUNET_h2s (key));
+    return total;
+  }
+
+  cnt = 0;
+  block.key = *key;
+  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  total);
+  while (cnt < total)
+  {
+    off = (off + 1) % total;
+    if (GNUNET_OK !=
+        GNUNET_SQ_bind (plugin->get_any_stmt,
+                        params_select))
+    {
+      LOG_SQLITE (plugin->dbh,
+                  GNUNET_ERROR_TYPE_ERROR,
+                  "sqlite3_bind_xxx");
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      return cnt;
+    }
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->get_any_stmt))
+      break;
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->get_any_stmt,
+                                  rs))
+    {
+      GNUNET_break (0);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      break;
+    }
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.type = (enum GNUNET_BLOCK_Type) btype32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    cnt++;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found %u-byte result when processing GET for key `%s'\n",
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+    if (GNUNET_OK !=
+        iter (iter_cls,
+              &block))
+    {
+      GNUNET_SQ_cleanup_result (rs);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_any_stmt);
+      break;
+    }
+    GNUNET_SQ_cleanup_result (rs);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_any_stmt);
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_any_stmt);
+  return cnt;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+get_typed (void *cls,
+           const struct GNUNET_HashCode *key,
+           enum GNUNET_BLOCK_Type type,
+           GNUNET_DATACACHE_Iterator iter,
+           void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = type;
+  struct GNUNET_TIME_Absolute now;
+  unsigned int cnt;
+  uint32_t off;
+  uint32_t bro32;
+  unsigned int total;
+  struct GNUNET_DATACACHE_Block block;
+  void *path;
+  void *data;
+  size_t path_size;
+  struct GNUNET_SQ_QueryParam params_count[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam params_select[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_uint32 (&off),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_auto_from_type (&block.trunc_peer),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_end
+  };
+
+  now = GNUNET_TIME_absolute_get ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing GET for key `%s'\n",
+       GNUNET_h2s (key));
+
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->get_count_stmt,
+                      params_count))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_bind_xxx");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_stmt);
+    return 0;
+  }
+  if (SQLITE_ROW !=
+      sqlite3_step (plugin->get_count_stmt))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_count_stmt);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No content found when processing GET for key `%s'\n",
+         GNUNET_h2s (key));
+    return 0;
+  }
+  total = sqlite3_column_int (plugin->get_count_stmt,
+                              0);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_count_stmt);
+  if ( (0 == total) ||
+       (NULL == iter) )
+  {
+    if (0 == total)
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "No content found when processing GET for key `%s'\n",
+           GNUNET_h2s (key));
+    return total;
+  }
+
+  cnt = 0;
+  block.key = *key;
+  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  total);
+  while (cnt < total)
+  {
+    off = (off + 1) % total;
+    if (GNUNET_OK !=
+        GNUNET_SQ_bind (plugin->get_stmt,
+                        params_select))
+    {
+      LOG_SQLITE (plugin->dbh,
+                  GNUNET_ERROR_TYPE_ERROR,
+                  "sqlite3_bind_xxx");
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
+      return cnt;
+    }
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->get_stmt))
+      break;
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->get_stmt,
+                                  rs))
+    {
+      GNUNET_break (0);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
+      break;
+    }
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.data = data;
+    block.put_path = path;
+    block.put_path_length = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.type = type;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    cnt++;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found %u-byte result when processing GET for key `%s'\n",
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+    if ( (NULL != iter) &&
+         (GNUNET_OK !=
+          iter (iter_cls,
+                &block)) )
+    {
+      GNUNET_SQ_cleanup_result (rs);
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->get_stmt);
+      break;
+    }
+    GNUNET_SQ_cleanup_result (rs);
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_stmt);
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_stmt);
+  return cnt;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+sqlite_plugin_get (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   enum GNUNET_BLOCK_Type type,
+                   GNUNET_DATACACHE_Iterator iter,
+                   void *iter_cls)
+{
+  if (GNUNET_BLOCK_TYPE_ANY == type)
+    return get_any (cls,
+                    key,
+                    iter,
+                    iter_cls);
+  return get_typed (cls,
+                    key,
+                    type,
+                    iter,
+                    iter_cls);
+}
+
+
+/**
+ * Delete the entry with the lowest expiration value
+ * from the datacache right now.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+sqlite_plugin_del (void *cls)
+{
+  struct Plugin *plugin = cls;
+  uint64_t rowid;
+  void *data;
+  size_t data_size;
+  struct GNUNET_HashCode hc;
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_uint64 (&rowid),
+    GNUNET_SQ_result_spec_auto_from_type (&hc),
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &data_size),
+    GNUNET_SQ_result_spec_end
+  };
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_uint64 (&rowid),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_QueryParam time_params[] = {
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing DEL\n");
+  now = GNUNET_TIME_absolute_get ();
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->del_expired_stmt,
+                      time_params))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_expired_stmt);
+    return GNUNET_SYSERR;
+  }
+  if ( (SQLITE_ROW !=
+        sqlite3_step (plugin->del_expired_stmt)) ||
+       (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->del_expired_stmt,
+                                  rs)))
+  {
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_expired_stmt);
+    if (SQLITE_ROW !=
+        sqlite3_step (plugin->del_select_stmt))
+    {
+      LOG_SQLITE (plugin->dbh,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_step");
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->del_select_stmt);
+      return GNUNET_SYSERR;
+    }
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->del_select_stmt,
+                                  rs))
+    {
+      GNUNET_SQ_reset (plugin->dbh,
+                       plugin->del_select_stmt);
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+  }
+  GNUNET_SQ_cleanup_result (rs);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->del_select_stmt);
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->del_stmt,
+                      params))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_stmt);
+    return GNUNET_SYSERR;
+  }
+  if (SQLITE_DONE !=
+      sqlite3_step (plugin->del_stmt))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->del_stmt);
+    return GNUNET_SYSERR;
+  }
+  plugin->num_items--;
+  plugin->env->delete_notify (plugin->env->cls,
+                              &hc,
+                              data_size + OVERHEAD);
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->del_stmt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterate over the results that are "close" to a particular key in
+ * the datacache.  "close" is defined as numerically larger than @a
+ * key (when interpreted as a circular address space), with small
+ * distance.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param key area of the keyspace to look into
+ * @param type desired block type for the replies
+ * @param num_results number of results that should be returned to @a iter
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+sqlite_plugin_get_closest (void *cls,
+                           const struct GNUNET_HashCode *key,
+                           enum GNUNET_BLOCK_Type type,
+                           unsigned int num_results,
+                           GNUNET_DATACACHE_Iterator iter,
+                           void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = type;
+  uint32_t num_results32 = num_results;
+  struct GNUNET_TIME_Absolute now;
+  void *data;
+  void *path;
+  size_t path_size;
+  unsigned int cnt;
+  uint32_t bro32;
+  struct GNUNET_DATACACHE_Block block;
+  uint32_t rtype32;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_uint32 (&num_results32),
+    GNUNET_SQ_query_param_end
+  };
+  struct GNUNET_SQ_ResultSpec rs[] = {
+    GNUNET_SQ_result_spec_variable_size (&data,
+                                         &block.data_size),
+    GNUNET_SQ_result_spec_absolute_time (&block.expiration_time),
+    GNUNET_SQ_result_spec_variable_size (&path,
+                                         &path_size),
+    GNUNET_SQ_result_spec_auto_from_type (&block.trunc_peer),
+    GNUNET_SQ_result_spec_uint32 (&rtype32),
+    GNUNET_SQ_result_spec_uint32 (&bro32),
+    GNUNET_SQ_result_spec_auto_from_type (&block.key),
+    GNUNET_SQ_result_spec_end
+  };
+
+  now = GNUNET_TIME_absolute_get ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing GET_CLOSEST for key `%s'\n",
+       GNUNET_h2s (key));
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (plugin->get_closest_stmt,
+                      params))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_xxx");
+    GNUNET_SQ_reset (plugin->dbh,
+                     plugin->get_closest_stmt);
+    return 0;
+  }
+  cnt = 0;
+  while (SQLITE_ROW ==
+         sqlite3_step (plugin->get_closest_stmt))
+  {
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (plugin->get_closest_stmt,
+                                  rs))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    if (0 != path_size % sizeof(struct GNUNET_DHT_PathElement))
+    {
+      GNUNET_break (0);
+      path_size = 0;
+      path = NULL;
+    }
+    block.put_path_length
+      = path_size / sizeof(struct GNUNET_DHT_PathElement);
+    block.put_path = path;
+    block.data = data;
+    block.type = (enum GNUNET_BLOCK_Type) rtype32;
+    block.ro = (enum GNUNET_DHT_RouteOption) bro32;
+    cnt++;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found %u-byte result at %s when processing GET_CLOSE\n",
+         (unsigned int) block.data_size,
+         GNUNET_h2s (&block.key));
+
+    if (GNUNET_OK !=
+        iter (iter_cls,
+              &block))
+    {
+      GNUNET_SQ_cleanup_result (rs);
+      break;
+    }
+    GNUNET_SQ_cleanup_result (rs);
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   plugin->get_closest_stmt);
+  return cnt;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironment`)
+ * @return the plugin's closure (our `struct Plugin`)
+ */
+void *
+libgnunet_plugin_datacache_sqlite_init (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
+  struct GNUNET_DATACACHE_PluginFunctions *api;
+  struct Plugin *plugin;
+  char *fn;
+  char *fn_utf8;
+  sqlite3 *dbh;
+  char *emsg;
+
+  if (GNUNET_YES ==
+      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                            "datacache-sqlite",
+                                            "IN_MEMORY"))
+  {
+    if (SQLITE_OK !=
+        sqlite3_open (":memory:",
+                      &dbh))
+      return NULL;
+    fn_utf8 = NULL;
+  }
+  else
+  {
+    fn = GNUNET_DISK_mktemp ("gnunet-datacache");
+    if (NULL == fn)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+    /* fn should be UTF-8-encoded. If it isn't, it's a bug. */
+    fn_utf8 = GNUNET_strdup (fn);
+    if (SQLITE_OK !=
+        sqlite3_open (fn_utf8,
+                      &dbh))
+    {
+      GNUNET_free (fn);
+      GNUNET_free (fn_utf8);
+      return NULL;
+    }
+    GNUNET_free (fn);
+  }
+
+  SQLITE3_EXEC (dbh, "PRAGMA temp_store=MEMORY");
+  SQLITE3_EXEC (dbh, "PRAGMA locking_mode=EXCLUSIVE");
+  SQLITE3_EXEC (dbh, "PRAGMA journal_mode=OFF");
+  SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF");
+  SQLITE3_EXEC (dbh, "PRAGMA page_size=4092");
+  if (GNUNET_YES ==
+      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                            "datacache-sqlite",
+                                            "IN_MEMORY"))
+    SQLITE3_EXEC (dbh, "PRAGMA sqlite_temp_store=3");
+
+  SQLITE3_EXEC (dbh,
+                "CREATE TABLE ds180 ("
+                "  type INTEGER NOT NULL DEFAULT 0,"
+                "  ro INTEGER NOT NULL DEFAULT 0,"
+                "  expire INTEGER NOT NULL,"
+                "  key BLOB NOT NULL DEFAULT '',"
+                "  prox INTEGER NOT NULL,"
+                "  value BLOB NOT NULL,"
+                "  trunc BLOB NOT NULL,"
+                "  path BLOB DEFAULT '')");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_hashidx"
+                " ON ds180 (key,type,expire)");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_prox_expire"
+                " ON ds180 (prox,expire)");
+  SQLITE3_EXEC (dbh,
+                "CREATE INDEX idx_expire_only"
+                " ON ds180 (expire)");
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+  plugin->dbh = dbh;
+  plugin->fn = fn_utf8;
+
+  if ((SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "INSERT INTO ds180"
+                   " (type, ro, expire, key, prox, value, path, trunc)"
+                   " VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                   &plugin->insert_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT COUNT(*) FROM ds180 "
+                   "WHERE key=?"
+                   " AND type=?"
+                   " AND expire >= ?",
+                   &plugin->get_count_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT COUNT(*) FROM ds180 "
+                   "WHERE key=? AND expire >= ?",
+                   &plugin->get_count_any_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path,trunc,ro"
+                   " FROM ds180"
+                   " WHERE key=?"
+                   " AND type=?"
+                   " AND expire >= ?"
+                   " LIMIT 1 OFFSET ?",
+                   &plugin->get_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path,trunc,type,ro"
+                   " FROM ds180"
+                   " WHERE key=?"
+                   " AND expire >= ?"
+                   " LIMIT 1 OFFSET ?",
+                   &plugin->get_any_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT _ROWID_,key,value FROM ds180"
+                   " WHERE expire < ?1"
+                   " ORDER BY expire ASC LIMIT 1",
+                   &plugin->del_expired_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT _ROWID_,key,value FROM ds180"
+                   " ORDER BY prox ASC, expire ASC LIMIT 1",
+                   &plugin->del_select_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "DELETE FROM ds180 WHERE _ROWID_=?",
+                   &plugin->del_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT * FROM ("
+                   " SELECT value,expire,path,trunc,type,ro,key"
+                   " FROM ds180 "
+                   " WHERE key>=?1 "
+                   "  AND expire >= ?2"
+                   "  AND ( (type=?3) or (0 == ?3) )"
+                   " ORDER BY KEY ASC LIMIT ?4)"
+                   "UNION "
+                   "SELECT * FROM ("
+                   " SELECT value,expire,path,trunc,type,ro,key"
+                   " FROM ds180 "
+                   " WHERE key<=?1 "
+                   "  AND expire >= ?2"
+                   "  AND ( (type=?3) or (0 == ?3) )"
+                   " ORDER BY KEY DESC LIMIT ?4)",
+                   &plugin->get_closest_stmt)))
+  {
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sq_prepare");
+    GNUNET_break (SQLITE_OK ==
+                  sqlite3_close (plugin->dbh));
+    GNUNET_free (plugin);
+    return NULL;
+  }
+
+  api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions);
+  api->cls = plugin;
+  api->get = &sqlite_plugin_get;
+  api->put = &sqlite_plugin_put;
+  api->del = &sqlite_plugin_del;
+  api->get_closest = &sqlite_plugin_get_closest;
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Sqlite datacache running\n");
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return NULL
+ */
+void *
+libgnunet_plugin_datacache_sqlite_done (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+  int result;
+
+#if SQLITE_VERSION_NUMBER >= 3007000
+  sqlite3_stmt *stmt;
+#endif
+
+#if ! WINDOWS || defined(__CYGWIN__)
+  if ( (NULL != plugin->fn) &&
+       (0 != unlink (plugin->fn)) )
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
+                       "unlink",
+                       plugin->fn);
+  GNUNET_free (plugin->fn);
+#endif
+  sqlite3_finalize (plugin->insert_stmt);
+  sqlite3_finalize (plugin->get_count_stmt);
+  sqlite3_finalize (plugin->get_count_any_stmt);
+  sqlite3_finalize (plugin->get_stmt);
+  sqlite3_finalize (plugin->get_any_stmt);
+  sqlite3_finalize (plugin->del_select_stmt);
+  sqlite3_finalize (plugin->del_expired_stmt);
+  sqlite3_finalize (plugin->del_stmt);
+  sqlite3_finalize (plugin->get_closest_stmt);
+  result = sqlite3_close (plugin->dbh);
+#if SQLITE_VERSION_NUMBER >= 3007000
+  if (SQLITE_BUSY == result)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         _ (
+           "Tried to close sqlite without finalizing all prepared statements.\n"));
+    stmt = sqlite3_next_stmt (plugin->dbh,
+                              NULL);
+    while (NULL != stmt)
+    {
+      result = sqlite3_finalize (stmt);
+      if (result != SQLITE_OK)
+        LOG (GNUNET_ERROR_TYPE_WARNING,
+             "Failed to close statement %p: %d\n",
+             stmt,
+             result);
+      stmt = sqlite3_next_stmt (plugin->dbh,
+                                NULL);
+    }
+    result = sqlite3_close (plugin->dbh);
+  }
+#endif
+  if (SQLITE_OK != result)
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_close");
+
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datacache_sqlite.c */
diff --git a/src/plugin/datacache/plugin_datacache_template.c b/src/plugin/datacache/plugin_datacache_template.c
new file mode 100644
index 000000000..1bd712d39
--- /dev/null
+++ b/src/plugin/datacache/plugin_datacache_template.c
@@ -0,0 +1,172 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2006, 2009, 2015, 2022 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 datacache/plugin_datacache_template.c
+ * @brief template for an implementation of a database backend for the datacache
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_datacache_plugin.h"
+
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATACACHE_PluginEnvironment *env;
+};
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param xor_distance distance of @a key to our PID
+ * @param block data to store
+ * @return 0 if duplicate, -1 on error, number of bytes used otherwise
+ */
+static ssize_t
+template_plugin_put (void *cls,
+                     uint32_t xor_distance,
+                     const struct GNUNET_DATACACHE_Block *block)
+{
+  GNUNET_break (0);
+  return -1;
+}
+
+
+/**
+ * Iterate over the results for a particular key
+ * in the datastore.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @param key
+ * @param type entries of which type are relevant?
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+template_plugin_get (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     enum GNUNET_BLOCK_Type type,
+                     GNUNET_DATACACHE_Iterator iter,
+                     void *iter_cls)
+{
+  GNUNET_break (0);
+  return 0;
+}
+
+
+/**
+ * Delete the entry with the lowest expiration value
+ * from the datacache right now.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+template_plugin_del (void *cls)
+{
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Iterate over the results that are "close" to a particular key in
+ * the datacache.  "close" is defined as numerically larger than @a
+ * key (when interpreted as a circular address space), with small
+ * distance.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param key area of the keyspace to look into
+ * @param type desired block type for the replies
+ * @param num_results number of results that should be returned to @a iter
+ * @param iter maybe NULL (to just count)
+ * @param iter_cls closure for @a iter
+ * @return the number of results found
+ */
+static unsigned int
+template_plugin_get_closest (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             enum GNUNET_BLOCK_Type type,
+                             unsigned int num_results,
+                             GNUNET_DATACACHE_Iterator iter,
+                             void *iter_cls)
+{
+  GNUNET_break (0);
+  return 0;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironmnet`)
+ * @return the plugin's closure (our `struct Plugin`)
+ */
+void *
+libgnunet_plugin_datacache_template_init (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
+  struct GNUNET_DATACACHE_PluginFunctions *api;
+  struct Plugin *plugin;
+
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+  api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions);
+  api->cls = plugin;
+  api->get = &template_plugin_get;
+  api->put = &template_plugin_put;
+  api->del = &template_plugin_del;
+  api->get_closest = &template_plugin_get_closest;
+  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
+                   "template",
+                   "Template datacache running\n");
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return NULL
+ */
+void *
+libgnunet_plugin_datacache_template_done (void *cls)
+{
+  struct GNUNET_DATACACHE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datacache_template.c */
diff --git a/src/plugin/datastore/Makefile.am b/src/plugin/datastore/Makefile.am
new file mode 100644
index 000000000..1f4ab59c8
--- /dev/null
+++ b/src/plugin/datastore/Makefile.am
@@ -0,0 +1,150 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+sqldir = $(prefix)/share/gnunet/sql/
+
+sql_DATA = \
+  datastore-0001.sql \
+  datastore-drop.sql
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIBS = -lgcov
+endif
+
+
+if HAVE_SQLITE
+ SQLITE_PLUGIN = libgnunet_plugin_datastore_sqlite.la
+if HAVE_BENCHMARKS
+  SQLITE_BENCHMARKS = \
+   perf_plugin_datastore_sqlite
+endif
+ SQLITE_TESTS = \
+  test_plugin_datastore_sqlite \
+  $(SQLITE_BENCHMARKS)
+endif
+if HAVE_POSTGRESQL
+ POSTGRES_PLUGIN = libgnunet_plugin_datastore_postgres.la
+if HAVE_BENCHMARKS
+  POSTGRES_BENCHMARKS = \
+   perf_plugin_datastore_postgres
+endif
+ POSTGRES_TESTS = \
+  test_plugin_datastore_postgres \
+  $(POSTGRES_BENCHMARKS)
+endif
+
+plugin_LTLIBRARIES = \
+  $(SQLITE_PLUGIN) \
+  $(POSTGRES_PLUGIN) \
+  libgnunet_plugin_datastore_heap.la
+
+# Real plugins should of course go into
+# plugin_LTLIBRARIES
+noinst_LTLIBRARIES = \
+  libgnunet_plugin_datastore_template.la
+
+
+libgnunet_plugin_datastore_sqlite_la_SOURCES = \
+  plugin_datastore_sqlite.c
+libgnunet_plugin_datastore_sqlite_la_LIBADD = \
+  $(top_builddir)/src/lib/sq/libgnunetsq.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lsqlite3 \
+  $(LTLIBINTL)
+libgnunet_plugin_datastore_sqlite_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+libgnunet_plugin_datastore_heap_la_SOURCES = \
+  plugin_datastore_heap.c
+libgnunet_plugin_datastore_heap_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
+  $(LTLIBINTL)
+libgnunet_plugin_datastore_heap_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+libgnunet_plugin_datastore_postgres_la_SOURCES = \
+  plugin_datastore_postgres.c
+libgnunet_plugin_datastore_postgres_la_LIBADD = \
+  $(top_builddir)/src/lib/pq/libgnunetpq.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lpq
+libgnunet_plugin_datastore_postgres_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS) $(POSTGRESQL_LDFLAGS)
+libgnunet_plugin_datastore_postgres_la_CPPFLAGS = \
+ $(POSTGRESQL_CPPFLAGS) $(AM_CPPFLAGS)
+
+
+libgnunet_plugin_datastore_template_la_SOURCES = \
+  plugin_datastore_template.c
+libgnunet_plugin_datastore_template_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
+  $(LTLIBINTL)
+libgnunet_plugin_datastore_template_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+check_PROGRAMS = \
+  perf_plugin_datastore_heap \
+  test_plugin_datastore_heap \
+  $(SQLITE_TESTS) \
+  $(POSTGRES_TESTS)
+
+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
+
+perf_plugin_datastore_heap_SOURCES = \
+ perf_plugin_datastore.c
+perf_plugin_datastore_heap_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_plugin_datastore_heap_SOURCES = \
+ test_plugin_datastore.c
+test_plugin_datastore_heap_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+
+perf_plugin_datastore_sqlite_SOURCES = \
+ perf_plugin_datastore.c
+perf_plugin_datastore_sqlite_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_plugin_datastore_sqlite_SOURCES = \
+ test_plugin_datastore.c
+test_plugin_datastore_sqlite_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+
+test_plugin_datastore_postgres_SOURCES = \
+ test_plugin_datastore.c
+test_plugin_datastore_postgres_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+perf_plugin_datastore_postgres_SOURCES = \
+ perf_plugin_datastore.c
+perf_plugin_datastore_postgres_LDADD = \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+
+
+EXTRA_DIST = \
+ test_defaults.conf \
+ perf_plugin_datastore_data_sqlite.conf \
+ test_plugin_datastore_data_sqlite.conf \
+ perf_plugin_datastore_data_heap.conf \
+ test_plugin_datastore_data_heap.conf \
+ perf_plugin_datastore_data_postgres.conf \
+ test_plugin_datastore_data_postgres.conf \
+ $(sql_DATA)
diff --git a/src/plugin/datastore/datastore-0001.sql b/src/plugin/datastore/datastore-0001.sql
new file mode 100644
index 000000000..0d4758be2
--- /dev/null
+++ b/src/plugin/datastore/datastore-0001.sql
@@ -0,0 +1,49 @@
+--
+-- This file is part of GNUnet
+-- Copyright (C) 2014--2022 GNUnet e.V.
+--
+-- GNUnet is free software; you can redistribute it and/or modify it under the
+-- terms of the GNU General Public License as published by the Free Software
+-- Foundation; either version 3, 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 General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License along with
+-- GNUnet; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+--
+
+-- Everything in one big transaction
+BEGIN;
+
+-- Check patch versioning is in place.
+SELECT _v.register_patch('datastore-0001', NULL, NULL);
+
+-------------------- Schema ----------------------------
+
+CREATE SCHEMA datastore;
+COMMENT ON SCHEMA datastore IS 'gnunet-datastore data';
+
+SET search_path TO datastore;
+
+CREATE TABLE IF NOT EXISTS gn090 (
+  repl INTEGER NOT NULL DEFAULT 0,
+  type INTEGER NOT NULL DEFAULT 0,
+  prio INTEGER NOT NULL DEFAULT 0,
+  anonLevel INTEGER NOT NULL DEFAULT 0,
+  expire BIGINT NOT NULL DEFAULT 0,
+  rvalue BIGINT NOT NULL DEFAULT 0,
+  hash BYTEA NOT NULL DEFAULT '',
+  vhash BYTEA NOT NULL DEFAULT '',
+  value BYTEA NOT NULL DEFAULT '',
+  oid  BIGINT GENERATED BY DEFAULT AS IDENTITY);
+
+CREATE INDEX IF NOT EXISTS oid_hash ON gn090 (oid);
+CREATE INDEX IF NOT EXISTS idx_hash ON gn090 (hash);
+CREATE INDEX IF NOT EXISTS idx_prio_anon ON gn090 (prio,anonLevel);
+CREATE INDEX IF NOT EXISTS idx_prio_hash_anon ON gn090 (prio,hash,anonLevel);
+CREATE INDEX IF NOT EXISTS idx_repl_rvalue ON gn090 (repl,rvalue);
+CREATE INDEX IF NOT EXISTS idx_expire_hash ON gn090 (expire,hash);
+
+COMMIT;
diff --git a/src/plugin/datastore/datastore-drop.sql b/src/plugin/datastore/datastore-drop.sql
new file mode 100644
index 000000000..67fee303d
--- /dev/null
+++ b/src/plugin/datastore/datastore-drop.sql
@@ -0,0 +1,25 @@
+--
+-- This file is part of GNUnet
+-- Copyright (C) 2014--2022 GNUnet e.V.
+--
+-- GNUnet is free software; you can redistribute it and/or modify it under the
+-- terms of the GNU General Public License as published by the Free Software
+-- Foundation; either version 3, 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 General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License along with
+-- GNUnet; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+--
+
+-- Everything in one big transaction
+BEGIN;
+
+
+SELECT _v.unregister_patch('datastore-0001');
+
+DROP SCHEMA datastore CASCADE;
+
+COMMIT;
diff --git a/src/plugin/datastore/meson.build b/src/plugin/datastore/meson.build
new file mode 100644
index 000000000..6769cb78b
--- /dev/null
+++ b/src/plugin/datastore/meson.build
@@ -0,0 +1,75 @@
+install_data ('datastore-0001.sql',
+              'datastore-drop.sql',
+               install_dir: get_option('datadir')/'gnunet'/'sql')
+
+shared_module('gnunet_plugin_datastore_sqlite',
+        ['plugin_datastore_sqlite.c'],
+        dependencies: [libgnunetutil_dep,
+                       sqlite_dep,
+                       libgnunetsq_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+shared_module('gnunet_plugin_datastore_heap',
+        ['plugin_datastore_heap.c'],
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+if pq_dep.found()
+  shared_module('gnunet_plugin_datastore_postgres',
+          ['plugin_datastore_postgres.c'],
+          dependencies: [libgnunetutil_dep,
+                         pq_dep,
+                         libgnunetpq_dep],
+          include_directories: [incdir, configuration_inc],
+          install: true,
+          install_dir: get_option('libdir')/'gnunet')
+endif
+
+testds_plugin_sqlite = executable ('test_plugin_datastore_sqlite',
+            ['test_plugin_datastore.c'],
+            dependencies: [
+              libgnunetutil_dep,
+              ],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+
+testds_plugin_heap = executable ('test_plugin_datastore_heap',
+            ['test_plugin_datastore.c'],
+            dependencies: [
+              libgnunetutil_dep,
+              ],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+
+testds_plugin_pq = executable ('test_plugin_datastore_postgres',
+            ['test_plugin_datastore.c'],
+            dependencies: [
+              libgnunetutil_dep,
+              ],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+
+configure_file(input : 'test_defaults.conf',
+               output : 'test_defaults.conf',
+               copy: true)
+configure_file(input : 'test_plugin_datastore_data_sqlite.conf',
+               output : 'test_plugin_datastore_data_sqlite.conf',
+               copy: true)
+configure_file(input : 'test_plugin_datastore_data_heap.conf',
+               output : 'test_plugin_datastore_data_heap.conf',
+               copy: true)
+configure_file(input : 'test_plugin_datastore_data_postgres.conf',
+               output : 'test_plugin_datastore_data_postgres.conf',
+               copy: true)
+
+test('test_plugin_datastore_sqlite', testds_plugin_sqlite,
+  suite: 'datastore', workdir: meson.current_build_dir())
+test('test_plugin_datastore_heap', testds_plugin_heap,
+  suite: 'datastore', workdir: meson.current_build_dir())
+test('test_plugin_datastore_postgres', testds_plugin_pq,
+  suite: 'datastore', workdir: meson.current_build_dir())
+
diff --git a/src/plugin/datastore/perf_plugin_datastore.c b/src/plugin/datastore/perf_plugin_datastore.c
new file mode 100644
index 000000000..8e63b08e6
--- /dev/null
+++ b/src/plugin/datastore/perf_plugin_datastore.c
@@ -0,0 +1,573 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 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 perf_plugin_datastore.c
+ * @brief Profile database plugin directly, focusing on iterators.
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_datastore_plugin.h"
+#include "gnunet_testing_lib.h"
+#include <gauger.h>
+
+/**
+ * Target datastore size (in bytes).  Realistic sizes are
+ * more like 16 GB (not the default of 16 MB); however,
+ * those take too long to run them in the usual "make check"
+ * sequence.  Hence the value used for shipping is tiny.
+ */
+#define MAX_SIZE 1024LL * 1024 * 16 * 1
+
+#define ITERATIONS 2
+
+/**
+ * Number of put operations equivalent to 1/10th of MAX_SIZE
+ */
+#define PUT_10 (MAX_SIZE / 32 / 1024 / ITERATIONS)
+
+static char category[256];
+
+static unsigned int hits[PUT_10 / 8 + 1];
+
+static unsigned long long stored_bytes;
+
+static unsigned long long stored_entries;
+
+static unsigned long long stored_ops;
+
+static const char *plugin_name;
+
+static int ok;
+
+enum RunPhase
+{
+  RP_ERROR = 0,
+  RP_PUT,
+  RP_REP_GET,
+  RP_ZA_GET,
+  RP_EXP_GET,
+  RP_DONE
+};
+
+
+struct CpsRunContext
+{
+  unsigned int i;
+  struct GNUNET_TIME_Absolute start;
+  struct GNUNET_TIME_Absolute end;
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  enum RunPhase phase;
+  unsigned int cnt;
+  unsigned int iter;
+  uint64_t offset;
+};
+
+
+/**
+ * Function called by plugins to notify us about a
+ * change in their disk utilization.
+ *
+ * @param cls closure (NULL)
+ * @param delta change in disk utilization,
+ *        0 for "reset to empty"
+ */
+static void
+disk_utilization_change_cb (void *cls, int delta)
+{
+}
+
+
+static void
+test (void *cls);
+
+
+/**
+ * Put continuation.
+ *
+ * @param cls closure
+ * @param key key for the item stored
+ * @param size size of the item stored
+ * @param status #GNUNET_OK or #GNUNET_SYSERROR
+ * @param msg error message on error
+ */
+static void
+put_continuation (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  uint32_t size,
+                  int status,
+                  const char *msg)
+{
+  struct CpsRunContext *crc = cls;
+
+  if (GNUNET_OK != status)
+  {
+    fprintf (stderr, "ERROR: `%s'\n", msg);
+  }
+  else
+  {
+    stored_bytes += size;
+    stored_ops++;
+    stored_entries++;
+  }
+  GNUNET_SCHEDULER_add_now (&test, crc);
+}
+
+
+static void
+do_put (struct CpsRunContext *crc)
+{
+  char value[65536];
+  size_t size;
+  static struct GNUNET_HashCode key;
+  static int i;
+  unsigned int prio;
+
+  if (0 == i)
+    crc->start = GNUNET_TIME_absolute_get ();
+  if (PUT_10 == i)
+  {
+    i = 0;
+    crc->end = GNUNET_TIME_absolute_get ();
+    {
+      printf ("%s took %s for %llu items\n", "Storing an item",
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_difference (crc->start,
+                                                     crc
+                                                     ->end),
+                GNUNET_YES),
+              PUT_10);
+      if (PUT_10 > 0)
+        GAUGER (category, "Storing an item",
+                (crc->end.abs_value_us - crc->start.abs_value_us) / 1000LL
+                / PUT_10,
+                "ms/item");
+    }
+    crc->i++;
+    crc->start = GNUNET_TIME_absolute_get ();
+    crc->phase++;
+    GNUNET_SCHEDULER_add_now (&test, crc);
+    return;
+  }
+  /* most content is 32k */
+  size = 32 * 1024;
+  if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16) == 0)   /* but some of it is less! */
+    size = 8 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 32 * 1024);
+  size = size - (size & 7);     /* always multiple of 8 */
+
+  /* generate random key */
+  key.bits[0] = (unsigned int) GNUNET_TIME_absolute_get ().abs_value_us;
+  GNUNET_CRYPTO_hash (&key, sizeof(struct GNUNET_HashCode), &key);
+  memset (value, i, size);
+  if (i > 255)
+    memset (value, i - 255, size / 2);
+  value[0] = crc->i;
+  GNUNET_memcpy (&value[4], &i, sizeof(i));
+  prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
+  crc->api->put (crc->api->cls,
+                 &key,
+                 false /* absent */,
+                 size,
+                 value,
+                 1 + i % 4 /* type */,
+                 prio,
+                 i % 4 /* anonymity */,
+                 0 /* replication */,
+                 GNUNET_TIME_relative_to_absolute
+                   (GNUNET_TIME_relative_multiply
+                     (GNUNET_TIME_UNIT_MILLISECONDS,
+                     60 * 60 * 60 * 1000
+                     + GNUNET_CRYPTO_random_u32
+                       (GNUNET_CRYPTO_QUALITY_WEAK, 1000))),
+                 put_continuation,
+                 crc);
+  i++;
+}
+
+
+static int
+iterate_zeros (void *cls,
+               const struct GNUNET_HashCode *key,
+               uint32_t size,
+               const void *data,
+               enum GNUNET_BLOCK_Type type,
+               uint32_t priority,
+               uint32_t anonymity,
+               uint32_t replication,
+               struct GNUNET_TIME_Absolute expiration,
+               uint64_t uid)
+{
+  struct CpsRunContext *crc = cls;
+  int i;
+  const char *cdata = data;
+
+  GNUNET_assert (key != NULL);
+  GNUNET_assert (size >= 8);
+  GNUNET_memcpy (&i, &cdata[4], sizeof(i));
+  hits[i / 8] |= (1 << (i % 8));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Found result %d type=%u, priority=%u, size=%u, expire=%s\n",
+              i,
+              type, priority, size,
+              GNUNET_STRINGS_absolute_time_to_string (expiration));
+  crc->cnt++;
+  if (crc->cnt == PUT_10 / 4 - 1)
+  {
+    unsigned int bc;
+
+    bc = 0;
+    for (i = 0; i < PUT_10; i++)
+      if (0 != (hits[i / 8] & (1 << (i % 8))))
+        bc++;
+
+    crc->end = GNUNET_TIME_absolute_get ();
+    printf ("%s took %s yielding %u/%u items\n",
+            "Select random zero-anonymity item",
+            GNUNET_STRINGS_relative_time_to_string (
+              GNUNET_TIME_absolute_get_difference (crc->start,
+                                                   crc
+                                                   ->end),
+              GNUNET_YES),
+            bc, crc->cnt);
+    if (crc->cnt > 0)
+      GAUGER (category, "Select random zero-anonymity item",
+              (crc->end.abs_value_us - crc->start.abs_value_us) / 1000LL
+              / crc->cnt,
+              "ms/item");
+    memset (hits, 0, sizeof(hits));
+    crc->phase++;
+    crc->cnt = 0;
+    crc->start = GNUNET_TIME_absolute_get ();
+  }
+  GNUNET_SCHEDULER_add_now (&test, crc);
+  return GNUNET_OK;
+}
+
+
+static int
+expiration_get (void *cls,
+                const struct GNUNET_HashCode *key,
+                uint32_t size,
+                const void *data,
+                enum GNUNET_BLOCK_Type type,
+                uint32_t priority,
+                uint32_t anonymity,
+                uint32_t replication,
+                struct GNUNET_TIME_Absolute expiration,
+                uint64_t uid)
+{
+  struct CpsRunContext *crc = cls;
+  int i;
+  const char *cdata = data;
+
+  GNUNET_assert (size >= 8);
+  GNUNET_memcpy (&i, &cdata[4], sizeof(i));
+  hits[i / 8] |= (1 << (i % 8));
+  crc->cnt++;
+  if (PUT_10 <= crc->cnt)
+  {
+    unsigned int bc;
+
+    bc = 0;
+    for (i = 0; i < PUT_10; i++)
+      if (0 != (hits[i / 8] & (1 << (i % 8))))
+        bc++;
+
+    crc->end = GNUNET_TIME_absolute_get ();
+    printf ("%s took %s yielding %u/%u items\n",
+            "Selecting and deleting by expiration",
+            GNUNET_STRINGS_relative_time_to_string (
+              GNUNET_TIME_absolute_get_difference (crc->start,
+                                                   crc
+                                                   ->end),
+              GNUNET_YES),
+            bc, (unsigned int) PUT_10);
+    if (crc->cnt > 0)
+      GAUGER (category, "Selecting and deleting by expiration",
+              (crc->end.abs_value_us - crc->start.abs_value_us) / 1000LL
+              / crc->cnt,
+              "ms/item");
+    memset (hits, 0, sizeof(hits));
+    if (++crc->iter == ITERATIONS)
+      crc->phase++;
+    else
+      crc->phase = RP_PUT;
+    crc->cnt = 0;
+    crc->start = GNUNET_TIME_absolute_get ();
+  }
+  GNUNET_SCHEDULER_add_now (&test, crc);
+  return GNUNET_NO;
+}
+
+
+static int
+replication_get (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 uint32_t size,
+                 const void *data,
+                 enum GNUNET_BLOCK_Type type,
+                 uint32_t priority,
+                 uint32_t anonymity,
+                 uint32_t replication,
+                 struct GNUNET_TIME_Absolute expiration,
+                 uint64_t uid)
+{
+  struct CpsRunContext *crc = cls;
+  int i;
+  const char *cdata = data;
+
+  GNUNET_assert (NULL != key);
+  GNUNET_assert (size >= 8);
+  GNUNET_memcpy (&i, &cdata[4], sizeof(i));
+  hits[i / 8] |= (1 << (i % 8));
+  crc->cnt++;
+  if (PUT_10 <= crc->cnt)
+  {
+    unsigned int bc;
+
+    bc = 0;
+    for (i = 0; i < PUT_10; i++)
+      if (0 != (hits[i / 8] & (1 << (i % 8))))
+        bc++;
+
+    crc->end = GNUNET_TIME_absolute_get ();
+    printf ("%s took %s yielding %u/%u items\n",
+            "Selecting random item for replication",
+            GNUNET_STRINGS_relative_time_to_string (
+              GNUNET_TIME_absolute_get_difference (crc->start,
+                                                   crc
+                                                   ->end),
+              GNUNET_YES),
+            bc, (unsigned int) PUT_10);
+    if (crc->cnt > 0)
+      GAUGER (category, "Selecting random item for replication",
+              (crc->end.abs_value_us - crc->start.abs_value_us) / 1000LL
+              / crc->cnt,
+              "ms/item");
+    memset (hits, 0, sizeof(hits));
+    crc->phase++;
+    crc->offset = 0;
+    crc->cnt = 0;
+    crc->start = GNUNET_TIME_absolute_get ();
+  }
+
+  GNUNET_SCHEDULER_add_now (&test, crc);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called when the service shuts
+ * down.  Unloads our datastore plugin.
+ *
+ * @param api api to unload
+ * @param cfg configuration to use
+ */
+static void
+unload_plugin (struct GNUNET_DATASTORE_PluginFunctions *api,
+               const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  char *name;
+  char *libname;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "DATASTORE", "DATABASE",
+                                             &name))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No `%s' specified for `%s' in configuration!\n"),
+                "DATABASE",
+                "DATASTORE");
+    return;
+  }
+  GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
+  GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api));
+  GNUNET_free (libname);
+  GNUNET_free (name);
+}
+
+
+/**
+ * Last task run during shutdown.  Disconnects us from
+ * the transport and core.
+ */
+static void
+cleaning_task (void *cls)
+{
+  struct CpsRunContext *crc = cls;
+
+  unload_plugin (crc->api, crc->cfg);
+  GNUNET_free (crc);
+}
+
+
+static void
+test (void *cls)
+{
+  struct CpsRunContext *crc = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "In phase %d, iteration %u\n", crc->phase, crc->cnt);
+  switch (crc->phase)
+  {
+  case RP_ERROR:
+    GNUNET_break (0);
+    crc->api->drop (crc->api->cls);
+    ok = 1;
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                        &cleaning_task, crc);
+    break;
+
+  case RP_PUT:
+    do_put (crc);
+    break;
+
+  case RP_REP_GET:
+    crc->api->get_replication (crc->api->cls, &replication_get, crc);
+    break;
+
+  case RP_ZA_GET:
+    crc->api->get_zero_anonymity (crc->api->cls, crc->offset++, 1,
+                                  &iterate_zeros, crc);
+    break;
+
+  case RP_EXP_GET:
+    crc->api->get_expiration (crc->api->cls, &expiration_get, crc);
+    break;
+
+  case RP_DONE:
+    crc->api->drop (crc->api->cls);
+    ok = 0;
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                        &cleaning_task, crc);
+    break;
+  }
+}
+
+
+/**
+ * Load the datastore plugin.
+ */
+static struct GNUNET_DATASTORE_PluginFunctions *
+load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  static struct GNUNET_DATASTORE_PluginEnvironment env;
+  struct GNUNET_DATASTORE_PluginFunctions *ret;
+  char *name;
+  char *libname;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "DATASTORE", "DATABASE",
+                                             &name))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No `%s' specified for `%s' in configuration!\n"),
+                "DATABASE",
+                "DATASTORE");
+    return NULL;
+  }
+  env.cfg = cfg;
+  env.duc = &disk_utilization_change_cb;
+  env.cls = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Loading `%s' datastore plugin\n"),
+              name);
+  GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
+  if (NULL == (ret = GNUNET_PLUGIN_load (libname, &env)))
+  {
+    fprintf (stderr, "Failed to load plugin `%s'!\n", name);
+    GNUNET_free (name);
+    GNUNET_free (libname);
+    return NULL;
+  }
+  GNUNET_free (libname);
+  GNUNET_free (name);
+  return ret;
+}
+
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  struct CpsRunContext *crc;
+
+  if (NULL == c)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  api = load_plugin (c);
+  if (api == NULL)
+  {
+    fprintf (stderr,
+             "%s",
+             "Could not initialize plugin, assuming database not configured. Test not run!\n");
+    return;
+  }
+  crc = GNUNET_new (struct CpsRunContext);
+  crc->api = api;
+  crc->cfg = c;
+  crc->phase = RP_PUT;
+  ok = 2;
+  GNUNET_SCHEDULER_add_now (&test, crc);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  char dir_name[PATH_MAX];
+  char cfg_name[PATH_MAX];
+  char *const xargv[] = {
+    "perf-plugin-datastore",
+    "-c",
+    cfg_name,
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  plugin_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]);
+  GNUNET_snprintf (dir_name, sizeof(dir_name), "/tmp/perf-gnunet-datastore-%s",
+                   plugin_name);
+  GNUNET_DISK_directory_remove (dir_name);
+  GNUNET_log_setup ("perf-plugin-datastore",
+                    "WARNING",
+                    NULL);
+  GNUNET_snprintf (category, sizeof(category), "DATASTORE-%s", plugin_name);
+  GNUNET_snprintf (cfg_name, sizeof(cfg_name),
+                   "perf_plugin_datastore_data_%s.conf", plugin_name);
+  GNUNET_PROGRAM_run ((sizeof(xargv) / sizeof(char *)) - 1, xargv,
+                      "perf-plugin-datastore", "nohelp", options, &run, NULL);
+  if (ok != 0)
+    fprintf (stderr, "Missed some testcases: %u\n", ok);
+  GNUNET_DISK_directory_remove (dir_name);
+
+  return ok;
+}
+
+
+/* end of perf_plugin_datastore.c */
diff --git a/src/plugin/datastore/perf_plugin_datastore_data_heap.conf b/src/plugin/datastore/perf_plugin_datastore_data_heap.conf
new file mode 100644
index 000000000..873cf9606
--- /dev/null
+++ b/src/plugin/datastore/perf_plugin_datastore_data_heap.conf
@@ -0,0 +1,7 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/perf-gnunet-datastore-heap/
+
+
+[datastore]
+DATABASE = heap
diff --git a/src/plugin/datastore/perf_plugin_datastore_data_postgres.conf b/src/plugin/datastore/perf_plugin_datastore_data_postgres.conf
new file mode 100644
index 000000000..7683887a8
--- /dev/null
+++ b/src/plugin/datastore/perf_plugin_datastore_data_postgres.conf
@@ -0,0 +1,10 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/perf-gnunet-datastore-postgres/
+
+[datastore]
+DATABASE = postgres
+
+[datastore-postgres]
+CONFIG = dbname=gnunetcheck
+
diff --git a/src/plugin/datastore/perf_plugin_datastore_data_sqlite.conf b/src/plugin/datastore/perf_plugin_datastore_data_sqlite.conf
new file mode 100644
index 000000000..888e020a6
--- /dev/null
+++ b/src/plugin/datastore/perf_plugin_datastore_data_sqlite.conf
@@ -0,0 +1,4 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/perf-gnunet-datastore-sqlite/
+
diff --git a/src/plugin/datastore/plugin_datastore_heap.c b/src/plugin/datastore/plugin_datastore_heap.c
new file mode 100644
index 000000000..a827a2763
--- /dev/null
+++ b/src/plugin/datastore/plugin_datastore_heap.c
@@ -0,0 +1,944 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file datastore/plugin_datastore_heap.c
+ * @brief heap-based datastore backend; usually we want the datastore
+ *        to be persistent, and storing data in the heap is obviously
+ *        NOT going to be persistent; still, this plugin is useful for
+ *        testing/benchmarking --- but never for production!
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_datastore_plugin.h"
+
+
+/**
+ * A value that we are storing.
+ */
+struct Value
+{
+  /**
+   * Key for the value.
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Pointer to the value's data (allocated at the end of this struct).
+   */
+  const void *data;
+
+  /**
+   * Entry for this value in the 'expire' heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *expire_heap;
+
+  /**
+   * Entry for this value in the 'replication' heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *replication_heap;
+
+  /**
+   * Expiration time for this value.
+   */
+  struct GNUNET_TIME_Absolute expiration;
+
+  /**
+   * Offset of this value in the array of the 'struct ZeroAnonByType';
+   * only used if anonymity is zero.
+   */
+  unsigned int zero_anon_offset;
+
+  /**
+   * Number of bytes in 'data'.
+   */
+  uint32_t size;
+
+  /**
+   * Priority of the value.
+   */
+  uint32_t priority;
+
+  /**
+   * Anonymity level for the value.
+   */
+  uint32_t anonymity;
+
+  /**
+   * Replication level for the value.
+   */
+  uint32_t replication;
+
+  /**
+   * Type of 'data'.
+   */
+  enum GNUNET_BLOCK_Type type;
+};
+
+
+/**
+ * We organize 0-anonymity values in arrays "by type".
+ */
+struct ZeroAnonByType
+{
+  /**
+   * We keep these in a DLL.
+   */
+  struct ZeroAnonByType *next;
+
+  /**
+   * We keep these in a DLL.
+   */
+  struct ZeroAnonByType *prev;
+
+  /**
+   * Array of 0-anonymity items of the given type.
+   */
+  struct Value **array;
+
+  /**
+   * Allocated size of the array.
+   */
+  unsigned int array_size;
+
+  /**
+   * First unused offset in 'array'.
+   */
+  unsigned int array_pos;
+
+  /**
+   * Type of all of the values in 'array'.
+   */
+  enum GNUNET_BLOCK_Type type;
+};
+
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATASTORE_PluginEnvironment *env;
+
+  /**
+   * Mapping from keys to 'struct Value's.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *keyvalue;
+
+  /**
+   * Heap organized by minimum expiration time.
+   */
+  struct GNUNET_CONTAINER_Heap *by_expiration;
+
+  /**
+   * Heap organized by maximum replication value.
+   */
+  struct GNUNET_CONTAINER_Heap *by_replication;
+
+  /**
+   * Head of list of arrays containing zero-anonymity values by type.
+   */
+  struct ZeroAnonByType *zero_head;
+
+  /**
+   * Tail of list of arrays containing zero-anonymity values by type.
+   */
+  struct ZeroAnonByType *zero_tail;
+
+  /**
+   * Size of all values we're storing.
+   */
+  unsigned long long size;
+};
+
+
+/**
+ * Get an estimate of how much space the database is
+ * currently using.
+ *
+ * @param cls our "struct Plugin*"
+ * @return number of bytes used on disk
+ */
+static void
+heap_plugin_estimate_size (void *cls, unsigned long long *estimate)
+{
+  struct Plugin *plugin = cls;
+
+  if (NULL != estimate)
+    *estimate = plugin->size;
+}
+
+
+/**
+ * Closure for iterator for updating.
+ */
+struct UpdateContext
+{
+  /**
+   * Number of bytes in 'data'.
+   */
+  uint32_t size;
+
+  /**
+   * Pointer to the data.
+   */
+  const void *data;
+
+  /**
+   * Priority of the value.
+   */
+  uint32_t priority;
+
+  /**
+   * Replication level for the value.
+   */
+  uint32_t replication;
+
+  /**
+   * Expiration time for this value.
+   */
+  struct GNUNET_TIME_Absolute expiration;
+
+  /**
+   * True if the value was found and updated.
+   */
+  bool updated;
+};
+
+
+/**
+ * Update the matching value.
+ *
+ * @param cls the 'struct UpdateContext'
+ * @param key unused
+ * @param val the 'struct Value'
+ * @return GNUNET_YES (continue iteration), GNUNET_NO if value was found
+ */
+static int
+update_iterator (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *val)
+{
+  struct UpdateContext *uc = cls;
+  struct Value *value = val;
+
+  if (value->size != uc->size)
+    return GNUNET_YES;
+  if (0 != memcmp (value->data, uc->data, uc->size))
+    return GNUNET_YES;
+  uc->expiration = GNUNET_TIME_absolute_max (value->expiration,
+                                             uc->expiration);
+  if (value->expiration.abs_value_us != uc->expiration.abs_value_us)
+  {
+    value->expiration = uc->expiration;
+    GNUNET_CONTAINER_heap_update_cost (value->expire_heap,
+                                       value->expiration.abs_value_us);
+  }
+  /* Saturating adds, don't overflow */
+  if (value->priority > UINT32_MAX - uc->priority)
+    value->priority = UINT32_MAX;
+  else
+    value->priority += uc->priority;
+  if (value->replication > UINT32_MAX - uc->replication)
+    value->replication = UINT32_MAX;
+  else
+    value->replication += uc->replication;
+  uc->updated = true;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the item
+ * @param absent true if the key was not found in the bloom filter
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure
+ */
+static void
+heap_plugin_put (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 bool absent,
+                 uint32_t size,
+                 const void *data,
+                 enum GNUNET_BLOCK_Type type,
+                 uint32_t priority,
+                 uint32_t anonymity,
+                 uint32_t replication,
+                 struct GNUNET_TIME_Absolute expiration,
+                 PluginPutCont cont,
+                 void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct Value *value;
+
+  if (! absent)
+  {
+    struct UpdateContext uc;
+
+    uc.size = size;
+    uc.data = data;
+    uc.priority = priority;
+    uc.replication = replication;
+    uc.expiration = expiration;
+    uc.updated = false;
+    GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
+                                                key,
+                                                &update_iterator,
+                                                &uc);
+    if (uc.updated)
+    {
+      cont (cont_cls, key, size, GNUNET_NO, NULL);
+      return;
+    }
+  }
+  value = GNUNET_malloc (sizeof(struct Value) + size);
+  value->key = *key;
+  value->data = &value[1];
+  value->expire_heap = GNUNET_CONTAINER_heap_insert (plugin->by_expiration,
+                                                     value,
+                                                     expiration.abs_value_us);
+  value->replication_heap = GNUNET_CONTAINER_heap_insert (
+    plugin->by_replication,
+    value,
+    replication);
+  value->expiration = expiration;
+  if (0 == anonymity)
+  {
+    struct ZeroAnonByType *zabt;
+
+    for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
+      if (zabt->type == type)
+        break;
+    if (NULL == zabt)
+    {
+      zabt = GNUNET_new (struct ZeroAnonByType);
+      zabt->type = type;
+      GNUNET_CONTAINER_DLL_insert (plugin->zero_head,
+                                   plugin->zero_tail,
+                                   zabt);
+    }
+    if (zabt->array_size == zabt->array_pos)
+    {
+      GNUNET_array_grow (zabt->array,
+                         zabt->array_size,
+                         zabt->array_size * 2 + 4);
+    }
+    value->zero_anon_offset = zabt->array_pos;
+    zabt->array[zabt->array_pos++] = value;
+  }
+  value->size = size;
+  value->priority = priority;
+  value->anonymity = anonymity;
+  value->replication = replication;
+  value->type = type;
+  GNUNET_memcpy (&value[1], data, size);
+  GNUNET_CONTAINER_multihashmap_put (plugin->keyvalue,
+                                     &value->key,
+                                     value,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  plugin->size += size;
+  cont (cont_cls, key, size, GNUNET_OK, NULL);
+}
+
+
+/**
+ * Delete the given value, removing it from the plugin's data
+ * structures.
+ *
+ * @param plugin the plugin
+ * @param value value to delete
+ */
+static void
+delete_value (struct Plugin *plugin,
+              struct Value *value)
+{
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (plugin->keyvalue,
+                                                       &value->key,
+                                                       value));
+  GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (
+                   value->expire_heap));
+  GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (
+                   value->replication_heap));
+  if (0 == value->anonymity)
+  {
+    struct ZeroAnonByType *zabt;
+
+    for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
+      if (zabt->type == value->type)
+        break;
+    GNUNET_assert (NULL != zabt);
+    zabt->array[value->zero_anon_offset] = zabt->array[--zabt->array_pos];
+    zabt->array[value->zero_anon_offset]->zero_anon_offset =
+      value->zero_anon_offset;
+    if (0 == zabt->array_pos)
+    {
+      GNUNET_array_grow (zabt->array,
+                         zabt->array_size,
+                         0);
+      GNUNET_CONTAINER_DLL_remove (plugin->zero_head,
+                                   plugin->zero_tail,
+                                   zabt);
+      GNUNET_free (zabt);
+    }
+  }
+  plugin->size -= value->size;
+  GNUNET_free (value);
+}
+
+
+/**
+ * Closure for iterator called during 'get_key'.
+ */
+struct GetContext
+{
+  /**
+   * Lowest uid to consider.
+   */
+  uint64_t next_uid;
+
+  /**
+   * Value with lowest uid >= next_uid found so far.
+   */
+  struct Value *value;
+
+  /**
+   * Requested type.
+   */
+  enum GNUNET_BLOCK_Type type;
+
+  /**
+   * If true, return a random value
+   */
+  bool random;
+};
+
+
+/**
+ * Obtain the matching value with the lowest uid >= next_uid.
+ *
+ * @param cls the 'struct GetContext'
+ * @param key unused
+ * @param val the 'struct Value'
+ * @return GNUNET_YES (continue iteration), GNUNET_NO if result was found
+ */
+static int
+get_iterator (void *cls,
+              const struct GNUNET_HashCode *key,
+              void *val)
+{
+  struct GetContext *gc = cls;
+  struct Value *value = val;
+
+  if ((gc->type != GNUNET_BLOCK_TYPE_ANY) &&
+      (gc->type != value->type))
+    return GNUNET_OK;
+  if (gc->random)
+  {
+    gc->value = value;
+    return GNUNET_NO;
+  }
+  if ((uint64_t) (intptr_t) value < gc->next_uid)
+    return GNUNET_OK;
+  if ((NULL != gc->value) &&
+      (value > gc->value))
+    return GNUNET_OK;
+  gc->value = value;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get one of the results for a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param random if true, return a random result instead of using next_uid
+ * @param key maybe NULL (to match all entries)
+ * @param type entries of which type are relevant?
+ *     Use 0 for any type.
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if nothing matches
+ * @param proc_cls closure for @a proc
+ */
+static void
+heap_plugin_get_key (void *cls,
+                     uint64_t next_uid,
+                     bool random,
+                     const struct GNUNET_HashCode *key,
+                     enum GNUNET_BLOCK_Type type,
+                     PluginDatumProcessor proc,
+                     void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GetContext gc;
+
+  gc.value = NULL;
+  gc.next_uid = next_uid;
+  gc.random = random;
+  gc.type = type;
+  if (NULL == key)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
+                                           &get_iterator,
+                                           &gc);
+  }
+  else
+  {
+    GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
+                                                key,
+                                                &get_iterator,
+                                                &gc);
+  }
+  if (NULL == gc.value)
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 proc (proc_cls,
+                       &gc.value->key,
+                       gc.value->size,
+                       &gc.value[1],
+                       gc.value->type,
+                       gc.value->priority,
+                       gc.value->anonymity,
+                       gc.value->replication,
+                       gc.value->expiration,
+                       (uint64_t) (intptr_t) gc.value));
+}
+
+
+/**
+ * Get a random item for replication.  Returns a single, not expired,
+ * random item from those with the highest replication counters.  The
+ * item's replication counter is decremented by one IF it was positive
+ * before.  Call 'proc' with all values ZERO or NULL if the datastore
+ * is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for proc
+ */
+static void
+heap_plugin_get_replication (void *cls,
+                             PluginDatumProcessor proc,
+                             void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct Value *value;
+
+  value = GNUNET_CONTAINER_heap_remove_root (plugin->by_replication);
+  if (NULL == value)
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  if (value->replication > 0)
+  {
+    value->replication--;
+    value->replication_heap = GNUNET_CONTAINER_heap_insert (
+      plugin->by_replication,
+      value,
+      value->replication);
+  }
+  else
+  {
+    /* need a better way to pick a random item, replication level is always 0 */
+    value->replication_heap = GNUNET_CONTAINER_heap_insert (
+      plugin->by_replication,
+      value,
+      value->replication);
+    value = GNUNET_CONTAINER_heap_walk_get_next (plugin->by_replication);
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 proc (proc_cls,
+                       &value->key,
+                       value->size,
+                       &value[1],
+                       value->type,
+                       value->priority,
+                       value->anonymity,
+                       value->replication,
+                       value->expiration,
+                       (uint64_t) (intptr_t) value));
+}
+
+
+/**
+ * Get a random item for expiration.  Call 'proc' with all values ZERO
+ * or NULL if the datastore is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for proc
+ */
+static void
+heap_plugin_get_expiration (void *cls, PluginDatumProcessor proc,
+                            void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct Value *value;
+
+  value = GNUNET_CONTAINER_heap_peek (plugin->by_expiration);
+  if (NULL == value)
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  if (GNUNET_NO ==
+      proc (proc_cls,
+            &value->key,
+            value->size,
+            &value[1],
+            value->type,
+            value->priority,
+            value->anonymity,
+            value->replication,
+            value->expiration,
+            (uint64_t) (intptr_t) value))
+    delete_value (plugin, value);
+}
+
+
+/**
+ * Call the given processor on an item with zero anonymity.
+ *
+ * @param cls our "struct Plugin*"
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param type entries of which type should be considered?
+ *        Must not be zero (ANY).
+ * @param proc function to call on each matching value;
+ *        will be called with NULL if no value matches
+ * @param proc_cls closure for proc
+ */
+static void
+heap_plugin_get_zero_anonymity (void *cls, uint64_t next_uid,
+                                enum GNUNET_BLOCK_Type type,
+                                PluginDatumProcessor proc, void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct ZeroAnonByType *zabt;
+  struct Value *value = NULL;
+
+  for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
+  {
+    if ((type != GNUNET_BLOCK_TYPE_ANY) &&
+        (type != zabt->type))
+      continue;
+    for (int i = 0; i < zabt->array_pos; ++i)
+    {
+      if ((uint64_t) (intptr_t) zabt->array[i] < next_uid)
+        continue;
+      if ((NULL != value) &&
+          (zabt->array[i] > value))
+        continue;
+      value = zabt->array[i];
+    }
+  }
+  if (NULL == value)
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 proc (proc_cls,
+                       &value->key,
+                       value->size,
+                       &value[1],
+                       value->type,
+                       value->priority,
+                       value->anonymity,
+                       value->replication,
+                       value->expiration,
+                       (uint64_t) (intptr_t) value));
+}
+
+
+/**
+ * Drop database.
+ */
+static void
+heap_plugin_drop (void *cls)
+{
+  /* nothing needs to be done */
+}
+
+
+/**
+ * Closure for the 'return_value' function.
+ */
+struct GetAllContext
+{
+  /**
+   * Function to call.
+   */
+  PluginKeyProcessor proc;
+
+  /**
+   * Closure for 'proc'.
+   */
+  void *proc_cls;
+};
+
+
+/**
+ * Callback invoked to call callback on each value.
+ *
+ * @param cls the plugin
+ * @param key unused
+ * @param val the value
+ * @return GNUNET_OK (continue to iterate)
+ */
+static int
+return_value (void *cls,
+              const struct GNUNET_HashCode *key,
+              void *val)
+{
+  struct GetAllContext *gac = cls;
+
+  gac->proc (gac->proc_cls,
+             key,
+             1);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get all of the keys in the datastore.
+ *
+ * @param cls closure
+ * @param proc function to call on each key
+ * @param proc_cls closure for proc
+ */
+static void
+heap_get_keys (void *cls,
+               PluginKeyProcessor proc,
+               void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GetAllContext gac;
+
+  gac.proc = proc;
+  gac.proc_cls = proc_cls;
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
+                                         &return_value,
+                                         &gac);
+  proc (proc_cls, NULL, 0);
+}
+
+
+/**
+ * Closure for iterator called during 'remove_key'.
+ */
+struct RemoveContext
+{
+  /**
+   * Value found.
+   */
+  struct Value *value;
+
+  /**
+   * Size of data.
+   */
+  uint32_t size;
+
+  /**
+   * Data to remove.
+   */
+  const void *data;
+};
+
+
+/**
+ * Obtain the matching value with the lowest uid >= next_uid.
+ *
+ * @param cls the 'struct GetContext'
+ * @param key unused
+ * @param val the 'struct Value'
+ * @return GNUNET_YES (continue iteration), GNUNET_NO if result was found
+ */
+static int
+remove_iterator (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *val)
+{
+  struct RemoveContext *rc = cls;
+  struct Value *value = val;
+
+  if (value->size != rc->size)
+    return GNUNET_YES;
+  if (0 != memcmp (value->data, rc->data, rc->size))
+    return GNUNET_YES;
+  rc->value = value;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Remove a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the content
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure for @a cont
+ */
+static void
+heap_plugin_remove_key (void *cls,
+                        const struct GNUNET_HashCode *key,
+                        uint32_t size,
+                        const void *data,
+                        PluginRemoveCont cont,
+                        void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct RemoveContext rc;
+
+  rc.value = NULL;
+  rc.size = size;
+  rc.data = data;
+  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
+                                              key,
+                                              &remove_iterator,
+                                              &rc);
+  if (NULL == rc.value)
+  {
+    cont (cont_cls,
+          key,
+          size,
+          GNUNET_NO,
+          NULL);
+    return;
+  }
+  delete_value (plugin,
+                rc.value);
+  cont (cont_cls,
+        key,
+        size,
+        GNUNET_OK,
+        NULL);
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls the "struct GNUNET_DATASTORE_PluginEnvironment*"
+ * @return our "struct Plugin*"
+ */
+void *
+libgnunet_plugin_datastore_heap_init (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  struct Plugin *plugin;
+  unsigned long long esize;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (env->cfg,
+                                             "datastore-heap",
+                                             "HASHMAPSIZE",
+                                             &esize))
+    esize = 128 * 1024;
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+  plugin->keyvalue = GNUNET_CONTAINER_multihashmap_create (esize, GNUNET_YES);
+  plugin->by_expiration = GNUNET_CONTAINER_heap_create (
+    GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  plugin->by_replication = GNUNET_CONTAINER_heap_create (
+    GNUNET_CONTAINER_HEAP_ORDER_MAX);
+  api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
+  api->cls = plugin;
+  api->estimate_size = &heap_plugin_estimate_size;
+  api->put = &heap_plugin_put;
+  api->get_key = &heap_plugin_get_key;
+  api->get_replication = &heap_plugin_get_replication;
+  api->get_expiration = &heap_plugin_get_expiration;
+  api->get_zero_anonymity = &heap_plugin_get_zero_anonymity;
+  api->drop = &heap_plugin_drop;
+  api->get_keys = &heap_get_keys;
+  api->remove_key = &heap_plugin_remove_key;
+  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "heap",
+                   _ ("Heap database running\n"));
+  return api;
+}
+
+
+/**
+ * Callback invoked to free all value.
+ *
+ * @param cls the plugin
+ * @param key unused
+ * @param val the value
+ * @return GNUNET_OK (continue to iterate)
+ */
+static int
+free_value (void *cls,
+            const struct GNUNET_HashCode *key,
+            void *val)
+{
+  struct Plugin *plugin = cls;
+  struct Value *value = val;
+
+  delete_value (plugin, value);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Exit point from the plugin.
+ * @param cls our "struct Plugin*"
+ * @return always NULL
+ */
+void *
+libgnunet_plugin_datastore_heap_done (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
+                                         &free_value,
+                                         plugin);
+  GNUNET_CONTAINER_multihashmap_destroy (plugin->keyvalue);
+  GNUNET_CONTAINER_heap_destroy (plugin->by_expiration);
+  GNUNET_CONTAINER_heap_destroy (plugin->by_replication);
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datastore_heap.c */
diff --git a/src/plugin/datastore/plugin_datastore_postgres.c b/src/plugin/datastore/plugin_datastore_postgres.c
new file mode 100644
index 000000000..5fcacc17b
--- /dev/null
+++ b/src/plugin/datastore/plugin_datastore_postgres.c
@@ -0,0 +1,930 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2009-2017, 2022 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 datastore/plugin_datastore_postgres.c
+ * @brief postgres-based datastore backend
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_datastore_plugin.h"
+#include "gnunet_pq_lib.h"
+
+
+/**
+ * After how many ms "busy" should a DB operation fail for good?
+ * A low value makes sure that we are more responsive to requests
+ * (especially PUTs).  A high value guarantees a higher success
+ * rate (SELECTs in iterate can take several seconds despite LIMIT=1).
+ *
+ * The default value of 1s should ensure that users do not experience
+ * huge latencies while at the same time allowing operations to succeed
+ * with reasonable probability.
+ */
+#define BUSY_TIMEOUT GNUNET_TIME_UNIT_SECONDS
+
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATASTORE_PluginEnvironment *env;
+
+  /**
+   * Native Postgres database handle.
+   */
+  struct GNUNET_PQ_Context *dbh;
+};
+
+
+/**
+ * @brief Get a database handle
+ *
+ * @param plugin global context
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static enum GNUNET_GenericReturnValue
+init_connection (struct Plugin *plugin)
+{
+#define RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, oid"
+  struct GNUNET_PQ_PreparedStatement ps[] = {
+    GNUNET_PQ_make_prepare ("get",
+                            "SELECT " RESULT_COLUMNS
+                            " FROM datastore.gn090"
+                            " WHERE oid >= $1::bigint AND"
+                            " (rvalue >= $2 OR 0 = $3::smallint) AND"
+                            " (hash = $4 OR 0 = $5::smallint) AND"
+                            " (type = $6 OR 0 = $7::smallint)"
+                            " ORDER BY oid ASC LIMIT 1"),
+    GNUNET_PQ_make_prepare ("put",
+                            "INSERT INTO datastore.gn090"
+                            " (repl, type, prio, anonLevel, expire, rvalue, hash, vhash, value) "
+                            "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)"),
+    GNUNET_PQ_make_prepare ("update",
+                            "UPDATE datastore.gn090"
+                            " SET prio = prio + $1,"
+                            " repl = repl + $2,"
+                            " expire = GREATEST(expire, $3)"
+                            " WHERE hash = $4 AND vhash = $5"),
+    GNUNET_PQ_make_prepare ("decrepl",
+                            "UPDATE datastore.gn090"
+                            " SET repl = GREATEST (repl - 1, 0)"
+                            " WHERE oid = $1"),
+    GNUNET_PQ_make_prepare ("select_non_anonymous",
+                            "SELECT " RESULT_COLUMNS
+                            " FROM datastore.gn090"
+                            " WHERE anonLevel = 0 AND type = $1 AND oid >= $2::bigint"
+                            " ORDER BY oid ASC LIMIT 1"),
+    GNUNET_PQ_make_prepare ("select_expiration_order",
+                            "(SELECT " RESULT_COLUMNS
+                            " FROM datastore.gn090"
+                            " WHERE expire < $1 ORDER BY prio ASC LIMIT 1) "
+                            "UNION "
+                            "(SELECT " RESULT_COLUMNS
+                            " FROM datastore.gn090"
+                            " ORDER BY prio ASC LIMIT 1)"
+                            " ORDER BY expire ASC LIMIT 1"),
+    GNUNET_PQ_make_prepare ("select_replication_order",
+                            "SELECT " RESULT_COLUMNS
+                            " FROM datastore.gn090"
+                            " ORDER BY repl DESC,RANDOM() LIMIT 1"),
+    GNUNET_PQ_make_prepare ("delrow",
+                            "DELETE FROM datastore.gn090"
+                            " WHERE oid=$1"),
+    GNUNET_PQ_make_prepare ("remove",
+                            "DELETE FROM datastore.gn090"
+                            " WHERE hash = $1 AND"
+                            " value = $2"),
+    GNUNET_PQ_make_prepare ("get_keys",
+                            "SELECT hash"
+                            " FROM datastore.gn090"),
+    GNUNET_PQ_make_prepare ("estimate_size",
+                            "SELECT CASE WHEN NOT EXISTS"
+                            "  (SELECT 1 FROM datastore.gn090)"
+                            "  THEN 0"
+                            "  ELSE (SELECT SUM(LENGTH(value))+256*COUNT(*)"
+                            "        FROM datastore.gn090)"
+                            "END AS total"),
+    GNUNET_PQ_PREPARED_STATEMENT_END
+  };
+#undef RESULT_COLUMNS
+
+  plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->env->cfg,
+                                            "datastore-postgres",
+                                            "datastore-",
+                                            NULL,
+                                            ps);
+  if (NULL == plugin->dbh)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get an estimate of how much space the database is
+ * currently using.
+ *
+ * @param cls our `struct Plugin *`
+ * @return number of bytes used on disk
+ */
+static void
+postgres_plugin_estimate_size (void *cls,
+                               unsigned long long *estimate)
+{
+  struct Plugin *plugin = cls;
+  uint64_t total;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_end
+  };
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("total",
+                                  &total),
+    GNUNET_PQ_result_spec_end
+  };
+  enum GNUNET_DB_QueryStatus ret;
+
+  if (NULL == estimate)
+    return;
+  ret = GNUNET_PQ_eval_prepared_singleton_select (plugin->dbh,
+                                                  "estimate_size",
+                                                  params,
+                                                  rs);
+  if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != ret)
+  {
+    *estimate = 0LL;
+    return;
+  }
+  *estimate = total;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @param key key for the item
+ * @param absent true if the key was not found in the bloom filter
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure
+ */
+static void
+postgres_plugin_put (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     bool absent,
+                     uint32_t size,
+                     const void *data,
+                     enum GNUNET_BLOCK_Type type,
+                     uint32_t priority,
+                     uint32_t anonymity,
+                     uint32_t replication,
+                     struct GNUNET_TIME_Absolute expiration,
+                     PluginPutCont cont,
+                     void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_HashCode vhash;
+  enum GNUNET_DB_QueryStatus ret;
+
+  GNUNET_CRYPTO_hash (data,
+                      size,
+                      &vhash);
+  if (! absent)
+  {
+    struct GNUNET_PQ_QueryParam params[] = {
+      GNUNET_PQ_query_param_uint32 (&priority),
+      GNUNET_PQ_query_param_uint32 (&replication),
+      GNUNET_PQ_query_param_absolute_time (&expiration),
+      GNUNET_PQ_query_param_auto_from_type (key),
+      GNUNET_PQ_query_param_auto_from_type (&vhash),
+      GNUNET_PQ_query_param_end
+    };
+    ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                              "update",
+                                              params);
+    if (0 > ret)
+    {
+      cont (cont_cls,
+            key,
+            size,
+            GNUNET_SYSERR,
+            _ ("Postgresql exec failure"));
+      return;
+    }
+    bool affected = (0 != ret);
+    if (affected)
+    {
+      cont (cont_cls,
+            key,
+            size,
+            GNUNET_NO,
+            NULL);
+      return;
+    }
+  }
+
+  {
+    uint32_t utype = (uint32_t) type;
+    uint64_t rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                UINT64_MAX);
+    struct GNUNET_PQ_QueryParam params[] = {
+      GNUNET_PQ_query_param_uint32 (&replication),
+      GNUNET_PQ_query_param_uint32 (&utype),
+      GNUNET_PQ_query_param_uint32 (&priority),
+      GNUNET_PQ_query_param_uint32 (&anonymity),
+      GNUNET_PQ_query_param_absolute_time (&expiration),
+      GNUNET_PQ_query_param_uint64 (&rvalue),
+      GNUNET_PQ_query_param_auto_from_type (key),
+      GNUNET_PQ_query_param_auto_from_type (&vhash),
+      GNUNET_PQ_query_param_fixed_size (data, size),
+      GNUNET_PQ_query_param_end
+    };
+
+    ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                              "put",
+                                              params);
+    if (0 > ret)
+    {
+      cont (cont_cls,
+            key,
+            size,
+            GNUNET_SYSERR,
+            "Postgresql exec failure");
+      return;
+    }
+  }
+  plugin->env->duc (plugin->env->cls,
+                    size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "datastore-postgres",
+                   "Stored %u bytes in database\n",
+                   (unsigned int) size);
+  cont (cont_cls,
+        key,
+        size,
+        GNUNET_OK,
+        NULL);
+}
+
+
+/**
+ * Closure for #process_result.
+ */
+struct ProcessResultContext
+{
+  /**
+   * The plugin handle.
+   */
+  struct Plugin *plugin;
+
+  /**
+   * Function to call on each result.
+   */
+  PluginDatumProcessor proc;
+
+  /**
+   * Closure for @e proc.
+   */
+  void *proc_cls;
+};
+
+
+/**
+ * Function invoked to process the result and call the processor of @a
+ * cls.
+ *
+ * @param cls our `struct ProcessResultContext`
+ * @param res result from exec
+ * @param num_results number of results in @a res
+ */
+static void
+process_result (void *cls,
+                PGresult *res,
+                unsigned int num_results)
+{
+  struct ProcessResultContext *prc = cls;
+  struct Plugin *plugin = prc->plugin;
+
+  if (0 == num_results)
+  {
+    /* no result */
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "datastore-postgres",
+                     "Ending iteration (no more results)\n");
+    prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+               GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  if (1 != num_results)
+  {
+    GNUNET_break (0);
+    prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+               GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  /* Technically we don't need the loop here, but nicer in case
+     we ever relax the condition above. */
+  for (unsigned int i = 0; i < num_results; i++)
+  {
+    int iret;
+    uint64_t rowid;
+    uint32_t utype;
+    uint32_t anonymity;
+    uint32_t replication;
+    uint32_t priority;
+    size_t size;
+    void *data;
+    struct GNUNET_TIME_Absolute expiration_time;
+    struct GNUNET_HashCode key;
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_uint32 ("repl", &replication),
+      GNUNET_PQ_result_spec_uint32 ("type", &utype),
+      GNUNET_PQ_result_spec_uint32 ("prio", &priority),
+      GNUNET_PQ_result_spec_uint32 ("anonLevel", &anonymity),
+      GNUNET_PQ_result_spec_absolute_time ("expire", &expiration_time),
+      GNUNET_PQ_result_spec_auto_from_type ("hash", &key),
+      GNUNET_PQ_result_spec_variable_size ("value", &data, &size),
+      GNUNET_PQ_result_spec_uint64 ("oid", &rowid),
+      GNUNET_PQ_result_spec_end
+    };
+
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (res,
+                                  rs,
+                                  i))
+    {
+      GNUNET_break (0);
+      prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+                 GNUNET_TIME_UNIT_ZERO_ABS, 0);
+      return;
+    }
+
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "datastore-postgres",
+                     "Found result of size %u bytes and type %u in database\n",
+                     (unsigned int) size,
+                     (unsigned int) utype);
+    iret = prc->proc (prc->proc_cls,
+                      &key,
+                      size,
+                      data,
+                      (enum GNUNET_BLOCK_Type) utype,
+                      priority,
+                      anonymity,
+                      replication,
+                      expiration_time,
+                      rowid);
+    if (iret == GNUNET_NO)
+    {
+      struct GNUNET_PQ_QueryParam param[] = {
+        GNUNET_PQ_query_param_uint64 (&rowid),
+        GNUNET_PQ_query_param_end
+      };
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Processor asked for item %u to be removed.\n",
+                  (unsigned int) rowid);
+      if (0 <
+          GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                              "delrow",
+                                              param))
+      {
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                         "datastore-postgres",
+                         "Deleting %u bytes from database\n",
+                         (unsigned int) size);
+        plugin->env->duc (plugin->env->cls,
+                          -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                         "datastore-postgres",
+                         "Deleted %u bytes from database\n",
+                         (unsigned int) size);
+      }
+    }
+    GNUNET_PQ_cleanup_result (rs);
+  }   /* for (i) */
+}
+
+
+/**
+ * Get one of the results for a particular key in the datastore.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param random if true, return a random result instead of using next_uid
+ * @param key maybe NULL (to match all entries)
+ * @param type entries of which type are relevant?
+ *     Use 0 for any type.
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if nothing matches
+ * @param proc_cls closure for @a proc
+ */
+static void
+postgres_plugin_get_key (void *cls,
+                         uint64_t next_uid,
+                         bool random,
+                         const struct GNUNET_HashCode *key,
+                         enum GNUNET_BLOCK_Type type,
+                         PluginDatumProcessor proc,
+                         void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t utype = type;
+  uint16_t use_rvalue = random;
+  uint16_t use_key = NULL != key;
+  uint16_t use_type = GNUNET_BLOCK_TYPE_ANY != type;
+  uint64_t rvalue;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_uint64 (&next_uid),
+    GNUNET_PQ_query_param_uint64 (&rvalue),
+    GNUNET_PQ_query_param_uint16 (&use_rvalue),
+    GNUNET_PQ_query_param_auto_from_type (key),
+    GNUNET_PQ_query_param_uint16 (&use_key),
+    GNUNET_PQ_query_param_uint32 (&utype),
+    GNUNET_PQ_query_param_uint16 (&use_type),
+    GNUNET_PQ_query_param_end
+  };
+  struct ProcessResultContext prc;
+  enum GNUNET_DB_QueryStatus res;
+
+  if (random)
+  {
+    rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                       UINT64_MAX);
+    next_uid = 0;
+  }
+  else
+  {
+    rvalue = 0;
+  }
+  prc.plugin = plugin;
+  prc.proc = proc;
+  prc.proc_cls = proc_cls;
+
+  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                              "get",
+                                              params,
+                                              &process_result,
+                                              &prc);
+  if (0 > res)
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+          GNUNET_TIME_UNIT_ZERO_ABS, 0);
+}
+
+
+/**
+ * Select a subset of the items in the datastore and call
+ * the given iterator for each of them.
+ *
+ * @param cls our `struct Plugin *`
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param type entries of which type should be considered?
+ *        Must not be zero (ANY).
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if no value matches
+ * @param proc_cls closure for @a proc
+ */
+static void
+postgres_plugin_get_zero_anonymity (void *cls,
+                                    uint64_t next_uid,
+                                    enum GNUNET_BLOCK_Type type,
+                                    PluginDatumProcessor proc,
+                                    void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t utype = type;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_uint32 (&utype),
+    GNUNET_PQ_query_param_uint64 (&next_uid),
+    GNUNET_PQ_query_param_end
+  };
+  struct ProcessResultContext prc;
+  enum GNUNET_DB_QueryStatus res;
+
+  prc.plugin = plugin;
+  prc.proc = proc;
+  prc.proc_cls = proc_cls;
+  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                              "select_non_anonymous",
+                                              params,
+                                              &process_result,
+                                              &prc);
+  if (0 > res)
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+          GNUNET_TIME_UNIT_ZERO_ABS, 0);
+}
+
+
+/**
+ * Context for #repl_iter() function.
+ */
+struct ReplCtx
+{
+  /**
+   * Plugin handle.
+   */
+  struct Plugin *plugin;
+
+  /**
+   * Function to call for the result (or the NULL).
+   */
+  PluginDatumProcessor proc;
+
+  /**
+   * Closure for @e proc.
+   */
+  void *proc_cls;
+};
+
+
+/**
+ * Wrapper for the iterator for 'sqlite_plugin_replication_get'.
+ * Decrements the replication counter and calls the original
+ * iterator.
+ *
+ * @param cls closure with the `struct ReplCtx *`
+ * @param key key for the content
+ * @param size number of bytes in @a data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param uid unique identifier for the datum;
+ *        maybe 0 if no unique identifier is available
+ * @return #GNUNET_SYSERR to abort the iteration,
+ *         #GNUNET_OK to continue
+ *         (continue on call to "next", of course),
+ *         #GNUNET_NO to delete the item and continue (if supported)
+ */
+static int
+repl_proc (void *cls,
+           const struct GNUNET_HashCode *key,
+           uint32_t size,
+           const void *data,
+           enum GNUNET_BLOCK_Type type,
+           uint32_t priority,
+           uint32_t anonymity,
+           uint32_t replication,
+           struct GNUNET_TIME_Absolute expiration,
+           uint64_t uid)
+{
+  struct ReplCtx *rc = cls;
+  struct Plugin *plugin = rc->plugin;
+  int ret;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_uint64 (&uid),
+    GNUNET_PQ_query_param_end
+  };
+  enum GNUNET_DB_QueryStatus qret;
+
+  ret = rc->proc (rc->proc_cls,
+                  key,
+                  size,
+                  data,
+                  type,
+                  priority,
+                  anonymity,
+                  replication,
+                  expiration,
+                  uid);
+  if (NULL == key)
+    return ret;
+  qret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                             "decrepl",
+                                             params);
+  if (0 > qret)
+    return GNUNET_SYSERR;
+  return ret;
+}
+
+
+/**
+ * Get a random item for replication.  Returns a single, not expired,
+ * random item from those with the highest replication counters.  The
+ * item's replication counter is decremented by one IF it was positive
+ * before.  Call @a proc with all values ZERO or NULL if the datastore
+ * is empty.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for @a proc
+ */
+static void
+postgres_plugin_get_replication (void *cls,
+                                 PluginDatumProcessor proc,
+                                 void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_end
+  };
+  struct ReplCtx rc;
+  struct ProcessResultContext prc;
+  enum GNUNET_DB_QueryStatus res;
+
+  rc.plugin = plugin;
+  rc.proc = proc;
+  rc.proc_cls = proc_cls;
+  prc.plugin = plugin;
+  prc.proc = &repl_proc;
+  prc.proc_cls = &rc;
+  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                              "select_replication_order",
+                                              params,
+                                              &process_result,
+                                              &prc);
+  if (0 > res)
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
+          GNUNET_TIME_UNIT_ZERO_ABS, 0);
+}
+
+
+/**
+ * Get a random item for expiration.  Call @a proc with all values
+ * ZERO or NULL if the datastore is empty.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for @a proc
+ */
+static void
+postgres_plugin_get_expiration (void *cls,
+                                PluginDatumProcessor proc,
+                                void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_TIME_Absolute now = { 0 };
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_absolute_time (&now),
+    GNUNET_PQ_query_param_end
+  };
+  struct ProcessResultContext prc;
+
+  now = GNUNET_TIME_absolute_get ();
+  prc.plugin = plugin;
+  prc.proc = proc;
+  prc.proc_cls = proc_cls;
+  (void) GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                               "select_expiration_order",
+                                               params,
+                                               &process_result,
+                                               &prc);
+}
+
+
+/**
+ * Closure for #process_keys.
+ */
+struct ProcessKeysContext
+{
+  /**
+   * Function to call for each key.
+   */
+  PluginKeyProcessor proc;
+
+  /**
+   * Closure for @e proc.
+   */
+  void *proc_cls;
+};
+
+
+/**
+ * Function to be called with the results of a SELECT statement
+ * that has returned @a num_results results.
+ *
+ * @param cls closure with a `struct ProcessKeysContext`
+ * @param result the postgres result
+ * @param num_results the number of results in @a result
+ */
+static void
+process_keys (void *cls,
+              PGresult *result,
+              unsigned int num_results)
+{
+  struct ProcessKeysContext *pkc = cls;
+
+  for (unsigned i = 0; i < num_results; i++)
+  {
+    struct GNUNET_HashCode key;
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_auto_from_type ("hash",
+                                            &key),
+      GNUNET_PQ_result_spec_end
+    };
+
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (result,
+                                  rs,
+                                  i))
+    {
+      GNUNET_break (0);
+      continue;
+    }
+    pkc->proc (pkc->proc_cls,
+               &key,
+               1);
+    GNUNET_PQ_cleanup_result (rs);
+  }
+}
+
+
+/**
+ * Get all of the keys in the datastore.
+ *
+ * @param cls closure with the `struct Plugin *`
+ * @param proc function to call on each key
+ * @param proc_cls closure for @a proc
+ */
+static void
+postgres_plugin_get_keys (void *cls,
+                          PluginKeyProcessor proc,
+                          void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_end
+  };
+  struct ProcessKeysContext pkc;
+
+  pkc.proc = proc;
+  pkc.proc_cls = proc_cls;
+  (void) GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
+                                               "get_keys",
+                                               params,
+                                               &process_keys,
+                                               &pkc);
+  proc (proc_cls,
+        NULL,
+        0);
+}
+
+
+/**
+ * Drop database.
+ *
+ * @param cls closure with the `struct Plugin *`
+ */
+static void
+postgres_plugin_drop (void *cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PQ_ExecuteStatement es[] = {
+    GNUNET_PQ_make_execute ("DROP TABLE gn090"),
+    GNUNET_PQ_EXECUTE_STATEMENT_END
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_PQ_exec_statements (plugin->dbh,
+                                 es))
+    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                     "postgres",
+                     _ ("Failed to drop table from database.\n"));
+}
+
+
+/**
+ * Remove a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the content
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure for @a cont
+ */
+static void
+postgres_plugin_remove_key (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            uint32_t size,
+                            const void *data,
+                            PluginRemoveCont cont,
+                            void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  enum GNUNET_DB_QueryStatus ret;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (key),
+    GNUNET_PQ_query_param_fixed_size (data, size),
+    GNUNET_PQ_query_param_end
+  };
+
+  ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
+                                            "remove",
+                                            params);
+  if (0 > ret)
+  {
+    cont (cont_cls,
+          key,
+          size,
+          GNUNET_SYSERR,
+          _ ("Postgresql exec failure"));
+    return;
+  }
+  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == ret)
+  {
+    cont (cont_cls,
+          key,
+          size,
+          GNUNET_NO,
+          NULL);
+    return;
+  }
+  plugin->env->duc (plugin->env->cls,
+                    -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "datastore-postgres",
+                   "Deleted %u bytes from database\n",
+                   (unsigned int) size);
+  cont (cont_cls,
+        key,
+        size,
+        GNUNET_OK,
+        NULL);
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls the `struct GNUNET_DATASTORE_PluginEnvironment*`
+ * @return our `struct Plugin *`
+ */
+void *
+libgnunet_plugin_datastore_postgres_init (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  struct Plugin *plugin;
+
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+  if (GNUNET_OK != init_connection (plugin))
+  {
+    GNUNET_free (plugin);
+    return NULL;
+  }
+  api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
+  api->cls = plugin;
+  api->estimate_size = &postgres_plugin_estimate_size;
+  api->put = &postgres_plugin_put;
+  api->get_key = &postgres_plugin_get_key;
+  api->get_replication = &postgres_plugin_get_replication;
+  api->get_expiration = &postgres_plugin_get_expiration;
+  api->get_zero_anonymity = &postgres_plugin_get_zero_anonymity;
+  api->get_keys = &postgres_plugin_get_keys;
+  api->drop = &postgres_plugin_drop;
+  api->remove_key = &postgres_plugin_remove_key;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls our `struct Plugin *`
+ * @return always NULL
+ */
+void *
+libgnunet_plugin_datastore_postgres_done (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_PQ_disconnect (plugin->dbh);
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datastore_postgres.c */
diff --git a/src/plugin/datastore/plugin_datastore_sqlite.c b/src/plugin/datastore/plugin_datastore_sqlite.c
new file mode 100644
index 000000000..5ea9da4cb
--- /dev/null
+++ b/src/plugin/datastore/plugin_datastore_sqlite.c
@@ -0,0 +1,1375 @@
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2009, 2011, 2017 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 datastore/plugin_datastore_sqlite.c
+ * @brief sqlite-based datastore backend
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_datastore_plugin.h"
+#include "gnunet_sq_lib.h"
+#include <sqlite3.h>
+
+
+/**
+ * We allocate items on the stack at times.  To prevent a stack
+ * overflow, we impose a limit on the maximum size for the data per
+ * item.  64k should be enough.
+ */
+#define MAX_ITEM_SIZE 65536
+
+/**
+ * After how many ms "busy" should a DB operation fail for good?
+ * A low value makes sure that we are more responsive to requests
+ * (especially PUTs).  A high value guarantees a higher success
+ * rate (SELECTs in iterate can take several seconds despite LIMIT=1).
+ *
+ * The default value of 250ms should ensure that users do not experience
+ * huge latencies while at the same time allowing operations to succeed
+ * with reasonable probability.
+ */
+#define BUSY_TIMEOUT_MS 250
+
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' on file 'filename'
+ * with the message given by strerror(errno).
+ */
+#define LOG_SQLITE(db, level, cmd)                                \
+  do                                                              \
+  {                                                               \
+    GNUNET_log_from (level,                                       \
+                     "sqlite",                                    \
+                     _ ("`%s' failed at %s:%d with error: %s\n"), \
+                     cmd,                                         \
+                     __FILE__,                                    \
+                     __LINE__,                                    \
+                     sqlite3_errmsg (db->dbh));                   \
+  } while (0)
+
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' on file 'filename'
+ * with the message given by strerror(errno).
+ */
+#define LOG_SQLITE_MSG(db, msg, level, cmd)                       \
+  do                                                              \
+  {                                                               \
+    GNUNET_log_from (level,                                       \
+                     "sqlite",                                    \
+                     _ ("`%s' failed at %s:%d with error: %s\n"), \
+                     cmd,                                         \
+                     __FILE__,                                    \
+                     __LINE__,                                    \
+                     sqlite3_errmsg (db->dbh));                   \
+    GNUNET_asprintf (msg,                                         \
+                     _ ("`%s' failed at %s:%u with error: %s"),   \
+                     cmd,                                         \
+                     __FILE__,                                    \
+                     __LINE__,                                    \
+                     sqlite3_errmsg (db->dbh));                   \
+  } while (0)
+
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATASTORE_PluginEnvironment *env;
+
+  /**
+   * Database filename.
+   */
+  char *fn;
+
+  /**
+   * Native SQLite database handle.
+   */
+  sqlite3 *dbh;
+
+  /**
+   * Precompiled SQL for remove_key.
+   */
+  sqlite3_stmt *remove;
+
+  /**
+   * Precompiled SQL for deletion.
+   */
+  sqlite3_stmt *delRow;
+
+  /**
+   * Precompiled SQL for update.
+   */
+  sqlite3_stmt *update;
+
+  /**
+   * Get maximum repl value in database.
+   */
+  sqlite3_stmt *maxRepl;
+
+  /**
+   * Precompiled SQL for replication decrement.
+   */
+  sqlite3_stmt *updRepl;
+
+  /**
+   * Precompiled SQL for replication selection.
+   */
+  sqlite3_stmt *selRepl;
+
+  /**
+   * Precompiled SQL for expiration selection.
+   */
+  sqlite3_stmt *selExpi;
+
+  /**
+   * Precompiled SQL for expiration selection.
+   */
+  sqlite3_stmt *selZeroAnon;
+
+  /**
+   * Precompiled SQL for insertion.
+   */
+  sqlite3_stmt *insertContent;
+
+  /**
+   * Precompiled SQL for selection
+   */
+  sqlite3_stmt *get[8];
+
+  /**
+   * Should the database be dropped on shutdown?
+   */
+  int drop_on_shutdown;
+};
+
+
+/**
+ * @brief Prepare a SQL statement
+ *
+ * @param dbh handle to the database
+ * @param zSql SQL statement, UTF-8 encoded
+ * @param ppStmt set to the prepared statement
+ * @return 0 on success
+ */
+static int
+sq_prepare (sqlite3 *dbh, const char *zSql, sqlite3_stmt **ppStmt)
+{
+  char *dummy;
+  int result;
+
+  result = sqlite3_prepare_v2 (dbh,
+                               zSql,
+                               strlen (zSql),
+                               ppStmt,
+                               (const char **) &dummy);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "sqlite",
+                   "Prepared `%s' / %p: %d\n",
+                   zSql,
+                   *ppStmt,
+                   result);
+  return result;
+}
+
+
+/**
+ * Create our database indices.
+ *
+ * @param dbh handle to the database
+ */
+static void
+create_indices (sqlite3 *dbh)
+{
+  /* create indices */
+  if (
+    0 !=
+    (SQLITE_OK !=
+     sqlite3_exec (dbh,
+                   "CREATE INDEX IF NOT EXISTS idx_hash ON gn091 (hash)",
+                   NULL,
+                   NULL,
+                   NULL))
+    + (SQLITE_OK !=
+       sqlite3_exec (
+         dbh,
+         "CREATE INDEX IF NOT EXISTS idx_anon_type ON gn091 (anonLevel ASC,type)",
+         NULL,
+         NULL,
+         NULL))
+    + (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_expire ON gn091 (expire ASC)",
+                     NULL,
+                     NULL,
+                     NULL))
+    + (SQLITE_OK !=
+       sqlite3_exec (
+         dbh,
+         "CREATE INDEX IF NOT EXISTS idx_repl_rvalue ON gn091 (repl,rvalue)",
+         NULL,
+         NULL,
+         NULL)))
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "sqlite",
+                     "Failed to create indices: %s\n",
+                     sqlite3_errmsg (dbh));
+}
+
+
+#if 0
+#define CHECK(a) GNUNET_break (a)
+#define ENULL NULL
+#else
+#define ENULL &e
+#define ENULL_DEFINED 1
+#define CHECK(a)                                     \
+  if (! (a))                                         \
+  {                                                  \
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", e); \
+    sqlite3_free (e);                                \
+    e = NULL;                                        \
+  }
+#endif
+
+
+/**
+ * Initialize the database connections and associated
+ * data structures (create tables and indices
+ * as needed as well).
+ *
+ * @param cfg our configuration
+ * @param plugin the plugin context (state for this module)
+ * @return #GNUNET_OK on success
+ */
+static int
+database_setup (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                struct Plugin *plugin)
+{
+  sqlite3_stmt *stmt;
+  char *afsdir;
+
+#if ENULL_DEFINED
+  char *e;
+#endif
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                            "datastore-sqlite",
+                                                            "FILENAME",
+                                                            &afsdir))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "datastore-sqlite",
+                               "FILENAME");
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
+    {
+      GNUNET_break (0);
+      GNUNET_free (afsdir);
+      return GNUNET_SYSERR;
+    }
+    /* database is new or got deleted, reset payload to zero! */
+    if (NULL != plugin->env->duc)
+      plugin->env->duc (plugin->env->cls, 0);
+  }
+  /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
+  plugin->fn = afsdir;
+
+  /* Open database and precompile statements */
+  if (SQLITE_OK != sqlite3_open (plugin->fn, &plugin->dbh))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "sqlite",
+                     _ ("Unable to initialize SQLite: %s.\n"),
+                     sqlite3_errmsg (plugin->dbh));
+    return GNUNET_SYSERR;
+  }
+  CHECK (
+    SQLITE_OK ==
+    sqlite3_exec (plugin->dbh, "PRAGMA temp_store=MEMORY", NULL, NULL, ENULL));
+  CHECK (
+    SQLITE_OK ==
+    sqlite3_exec (plugin->dbh, "PRAGMA synchronous=OFF", NULL, NULL, ENULL));
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
+                                    "PRAGMA legacy_file_format=OFF",
+                                    NULL,
+                                    NULL,
+                                    ENULL));
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
+                                    "PRAGMA auto_vacuum=INCREMENTAL",
+                                    NULL,
+                                    NULL,
+                                    ENULL));
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
+                                    "PRAGMA locking_mode=EXCLUSIVE",
+                                    NULL,
+                                    NULL,
+                                    ENULL));
+  CHECK (
+    SQLITE_OK ==
+    sqlite3_exec (plugin->dbh, "PRAGMA page_size=4096", NULL, NULL, ENULL));
+
+  CHECK (SQLITE_OK == sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS));
+
+
+  /* We have to do it here, because otherwise precompiling SQL might fail */
+  CHECK (SQLITE_OK ==
+         sq_prepare (plugin->dbh,
+                     "SELECT 1 FROM sqlite_master WHERE tbl_name = 'gn091'",
+                     &stmt));
+
+  /* FIXME: SQLite does not have unsigned integers! This is ok for the type column because
+   * we only test equality on it and can cast it to/from uint32_t. For repl, prio, and anonLevel
+   * we do math or inequality tests, so we can't handle the entire range of uint32_t.
+   * This will also cause problems for expiration times after 294247-01-10-04:00:54 UTC.
+   */if ((SQLITE_DONE == sqlite3_step (stmt)) &&
+      (SQLITE_OK != sqlite3_exec (plugin->dbh,
+                                  "CREATE TABLE gn091 ("
+                                  "  repl INT4 NOT NULL DEFAULT 0,"
+                                  "  type INT4 NOT NULL DEFAULT 0,"
+                                  "  prio INT4 NOT NULL DEFAULT 0,"
+                                  "  anonLevel INT4 NOT NULL DEFAULT 0,"
+                                  "  expire INT8 NOT NULL DEFAULT 0,"
+                                  "  rvalue INT8 NOT NULL,"
+                                  "  hash TEXT NOT NULL DEFAULT '',"
+                                  "  vhash TEXT NOT NULL DEFAULT '',"
+                                  "  value BLOB NOT NULL DEFAULT '')",
+                                  NULL,
+                                  NULL,
+                                  NULL)))
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
+    sqlite3_finalize (stmt);
+    return GNUNET_SYSERR;
+  }
+  sqlite3_finalize (stmt);
+  create_indices (plugin->dbh);
+
+#define RESULT_COLUMNS \
+  "repl, type, prio, anonLevel, expire, hash, value, _ROWID_"
+  if (
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "UPDATE gn091 "
+                              "SET prio = prio + ?, "
+                              "repl = repl + ?, "
+                              "expire = MAX(expire, ?) "
+                              "WHERE hash = ? AND vhash = ?",
+                              &plugin->update)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "UPDATE gn091 "
+                              "SET repl = MAX (0, repl - 1) WHERE _ROWID_ = ?",
+                              &plugin->updRepl)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE repl=?2 AND "
+                              " (rvalue>=?1 OR "
+                              "  NOT EXISTS (SELECT 1 FROM gn091 "
+                              "WHERE repl=?2 AND rvalue>=?1 LIMIT 1) ) "
+                              "ORDER BY rvalue ASC LIMIT 1",
+                              &plugin->selRepl)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT MAX(repl) FROM gn091",
+                              &plugin->maxRepl)) ||
+    (SQLITE_OK !=
+     sq_prepare (plugin->dbh,
+                 "SELECT " RESULT_COLUMNS " FROM gn091 "
+                 "WHERE NOT EXISTS (SELECT 1 FROM gn091 WHERE expire < ?1 LIMIT 1) OR (expire < ?1) "
+                 "ORDER BY expire ASC LIMIT 1",
+                 &plugin->selExpi)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ? AND "
+                              "anonLevel = 0 AND "
+                              "type = ? "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->selZeroAnon)) ||
+    (SQLITE_OK !=
+     sq_prepare (plugin->dbh,
+                 "INSERT INTO gn091 (repl, type, prio, anonLevel, expire, rvalue, hash, vhash, value) "
+                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                 &plugin->insertContent)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[0])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "type = ?4 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[1])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "hash = ?3 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[2])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "hash = ?3 AND "
+                              "type = ?4 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[3])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "rvalue >= ?2 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[4])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "rvalue >= ?2 AND "
+                              "type = ?4 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[5])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "rvalue >= ?2 AND "
+                              "hash = ?3 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[6])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "SELECT " RESULT_COLUMNS " FROM gn091 "
+                              "WHERE _ROWID_ >= ?1 AND "
+                              "rvalue >= ?2 AND "
+                              "hash = ?3 AND "
+                              "type = ?4 "
+                              "ORDER BY _ROWID_ ASC LIMIT 1",
+                              &plugin->get[7])) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "DELETE FROM gn091 WHERE _ROWID_ = ?",
+                              &plugin->delRow)) ||
+    (SQLITE_OK != sq_prepare (plugin->dbh,
+                              "DELETE FROM gn091 "
+                              "WHERE hash = ? AND "
+                              "value = ? ",
+                              &plugin->remove)) ||
+    false)
+  {
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "precompiling");
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown database connection and associate data
+ * structures.
+ *
+ * @param plugin the plugin context (state for this module)
+ */
+static void
+database_shutdown (struct Plugin *plugin)
+{
+  int result;
+
+#if SQLITE_VERSION_NUMBER >= 3007000
+  sqlite3_stmt *stmt;
+#endif
+
+  if (NULL != plugin->remove)
+    sqlite3_finalize (plugin->remove);
+  if (NULL != plugin->delRow)
+    sqlite3_finalize (plugin->delRow);
+  if (NULL != plugin->update)
+    sqlite3_finalize (plugin->update);
+  if (NULL != plugin->updRepl)
+    sqlite3_finalize (plugin->updRepl);
+  if (NULL != plugin->selRepl)
+    sqlite3_finalize (plugin->selRepl);
+  if (NULL != plugin->maxRepl)
+    sqlite3_finalize (plugin->maxRepl);
+  if (NULL != plugin->selExpi)
+    sqlite3_finalize (plugin->selExpi);
+  if (NULL != plugin->selZeroAnon)
+    sqlite3_finalize (plugin->selZeroAnon);
+  if (NULL != plugin->insertContent)
+    sqlite3_finalize (plugin->insertContent);
+  for (int i = 0; i < 8; ++i)
+    if (NULL != plugin->get[i])
+      sqlite3_finalize (plugin->get[i]);
+  result = sqlite3_close (plugin->dbh);
+#if SQLITE_VERSION_NUMBER >= 3007000
+  if (result == SQLITE_BUSY)
+  {
+    GNUNET_log_from (
+      GNUNET_ERROR_TYPE_WARNING,
+      "sqlite",
+      _ (
+        "Tried to close sqlite without finalizing all prepared statements.\n"));
+    stmt = sqlite3_next_stmt (plugin->dbh, NULL);
+    while (NULL != stmt)
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "sqlite",
+                       "Closing statement %p\n",
+                       stmt);
+      result = sqlite3_finalize (stmt);
+      if (result != SQLITE_OK)
+        GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                         "sqlite",
+                         "Failed to close statement %p: %d\n",
+                         stmt,
+                         result);
+      stmt = sqlite3_next_stmt (plugin->dbh, NULL);
+    }
+    result = sqlite3_close (plugin->dbh);
+  }
+#endif
+  if (SQLITE_OK != result)
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
+  GNUNET_free (plugin->fn);
+}
+
+
+/**
+ * Delete the database entry with the given
+ * row identifier.
+ *
+ * @param plugin the plugin context (state for this module)
+ * @param rid the ID of the row to delete
+ */
+static int
+delete_by_rowid (struct Plugin *plugin, uint64_t rid)
+{
+  struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 (&rid),
+                                           GNUNET_SQ_query_param_end };
+
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->delRow, params))
+    return GNUNET_SYSERR;
+  if (SQLITE_DONE != sqlite3_step (plugin->delRow))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh, plugin->delRow);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_SQ_reset (plugin->dbh, plugin->delRow);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the item
+ * @param absent true if the key was not found in the bloom filter
+ * @param size number of bytes in @a data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure
+ */
+static void
+sqlite_plugin_put (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   bool absent,
+                   uint32_t size,
+                   const void *data,
+                   enum GNUNET_BLOCK_Type type,
+                   uint32_t priority,
+                   uint32_t anonymity,
+                   uint32_t replication,
+                   struct GNUNET_TIME_Absolute expiration,
+                   PluginPutCont cont,
+                   void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_HashCode vhash;
+  char *msg = NULL;
+
+  GNUNET_CRYPTO_hash (data, size, &vhash);
+
+  if (! absent)
+  {
+    struct GNUNET_SQ_QueryParam params[] =
+    { GNUNET_SQ_query_param_uint32 (&priority),
+      GNUNET_SQ_query_param_uint32 (&replication),
+      GNUNET_SQ_query_param_absolute_time (&expiration),
+      GNUNET_SQ_query_param_auto_from_type (key),
+      GNUNET_SQ_query_param_auto_from_type (&vhash),
+      GNUNET_SQ_query_param_end };
+
+    if (GNUNET_OK != GNUNET_SQ_bind (plugin->update, params))
+    {
+      cont (cont_cls, key, size, GNUNET_SYSERR, _ ("sqlite bind failure"));
+      return;
+    }
+    if (SQLITE_DONE != sqlite3_step (plugin->update))
+    {
+      LOG_SQLITE_MSG (plugin,
+                      &msg,
+                      GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                      "sqlite3_step");
+      cont (cont_cls, key, size, GNUNET_SYSERR, msg);
+      GNUNET_free (msg);
+      return;
+    }
+    int changes = sqlite3_changes (plugin->dbh);
+    GNUNET_SQ_reset (plugin->dbh, plugin->update);
+    if (0 != changes)
+    {
+      cont (cont_cls, key, size, GNUNET_NO, NULL);
+      return;
+    }
+  }
+
+  uint64_t rvalue;
+  uint32_t type32 = (uint32_t) type;
+  struct GNUNET_SQ_QueryParam params[] =
+  { GNUNET_SQ_query_param_uint32 (&replication),
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_uint32 (&priority),
+    GNUNET_SQ_query_param_uint32 (&anonymity),
+    GNUNET_SQ_query_param_absolute_time (&expiration),
+    GNUNET_SQ_query_param_uint64 (&rvalue),
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_auto_from_type (&vhash),
+    GNUNET_SQ_query_param_fixed_size (data, size),
+    GNUNET_SQ_query_param_end };
+  int n;
+  int ret;
+  sqlite3_stmt *stmt;
+
+  if (size > MAX_ITEM_SIZE)
+  {
+    cont (cont_cls, key, size, GNUNET_SYSERR, _ ("Data too large"));
+    return;
+  }
+  GNUNET_log_from (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "sqlite",
+    "Storing in database block with type %u/key `%s'/priority %u/expiration in %s (%s).\n",
+    type,
+    GNUNET_h2s (key),
+    priority,
+    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (
+                                              expiration),
+                                            GNUNET_YES),
+    GNUNET_STRINGS_absolute_time_to_string (expiration));
+  stmt = plugin->insertContent;
+  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+  if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
+  {
+    cont (cont_cls, key, size, GNUNET_SYSERR, NULL);
+    return;
+  }
+  n = sqlite3_step (stmt);
+  switch (n)
+  {
+  case SQLITE_DONE:
+    if (NULL != plugin->env->duc)
+      plugin->env->duc (plugin->env->cls,
+                        size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "sqlite",
+                     "Stored new entry (%u bytes)\n",
+                     size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
+    ret = GNUNET_OK;
+    break;
+
+  case SQLITE_BUSY:
+    GNUNET_break (0);
+    LOG_SQLITE_MSG (plugin,
+                    &msg,
+                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                    "sqlite3_step");
+    ret = GNUNET_SYSERR;
+    break;
+
+  default:
+    LOG_SQLITE_MSG (plugin,
+                    &msg,
+                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                    "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh, stmt);
+    database_shutdown (plugin);
+    database_setup (plugin->env->cfg, plugin);
+    cont (cont_cls, key, size, GNUNET_SYSERR, msg);
+    GNUNET_free (msg);
+    return;
+  }
+  GNUNET_SQ_reset (plugin->dbh, stmt);
+  cont (cont_cls, key, size, ret, msg);
+  GNUNET_free (msg);
+}
+
+
+/**
+ * Execute statement that gets a row and call the callback
+ * with the result.  Resets the statement afterwards.
+ *
+ * @param plugin the plugin
+ * @param stmt the statement
+ * @param proc processor to call
+ * @param proc_cls closure for @a proc
+ */
+static void
+execute_get (struct Plugin *plugin,
+             sqlite3_stmt *stmt,
+             PluginDatumProcessor proc,
+             void *proc_cls)
+{
+  int n;
+  struct GNUNET_TIME_Absolute expiration;
+  uint32_t replication;
+  uint32_t type;
+  uint32_t priority;
+  uint32_t anonymity;
+  uint64_t rowid;
+  void *value;
+  size_t value_size;
+  struct GNUNET_HashCode key;
+  int ret;
+  struct GNUNET_SQ_ResultSpec rs[] =
+  { GNUNET_SQ_result_spec_uint32 (&replication),
+    GNUNET_SQ_result_spec_uint32 (&type),
+    GNUNET_SQ_result_spec_uint32 (&priority),
+    GNUNET_SQ_result_spec_uint32 (&anonymity),
+    GNUNET_SQ_result_spec_absolute_time (&expiration),
+    GNUNET_SQ_result_spec_auto_from_type (&key),
+    GNUNET_SQ_result_spec_variable_size (&value, &value_size),
+    GNUNET_SQ_result_spec_uint64 (&rowid),
+    GNUNET_SQ_result_spec_end };
+
+  n = sqlite3_step (stmt);
+  switch (n)
+  {
+  case SQLITE_ROW:
+    if (GNUNET_OK != GNUNET_SQ_extract_result (stmt, rs))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "sqlite",
+                     "Found reply in database with expiration %s\n",
+                     GNUNET_STRINGS_absolute_time_to_string (expiration));
+    ret = proc (proc_cls,
+                &key,
+                value_size,
+                value,
+                type,
+                priority,
+                anonymity,
+                replication,
+                expiration,
+                rowid);
+    GNUNET_SQ_cleanup_result (rs);
+    GNUNET_SQ_reset (plugin->dbh, stmt);
+    if ((GNUNET_NO == ret) && (GNUNET_OK == delete_by_rowid (plugin, rowid)) &&
+        (NULL != plugin->env->duc))
+      plugin->env->duc (plugin->env->cls,
+                        -(value_size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
+    return;
+
+  case SQLITE_DONE:
+    /* database must be empty */
+    break;
+
+  case SQLITE_BUSY:
+  case SQLITE_ERROR:
+  case SQLITE_MISUSE:
+  default:
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    GNUNET_break (0);
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    database_shutdown (plugin);
+    database_setup (plugin->env->cfg, plugin);
+    return;
+  }
+  GNUNET_SQ_reset (plugin->dbh, stmt);
+  proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+}
+
+
+/**
+ * Select a subset of the items in the datastore and call
+ * the given processor for the item.
+ *
+ * @param cls our plugin context
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param type entries of which type should be considered?
+ *        Must not be zero (ANY).
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if no value matches
+ * @param proc_cls closure for @a proc
+ */
+static void
+sqlite_plugin_get_zero_anonymity (void *cls,
+                                  uint64_t next_uid,
+                                  enum GNUNET_BLOCK_Type type,
+                                  PluginDatumProcessor proc,
+                                  void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  uint32_t type32 = type;
+  struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 (
+                                             &next_uid),
+                                           GNUNET_SQ_query_param_uint32 (
+                                             &type32),
+                                           GNUNET_SQ_query_param_end };
+
+  GNUNET_assert (type != GNUNET_BLOCK_TYPE_ANY);
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->selZeroAnon, params))
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  execute_get (plugin, plugin->selZeroAnon, proc, proc_cls);
+}
+
+
+/**
+ * Get results for a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param random if true, return a random result instead of using next_uid
+ * @param key maybe NULL (to match all entries)
+ * @param type entries of which type are relevant?
+ *     Use 0 for any type.
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if nothing matches
+ * @param proc_cls closure for @a proc
+ */
+static void
+sqlite_plugin_get_key (void *cls,
+                       uint64_t next_uid,
+                       bool random,
+                       const struct GNUNET_HashCode *key,
+                       enum GNUNET_BLOCK_Type type,
+                       PluginDatumProcessor proc,
+                       void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  uint64_t rvalue;
+  int use_rvalue = random;
+  uint32_t type32 = (uint32_t) type;
+  int use_type = GNUNET_BLOCK_TYPE_ANY != type;
+  int use_key = NULL != key;
+  sqlite3_stmt *stmt = plugin->get[use_rvalue * 4 + use_key * 2 + use_type];
+  struct GNUNET_SQ_QueryParam params[] =
+  { GNUNET_SQ_query_param_uint64 (&next_uid),
+    GNUNET_SQ_query_param_uint64 (&rvalue),
+    GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_uint32 (&type32),
+    GNUNET_SQ_query_param_end };
+
+  /* SQLite doesn't like it when you try to bind a parameter greater than the
+   * last numbered parameter, but unused parameters in the middle are OK.
+   */
+  if (! use_type)
+  {
+    params[3] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
+    if (! use_key)
+    {
+      params[2] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
+      if (! use_rvalue)
+        params[1] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
+    }
+  }
+  if (random)
+  {
+    rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+    next_uid = 0;
+  }
+  else
+    rvalue = 0;
+
+  if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  execute_get (plugin, stmt, proc, proc_cls);
+}
+
+
+/**
+ * Context for #repl_proc() function.
+ */
+struct ReplCtx
+{
+  /**
+   * Function to call for the result (or the NULL).
+   */
+  PluginDatumProcessor proc;
+
+  /**
+   * Closure for @e proc.
+   */
+  void *proc_cls;
+
+  /**
+   * UID to use.
+   */
+  uint64_t uid;
+
+  /**
+   * Yes if UID was set.
+   */
+  int have_uid;
+};
+
+
+/**
+ * Wrapper for the processor for #sqlite_plugin_get_replication().
+ * Decrements the replication counter and calls the original
+ * processor.
+ *
+ * @param cls closure
+ * @param key key for the content
+ * @param size number of bytes in @a data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param uid unique identifier for the datum;
+ *        maybe 0 if no unique identifier is available
+ * @return #GNUNET_OK for normal return,
+ *         #GNUNET_NO to delete the item
+ */
+static int
+repl_proc (void *cls,
+           const struct GNUNET_HashCode *key,
+           uint32_t size,
+           const void *data,
+           enum GNUNET_BLOCK_Type type,
+           uint32_t priority,
+           uint32_t anonymity,
+           uint32_t replication,
+           struct GNUNET_TIME_Absolute expiration,
+           uint64_t uid)
+{
+  struct ReplCtx *rc = cls;
+  int ret;
+
+  if (GNUNET_SYSERR == rc->have_uid)
+    rc->have_uid = GNUNET_NO;
+  ret = rc->proc (rc->proc_cls,
+                  key,
+                  size,
+                  data,
+                  type,
+                  priority,
+                  anonymity,
+                  replication,
+                  expiration,
+                  uid);
+  if (NULL != key)
+  {
+    rc->uid = uid;
+    rc->have_uid = GNUNET_YES;
+  }
+  return ret;
+}
+
+
+/**
+ * Get a random item for replication.  Returns a single random item
+ * from those with the highest replication counters.  The item's
+ * replication counter is decremented by one IF it was positive before.
+ * Call @a proc with all values ZERO or NULL if the datastore is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for @a proc
+ */
+static void
+sqlite_plugin_get_replication (void *cls,
+                               PluginDatumProcessor proc,
+                               void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct ReplCtx rc;
+  uint64_t rvalue = 0;
+  uint32_t repl;
+  struct GNUNET_SQ_QueryParam params_sel_repl[] =
+  { GNUNET_SQ_query_param_uint64 (&rvalue),
+    GNUNET_SQ_query_param_uint32 (&repl),
+    GNUNET_SQ_query_param_end };
+  struct GNUNET_SQ_QueryParam params_upd_repl[] =
+  { GNUNET_SQ_query_param_uint64 (&rc.uid), GNUNET_SQ_query_param_end };
+
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "datastore-sqlite",
+                   "Getting random block based on replication order.\n");
+  if (SQLITE_ROW != sqlite3_step (plugin->maxRepl))
+  {
+    GNUNET_SQ_reset (plugin->dbh, plugin->maxRepl);
+    /* DB empty */
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  repl = sqlite3_column_int (plugin->maxRepl, 0);
+  GNUNET_SQ_reset (plugin->dbh, plugin->maxRepl);
+  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->selRepl, params_sel_repl))
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  rc.have_uid = GNUNET_SYSERR;
+  rc.proc = proc;
+  rc.proc_cls = proc_cls;
+  execute_get (plugin, plugin->selRepl, &repl_proc, &rc);
+  if (GNUNET_YES == rc.have_uid)
+  {
+    if (GNUNET_OK != GNUNET_SQ_bind (plugin->updRepl, params_upd_repl))
+    {
+      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+      return;
+    }
+    if (SQLITE_DONE != sqlite3_step (plugin->updRepl))
+      LOG_SQLITE (plugin,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh, plugin->updRepl);
+  }
+  if (GNUNET_SYSERR == rc.have_uid)
+  {
+    /* proc was not called at all so far, do it now. */
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+  }
+}
+
+
+/**
+ * Get a random item that has expired or has low priority.
+ * Call @a proc with all values ZERO or NULL if the datastore is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for @a proc
+ */
+static void
+sqlite_plugin_get_expiration (void *cls,
+                              PluginDatumProcessor proc,
+                              void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt;
+  struct GNUNET_TIME_Absolute now = { 0 };
+  struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_absolute_time (
+                                             &now),
+                                           GNUNET_SQ_query_param_end };
+
+  GNUNET_log_from (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "sqlite",
+    "Getting random block based on expiration and priority order.\n");
+  now = GNUNET_TIME_absolute_get ();
+  stmt = plugin->selExpi;
+  if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  execute_get (plugin, stmt, proc, proc_cls);
+}
+
+
+/**
+ * Get all of the keys in the datastore.
+ *
+ * @param cls closure
+ * @param proc function to call on each key
+ * @param proc_cls closure for @a proc
+ */
+static void
+sqlite_plugin_get_keys (void *cls, PluginKeyProcessor proc, void *proc_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_HashCode key;
+  struct GNUNET_SQ_ResultSpec results[] =
+  { GNUNET_SQ_result_spec_auto_from_type (&key), GNUNET_SQ_result_spec_end };
+  sqlite3_stmt *stmt;
+  int ret;
+
+  GNUNET_assert (NULL != proc);
+  if (SQLITE_OK != sq_prepare (plugin->dbh, "SELECT hash FROM gn091", &stmt))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite_prepare");
+    proc (proc_cls, NULL, 0);
+    return;
+  }
+  while (SQLITE_ROW == (ret = sqlite3_step (stmt)))
+  {
+    if (GNUNET_OK == GNUNET_SQ_extract_result (stmt, results))
+      proc (proc_cls, &key, 1);
+    else
+      GNUNET_break (0);
+  }
+  if (SQLITE_DONE != ret)
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
+  sqlite3_finalize (stmt);
+  proc (proc_cls, NULL, 0);
+}
+
+
+/**
+ * Drop database.
+ *
+ * @param cls our plugin context
+ */
+static void
+sqlite_plugin_drop (void *cls)
+{
+  struct Plugin *plugin = cls;
+
+  plugin->drop_on_shutdown = GNUNET_YES;
+}
+
+
+/**
+ * Remove a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the content
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure for @a cont
+ */
+static void
+sqlite_plugin_remove_key (void *cls,
+                          const struct GNUNET_HashCode *key,
+                          uint32_t size,
+                          const void *data,
+                          PluginRemoveCont cont,
+                          void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_SQ_QueryParam params[] =
+  { GNUNET_SQ_query_param_auto_from_type (key),
+    GNUNET_SQ_query_param_fixed_size (data, size),
+    GNUNET_SQ_query_param_end };
+
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->remove, params))
+  {
+    cont (cont_cls, key, size, GNUNET_SYSERR, "bind failed");
+    return;
+  }
+  if (SQLITE_DONE != sqlite3_step (plugin->remove))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh, plugin->remove);
+    cont (cont_cls, key, size, GNUNET_SYSERR, "sqlite3_step failed");
+    return;
+  }
+  int changes = sqlite3_changes (plugin->dbh);
+  GNUNET_SQ_reset (plugin->dbh, plugin->remove);
+  if (0 == changes)
+  {
+    cont (cont_cls, key, size, GNUNET_NO, NULL);
+    return;
+  }
+  if (NULL != plugin->env->duc)
+    plugin->env->duc (plugin->env->cls,
+                      -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
+  cont (cont_cls, key, size, GNUNET_OK, NULL);
+}
+
+
+/**
+ * Get an estimate of how much space the database is
+ * currently using.
+ *
+ * @param cls the `struct Plugin`
+ * @return the size of the database on disk (estimate)
+ */
+static void
+sqlite_plugin_estimate_size (void *cls, unsigned long long *estimate)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt;
+  uint64_t pages;
+  uint64_t page_size;
+
+#if ENULL_DEFINED
+  char *e;
+#endif
+
+  if (NULL == estimate)
+    return;
+  if (SQLITE_VERSION_NUMBER < 3006000)
+  {
+    GNUNET_log_from (
+      GNUNET_ERROR_TYPE_WARNING,
+      "datastore-sqlite",
+      _ ("sqlite version to old to determine size, assuming zero\n"));
+    *estimate = 0;
+    return;
+  }
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh, "VACUUM", NULL, NULL, ENULL));
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
+                                    "PRAGMA auto_vacuum=INCREMENTAL",
+                                    NULL,
+                                    NULL,
+                                    ENULL));
+  if (SQLITE_OK != sq_prepare (plugin->dbh, "PRAGMA page_count", &stmt))
+  {
+    GNUNET_log_from (
+      GNUNET_ERROR_TYPE_WARNING,
+      "datastore-sqlite",
+      _("error preparing statement\n"));
+    return;
+  }
+  if (SQLITE_ROW == sqlite3_step (stmt))
+    pages = sqlite3_column_int64 (stmt, 0);
+  else
+    pages = 0;
+  sqlite3_finalize (stmt);
+  if (SQLITE_OK != sq_prepare (plugin->dbh, "PRAGMA page_size", &stmt))
+  {
+    GNUNET_log_from (
+      GNUNET_ERROR_TYPE_WARNING,
+      "datastore-sqlite",
+      _("error preparing statement\n"));
+    return;
+  }
+  if (SQLITE_ROW != sqlite3_step (stmt))
+  {
+    GNUNET_log_from (
+      GNUNET_ERROR_TYPE_WARNING,
+      "datastore-sqlite",
+      _("error stepping\n"));
+    return;
+  }
+  page_size = sqlite3_column_int64 (stmt, 0);
+  sqlite3_finalize (stmt);
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_INFO,
+    _ (
+      "Using sqlite page utilization to estimate payload (%llu pages of size %llu bytes)\n"),
+    (unsigned long long) pages,
+    (unsigned long long) page_size);
+  *estimate = pages * page_size;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls the `struct GNUNET_DATASTORE_PluginEnvironment *`
+ * @return NULL on error, othrewise the plugin context
+ */
+void *
+libgnunet_plugin_datastore_sqlite_init (void *cls)
+{
+  static struct Plugin plugin;
+  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+
+  if (NULL != plugin.env)
+    return NULL; /* can only initialize once! */
+  memset (&plugin, 0, sizeof(struct Plugin));
+  plugin.env = env;
+  if (GNUNET_OK != database_setup (env->cfg, &plugin))
+  {
+    database_shutdown (&plugin);
+    return NULL;
+  }
+  api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
+  api->cls = &plugin;
+  api->estimate_size = &sqlite_plugin_estimate_size;
+  api->put = &sqlite_plugin_put;
+  api->get_key = &sqlite_plugin_get_key;
+  api->get_replication = &sqlite_plugin_get_replication;
+  api->get_expiration = &sqlite_plugin_get_expiration;
+  api->get_zero_anonymity = &sqlite_plugin_get_zero_anonymity;
+  api->get_keys = &sqlite_plugin_get_keys;
+  api->drop = &sqlite_plugin_drop;
+  api->remove_key = &sqlite_plugin_remove_key;
+  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
+                   "sqlite",
+                   _ ("Sqlite database running\n"));
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the plugin context (as returned by "init")
+ * @return always NULL
+ */
+void *
+libgnunet_plugin_datastore_sqlite_done (void *cls)
+{
+  char *fn;
+  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "sqlite",
+                   "sqlite plugin is done\n");
+  fn = NULL;
+  if (plugin->drop_on_shutdown)
+    fn = GNUNET_strdup (plugin->fn);
+  database_shutdown (plugin);
+  plugin->env = NULL;
+  GNUNET_free (api);
+  if (NULL != fn)
+  {
+    if (0 != unlink (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+    GNUNET_free (fn);
+  }
+  return NULL;
+}
+
+
+/* end of plugin_datastore_sqlite.c */
diff --git a/src/plugin/datastore/plugin_datastore_template.c b/src/plugin/datastore/plugin_datastore_template.c
new file mode 100644
index 000000000..2b455f8cb
--- /dev/null
+++ b/src/plugin/datastore/plugin_datastore_template.c
@@ -0,0 +1,274 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2009, 2011 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 datastore/plugin_datastore_template.c
+ * @brief template-based datastore backend
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_datastore_plugin.h"
+
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Our execution environment.
+   */
+  struct GNUNET_DATASTORE_PluginEnvironment *env;
+};
+
+
+/**
+ * Get an estimate of how much space the database is
+ * currently using.
+ *
+ * @param cls our "struct Plugin*"
+ * @return number of bytes used on disk
+ */
+static void
+template_plugin_estimate_size (void *cls, unsigned long long *estimate)
+{
+  if (NULL == estimate)
+    return;
+  GNUNET_break (0);
+  *estimate = 0;
+}
+
+
+/**
+ * Store an item in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the item
+ * @param absent true if the key was not found in the bloom filter
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param type type of the content
+ * @param priority priority of the content
+ * @param anonymity anonymity-level for the content
+ * @param replication replication-level for the content
+ * @param expiration expiration time for the content
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure
+ */
+static void
+template_plugin_put (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     bool absent,
+                     uint32_t size,
+                     const void *data,
+                     enum GNUNET_BLOCK_Type type,
+                     uint32_t priority,
+                     uint32_t anonymity,
+                     uint32_t replication,
+                     struct GNUNET_TIME_Absolute expiration,
+                     PluginPutCont cont,
+                     void *cont_cls)
+{
+  GNUNET_break (0);
+  cont (cont_cls, key, size, GNUNET_SYSERR, "not implemented");
+}
+
+
+/**
+ * Get one of the results for a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param random if true, return a random result instead of using next_uid
+ * @param key maybe NULL (to match all entries)
+ * @param type entries of which type are relevant?
+ *     Use 0 for any type.
+ * @param proc function to call on each matching value;
+ *        will be called with NULL if nothing matches
+ * @param proc_cls closure for proc
+ */
+static void
+template_plugin_get_key (void *cls,
+                         uint64_t next_uid,
+                         bool random,
+                         const struct GNUNET_HashCode *key,
+                         enum GNUNET_BLOCK_Type type,
+                         PluginDatumProcessor proc,
+                         void *proc_cls)
+{
+  GNUNET_break (0);
+}
+
+
+/**
+ * Get a random item for replication.  Returns a single, not expired,
+ * random item from those with the highest replication counters.  The
+ * item's replication counter is decremented by one IF it was positive
+ * before.  Call 'proc' with all values ZERO or NULL if the datastore
+ * is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for proc
+ */
+static void
+template_plugin_get_replication (void *cls, PluginDatumProcessor proc,
+                                 void *proc_cls)
+{
+  GNUNET_break (0);
+}
+
+
+/**
+ * Get a random item for expiration.  Call 'proc' with all values ZERO
+ * or NULL if the datastore is empty.
+ *
+ * @param cls closure
+ * @param proc function to call the value (once only).
+ * @param proc_cls closure for proc
+ */
+static void
+template_plugin_get_expiration (void *cls, PluginDatumProcessor proc,
+                                void *proc_cls)
+{
+  GNUNET_break (0);
+}
+
+
+/**
+ * Call the given processor on an item with zero anonymity.
+ *
+ * @param cls our "struct Plugin*"
+ * @param next_uid return the result with lowest uid >= next_uid
+ * @param type entries of which type should be considered?
+ *        Must not be zero (ANY).
+ * @param proc function to call on the matching value;
+ *        will be called with NULL if no value matches
+ * @param proc_cls closure for proc
+ */
+static void
+template_plugin_get_zero_anonymity (void *cls, uint64_t next_uid,
+                                    enum GNUNET_BLOCK_Type type,
+                                    PluginDatumProcessor proc, void *proc_cls)
+{
+  GNUNET_break (0);
+}
+
+
+/**
+ * Drop database.
+ */
+static void
+template_plugin_drop (void *cls)
+{
+  GNUNET_break (0);
+}
+
+
+/**
+ * Get all of the keys in the datastore.
+ *
+ * @param cls closure
+ * @param proc function to call on each key
+ * @param proc_cls closure for proc
+ */
+static void
+template_get_keys (void *cls,
+                   PluginKeyProcessor proc,
+                   void *proc_cls)
+{
+  proc (proc_cls, NULL, 0);
+}
+
+
+/**
+ * Remove a particular key in the datastore.
+ *
+ * @param cls closure
+ * @param key key for the content
+ * @param size number of bytes in data
+ * @param data content stored
+ * @param cont continuation called with success or failure status
+ * @param cont_cls continuation closure for @a cont
+ */
+static void
+template_plugin_remove_key (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            uint32_t size,
+                            const void *data,
+                            PluginRemoveCont cont,
+                            void *cont_cls)
+{
+  GNUNET_break (0);
+  cont (cont_cls, key, size, GNUNET_SYSERR, "not implemented");
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls the "struct GNUNET_DATASTORE_PluginEnvironment*"
+ * @return our "struct Plugin*"
+ */
+void *
+libgnunet_plugin_datastore_template_init (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  struct Plugin *plugin;
+
+  plugin = GNUNET_new (struct Plugin);
+  plugin->env = env;
+  api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
+  api->cls = plugin;
+  api->estimate_size = &template_plugin_estimate_size;
+  api->put = &template_plugin_put;
+  api->get_key = &template_plugin_get_key;
+  api->get_replication = &template_plugin_get_replication;
+  api->get_expiration = &template_plugin_get_expiration;
+  api->get_zero_anonymity = &template_plugin_get_zero_anonymity;
+  api->drop = &template_plugin_drop;
+  api->get_keys = &template_get_keys;
+  api->remove_key = &template_plugin_remove_key;
+  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "template",
+                   _ ("Template database running\n"));
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ * @param cls our "struct Plugin*"
+ * @return always NULL
+ */
+void *
+libgnunet_plugin_datastore_template_done (void *cls)
+{
+  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  GNUNET_free (plugin);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_datastore_template.c */
diff --git a/src/plugin/datastore/test_plugin_datastore.c b/src/plugin/datastore/test_plugin_datastore.c
new file mode 100644
index 000000000..7de1acf2d
--- /dev/null
+++ b/src/plugin/datastore/test_plugin_datastore.c
@@ -0,0 +1,478 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2011 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/*
+ * @file test_plugin_datastore.c
+ * @brief Test database plugin directly, calling each API function once
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_datastore_plugin.h"
+#include "gnunet_testing_lib.h"
+
+/**
+ * Number of put operations to perform.
+ */
+#define PUT_10 10
+
+static unsigned long long stored_bytes;
+
+static unsigned long long stored_entries;
+
+static unsigned long long stored_ops;
+
+static const char *plugin_name;
+
+static int ok;
+
+enum RunPhase
+{
+  RP_ERROR = 0,
+  RP_PUT,
+  RP_GET,
+  RP_ITER_ZERO,
+  RP_REPL_GET,
+  RP_EXPI_GET,
+  RP_REMOVE,
+  RP_DROP
+};
+
+
+struct CpsRunContext
+{
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  enum RunPhase phase;
+  unsigned int cnt;
+  unsigned int i;
+};
+
+
+/**
+ * Function called by plugins to notify us about a
+ * change in their disk utilization.
+ *
+ * @param cls closure (NULL)
+ * @param delta change in disk utilization,
+ *        0 for "reset to empty"
+ */
+static void
+disk_utilization_change_cb (void *cls, int delta)
+{
+  /* do nothing */
+}
+
+
+static void
+test (void *cls);
+
+
+/**
+ * Put continuation.
+ *
+ * @param cls closure
+ * @param key key for the item stored
+ * @param size size of the item stored
+ * @param status #GNUNET_OK or #GNUNET_SYSERROR
+ * @param msg error message on error
+ */
+static void
+put_continuation (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  uint32_t size,
+                  int status,
+                  const char *msg)
+{
+  struct CpsRunContext *crc = cls;
+  static unsigned long long os;
+  unsigned long long cs;
+
+  if (GNUNET_OK != status)
+  {
+    fprintf (stderr,
+             "ERROR: `%s'\n",
+             msg);
+  }
+  else
+  {
+    crc->api->estimate_size (crc->api->cls,
+                             &cs);
+    GNUNET_assert (os <= cs);
+    os = cs;
+    stored_bytes += size;
+    stored_ops++;
+    stored_entries++;
+  }
+  GNUNET_SCHEDULER_add_now (&test, crc);
+}
+
+
+static void
+gen_key (int i, struct GNUNET_HashCode *key)
+{
+  memset (key, 0, sizeof(struct GNUNET_HashCode));
+  key->bits[0] = (unsigned int) i;
+  GNUNET_CRYPTO_hash (key, sizeof(struct GNUNET_HashCode), key);
+}
+
+
+static void
+do_put (struct CpsRunContext *crc)
+{
+  char value[65536];
+  size_t size;
+  struct GNUNET_HashCode key;
+  unsigned int prio;
+  static int i;
+
+  if (PUT_10 == i)
+  {
+    i = 0;
+    crc->phase++;
+    GNUNET_SCHEDULER_add_now (&test, crc);
+    return;
+  }
+  /* most content is 32k */
+  size = 32 * 1024;
+
+  if ((0 != i) && (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16) ==
+                   0) )                                                           /* but some of it is less! */
+    size = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 32 * 1024);
+  size = size - (size & 7);     /* always multiple of 8 */
+
+  /* generate random key */
+  gen_key (i, &key);
+  memset (value, i, size);
+  if (i > 255)
+    memset (value, i - 255, size / 2);
+  value[0] = crc->i;
+  prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "putting type %u, anon %u under key %s\n", i + 1, i,
+              GNUNET_h2s (&key));
+  crc->api->put (crc->api->cls,
+                 &key,
+                 false /* absent */,
+                 size,
+                 value, i + 1 /* type */,
+                 prio,
+                 i /* anonymity */,
+                 0 /* replication */,
+                 GNUNET_TIME_relative_to_absolute
+                   (GNUNET_TIME_relative_multiply
+                     (GNUNET_TIME_UNIT_MILLISECONDS,
+                     60 * 60 * 60 * 1000
+                     + GNUNET_CRYPTO_random_u32
+                       (GNUNET_CRYPTO_QUALITY_WEAK, 1000))),
+                 put_continuation,
+                 crc);
+  i++;
+}
+
+
+static uint64_t guid;
+
+
+static int
+iterate_one_shot (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  uint32_t size,
+                  const void *data,
+                  enum GNUNET_BLOCK_Type type,
+                  uint32_t priority,
+                  uint32_t anonymity,
+                  uint32_t replication,
+                  struct GNUNET_TIME_Absolute expiration,
+                  uint64_t uid)
+{
+  struct CpsRunContext *crc = cls;
+
+  GNUNET_assert (NULL != key);
+  guid = uid;
+  crc->phase++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Found result type=%u, priority=%u, size=%u, expire=%s, key %s\n",
+              (unsigned int) type,
+              (unsigned int) priority,
+              (unsigned int) size,
+              GNUNET_STRINGS_absolute_time_to_string (expiration),
+              GNUNET_h2s (key));
+  GNUNET_SCHEDULER_add_now (&test,
+                            crc);
+  return GNUNET_OK;
+}
+
+
+static void
+remove_continuation (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     uint32_t size,
+                     int status,
+                     const char *msg)
+{
+  struct CpsRunContext *crc = cls;
+
+  GNUNET_assert (NULL != key);
+  GNUNET_assert (32768 == size);
+  GNUNET_assert (GNUNET_OK == status);
+  GNUNET_assert (NULL == msg);
+  crc->phase++;
+  GNUNET_SCHEDULER_add_now (&test,
+                            crc);
+}
+
+
+/**
+ * Function called when the service shuts
+ * down.  Unloads our datastore plugin.
+ *
+ * @param api api to unload
+ * @param cfg configuration to use
+ */
+static void
+unload_plugin (struct GNUNET_DATASTORE_PluginFunctions *api,
+               const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  char *name;
+  char *libname;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "DATASTORE",
+                                             "DATABASE",
+                                             &name))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No `%s' specified for `%s' in configuration!\n"),
+                "DATABASE",
+                "DATASTORE");
+    return;
+  }
+  GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
+  GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api));
+  GNUNET_free (libname);
+  GNUNET_free (name);
+}
+
+
+/**
+ * Last task run during shutdown.  Disconnects us from
+ * the transport and core.
+ */
+static void
+cleaning_task (void *cls)
+{
+  struct CpsRunContext *crc = cls;
+
+  unload_plugin (crc->api, crc->cfg);
+  GNUNET_free (crc);
+}
+
+
+static void
+test (void *cls)
+{
+  struct CpsRunContext *crc = cls;
+  struct GNUNET_HashCode key;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "In phase %d, iteration %u\n", crc->phase, crc->cnt);
+  switch (crc->phase)
+  {
+  case RP_ERROR:
+    ok = 1;
+    GNUNET_break (0);
+    crc->api->drop (crc->api->cls);
+    GNUNET_SCHEDULER_add_now (&cleaning_task, crc);
+    break;
+
+  case RP_PUT:
+    do_put (crc);
+    break;
+
+  case RP_GET:
+    if (crc->cnt == 1)
+    {
+      crc->cnt = 0;
+      crc->phase++;
+      GNUNET_SCHEDULER_add_now (&test, crc);
+      break;
+    }
+    gen_key (5, &key);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Looking for %s\n",
+                GNUNET_h2s (&key));
+    crc->api->get_key (crc->api->cls,
+                       0,
+                       false,
+                       &key,
+                       GNUNET_BLOCK_TYPE_ANY,
+                       &iterate_one_shot,
+                       crc);
+    break;
+
+  case RP_ITER_ZERO:
+    if (crc->cnt == 1)
+    {
+      crc->cnt = 0;
+      crc->phase++;
+      GNUNET_SCHEDULER_add_now (&test, crc);
+      break;
+    }
+    crc->api->get_zero_anonymity (crc->api->cls, 0, 1, &iterate_one_shot, crc);
+    break;
+
+  case RP_REPL_GET:
+    crc->api->get_replication (crc->api->cls, &iterate_one_shot, crc);
+    break;
+
+  case RP_EXPI_GET:
+    crc->api->get_expiration (crc->api->cls, &iterate_one_shot, crc);
+    break;
+
+  case RP_REMOVE:
+    {
+      struct GNUNET_HashCode key;
+      uint32_t size = 32768;
+      char value[size];
+
+      gen_key (0, &key);
+      memset (value, 0, size);
+      value[0] = crc->i;
+      crc->api->remove_key (crc->api->cls,
+                            &key,
+                            size,
+                            value,
+                            &remove_continuation,
+                            crc);
+      break;
+    }
+
+  case RP_DROP:
+    crc->api->drop (crc->api->cls);
+    GNUNET_SCHEDULER_add_now (&cleaning_task, crc);
+    break;
+  }
+}
+
+
+/**
+ * Load the datastore plugin.
+ */
+static struct GNUNET_DATASTORE_PluginFunctions *
+load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  static struct GNUNET_DATASTORE_PluginEnvironment env;
+  struct GNUNET_DATASTORE_PluginFunctions *ret;
+  char *name;
+  char *libname;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "DATASTORE",
+                                             "DATABASE",
+                                             &name))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("No `%s' specified for `%s' in configuration!\n"),
+                "DATABASE",
+                "DATASTORE");
+    return NULL;
+  }
+  env.cfg = cfg;
+  env.duc = &disk_utilization_change_cb;
+  env.cls = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Loading `%s' datastore plugin\n"),
+              name);
+  GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
+  if (NULL == (ret = GNUNET_PLUGIN_load (libname, &env)))
+  {
+    fprintf (stderr, "Failed to load plugin `%s'!\n", name);
+    GNUNET_free (libname);
+    GNUNET_free (name);
+    ok = 77;   /* mark test as skipped */
+    return NULL;
+  }
+  GNUNET_free (libname);
+  GNUNET_free (name);
+  return ret;
+}
+
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  struct GNUNET_DATASTORE_PluginFunctions *api;
+  struct CpsRunContext *crc;
+
+  api = load_plugin (c);
+  if (api == NULL)
+  {
+    fprintf (stderr,
+             "%s",
+             "Could not initialize plugin, assuming database not configured. Test not run!\n");
+    return;
+  }
+  crc = GNUNET_new (struct CpsRunContext);
+  crc->api = api;
+  crc->cfg = c;
+  crc->phase = RP_PUT;
+  GNUNET_SCHEDULER_add_now (&test, crc);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  char dir_name[PATH_MAX];
+  char cfg_name[PATH_MAX];
+  char *const xargv[] = {
+    "test-plugin-datastore",
+    "-c",
+    cfg_name,
+    NULL
+  };
+  static struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  /* determine name of plugin to use */
+  plugin_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]);
+  GNUNET_snprintf (dir_name, sizeof(dir_name),
+                   "/tmp/test-gnunet-datastore-plugin-%s", plugin_name);
+  GNUNET_DISK_directory_remove (dir_name);
+  GNUNET_log_setup ("test-plugin-datastore",
+                    "WARNING",
+                    NULL);
+  GNUNET_snprintf (cfg_name, sizeof(cfg_name),
+                   "test_plugin_datastore_data_%s.conf", plugin_name);
+  GNUNET_PROGRAM_run ((sizeof(xargv) / sizeof(char *)) - 1, xargv,
+                      "test-plugin-datastore", "nohelp", options, &run, NULL);
+  if ((0 != ok) && (77 != ok))
+    fprintf (stderr, "Missed some testcases: %u\n", ok);
+  GNUNET_DISK_directory_remove (dir_name);
+  return ok;
+}
+
+
+/* end of test_plugin_datastore.c */
diff --git a/src/plugin/datastore/test_plugin_datastore_data_heap.conf b/src/plugin/datastore/test_plugin_datastore_data_heap.conf
new file mode 100644
index 000000000..b1ea8ff67
--- /dev/null
+++ b/src/plugin/datastore/test_plugin_datastore_data_heap.conf
@@ -0,0 +1,6 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-datastore-plugin-heap/
+
+[datastore]
+DATABASE = heap
diff --git a/src/plugin/datastore/test_plugin_datastore_data_postgres.conf b/src/plugin/datastore/test_plugin_datastore_data_postgres.conf
new file mode 100644
index 000000000..d0e29437f
--- /dev/null
+++ b/src/plugin/datastore/test_plugin_datastore_data_postgres.conf
@@ -0,0 +1,10 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-datastore-plugin-postgres/
+
+[datastore]
+DATABASE = postgres
+
+[datastore-postgres]
+CONFIG = dbname=gnunetcheck
+
diff --git a/src/plugin/datastore/test_plugin_datastore_data_sqlite.conf b/src/plugin/datastore/test_plugin_datastore_data_sqlite.conf
new file mode 100644
index 000000000..ca837c77a
--- /dev/null
+++ b/src/plugin/datastore/test_plugin_datastore_data_sqlite.conf
@@ -0,0 +1,4 @@
+@INLINE@ test_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-datastore-plugin-sqlite/
+
diff --git a/src/plugin/dht/Makefile.am b/src/plugin/dht/Makefile.am
new file mode 100644
index 000000000..4df810066
--- /dev/null
+++ b/src/plugin/dht/Makefile.am
@@ -0,0 +1,27 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_dht.la
+
+libgnunet_plugin_block_dht_la_SOURCES = \
+  plugin_block_dht.c
+libgnunet_plugin_block_dht_la_LIBADD = \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_block_dht_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/dht/meson.build b/src/plugin/dht/meson.build
new file mode 100644
index 000000000..81b829dac
--- /dev/null
+++ b/src/plugin/dht/meson.build
@@ -0,0 +1,9 @@
+shared_module('gnunet_plugin_block_dht',
+        ['plugin_block_dht.c'],
+        dependencies: [libgnunetutil_dep,
+                       libgnunethello_dep,
+                       libgnunetblock_dep,
+                       libgnunetblockgroup_dep],
+        include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
diff --git a/src/plugin/dht/plugin_block_dht.c b/src/plugin/dht/plugin_block_dht.c
new file mode 100644
index 000000000..aa5ffc719
--- /dev/null
+++ b/src/plugin/dht/plugin_block_dht.c
@@ -0,0 +1,311 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2010, 2017, 2022 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 dht/plugin_block_dht.c
+ * @brief block plugin for DHT internals (right now, find-peer requests only);
+ *        other plugins should be used to store "useful" data in the
+ *        DHT (see fs block plugin)
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_constants.h"
+#include "gnunet_hello_uri_lib.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+
+#define DEBUG_DHT GNUNET_EXTRA_LOGGING
+
+/**
+ * Number of bits we set per entry in the bloomfilter.
+ * Do not change!
+ */
+#define BLOOMFILTER_K 16
+
+
+/**
+ * Create a new block group.
+ *
+ * @param ctx block context in which the block group is created
+ * @param type type of the block for which we are creating the group
+ * @param raw_data optional serialized prior state of the group, NULL if unavailable/fresh
+ * @param raw_data_size number of bytes in @a raw_data, 0 if unavailable/fresh
+ * @param va variable arguments specific to @a type
+ * @return block group handle, NULL if block groups are not supported
+ *         by this @a type of block (this is not an error)
+ */
+static struct GNUNET_BLOCK_Group *
+block_plugin_dht_create_group (void *cls,
+                               enum GNUNET_BLOCK_Type type,
+                               const void *raw_data,
+                               size_t raw_data_size,
+                               va_list va)
+{
+  unsigned int bf_size;
+  const char *guard;
+
+  guard = va_arg (va, const char *);
+  if (0 == strcmp (guard,
+                   "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va,
+                                                                   unsigned int),
+                                                           BLOOMFILTER_K);
+  else if (0 == strcmp (guard,
+                        "filter-size"))
+    bf_size = va_arg (va, unsigned int);
+  else
+  {
+    GNUNET_break (0);
+    bf_size = 8;
+  }
+  GNUNET_break (NULL == va_arg (va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create (cls,
+                                       bf_size,
+                                       BLOOMFILTER_K,
+                                       type,
+                                       raw_data,
+                                       raw_data_size);
+}
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dht_check_query (void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              const struct GNUNET_HashCode *query,
+                              const void *xquery,
+                              size_t xquery_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DHT_HELLO:
+    if (0 != xquery_size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dht_check_block (void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              const void *block,
+                              size_t block_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DHT_HELLO:
+    {
+      struct GNUNET_HELLO_Builder *b;
+      struct GNUNET_PeerIdentity pid;
+      struct GNUNET_HashCode h_pid;
+
+      b = GNUNET_HELLO_builder_from_block (block,
+                                           block_size);
+      if (NULL == b)
+      {
+        GNUNET_break (0);
+        return GNUNET_NO;
+      }
+      GNUNET_HELLO_builder_iterate (b,
+                                    &pid,
+                                    NULL, NULL);
+      GNUNET_CRYPTO_hash (&pid,
+                          sizeof (pid),
+                          &h_pid);
+      GNUNET_HELLO_builder_free (b);
+      return GNUNET_OK;
+    }
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_dht_check_reply (
+  void *cls,
+  enum GNUNET_BLOCK_Type type,
+  struct GNUNET_BLOCK_Group *group,
+  const struct GNUNET_HashCode *query,
+  const void *xquery,
+  size_t xquery_size,
+  const void *reply_block,
+  size_t reply_block_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DHT_HELLO:
+    {
+      struct GNUNET_HELLO_Builder *b;
+      struct GNUNET_PeerIdentity pid;
+      struct GNUNET_HashCode h_pid;
+
+      b = GNUNET_HELLO_builder_from_block (reply_block,
+                                           reply_block_size);
+      GNUNET_assert (NULL != b);
+      GNUNET_HELLO_builder_iterate (b,
+                                    &pid,
+                                    NULL, NULL);
+      GNUNET_CRYPTO_hash (&pid,
+                          sizeof (pid),
+                          &h_pid);
+      GNUNET_HELLO_builder_free (b);
+      if (GNUNET_YES ==
+          GNUNET_BLOCK_GROUP_bf_test_and_set (group,
+                                              &h_pid))
+        return GNUNET_BLOCK_REPLY_OK_DUPLICATE;
+      return GNUNET_BLOCK_REPLY_OK_MORE;
+    }
+  default:
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  }
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes @a block
+ * @param[out] key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dht_get_key (void *cls,
+                          enum GNUNET_BLOCK_Type type,
+                          const void *block,
+                          size_t block_size,
+                          struct GNUNET_HashCode *key)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DHT_HELLO:
+    {
+      struct GNUNET_HELLO_Builder *b;
+      struct GNUNET_PeerIdentity pid;
+
+      b = GNUNET_HELLO_builder_from_block (block,
+                                           block_size);
+      if (NULL == b)
+      {
+        GNUNET_break (0);
+        memset (key,
+                0,
+                sizeof (*key));
+        return GNUNET_OK;
+      }
+      GNUNET_HELLO_builder_iterate (b,
+                                    &pid,
+                                    NULL, NULL);
+      GNUNET_CRYPTO_hash (&pid,
+                          sizeof (pid),
+                          key);
+      GNUNET_HELLO_builder_free (b);
+      return GNUNET_OK;
+    }
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_dht_init (void *cls)
+{
+  static enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_DHT_HELLO,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_dht_get_key;
+  api->check_query = &block_plugin_dht_check_query;
+  api->check_block = &block_plugin_dht_check_block;
+  api->check_reply = &block_plugin_dht_check_reply;
+  api->create_group = &block_plugin_dht_create_group;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_dht_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_dht.c */
diff --git a/src/plugin/dhtu/.gitignore b/src/plugin/dhtu/.gitignore
deleted file mode 100644
index 21f1a7c9b..000000000
--- a/src/plugin/dhtu/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-test_dhtu_ip
diff --git a/src/plugin/dhtu/Makefile.am b/src/plugin/dhtu/Makefile.am
deleted file mode 100644
index 500d5a7b1..000000000
--- a/src/plugin/dhtu/Makefile.am
+++ /dev/null
@@ -1,81 +0,0 @@
-# This Makefile.am is in the public domain
-AM_CPPFLAGS = -I$(top_srcdir)/src/include
-
-plugindir = $(libdir)/gnunet
-
-pkgcfgdir= $(pkgdatadir)/config.d/
-
-if USE_COVERAGE
-  AM_CFLAGS = --coverage -O0
-  XLIBS = -lgcov
-endif
-
-pkgcfg_DATA = \
-  dhtu.conf
-
-plugin_LTLIBRARIES = \
-  libgnunet_plugin_dhtu_gnunet.la
-
-if !OPENBSD
-plugin_LTLIBRARIES += libgnunet_plugin_dhtu_ip.la
-
-libgnunet_plugin_dhtu_ip_la_SOURCES = \
-  plugin_dhtu_ip.c
-libgnunet_plugin_dhtu_ip_la_LIBADD = \
-  $(top_builddir)/src/lib/util/libgnunetutil.la \
-  $(XLIBS) \
-  $(LTLIBINTL)
-libgnunet_plugin_dhtu_ip_la_LDFLAGS = \
- $(GN_PLUGIN_LDFLAGS)
-endif
-
-
-libgnunet_plugin_dhtu_gnunet_la_SOURCES = \
-  plugin_dhtu_gnunet.c
-libgnunet_plugin_dhtu_gnunet_la_LIBADD = \
-  $(top_builddir)/src/service/core/libgnunetcore.la \
-  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
-  $(top_builddir)/src/service/transport/libgnunettransportapplication.la \
-  $(top_builddir)/src/lib/hello/libgnunethello.la \
-  $(top_builddir)/src/service/nse/libgnunetnse.la \
-  $(top_builddir)/src/lib/util/libgnunetutil.la \
-  $(XLIBS) \
-  $(LTLIBINTL)
-libgnunet_plugin_dhtu_gnunet_la_LDFLAGS = \
- $(GN_PLUGIN_LDFLAGS)
-
-
-lib_LTLIBRARIES = \
-  libgnunettestingdhtu.la
-
-libgnunettestingdhtu_la_SOURCES = \
-  testing_dhtu_cmd_send.c
-libgnunettestingdhtu_la_LIBADD = \
- $(top_builddir)/src/service/testing/libgnunettesting.la \
- $(top_builddir)/src/service/arm/libgnunetarm.la \
- $(top_builddir)/src/lib/util/libgnunetutil.la \
- $(LTLIBINTL)
-libgnunettestingdhtu_la_LDFLAGS = \
- $(GN_LIB_LDFLAGS) \
- -version-info 0:0:0
-
-
-
-test_dhtu_ip_SOURCES = \
- test_dhtu_ip.c
-test_dhtu_ip_LDADD = \
- $(top_builddir)/src/service/testing/libgnunettesting.la \
- $(top_builddir)/src/service/arm/libgnunetarm.la \
- $(top_builddir)/src/lib/util/libgnunetutil.la
-
-check_PROGRAMS = \
- test_dhtu_ip
-
-EXTRA_DIST = \
-  dhtu.conf
-
-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
diff --git a/src/plugin/dhtu/dhtu.conf b/src/plugin/dhtu/dhtu.conf
deleted file mode 100644
index ea5ade752..000000000
--- a/src/plugin/dhtu/dhtu.conf
+++ /dev/null
@@ -1,7 +0,0 @@
-[dhtu-gnunet]
-ENABLED = YES
-
-[dhtu-ip]
-ENABLED = NO
-NSE = 4
-UDP_PORT = 6666
diff --git a/src/plugin/dhtu/meson.build b/src/plugin/dhtu/meson.build
deleted file mode 100644
index b2525e782..000000000
--- a/src/plugin/dhtu/meson.build
+++ /dev/null
@@ -1,61 +0,0 @@
-libgnunetplugindhtuip_src = ['plugin_dhtu_ip.c']
-libgnunetplugindhtugnunet_src = ['plugin_dhtu_gnunet.c']
-
-configure_file(input : 'dhtu.conf',
-               output : 'dhtu.conf',
-               configuration : cdata,
-               install: true,
-               install_dir: pkgcfgdir)
-
-if get_option('monolith')
-  foreach p : libgnunetplugindhtuip_src + libgnunetplugindhtugnunet_src
-    gnunet_src += 'dhtu/' + p
-  endforeach
-  subdir_done()
-endif
-
-libgnunettestingdhtu = library('gnunettestingdhtu',
-        ['testing_dhtu_cmd_send.c'],
-        soversion: '0',
-        version: '0.0.0',
-        dependencies: [
-          libgnunetutil_dep,
-          libgnunetarm_dep,
-          libgnunettesting_dep
-          ],
-        include_directories: [incdir, configuration_inc],
-        install: true,
-        install_dir: get_option('libdir'))
-libgnunettestingdhtu_dep = declare_dependency(link_with : libgnunettestingdhtu)
-
-shared_module('gnunet_plugin_dhtu_ip',
-          libgnunetplugindhtuip_src,
-          dependencies: [libgnunetutil_dep, m_dep],
-          include_directories: [incdir, configuration_inc],
-          install: true,
-          install_dir: get_option('libdir')/'gnunet')
-
-shared_module('gnunet_plugin_dhtu_gnunet',
-          libgnunetplugindhtugnunet_src,
-          dependencies: [libgnunetutil_dep,
-                         m_dep,
-                         libgnunetcore_dep,
-                         libgnunethello_dep,
-                         libgnunetpeerstore_dep,
-                         libgnunetnse_dep,
-                         ],
-          include_directories: [incdir, configuration_inc],
-          install: true,
-          install_dir: get_option('libdir')/'gnunet')
-
-testdhtu_ip = executable('test_dhtu_ip',
-           ['test_dhtu_ip.c'],
-          dependencies: [libgnunetutil_dep,
-                         libgnunettesting_dep],
-          include_directories: [incdir, configuration_inc],
-          install: false)
-
-test('test_dhtu_ip', testdhtu_ip, suite: 'dhtu',
-     workdir: meson.current_build_dir())
-
-
diff --git a/src/plugin/dhtu/plugin_dhtu_gnunet.c b/src/plugin/dhtu/plugin_dhtu_gnunet.c
deleted file mode 100644
index 75f466916..000000000
--- a/src/plugin/dhtu/plugin_dhtu_gnunet.c
+++ /dev/null
@@ -1,603 +0,0 @@
-/*
-     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 Christian Grothoff
- *
- * @file plugin_dhtu_gnunet.c
- * @brief plain IP based DHT network underlay
- */
-#include "platform.h"
-#include "gnunet_dhtu_plugin.h"
-#include "gnunet_core_service.h"
-#include "gnunet_transport_application_service.h"
-#include "gnunet_hello_uri_lib.h"
-#include "gnunet_peerstore_service.h"
-#include "gnunet_nse_service.h"
-
-/**
- * Opaque handle that the underlay offers for our address to be used when
- * sending messages to another peer.
- */
-struct GNUNET_DHTU_Source
-{
-
-  /**
-   * Application context for this source.
-   */
-  void *app_ctx;
-
-};
-
-
-/**
- * Opaque handle that the underlay offers for the target peer when sending
- * messages to another peer.
- */
-struct GNUNET_DHTU_Target
-{
-
-  /**
-   * Application context for this target.
-   */
-  void *app_ctx;
-
-  /**
-   * Our plugin with its environment.
-   */
-  struct Plugin *plugin;
-
-  /**
-   * CORE MQ to send messages to this peer.
-   */
-  struct GNUNET_MQ_Handle *mq;
-
-  /**
-   * Head of preferences expressed for this target.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *ph_head;
-
-  /**
-   * Tail of preferences expressed for this target.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *ph_tail;
-
-  /**
-   * Transport suggest handle.
-   */
-  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *ash;
-
-  /**
-   * Identity of this peer.
-   */
-  struct GNUNET_PeerIdentity pid;
-
-  /**
-   * Preference counter, length of the @a ph_head DLL.
-   */
-  unsigned int ph_count;
-
-};
-
-
-/**
- * Opaque handle expressing a preference of the DHT to
- * keep a particular target connected.
- */
-struct GNUNET_DHTU_PreferenceHandle
-{
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *next;
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *prev;
-
-  /**
-   * Target a preference was expressed for.
-   */
-  struct GNUNET_DHTU_Target *target;
-};
-
-
-/**
- * Closure for all plugin functions.
- */
-struct Plugin
-{
-
-  /**
-   * Our "source" address. Traditional CORE API does not tell us which source
-   * it is, so they are all identical.
-   */
-  struct GNUNET_DHTU_Source src;
-
-  /**
-   * Callbacks into the DHT.
-   */
-  struct GNUNET_DHTU_PluginEnvironment *env;
-
-  /**
-   * Handle to the PEERSTORE service.
-   */
-  struct GNUNET_PEERSTORE_Handle *peerstore;
-
-  /**
-   * Handle to the CORE service.
-   */
-  struct GNUNET_CORE_Handle *core;
-
-  /**
-   * Handle to Transport service.
-   */
-  struct GNUNET_TRANSPORT_ApplicationHandle *transport;
-
-  /**
-   * Handle to the NSE service.
-   */
-  struct GNUNET_NSE_Handle *nse;
-
-  /**
-   * Our peerstore notification context.  We use notification
-   * to instantly learn about new peers as they are discovered.
-   */
-  struct GNUNET_PEERSTORE_NotifyContext *peerstore_notify;
-
-  /**
-   * Identity of this peer.
-   */
-  struct GNUNET_PeerIdentity my_identity;
-
-  /**
-   * Our private key.
-   */
-  struct GNUNET_CRYPTO_EddsaPrivateKey *my_priv;
-
-};
-
-
-//#include "../peerinfo-tool/gnunet-peerinfo_plugins.c"
-
-
-/**
- * Request creation of a session with a peer at the given @a address.
- *
- * @param cls closure (internal context for the plugin)
- * @param pid target identity of the peer to connect to
- * @param address target address to connect to
- */
-static void
-gnunet_try_connect (void *cls,
-                    const struct GNUNET_PeerIdentity *pid,
-                    const char *address)
-{
-  struct Plugin *plugin = cls;
-  enum GNUNET_NetworkType nt = 0;
-  char *addr;
-  const char *eou;
-  int pfx_len;
-
-  eou = strstr (address,
-                  "://");
-  if (NULL == eou)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  pfx_len = eou - address;
-  eou += 3;
-  GNUNET_asprintf (&addr,
-                   "%.*s-%s",
-                   pfx_len,
-                   address,
-                   eou);
-  GNUNET_TRANSPORT_application_validate (plugin->transport,
-                                         pid,
-                                         nt,
-                                         addr);
-  GNUNET_free (addr);
-}
-
-
-/**
- * Request underlay to keep the connection to @a target alive if possible.
- * Hold may be called multiple times to express a strong preference to
- * keep a connection, say because a @a target is in multiple tables.
- *
- * @param cls closure
- * @param target connection to keep alive
- */
-static struct GNUNET_DHTU_PreferenceHandle *
-gnunet_hold (void *cls,
-             struct GNUNET_DHTU_Target *target)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_DHTU_PreferenceHandle *ph;
-
-  ph = GNUNET_new (struct GNUNET_DHTU_PreferenceHandle);
-  ph->target = target;
-  GNUNET_CONTAINER_DLL_insert (target->ph_head,
-                               target->ph_tail,
-                               ph);
-  target->ph_count++;
-  if (NULL != target->ash)
-    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
-  target->ash
-    = GNUNET_TRANSPORT_application_suggest (plugin->transport,
-                                            &target->pid,
-                                            GNUNET_MQ_PRIO_BEST_EFFORT,
-                                            GNUNET_BANDWIDTH_ZERO);
-  return ph;
-}
-
-
-/**
- * Do no long request underlay to keep the connection alive.
- *
- * @param cls closure
- * @param target connection to keep alive
- */
-static void
-gnunet_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
-{
-  struct GNUNET_DHTU_Target *target = ph->target;
-  struct Plugin *plugin = target->plugin;
-
-  GNUNET_CONTAINER_DLL_remove (target->ph_head,
-                               target->ph_tail,
-                               ph);
-  target->ph_count--;
-  GNUNET_free (ph);
-  if (NULL != target->ash)
-    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
-  if (0 == target->ph_count)
-    target->ash = NULL;
-  else
-    target->ash
-      = GNUNET_TRANSPORT_application_suggest (plugin->transport,
-                                              &target->pid,
-                                              GNUNET_MQ_PRIO_BEST_EFFORT,
-                                              GNUNET_BANDWIDTH_ZERO);
-}
-
-
-/**
- * Send message to some other participant over the network.  Note that
- * sending is not guaranteeing that the other peer actually received the
- * message.  For any given @a target, the DHT must wait for the @a
- * finished_cb to be called before calling send() again.
- *
- * @param cls closure (internal context for the plugin)
- * @param target receiver identification
- * @param msg message
- * @param msg_size number of bytes in @a msg
- * @param finished_cb function called once transmission is done
- *        (not called if @a target disconnects, then only the
- *         disconnect_cb is called).
- * @param finished_cb_cls closure for @a finished_cb
- */
-static void
-gnunet_send (void *cls,
-             struct GNUNET_DHTU_Target *target,
-             const void *msg,
-             size_t msg_size,
-             GNUNET_SCHEDULER_TaskCallback finished_cb,
-             void *finished_cb_cls)
-{
-  struct GNUNET_MQ_Envelope *env;
-  struct GNUNET_MessageHeader *cmsg;
-
-  env = GNUNET_MQ_msg_extra (cmsg,
-                             msg_size,
-                             GNUNET_MESSAGE_TYPE_DHT_CORE);
-  GNUNET_MQ_notify_sent (env,
-                         finished_cb,
-                         finished_cb_cls);
-  memcpy (&cmsg[1],
-          msg,
-          msg_size);
-  GNUNET_MQ_send (target->mq,
-                  env);
-}
-
-
-/**
- * Method called whenever a given peer connects.
- *
- * @param cls closure
- * @param peer peer identity this notification is about
- * @return closure associated with @a peer. given to mq callbacks and
- *         #GNUNET_CORE_DisconnectEventHandler
- */
-static void *
-core_connect_cb (void *cls,
-                 const struct GNUNET_PeerIdentity *peer,
-                 struct GNUNET_MQ_Handle *mq)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_DHTU_Target *target;
-
-  target = GNUNET_new (struct GNUNET_DHTU_Target);
-  target->plugin = plugin;
-  target->mq = mq;
-  target->pid = *peer;
-  plugin->env->connect_cb (plugin->env->cls,
-                           target,
-                           &target->pid,
-                           &target->app_ctx);
-  return target;
-}
-
-
-/**
- * Method called whenever a peer disconnects.
- *
- * @param cls closure
- * @param peer peer identity this notification is about
- * @param peer_cls closure associated with peer. given in
- *        #GNUNET_CORE_ConnectEventHandler
- */
-static void
-core_disconnect_cb (void *cls,
-                    const struct GNUNET_PeerIdentity *peer,
-                    void *peer_cls)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_DHTU_Target *target = peer_cls;
-
-  plugin->env->disconnect_cb (target->app_ctx);
-  if (NULL != target->ash)
-    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
-  GNUNET_free (target);
-}
-
-
-static void
-add_addr (void *cls,
-          const char *addr)
-{
-  struct Plugin *plugin = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG ,
-              "peerinfo_cb addr %s\n",
-              addr);
-  plugin->env->address_add_cb (plugin->env->cls,
-                               addr,
-                               &plugin->src,
-                               &plugin->src.app_ctx);
-}
-
-
-/**
- * Find the @a hello for our identity and then pass
- * it to the DHT as a URL.  Note that we only
- * add addresses, never remove them, due to limitations
- * of the current peerinfo/core/transport APIs.
- * This will change with TNG.
- *
- * @param cls a `struct Plugin`
- * @param peer id of the peer, NULL for last call
- * @param hello hello message for the peer (can be NULL)
- * @param err_msg message
- */
-static void
-peerinfo_cb (void *cls,
-             const struct GNUNET_PeerIdentity *peer,
-             const struct GNUNET_MessageHeader *hello,
-             const char *emsg)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_HELLO_Builder *builder;
-
-  if (NULL == hello)
-    return;
-  if (NULL == peer)
-    return;
-  if (0 !=
-      GNUNET_memcmp (peer,
-                     &plugin->my_identity))
-    return;
-  builder = GNUNET_HELLO_builder_from_msg (hello);
-  GNUNET_HELLO_builder_iterate (builder,
-                                (struct GNUNET_PeerIdentity *) peer,
-                                add_addr,
-                                plugin);
-  GNUNET_HELLO_builder_free (builder);
-}
-
-
-/**
- * Function called after #GNUNET_CORE_connect has succeeded (or failed
- * for good).  Note that the private key of the peer is intentionally
- * not exposed here; if you need it, your process should try to read
- * the private key file directly (which should work if you are
- * authorized...).  Implementations of this function must not call
- * #GNUNET_CORE_disconnect (other than by scheduling a new task to
- * do this later).
- *
- * @param cls closure
- * @param my_identity ID of this peer, NULL if we failed
- */
-static void
- core_init_cb (void *cls,
-              const struct GNUNET_PeerIdentity *my_identity)
-{
-  struct Plugin *plugin = cls;
-
-  plugin->my_identity = *my_identity;
-  plugin->peerstore_notify =
-      GNUNET_PEERSTORE_hello_changed_notify (plugin->peerstore,
-                                             GNUNET_NO,
-                                             &peerinfo_cb,
-                                             plugin);
-}
-
-
-/**
- * Anything goes, always return #GNUNET_OK.
- *
- * @param cls unused
- * @param msg message to check
- * @return #GNUNET_OK if all is fine
- */
-static int
-check_core_message (void *cls,
-                    const struct GNUNET_MessageHeader *msg)
-{
-  (void) cls;
-  (void) msg;
-  return GNUNET_OK;
-}
-
-
-/**
- * Handle message from CORE for the DHT. Passes it to the
- * DHT logic.
- *
- * @param cls a `struct GNUNET_DHTU_Target` of the sender
- * @param msg the message we received
- */
-static void
-handle_core_message (void *cls,
-                     const struct GNUNET_MessageHeader *msg)
-{
-  struct GNUNET_DHTU_Target *origin = cls;
-  struct Plugin *plugin = origin->plugin;
-
-  plugin->env->receive_cb (plugin->env->cls,
-                           &origin->app_ctx,
-                           &plugin->src.app_ctx,
-                           &msg[1],
-                           ntohs (msg->size) - sizeof (*msg));
-}
-
-
-/**
- * Callback to call when network size estimate is updated.
- *
- * @param cls closure
- * @param timestamp time when the estimate was received from the server (or created by the server)
- * @param logestimate the log(Base 2) value of the current network size estimate
- * @param std_dev standard deviation for the estimate
- */
-static void
-nse_cb (void *cls,
-        struct GNUNET_TIME_Absolute timestamp,
-        double logestimate,
-        double std_dev)
-{
-  struct Plugin *plugin = cls;
-
-  plugin->env->network_size_cb (plugin->env->cls,
-                                timestamp,
-                                logestimate,
-                                std_dev);
-}
-
-
-/**
- * Exit point from the plugin.
- *
- * @param cls closure (our `struct Plugin`)
- * @return NULL
- */
-void *
-libgnunet_plugin_dhtu_gnunet_done (void *cls)
-{
-  struct GNUNET_DHTU_PluginFunctions *api = cls;
-  struct Plugin *plugin = api->cls;
-
-  if (NULL != plugin->nse)
-    GNUNET_NSE_disconnect (plugin->nse);
-  plugin->env->network_size_cb (plugin->env->cls,
-                                GNUNET_TIME_UNIT_FOREVER_ABS,
-                                0.0,
-                                0.0);
-  if (NULL != plugin->core)
-    GNUNET_CORE_disconnect (plugin->core);
-  if (NULL != plugin->transport)
-    GNUNET_TRANSPORT_application_done (plugin->transport);
-  if (NULL != plugin->peerstore_notify)
-    GNUNET_PEERSTORE_hello_changed_notify_cancel (plugin->peerstore_notify);
-  if (NULL != plugin->peerstore)
-    GNUNET_PEERSTORE_disconnect (plugin->peerstore, GNUNET_YES);
-  //GPI_plugins_unload ();
-  GNUNET_free (plugin->my_priv);
-  GNUNET_free (plugin);
-  GNUNET_free (api);
-  return NULL;
-}
-
-
-/**
- * Entry point for the plugin.
- *
- * @param cls closure (the `struct GNUNET_DHTU_PluginEnvironment`)
- * @return the plugin's API
- */
-void *
-libgnunet_plugin_dhtu_gnunet_init (void *cls)
-{
-  struct GNUNET_DHTU_PluginEnvironment *env = cls;
-  struct GNUNET_DHTU_PluginFunctions *api;
-  struct Plugin *plugin;
-  struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (core_message,
-                           GNUNET_MESSAGE_TYPE_DHT_CORE,
-                           struct GNUNET_MessageHeader,
-                           NULL),
-    GNUNET_MQ_handler_end ()
-  };
-
-  plugin = GNUNET_new (struct Plugin);
-  plugin->my_priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (env->cfg);
-  plugin->env = env;
-  api = GNUNET_new (struct GNUNET_DHTU_PluginFunctions);
-  api->cls = plugin;
-  api->try_connect = &gnunet_try_connect;
-  api->hold = &gnunet_hold;
-  api->drop = &gnunet_drop;
-  api->send = &gnunet_send;
-  plugin->peerstore = GNUNET_PEERSTORE_connect (env->cfg);
-  plugin->transport = GNUNET_TRANSPORT_application_init (env->cfg);
-  plugin->core = GNUNET_CORE_connect (env->cfg,
-                                      plugin,
-                                      &core_init_cb,
-                                      &core_connect_cb,
-                                      &core_disconnect_cb,
-                                      handlers);
-  plugin->nse = GNUNET_NSE_connect (env->cfg,
-                                    &nse_cb,
-                                    plugin);
-  if ( (NULL == plugin->transport) ||
-       (NULL == plugin->core) ||
-       (NULL == plugin->nse) )
-  {
-    GNUNET_break (0);
-    GNUNET_free (api);
-    libgnunet_plugin_dhtu_gnunet_done (plugin);
-    return NULL;
-  }
-  //GPI_plugins_load (env->cfg);
-  return api;
-}
diff --git a/src/plugin/dhtu/plugin_dhtu_ip.c b/src/plugin/dhtu/plugin_dhtu_ip.c
deleted file mode 100644
index 06d0f0f60..000000000
--- a/src/plugin/dhtu/plugin_dhtu_ip.c
+++ /dev/null
@@ -1,1171 +0,0 @@
-/*
-     This file is part of GNUnet
-     Copyright (C) 2021, 2022 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 Christian Grothoff
- *
- * @file plugin_dhtu_ip.c
- * @brief plain IP based DHT network underlay
- */
-#include "platform.h"
-#include "gnunet_dhtu_plugin.h"
-
-/**
- * How frequently should we re-scan our local interfaces for IPs?
- */
-#define SCAN_FREQ GNUNET_TIME_UNIT_MINUTES
-
-/**
- * Maximum number of concurrently active destinations to support.
- */
-#define MAX_DESTS 256
-
-
-/**
- * Opaque handle that the underlay offers for our address to be used when
- * sending messages to another peer.
- */
-struct GNUNET_DHTU_Source
-{
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_Source *next;
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_Source *prev;
-
-  /**
-   * Application context for this source.
-   */
-  void *app_ctx;
-
-  /**
-   * Address in URL form ("ip+udp://$PID/$IP:$PORT")
-   */
-  char *address;
-
-  /**
-   * My actual address.
-   */
-  struct sockaddr_storage addr;
-
-  /**
-   * Number of bytes in @a addr.
-   */
-  socklen_t addrlen;
-
-  /**
-   * Last generation this address was observed.
-   */
-  unsigned int scan_generation;
-
-};
-
-
-/**
- * Opaque handle that the underlay offers for the target peer when sending
- * messages to another peer.
- */
-struct GNUNET_DHTU_Target
-{
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_Target *next;
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_Target *prev;
-
-  /**
-   * Application context for this target.
-   */
-  void *app_ctx;
-
-  /**
-   * Head of preferences expressed for this target.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *ph_head;
-
-  /**
-   * Tail of preferences expressed for this target.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *ph_tail;
-
-  /**
-   * Peer's identity.
-   */
-  struct GNUNET_PeerIdentity pid;
-
-  /**
-   * Target IP address.
-   */
-  struct sockaddr_storage addr;
-
-  /**
-   * Number of bytes in @a addr.
-   */
-  socklen_t addrlen;
-
-  /**
-   * Preference counter, length of the @a ph_head DLL.
-   */
-  unsigned int ph_count;
-
-};
-
-/**
- * Opaque handle expressing a preference of the DHT to
- * keep a particular target connected.
- */
-struct GNUNET_DHTU_PreferenceHandle
-{
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *next;
-
-  /**
-   * Kept in a DLL.
-   */
-  struct GNUNET_DHTU_PreferenceHandle *prev;
-
-  /**
-   * Target a preference was expressed for.
-   */
-  struct GNUNET_DHTU_Target *target;
-};
-
-
-/**
- * Closure for all plugin functions.
- */
-struct Plugin
-{
-  /**
-   * Callbacks into the DHT.
-   */
-  struct GNUNET_DHTU_PluginEnvironment *env;
-
-  /**
-   * Head of sources where we receive traffic.
-   */
-  struct GNUNET_DHTU_Source *src_head;
-
-  /**
-   * Tail of sources where we receive traffic.
-   */
-  struct GNUNET_DHTU_Source *src_tail;
-
-  /**
-   * Head of destinations that are active. Sorted by
-   * last use, with latest used at the head.
-   */
-  struct GNUNET_DHTU_Target *dst_head;
-
-  /**
-   * Tail of destinations that are active.
-   */
-  struct GNUNET_DHTU_Target *dst_tail;
-
-  /**
-   * Map from hashes of sockaddrs to targets.
-   */
-  struct GNUNET_CONTAINER_MultiHashMap *dsts;
-
-  /**
-   * Task that scans for IP address changes.
-   */
-  struct GNUNET_SCHEDULER_Task *scan_task;
-
-  /**
-   * Task that reads incoming UDP packets.
-   */
-  struct GNUNET_SCHEDULER_Task *read_task;
-
-  /**
-   * Port we bind to.
-   */
-  char *port;
-
-  /**
-   * My UDP socket.
-   */
-  struct GNUNET_NETWORK_Handle *sock;
-
-  /**
-   * My identity.
-   */
-  struct GNUNET_PeerIdentity my_id;
-
-  /**
-   * How often have we scanned for IPs?
-   */
-  unsigned int scan_generation;
-
-  /**
-   * Port as a 16-bit value.
-   */
-  uint16_t port16;
-};
-
-
-/**
- * Create a target to which we may send traffic.
- *
- * @param plugin our plugin
- * @param pid presumed identity of the target
- * @param addr target address
- * @param addrlen number of bytes in @a addr
- * @return new target object
- */
-static struct GNUNET_DHTU_Target *
-create_target (struct Plugin *plugin,
-               const struct GNUNET_PeerIdentity *pid,
-               const struct sockaddr *addr,
-               socklen_t addrlen)
-{
-  struct GNUNET_DHTU_Target *dst;
-
-  if (MAX_DESTS <=
-      GNUNET_CONTAINER_multihashmap_size (plugin->dsts))
-  {
-    struct GNUNET_HashCode key;
-
-    dst = NULL;
-    for (struct GNUNET_DHTU_Target *pos = plugin->dst_head;
-         NULL != pos;
-         pos = pos->next)
-    {
-      /* >= here assures we remove oldest entries first */
-      if ( (NULL == dst) ||
-           (dst->ph_count >= pos->ph_count) )
-        dst = pos;
-    }
-    GNUNET_assert (NULL != dst);
-    plugin->env->disconnect_cb (dst->app_ctx);
-    GNUNET_CRYPTO_hash (&dst->addr,
-                        dst->addrlen,
-                        &key);
-    GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_remove (plugin->dsts,
-                                                         &key,
-                                                         dst));
-    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
-                                 plugin->dst_tail,
-                                 dst);
-    GNUNET_assert (NULL == dst->ph_head);
-    GNUNET_free (dst);
-  }
-  dst = GNUNET_new (struct GNUNET_DHTU_Target);
-  dst->addrlen = addrlen;
-  dst->pid = *pid;
-  memcpy (&dst->addr,
-          addr,
-          addrlen);
-  GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
-                               plugin->dst_tail,
-                               dst);
-  plugin->env->connect_cb (plugin->env->cls,
-                           dst,
-                           &dst->pid,
-                           &dst->app_ctx);
-  return dst;
-}
-
-
-/**
- * Find target matching @a addr. If none exists,
- * create one!
- *
- * @param plugin the plugin handle
- * @param pid presumed identity of the target
- * @param addr socket address to find
- * @param addrlen number of bytes in @a addr
- * @return matching target object
- */
-static struct GNUNET_DHTU_Target *
-find_target (struct Plugin *plugin,
-             const struct GNUNET_PeerIdentity *pid,
-             const void *addr,
-             size_t addrlen)
-{
-  struct GNUNET_HashCode key;
-  struct GNUNET_DHTU_Target *dst;
-
-  GNUNET_CRYPTO_hash (addr,
-                      addrlen,
-                      &key);
-  dst = GNUNET_CONTAINER_multihashmap_get (plugin->dsts,
-                                           &key);
-  if (NULL == dst)
-  {
-    dst = create_target (plugin,
-                         pid,
-                         (const struct sockaddr *) addr,
-                         addrlen);
-    GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_put (
-                     plugin->dsts,
-                     &key,
-                     dst,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  }
-  else
-  {
-    /* move to head of DLL */
-    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
-                                 plugin->dst_tail,
-                                 dst);
-    GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
-                                 plugin->dst_tail,
-                                 dst);
-
-  }
-  return dst;
-}
-
-
-/**
- * Request creation of a session with a peer at the given @a address.
- *
- * @param cls closure (internal context for the plugin)
- * @param pid identity of the target peer
- * @param address target address to connect to
- */
-static void
-ip_try_connect (void *cls,
-                const struct GNUNET_PeerIdentity *pid,
-                const char *address)
-{
-  struct Plugin *plugin = cls;
-  char *colon;
-  const char *port;
-  char *addr;
-  struct addrinfo hints = {
-    .ai_flags = AI_NUMERICHOST | AI_NUMERICSERV
-  };
-  struct addrinfo *result = NULL;
-
-  if (0 !=
-      strncmp (address,
-               "ip+",
-               strlen ("ip+")))
-    return;
-  address += strlen ("ip+");
-  if (0 !=
-      strncmp (address,
-               "udp://",
-               strlen ("udp://")))
-    return;
-  address += strlen ("udp://");
-  addr = GNUNET_strdup (address);
-  colon = strchr (addr, ':');
-  if (NULL == colon)
-  {
-    port = plugin->port;
-  }
-  else
-  {
-    *colon = '\0';
-    port = colon + 1;
-  }
-  if (0 !=
-      getaddrinfo (addr,
-                   port,
-                   &hints,
-                   &result))
-  {
-    GNUNET_break (0);
-    GNUNET_free (addr);
-    return;
-  }
-  GNUNET_free (addr);
-  (void) find_target (plugin,
-                      pid,
-                      result->ai_addr,
-                      result->ai_addrlen);
-  freeaddrinfo (result);
-}
-
-
-/**
- * Request underlay to keep the connection to @a target alive if possible.
- * Hold may be called multiple times to express a strong preference to
- * keep a connection, say because a @a target is in multiple tables.
- *
- * @param cls closure
- * @param target connection to keep alive
- */
-static struct GNUNET_DHTU_PreferenceHandle *
-ip_hold (void *cls,
-         struct GNUNET_DHTU_Target *target)
-{
-  struct GNUNET_DHTU_PreferenceHandle *ph;
-
-  ph = GNUNET_new (struct GNUNET_DHTU_PreferenceHandle);
-  ph->target = target;
-  GNUNET_CONTAINER_DLL_insert (target->ph_head,
-                               target->ph_tail,
-                               ph);
-  target->ph_count++;
-  return ph;
-}
-
-
-/**
- * Do no long request underlay to keep the connection alive.
- *
- * @param cls closure
- * @param target connection to keep alive
- */
-static void
-ip_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
-{
-  struct GNUNET_DHTU_Target *target = ph->target;
-
-  GNUNET_CONTAINER_DLL_remove (target->ph_head,
-                               target->ph_tail,
-                               ph);
-  target->ph_count--;
-  GNUNET_free (ph);
-}
-
-
-/**
- * Send message to some other participant over the network.  Note that
- * sending is not guaranteeing that the other peer actually received the
- * message.  For any given @a target, the DHT must wait for the @a
- * finished_cb to be called before calling send() again.
- *
- * @param cls closure (internal context for the plugin)
- * @param target receiver identification
- * @param msg message
- * @param msg_size number of bytes in @a msg
- * @param finished_cb function called once transmission is done
- *        (not called if @a target disconnects, then only the
- *         disconnect_cb is called).
- * @param finished_cb_cls closure for @a finished_cb
- */
-static void
-ip_send (void *cls,
-         struct GNUNET_DHTU_Target *target,
-         const void *msg,
-         size_t msg_size,
-         GNUNET_SCHEDULER_TaskCallback finished_cb,
-         void *finished_cb_cls)
-{
-  struct Plugin *plugin = cls;
-  char buf[sizeof (plugin->my_id) + msg_size];
-
-  memcpy (buf,
-          &plugin->my_id,
-          sizeof (plugin->my_id));
-  memcpy (&buf[sizeof (plugin->my_id)],
-          msg,
-          msg_size);
-  GNUNET_NETWORK_socket_sendto (plugin->sock,
-                                buf,
-                                sizeof (buf),
-                                (const struct sockaddr *) &target->addr,
-                                target->addrlen);
-  finished_cb (finished_cb_cls);
-}
-
-
-/**
- * Create a new source on which we may be receiving traffic.
- *
- * @param plugin our plugin
- * @param addr our address
- * @param addrlen number of bytes in @a addr
- * @return new source object
- */
-static struct GNUNET_DHTU_Source *
-create_source (struct Plugin *plugin,
-               const struct sockaddr *addr,
-               socklen_t addrlen)
-{
-  struct GNUNET_DHTU_Source *src;
-
-  src = GNUNET_new (struct GNUNET_DHTU_Source);
-  src->addrlen = addrlen;
-  memcpy (&src->addr,
-          addr,
-          addrlen);
-  src->scan_generation = plugin->scan_generation;
-  switch (addr->sa_family)
-  {
-  case AF_INET:
-    {
-      const struct sockaddr_in *s4 = (const struct sockaddr_in *) addr;
-      char buf[INET_ADDRSTRLEN];
-
-      GNUNET_assert (sizeof (struct sockaddr_in) == addrlen);
-      GNUNET_asprintf (&src->address,
-                       "ip+udp://%s:%u",
-                       inet_ntop (AF_INET,
-                                  &s4->sin_addr,
-                                  buf,
-                                  sizeof (buf)),
-                       ntohs (s4->sin_port));
-    }
-    break;
-  case AF_INET6:
-    {
-      const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) addr;
-      char buf[INET6_ADDRSTRLEN];
-
-      GNUNET_assert (sizeof (struct sockaddr_in6) == addrlen);
-      GNUNET_asprintf (&src->address,
-                       "ip+udp://[%s]:%u",
-                       inet_ntop (AF_INET6,
-                                  &s6->sin6_addr,
-                                  buf,
-                                  sizeof (buf)),
-                       ntohs (s6->sin6_port));
-    }
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_free (src);
-    return NULL;
-  }
-  GNUNET_CONTAINER_DLL_insert (plugin->src_head,
-                               plugin->src_tail,
-                               src);
-  plugin->env->address_add_cb (plugin->env->cls,
-                               src->address,
-                               src,
-                               &src->app_ctx);
-  return src;
-}
-
-
-/**
- * Compare two addresses excluding the ports for equality. Only compares IP
- * address. Must only be called on AF_INET or AF_INET6 addresses.
- *
- * @param a1 address to compare
- * @param a2 address to compare
- * @param alen number of bytes in @a a1 and @a a2
- * @return 0 if @a a1 == @a a2.
- */
-static int
-addrcmp_np (const struct sockaddr *a1,
-            const struct sockaddr *a2,
-            size_t alen)
-{
-  GNUNET_assert (a1->sa_family == a2->sa_family);
-  switch (a1->sa_family)
-  {
-  case AF_INET:
-    GNUNET_assert (sizeof (struct sockaddr_in) == alen);
-    {
-      const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
-      const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
-
-      if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
-        return 1;
-      break;
-    }
-  case AF_INET6:
-    GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
-    {
-      const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
-      const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
-
-      if (0 != GNUNET_memcmp (&s1->sin6_addr,
-                              &s2->sin6_addr))
-        return 1;
-      break;
-    }
-  default:
-    GNUNET_assert (0);
-  }
-  return 0;
-}
-
-
-/**
- * Compare two addresses for equality. Only
- * compares IP address and port. Must only be
- * called on AF_INET or AF_INET6 addresses.
- *
- * @param a1 address to compare
- * @param a2 address to compare
- * @param alen number of bytes in @a a1 and @a a2
- * @return 0 if @a a1 == @a a2.
- */
-static int
-addrcmp (const struct sockaddr *a1,
-         const struct sockaddr *a2,
-         size_t alen)
-{
-  GNUNET_assert (a1->sa_family == a2->sa_family);
-  switch (a1->sa_family)
-  {
-  case AF_INET:
-    GNUNET_assert (sizeof (struct sockaddr_in) == alen);
-    {
-      const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
-      const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
-
-      if (s1->sin_port != s2->sin_port)
-        return 1;
-      if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
-        return 1;
-      break;
-    }
-  case AF_INET6:
-    GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
-    {
-      const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
-      const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
-
-      if (s1->sin6_port != s2->sin6_port)
-        return 1;
-      if (0 != GNUNET_memcmp (&s1->sin6_addr,
-                              &s2->sin6_addr))
-        return 1;
-      break;
-    }
-  default:
-    GNUNET_assert (0);
-  }
-  return 0;
-}
-
-
-/**
- * Callback function invoked for each interface found.
- *
- * @param cls closure
- * @param name name of the interface (can be NULL for unknown)
- * @param isDefault is this presumably the default interface
- * @param addr address of this interface (can be NULL for unknown or unassigned)
- * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
- * @param netmask the network mask (can be NULL for unknown or unassigned)
- * @param addrlen length of the address
- * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
- */
-static enum GNUNET_GenericReturnValue
-process_ifcs (void *cls,
-              const char *name,
-              int isDefault,
-              const struct sockaddr *addr,
-              const struct sockaddr *broadcast_addr,
-              const struct sockaddr *netmask,
-              socklen_t addrlen)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_DHTU_Source *src;
-
-  for (src = plugin->src_head;
-       NULL != src;
-       src = src->next)
-  {
-    if ( (addrlen == src->addrlen) &&
-         (0 == addrcmp_np (addr,
-                           (const struct sockaddr *) &src->addr,
-                           addrlen)) )
-    {
-      src->scan_generation = plugin->scan_generation;
-      return GNUNET_OK;
-    }
-  }
-  switch (addr->sa_family)
-  {
-  case AF_INET:
-    {
-      struct sockaddr_in v4;
-
-      GNUNET_assert (sizeof(v4) == addrlen);
-      memcpy (&v4,
-              addr,
-              addrlen);
-      v4.sin_port = htons (plugin->port16);
-      (void) create_source (plugin,
-                            (const struct sockaddr *) &v4,
-                            sizeof (v4));
-      break;
-    }
-  case AF_INET6:
-    {
-      struct sockaddr_in6 v6;
-
-      GNUNET_assert (sizeof(v6) == addrlen);
-      memcpy (&v6,
-              addr,
-              addrlen);
-      v6.sin6_port = htons (plugin->port16);
-      (void) create_source (plugin,
-                            (const struct sockaddr *) &v6,
-                            sizeof (v6));
-      break;
-    }
-  }
-  return GNUNET_OK;
-}
-
-
-/**
- * Scan network interfaces for IP address changes.
- *
- * @param cls a `struct Plugin`
- */
-static void
-scan (void *cls)
-{
-  struct Plugin *plugin = cls;
-  struct GNUNET_DHTU_Source *next;
-
-  plugin->scan_generation++;
-  GNUNET_OS_network_interfaces_list (&process_ifcs,
-                                     plugin);
-  for (struct GNUNET_DHTU_Source *src = plugin->src_head;
-       NULL != src;
-       src = next)
-  {
-    next = src->next;
-    if (src->scan_generation >= plugin->scan_generation)
-      continue;
-    GNUNET_CONTAINER_DLL_remove (plugin->src_head,
-                                 plugin->src_tail,
-                                 src);
-    plugin->env->address_del_cb (src->app_ctx);
-    GNUNET_free (src->address);
-    GNUNET_free (src);
-  }
-  plugin->scan_task = GNUNET_SCHEDULER_add_delayed (SCAN_FREQ,
-                                                    &scan,
-                                                    plugin);
-}
-
-
-/**
- * Find our source matching @a addr. If none exists,
- * create one!
- *
- * @param plugin the plugin handle
- * @param addr socket address to find
- * @param addrlen number of bytes in @a addr
- * @return matching source object
- */
-static struct GNUNET_DHTU_Source *
-find_source (struct Plugin *plugin,
-             const void *addr,
-             size_t addrlen)
-{
-  for (struct GNUNET_DHTU_Source *src = plugin->src_head;
-       NULL != src;
-       src = src->next)
-  {
-    if ( (addrlen == src->addrlen) &&
-         (0 == addrcmp (addr,
-                        (const struct sockaddr *) &src->addr,
-                        addrlen)) )
-      return src;
-  }
-
-  return create_source (plugin,
-                        (const struct sockaddr *) addr,
-                        addrlen);
-}
-
-
-/**
- * UDP socket is ready to receive. Read.
- *
- * @param cls our `struct Plugin *`
- */
-static void
-read_cb (void *cls)
-{
-  struct Plugin *plugin = cls;
-  ssize_t ret;
-  const struct GNUNET_PeerIdentity *pid;
-  char buf[65536] GNUNET_ALIGN;
-  struct sockaddr_storage sa;
-  struct iovec iov = {
-    .iov_base = buf,
-    .iov_len = sizeof (buf)
-  };
-  char ctl[128];
-  struct msghdr mh = {
-    .msg_name = &sa,
-    .msg_namelen = sizeof (sa),
-    .msg_iov = &iov,
-    .msg_iovlen = 1,
-    .msg_control = ctl,
-    .msg_controllen = sizeof (ctl)
-  };
-  struct GNUNET_DHTU_Target *dst = NULL;
-  struct GNUNET_DHTU_Source *src = NULL;
-
-  ret = recvmsg  (GNUNET_NETWORK_get_fd (plugin->sock),
-                  &mh,
-                  MSG_DONTWAIT);
-  plugin->read_task = GNUNET_SCHEDULER_add_read_net (
-    GNUNET_TIME_UNIT_FOREVER_REL,
-    plugin->sock,
-    &read_cb,
-    plugin);
-  if (ret < 0)
-    return; /* read failure, hopefully EAGAIN */
-  if (ret < sizeof (*pid))
-  {
-    GNUNET_break_op (0);
-    return;
-  }
-  /* find IP where we received message */
-  for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mh);
-       NULL != cmsg;
-       cmsg = CMSG_NXTHDR (&mh,
-                           cmsg))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Got CMSG level %u (%d/%d), type %u (%d/%d)\n",
-                cmsg->cmsg_level,
-                (cmsg->cmsg_level == IPPROTO_IP),
-                (cmsg->cmsg_level == IPPROTO_IPV6),
-                cmsg->cmsg_type,
-                (cmsg->cmsg_type == IP_PKTINFO),
-                (cmsg->cmsg_type == IPV6_PKTINFO));
-    if ( (cmsg->cmsg_level == IPPROTO_IP) &&
-         (cmsg->cmsg_type == IP_PKTINFO) )
-    {
-      if (CMSG_LEN (sizeof (struct in_pktinfo)) ==
-          cmsg->cmsg_len)
-      {
-        struct in_pktinfo pi;
-
-        memcpy (&pi,
-                CMSG_DATA (cmsg),
-                sizeof (pi));
-        {
-          struct sockaddr_in sa = {
-            .sin_family = AF_INET,
-            .sin_addr = pi.ipi_addr,
-            .sin_port = htons (plugin->port16)
-          };
-
-          src = find_source (plugin,
-                             &sa,
-                             sizeof (sa));
-          /* For sources we discovered by reading,
-             force the generation far into the future */
-          src->scan_generation = plugin->scan_generation + 60;
-        }
-        break;
-      }
-      else
-        GNUNET_break (0);
-    }
-    if ( (cmsg->cmsg_level == IPPROTO_IPV6) &&
-         (cmsg->cmsg_type == IPV6_PKTINFO) )
-    {
-      if (CMSG_LEN (sizeof (struct in6_pktinfo)) ==
-          cmsg->cmsg_len)
-      {
-        struct in6_pktinfo pi;
-
-        memcpy (&pi,
-                CMSG_DATA (cmsg),
-                sizeof (pi));
-        {
-          struct sockaddr_in6 sa = {
-            .sin6_family = AF_INET6,
-            .sin6_addr = pi.ipi6_addr,
-            .sin6_port = htons (plugin->port16),
-            .sin6_scope_id = pi.ipi6_ifindex
-          };
-
-          src = find_source (plugin,
-                             &sa,
-                             sizeof (sa));
-          /* For sources we discovered by reading,
-             force the generation far into the future */
-          src->scan_generation = plugin->scan_generation + 60;
-          break;
-        }
-      }
-      else
-        GNUNET_break (0);
-    }
-  }
-  if (NULL == src)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  pid = (const struct GNUNET_PeerIdentity *) buf;
-  dst = find_target (plugin,
-                     pid,
-                     &sa,
-                     mh.msg_namelen);
-  if (NULL == dst)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  plugin->env->receive_cb (plugin->env->cls,
-                           &dst->app_ctx,
-                           &src->app_ctx,
-                           &buf[sizeof(*pid)],
-                           ret - sizeof (*pid));
-}
-
-
-/**
- * Entry point for the plugin.
- *
- * @param cls closure (the `struct GNUNET_DHTU_PluginEnvironment`)
- * @return the plugin's API
- */
-void *
-libgnunet_plugin_dhtu_ip_init (void *cls)
-{
-  struct GNUNET_DHTU_PluginEnvironment *env = cls;
-  struct GNUNET_DHTU_PluginFunctions *api;
-  struct Plugin *plugin;
-  char *port;
-  unsigned int nport;
-  int sock;
-  int af;
-  unsigned long long nse;
-
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "DHTU-IP",
-                                             "NSE",
-                                             &nse))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               "DHTU-IP",
-                               "NSE");
-    return NULL;
-  }
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (env->cfg,
-                                             "DHTU-IP",
-                                             "UDP_PORT",
-                                             &port))
-  {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               "DHTU-IP",
-                               "UDP_PORT");
-    return NULL;
-  }
-  {
-    char dummy;
-
-    if ( (1 != sscanf (port,
-                       "%u%c",
-                       &nport,
-                       &dummy)) ||
-         (nport > UINT16_MAX) )
-    {
-      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                                 "DHTU-IP",
-                                 "UDP_PORT",
-                                 "must be number below 65536");
-      GNUNET_free (port);
-      return NULL;
-    }
-  }
-  plugin = GNUNET_new (struct Plugin);
-  plugin->env = env;
-  plugin->port = port;
-  plugin->port16 = (uint16_t) nport;
-  if (GNUNET_OK !=
-      GNUNET_CRYPTO_get_peer_identity (env->cfg,
-                                       &plugin->my_id))
-  {
-    GNUNET_free (plugin);
-    return NULL;
-  }
-  af = AF_INET6;
-  sock = socket (af,
-                 SOCK_DGRAM,
-                 IPPROTO_UDP);
-  if (-1 == sock)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "socket");
-    GNUNET_free (plugin->port);
-    GNUNET_free (plugin);
-    return NULL;
-  }
-  switch (af)
-  {
-  case AF_INET:
-    {
-      int on = 1;
-
-      if (0 !=
-          setsockopt (sock,
-                      IPPROTO_IP,
-                      IP_PKTINFO,
-                      &on,
-                      sizeof (on)))
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                             "setsockopt");
-      }
-    }
-    {
-      struct sockaddr_in sa = {
-        .sin_family = AF_INET,
-        .sin_port = htons ((uint16_t) nport)
-      };
-
-      if (0 !=
-          bind (sock,
-                (const struct sockaddr *) &sa,
-                sizeof (sa)))
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                             "socket");
-        GNUNET_break (0 ==
-                      close (sock));
-        GNUNET_free (plugin->port);
-        GNUNET_free (plugin);
-        return NULL;
-      }
-    }
-    break;
-  case AF_INET6:
-    {
-      int on = 1;
-
-      if (0 !=
-          setsockopt (sock,
-                      IPPROTO_IPV6,
-                      IPV6_RECVPKTINFO,
-                      &on,
-                      sizeof (on)))
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                             "setsockopt");
-      }
-    }
-    {
-      struct sockaddr_in6 sa = {
-        .sin6_family = AF_INET6,
-        .sin6_port = htons ((uint16_t) nport)
-      };
-
-      if (0 !=
-          bind (sock,
-                (const struct sockaddr *) &sa,
-                sizeof (sa)))
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                             "socket");
-        GNUNET_break (0 ==
-                      close (sock));
-        GNUNET_free (plugin->port);
-        GNUNET_free (plugin);
-        return NULL;
-      }
-    }
-    break;
-  }
-  plugin->dsts = GNUNET_CONTAINER_multihashmap_create (128,
-                                                       GNUNET_NO);
-  plugin->sock = GNUNET_NETWORK_socket_box_native (sock);
-  plugin->read_task = GNUNET_SCHEDULER_add_read_net (
-    GNUNET_TIME_UNIT_FOREVER_REL,
-    plugin->sock,
-    &read_cb,
-    plugin);
-  env->network_size_cb (env->cls,
-                        GNUNET_TIME_UNIT_ZERO_ABS,
-                        log (nse) / log (2),
-                        -1.0 /* stddev */);
-  plugin->scan_task = GNUNET_SCHEDULER_add_now (&scan,
-                                                plugin);
-  api = GNUNET_new (struct GNUNET_DHTU_PluginFunctions);
-  api->cls = plugin;
-  api->try_connect = &ip_try_connect;
-  api->hold = &ip_hold;
-  api->drop = &ip_drop;
-  api->send = &ip_send;
-  return api;
-}
-
-
-/**
- * Exit point from the plugin.
- *
- * @param cls closure (our `struct Plugin`)
- * @return NULL
- */
-void *
-libgnunet_plugin_dhtu_ip_done (void *cls)
-{
-  struct GNUNET_DHTU_PluginFunctions *api = cls;
-  struct Plugin *plugin = api->cls;
-  struct GNUNET_DHTU_Source *src;
-  struct GNUNET_DHTU_Target *dst;
-
-  while (NULL != (dst = plugin->dst_head))
-  {
-    plugin->env->disconnect_cb (dst->app_ctx);
-    GNUNET_assert (NULL == dst->ph_head);
-    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
-                                 plugin->dst_tail,
-                                 dst);
-    GNUNET_free (dst);
-  }
-  while (NULL != (src = plugin->src_head))
-  {
-    plugin->env->address_del_cb (src->app_ctx);
-    GNUNET_CONTAINER_DLL_remove (plugin->src_head,
-                                 plugin->src_tail,
-                                 src);
-    GNUNET_free (src->address);
-    GNUNET_free (src);
-  }
-  plugin->env->network_size_cb (plugin->env->cls,
-                                GNUNET_TIME_UNIT_FOREVER_ABS,
-                                0.0,
-                                0.0);
-  GNUNET_CONTAINER_multihashmap_destroy (plugin->dsts);
-  if (NULL != plugin->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (plugin->read_task);
-    plugin->read_task = NULL;
-  }
-  GNUNET_SCHEDULER_cancel (plugin->scan_task);
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_NETWORK_socket_close (plugin->sock));
-  GNUNET_free (plugin->port);
-  GNUNET_free (plugin);
-  GNUNET_free (api);
-  return NULL;
-}
diff --git a/src/plugin/dhtu/test_dhtu_ip.c b/src/plugin/dhtu/test_dhtu_ip.c
deleted file mode 100644
index 030b17b5f..000000000
--- a/src/plugin/dhtu/test_dhtu_ip.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-      This file is part of GNUnet
-      Copyright (C) 2021 GNUnet e.V.
-
-      GNUnet is free software: you can redistribute it and/or modify it
-      under the terms of the GNU Affero General Public License as published
-      by the Free Software Foundation, either version 3 of the License,
-      or (at your option) any later version.
-
-      GNUnet is distributed in the hope that it will be useful, but
-      WITHOUT ANY WARRANTY; without even the implied warranty of
-      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-      Affero General Public License for more details.
-
-      You should have received a copy of the GNU Affero General Public License
-      along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-     SPDX-License-Identifier: AGPL3.0-or-later
- */
-
-/**
- * @file dhtu/test_dhtu_ip.c
- * @brief Test case for the DHTU implementation for IP
- * @author Christian Grothoff
- */
-#include "platform.h"
-#include "gnunet_testing_netjail_lib.h"
-#include "gnunet_util_lib.h"
-
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
-
-#define CONFIG_FILE "test_dhtu_ip.conf"
-
-
-int
-main (int argc,
-      char *const *argv)
-{
-  struct GNUNET_TESTING_Command commands[] = {
-    GNUNET_TESTING_cmd_end ()
-  };
-
-  return GNUNET_TESTING_main (commands,
-                              TIMEOUT);
-}
diff --git a/src/plugin/dhtu/testing_dhtu_cmd_send.c b/src/plugin/dhtu/testing_dhtu_cmd_send.c
deleted file mode 100644
index 45d166b14..000000000
--- a/src/plugin/dhtu/testing_dhtu_cmd_send.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-      This file is part of GNUnet
-      Copyright (C) 2021 GNUnet e.V.
-
-      GNUnet is free software: you can redistribute it and/or modify it
-      under the terms of the GNU Affero General Public License as published
-      by the Free Software Foundation, either version 3 of the License,
-      or (at your option) any later version.
-
-      GNUnet is distributed in the hope that it will be useful, but
-      WITHOUT ANY WARRANTY; without even the implied warranty of
-      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-      Affero General Public License for more details.
-
-      You should have received a copy of the GNU Affero General Public License
-      along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-     SPDX-License-Identifier: AGPL3.0-or-later
- */
-
-/**
- * @file testing/testing_dhtu_cmd_send.c
- * @brief use DHTU to send a message
- * @author Christian Grothoff
- */
-#include "platform.h"
-#include "gnunet_testing_ng_lib.h"
-#include "gnunet_testing_netjail_lib.h"
-
-
-/**
- * State for the 'send' command.
- */
-struct SendState
-{
-
-  /**
-   * Mandatory context for async commands.
-   */
-  struct GNUNET_TESTING_AsyncContext ac;
-
-};
-
-
-/**
- *
- *
- * @param cls a `struct SendState`
- */
-static void
-send_cleanup (void *cls)
-{
-  struct SendState *ss = cls;
-
-  GNUNET_free (ss);
-}
-
-
-/**
- * Return trains of the ``send`` command.
- *
- * @param cls closure.
- * @param[out] ret result
- * @param trait name of the trait.
- * @param index index number of the object to offer.
- * @return #GNUNET_OK on success.
- *         #GNUNET_NO if no trait was found
- */
-static enum GNUNET_GenericReturnValue
-send_traits (void *cls,
-             const void **ret,
-             const char *trait,
-             unsigned int index)
-{
-  return GNUNET_NO;
-}
-
-
-/**
- * Run the 'send' command.
- *
- * @param cls closure.
- * @param is interpreter state.
- */
-static void
-send_run (void *cls,
-          struct GNUNET_TESTING_Interpreter *is)
-{
-  struct SendState *ss = cls;
-
-#if 0
-  other_cmd = GNUNET_TESTING_interpreter_lookup_command (ss->other_label);
-  GNUNET_TESTING_get_trait_XXX (other_cmd,
-                                &data);
-#endif
-  GNUNET_TESTING_async_finish (&ss->ac);
-}
-
-
-struct GNUNET_TESTING_Command
-GNUNET_TESTING_DHTU_cmd_send (const char *label)
-{
-  struct SendState *ss;
-
-  ss = GNUNET_new (struct SendState);
-
-  {
-    struct GNUNET_TESTING_Command cmd = {
-      .cls = ss,
-      .run = &send_run,
-      .ac = &ss->ac,
-      .cleanup = &send_cleanup,
-      .traits = &send_traits
-    };
-    strncpy (cmd.label, label, GNUNET_TESTING_CMD_MAX_LABEL_LENGTH);
-
-    return cmd;
-  }
-}
diff --git a/src/plugin/dns/Makefile.am b/src/plugin/dns/Makefile.am
new file mode 100644
index 000000000..8b5843159
--- /dev/null
+++ b/src/plugin/dns/Makefile.am
@@ -0,0 +1,25 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_dns.la
+
+libgnunet_plugin_block_dns_la_SOURCES = \
+  plugin_block_dns.c
+libgnunet_plugin_block_dns_la_LIBADD = \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunet_plugin_block_dns_la_LDFLAGS = \
+  $(GN_LIBINTL) \
+  $(top_builddir)/src/block/$(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/dns/meson.build b/src/plugin/dns/meson.build
new file mode 100644
index 000000000..974b2c38d
--- /dev/null
+++ b/src/plugin/dns/meson.build
@@ -0,0 +1,6 @@
+shared_module('gnunet_plugin_block_dns',
+        ['plugin_block_dns.c'],
+        dependencies: [libgnunetutil_dep, libgnunetblockgroup_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
diff --git a/src/plugin/dns/plugin_block_dns.c b/src/plugin/dns/plugin_block_dns.c
new file mode 100644
index 000000000..1bbd7f750
--- /dev/null
+++ b/src/plugin/dns/plugin_block_dns.c
@@ -0,0 +1,290 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2013, 2017 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 dns/plugin_block_dns.c
+ * @brief block plugin for advertising a DNS exit service
+ * @author Christian Grothoff
+ *
+ * Note that this plugin might more belong with EXIT and PT
+ * as those two are using this type of block.  Still, this
+ * might be a natural enough place for people to find the code...
+ */
+#include "platform.h"
+#include "gnunet_block_plugin.h"
+#include "block_dns.h"
+#include "gnunet_signatures.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Number of bits we set per entry in the bloomfilter.
+ * Do not change!
+ */
+#define BLOOMFILTER_K 16
+
+
+/**
+ * Create a new block group.
+ *
+ * @param ctx block context in which the block group is created
+ * @param type type of the block for which we are creating the group
+ * @param raw_data optional serialized prior state of the group, NULL if unavailable/fresh
+ * @param raw_data_size number of bytes in @a raw_data, 0 if unavailable/fresh
+ * @param va variable arguments specific to @a type
+ * @return block group handle, NULL if block groups are not supported
+ *         by this @a type of block (this is not an error)
+ */
+static struct GNUNET_BLOCK_Group *
+block_plugin_dns_create_group (void *cls,
+                               enum GNUNET_BLOCK_Type type,
+                               const void *raw_data,
+                               size_t raw_data_size,
+                               va_list va)
+{
+  unsigned int bf_size;
+  const char *guard;
+
+  guard = va_arg (va, const char *);
+  if (0 == strcmp (guard,
+                   "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
+                                                                   int),
+                                                           BLOOMFILTER_K);
+  else if (0 == strcmp (guard,
+                        "filter-size"))
+    bf_size = va_arg (va, unsigned int);
+  else
+  {
+    GNUNET_break (0);
+    bf_size = 8;
+  }
+  GNUNET_break (NULL == va_arg (va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create (cls,
+                                       bf_size,
+                                       BLOOMFILTER_K,
+                                       type,
+                                       raw_data,
+                                       raw_data_size);
+}
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dns_check_query (void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              const struct GNUNET_HashCode *query,
+                              const void *xquery,
+                              size_t xquery_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DNS:
+    if (0 != xquery_size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dns_check_block (void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              const void *block,
+                              size_t block_size)
+{
+  const struct GNUNET_DNS_Advertisement *ad;
+
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DNS:
+    if (sizeof(struct GNUNET_DNS_Advertisement) != block_size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    ad = block;
+
+    if (ntohl (ad->purpose.size) !=
+        sizeof(struct GNUNET_DNS_Advertisement)
+        - sizeof(struct GNUNET_CRYPTO_EddsaSignature))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    if (GNUNET_TIME_absolute_is_past (
+          GNUNET_TIME_absolute_ntoh (ad->expiration_time)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "DNS advertisement has expired\n");
+      return GNUNET_NO;
+    }
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_eddsa_verify_ (GNUNET_SIGNATURE_PURPOSE_DNS_RECORD,
+                                     &ad->purpose,
+                                     &ad->signature,
+                                     &ad->peer.public_key))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_dns_check_reply (
+  void *cls,
+  enum GNUNET_BLOCK_Type type,
+  struct GNUNET_BLOCK_Group *group,
+  const struct GNUNET_HashCode *query,
+  const void *xquery,
+  size_t xquery_size,
+  const void *reply_block,
+  size_t reply_block_size)
+{
+  struct GNUNET_HashCode phash;
+
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_DNS:
+    GNUNET_CRYPTO_hash (reply_block,
+                        reply_block_size,
+                        &phash);
+    if (GNUNET_YES ==
+        GNUNET_BLOCK_GROUP_bf_test_and_set (group,
+                                            &phash))
+      return GNUNET_BLOCK_REPLY_OK_DUPLICATE;
+    return GNUNET_BLOCK_REPLY_OK_MORE;
+  default:
+    GNUNET_break (0);
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  }
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in @a block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_dns_get_key (void *cls,
+                          enum GNUNET_BLOCK_Type type,
+                          const void *block,
+                          size_t block_size,
+                          struct GNUNET_HashCode *key)
+{
+  if (GNUNET_BLOCK_TYPE_DNS != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_dns_init (void *cls)
+{
+  static enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_DNS,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_dns_get_key;
+  api->check_query = &block_plugin_dns_check_query;
+  api->check_block = &block_plugin_dns_check_block;
+  api->check_reply = &block_plugin_dns_check_reply;
+  api->create_group = &block_plugin_dns_create_group;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_dns_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_dns.c */
diff --git a/src/plugin/fs/Makefile.am b/src/plugin/fs/Makefile.am
index 928997e4d..7c0e55cba 100644
--- a/src/plugin/fs/Makefile.am
+++ b/src/plugin/fs/Makefile.am
@@ -20,7 +20,6 @@ libgnunet_plugin_block_fs_la_SOURCES = \
 libgnunet_plugin_block_fs_la_LIBADD = \
   $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
   $(top_builddir)/src/lib/block/libgnunetblock.la \
-  $(top_builddir)/src/service/fs/libgnunetfs.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la \
   $(LTLIBINTL)
 libgnunet_plugin_block_fs_la_LDFLAGS = \
diff --git a/src/plugin/gns/Makefile.am b/src/plugin/gns/Makefile.am
index ebbb9aa51..8dc9ef2b2 100644
--- a/src/plugin/gns/Makefile.am
+++ b/src/plugin/gns/Makefile.am
@@ -34,7 +34,6 @@ libgnunet_plugin_gnsrecord_gns_la_SOURCES = \
   plugin_gnsrecord_gns.c
 libgnunet_plugin_gnsrecord_gns_la_LIBADD = \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la \
   $(LTLIBINTL)
 libgnunet_plugin_gnsrecord_gns_la_LDFLAGS = \
@@ -47,7 +46,6 @@ libgnunet_plugin_block_gns_la_LIBADD = \
   $(top_builddir)/src/lib/util/libgnunetutil.la \
   $(top_builddir)/src/lib/block/libgnunetblock.la \
   $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la  \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la
 libgnunet_plugin_block_gns_la_LDFLAGS = \
   $(GN_LIBINTL) \
diff --git a/src/plugin/gns/meson.build b/src/plugin/gns/meson.build
index 0e551b22e..2cdf770f8 100644
--- a/src/plugin/gns/meson.build
+++ b/src/plugin/gns/meson.build
@@ -2,7 +2,7 @@ shared_module('gnunet_plugin_gnsrecord_gns',
         ['plugin_gnsrecord_gns.c'],
         dependencies: [libgnunetutil_dep,
                        libgnunetgnsrecord_dep,
-                       libgnunetidentity_dep],
+                      ],
         include_directories: [incdir, configuration_inc],
         install: true,
         install_dir: get_option('libdir')/'gnunet')
diff --git a/src/plugin/meson.build b/src/plugin/meson.build
index 6ebae59d7..d4f797c54 100644
--- a/src/plugin/meson.build
+++ b/src/plugin/meson.build
@@ -1,9 +1,17 @@
 subdir('block')
-subdir('dhtu')
+subdir('dns')
 subdir('gnsrecord')
+subdir('datacache')
+subdir('datastore')
+subdir('peerstore')
 subdir('namecache')
 subdir('namestore')
+subdir('dht')
+subdir('seti')
+subdir('setu')
+subdir('regex')
 subdir('revocation')
 subdir('gns')
 subdir('fs')
 subdir('reclaim')
+subdir('messenger')
diff --git a/src/plugin/messenger/Makefile.am b/src/plugin/messenger/Makefile.am
new file mode 100644
index 000000000..e3c69ea33
--- /dev/null
+++ b/src/plugin/messenger/Makefile.am
@@ -0,0 +1,26 @@
+# 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/
+
+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/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_gnsrecord_messenger_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+plugindir = $(libdir)/gnunet
diff --git a/src/plugin/messenger/meson.build b/src/plugin/messenger/meson.build
new file mode 100644
index 000000000..17dd9bd32
--- /dev/null
+++ b/src/plugin/messenger/meson.build
@@ -0,0 +1,7 @@
+shared_module('gnunet_plugin_gnsrecord_messenger',
+              ['plugin_gnsrecord_messenger.c'],
+              dependencies: [libgnunetutil_dep, libgnunetgnsrecord_dep,
+                            ],
+              include_directories: [incdir, configuration_inc],
+              install: true,
+              install_dir: get_option('libdir')/'gnunet')
diff --git a/src/plugin/messenger/plugin_gnsrecord_messenger.c b/src/plugin/messenger/plugin_gnsrecord_messenger.c
new file mode 100644
index 000000000..e09a0330d
--- /dev/null
+++ b/src/plugin/messenger/plugin_gnsrecord_messenger.c
@@ -0,0 +1,298 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2021--2022 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", key, door);
+      GNUNET_free (key);
+      GNUNET_free (door);
+      return ret;
+    }
+  case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS:
+    {
+      if (data_size != sizeof(struct GNUNET_MESSENGER_RoomDetailsRecord))
+      {
+        GNUNET_break_op (0);
+        return NULL;
+      }
+
+      const struct GNUNET_MESSENGER_RoomDetailsRecord *record = data;
+
+      char *name = GNUNET_strndup(record->name, 256);
+      char *flags = GNUNET_STRINGS_data_to_string_alloc (&(record->flags), sizeof(uint32_t));
+
+      char *ret;
+      GNUNET_asprintf (&ret, "%s-%s", flags, name);
+      GNUNET_free (flags);
+      GNUNET_free (name);
+      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;
+    }
+  case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS:
+    {
+      char flags [7];
+      const char *dash;
+
+      if ((NULL == (dash = strchr (s, '-'))) ||
+          (1 != sscanf (s, "%7s-", flags)) ||
+          (strlen (dash + 1) > 256))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse MESSENGER_ROOM_DETAILS record `%s'\n"),
+                    s);
+        return GNUNET_SYSERR;
+      }
+
+      struct GNUNET_MESSENGER_RoomDetailsRecord *record = GNUNET_new (
+          struct GNUNET_MESSENGER_RoomDetailsRecord
+      );
+
+      if (GNUNET_OK != GNUNET_STRINGS_string_to_data (flags,
+                                                      strlen (flags),
+                                                      &(record->flags),
+                                                      sizeof(uint32_t)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse MESSENGER_ROOM_DETAILS record `%s'\n"),
+                    s);
+        GNUNET_free (record);
+        return GNUNET_SYSERR;
+      }
+
+      GNUNET_memcpy(record->name, dash + 1, strlen(dash + 1));
+
+      *data = record;
+      *data_size = sizeof(struct GNUNET_MESSENGER_RoomDetailsRecord);
+      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 },
+  { "MESSENGER_ROOM_DETAILS", GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS },
+  { 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/plugin/namecache/Makefile.am b/src/plugin/namecache/Makefile.am
index 0ccbf9ea1..bf8fc9b8d 100644
--- a/src/plugin/namecache/Makefile.am
+++ b/src/plugin/namecache/Makefile.am
@@ -56,10 +56,7 @@ plugin_LTLIBRARIES = \
 libgnunet_plugin_namecache_flat_la_SOURCES = \
   plugin_namecache_flat.c
 libgnunet_plugin_namecache_flat_la_LIBADD = \
-  $(top_builddir)/src/service/namecache/libgnunetnamecache.la  \
-  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
   $(LTLIBINTL)
 libgnunet_plugin_namecache_flat_la_LDFLAGS = \
@@ -68,11 +65,8 @@ libgnunet_plugin_namecache_flat_la_LDFLAGS = \
 libgnunet_plugin_namecache_sqlite_la_SOURCES = \
   plugin_namecache_sqlite.c
 libgnunet_plugin_namecache_sqlite_la_LIBADD = \
-  $(top_builddir)/src/service/namecache/libgnunetnamecache.la  \
   $(top_builddir)/src/lib/sq/libgnunetsq.la \
-  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lsqlite3 \
   $(LTLIBINTL)
 libgnunet_plugin_namecache_sqlite_la_LDFLAGS = \
@@ -82,11 +76,8 @@ libgnunet_plugin_namecache_sqlite_la_LDFLAGS = \
 libgnunet_plugin_namecache_postgres_la_SOURCES = \
   plugin_namecache_postgres.c
 libgnunet_plugin_namecache_postgres_la_LIBADD = \
-  $(top_builddir)/src/service/namecache/libgnunetnamecache.la  \
   $(top_builddir)/src/lib/pq/libgnunetpq.la  \
-  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lpq \
   $(LTLIBINTL)
 libgnunet_plugin_namecache_postgres_la_LDFLAGS = \
diff --git a/src/plugin/namestore/Makefile.am b/src/plugin/namestore/Makefile.am
index e413c1b08..03b743d7a 100644
--- a/src/plugin/namestore/Makefile.am
+++ b/src/plugin/namestore/Makefile.am
@@ -76,37 +76,16 @@ TESTS = \
   $(check_SCRIPTS)
 endif
 
-REST_PLUGIN = libgnunet_plugin_rest_namestore.la
-
 plugin_LTLIBRARIES = \
   $(SQLITE_PLUGIN) \
-  $(POSTGRES_PLUGIN) \
-  $(REST_PLUGIN)
-
-
-libgnunet_plugin_rest_namestore_la_SOURCES = \
-  plugin_rest_namestore.c
-libgnunet_plugin_rest_namestore_la_LIBADD = \
-  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
-  $(top_builddir)/src/service/rest/libgnunetrest.la \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
-  $(top_builddir)/src/lib/json/libgnunetjson.la \
-  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
-  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecordjson.la \
-  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
-  $(LTLIBINTL) -ljansson $(MHD_LIBS)
-libgnunet_plugin_rest_namestore_la_LDFLAGS = \
- $(GN_PLUGIN_LDFLAGS)
-libgnunet_plugin_rest_namestore_la_CFLAGS = $(MHD_CFLAGS) $(AM_CFLAGS)
+  $(POSTGRES_PLUGIN)
 
 
 libgnunet_plugin_namestore_sqlite_la_SOURCES = \
   plugin_namestore_sqlite.c
 libgnunet_plugin_namestore_sqlite_la_LIBADD = \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la  \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/sq/libgnunetsq.la \
-  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lsqlite3 \
   $(LTLIBINTL)
 libgnunet_plugin_namestore_sqlite_la_LDFLAGS = \
@@ -116,9 +95,7 @@ libgnunet_plugin_namestore_postgres_la_SOURCES = \
   plugin_namestore_postgres.c
 libgnunet_plugin_namestore_postgres_la_LIBADD = \
   $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la  \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/pq/libgnunetpq.la  \
-  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) -lpq \
   $(LTLIBINTL)
 libgnunet_plugin_namestore_postgres_la_LDFLAGS = \
@@ -422,9 +399,6 @@ test_plugin_namestore_postgres_LDADD = \
   $(top_builddir)/src/service/testing/libgnunettesting.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la
 
-check_SCRIPTS = \
-  test_plugin_rest_namestore.sh
-
 EXTRA_DIST = \
   test_common.c \
   test_namestore_api.conf \
@@ -434,5 +408,4 @@ EXTRA_DIST = \
   perf_namestore_api_sqlite.conf \
   test_plugin_namestore_sqlite.conf \
   test_plugin_namestore_postgres.conf \
-  $(check_SCRIPTS) \
   $(sql_DATA)
diff --git a/src/plugin/namestore/meson.build b/src/plugin/namestore/meson.build
index 32db8c104..d51b4b730 100644
--- a/src/plugin/namestore/meson.build
+++ b/src/plugin/namestore/meson.build
@@ -1,26 +1,10 @@
-shared_module('gnunet_plugin_rest_namestore',
-              ['plugin_rest_namestore.c'],
-              dependencies: [libgnunetrest_dep,
-                             libgnunetidentity_dep,
-                             libgnunetgnsrecordjson_dep,
-                             libgnunetgnsrecord_dep,
-                             libgnunetnamestore_dep,
-                             libgnunetjson_dep,
-                             libgnunetutil_dep,
-                             json_dep,
-                             mhd_dep],
-              include_directories: [incdir, configuration_inc],
-              install: true,
-              install_dir: get_option('libdir') / 'gnunet')
-
+libgnunetpluginnamestore_sqlite_src = ['plugin_namestore_sqlite.c']
 
 shared_module('gnunet_plugin_namestore_sqlite',
         libgnunetpluginnamestore_sqlite_src,
         dependencies: [libgnunetutil_dep,
                        libgnunetgnsrecord_dep,
-                       libgnunetidentity_dep,
                        libgnunetsq_dep,
-                       libgnunetstatistics_dep,
                        sqlite_dep],
         include_directories: [incdir, configuration_inc],
         install: true,
@@ -31,9 +15,7 @@ if pq_dep.found()
           ['plugin_namestore_postgres.c'],
           dependencies: [libgnunetutil_dep,
                          libgnunetgnsrecord_dep,
-                         libgnunetidentity_dep,
                          libgnunetpq_dep,
-                         libgnunetstatistics_dep,
                          pq_dep],
           include_directories: [incdir, configuration_inc],
           install: true,
diff --git a/src/plugin/namestore/plugin_rest_namestore.c b/src/plugin/namestore/plugin_rest_namestore.c
deleted file mode 100644
index 31e78e6dd..000000000
--- a/src/plugin/namestore/plugin_rest_namestore.c
+++ /dev/null
@@ -1,1364 +0,0 @@
-/*
-   This file is part of GNUnet.
-   Copyright (C) 2012-2015 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 Martin Schanzenbach
- * @author Philippe Buschmann
- * @file namestore/plugin_rest_namestore.c
- * @brief GNUnet Namestore REST plugin
- */
-
-#include "platform.h"
-#include "gnunet_error_codes.h"
-#include "gnunet_rest_plugin.h"
-#include "gnunet_gns_service.h"
-#include "gnunet_namestore_service.h"
-#include "gnunet_identity_service.h"
-#include "gnunet_rest_lib.h"
-#include "gnunet_gnsrecord_json_lib.h"
-#include "microhttpd.h"
-#include <jansson.h>
-
-/**
- * Namestore namespace
- */
-#define GNUNET_REST_API_NS_NAMESTORE "/namestore"
-
-/**
- * Namestore import API namespace
- */
-#define GNUNET_REST_API_NS_NAMESTORE_IMPORT "/namestore/import"
-
-/**
- * State while collecting all egos
- */
-#define ID_REST_STATE_INIT 0
-
-/**
- * Done collecting egos
- */
-#define ID_REST_STATE_POST_INIT 1
-/**
- * The configuration handle
- */
-const struct GNUNET_CONFIGURATION_Handle *cfg;
-
-/**
- * HTTP methods allows for this plugin
- */
-static char *allow_methods;
-
-/**
- * Ego list
- */
-static struct EgoEntry *ego_head;
-
-/**
- * Ego list
- */
-static struct EgoEntry *ego_tail;
-
-/**
- * The processing state
- */
-static int state;
-
-/**
- * Handle to NAMESTORE
- */
-static struct GNUNET_NAMESTORE_Handle *ns_handle;
-
-/**
- * Handle to Identity service.
- */
-static struct GNUNET_IDENTITY_Handle *identity_handle;
-
-/**
- * @brief struct returned by the initialization function of the plugin
- */
-struct Plugin
-{
-  const struct GNUNET_CONFIGURATION_Handle *cfg;
-};
-
-/**
- * The default namestore ego
- */
-struct EgoEntry
-{
-  /**
-   * DLL
-   */
-  struct EgoEntry *next;
-
-  /**
-   * DLL
-   */
-  struct EgoEntry *prev;
-
-  /**
-   * Ego Identifier
-   */
-  char *identifier;
-
-  /**
-   * Public key string
-   */
-  char *keystring;
-
-  /**
-   * The Ego
-   */
-  struct GNUNET_IDENTITY_Ego *ego;
-};
-
-
-enum UpdateStrategy
-{
-  UPDATE_STRATEGY_REPLACE,
-  UPDATE_STRATEGY_APPEND
-};
-
-/**
- * The request handle
- */
-struct RequestHandle
-{
-  /**
-   * DLL
-   */
-  struct RequestHandle *next;
-
-  /**
-   * DLL
-   */
-  struct RequestHandle *prev;
-
-  /**
-   * Records to store
-   */
-  char *record_name;
-
-  /**
-   * Record type filter
-   */
-  uint32_t record_type;
-
-  /**
-   * How to update the record set
-   */
-  enum UpdateStrategy update_strategy;
-
-  /**
-   * Records to store
-   */
-  struct GNUNET_GNSRECORD_Data *rd;
-
-  /**
-   * Number of records in rd
-   */
-  unsigned int rd_count;
-
-  /**
-   * RecordInfo array
-   */
-  struct GNUNET_NAMESTORE_RecordInfo *ri;
-
-  /**
-   * Size of record info
-   */
-  unsigned int rd_set_count;
-
-  /**
-   * Position of record info
-   */
-  unsigned int rd_set_pos;
-
-  /**
-   * NAMESTORE Operation
-   */
-  struct GNUNET_NAMESTORE_QueueEntry *ns_qe;
-
-  /**
-   * For bulk import, we need a dedicated Namestore handle
-   */
-  struct GNUNET_NAMESTORE_Handle *nc;
-
-  /**
-   * Response object
-   */
-  json_t *resp_object;
-
-
-  /**
-   * Handle to NAMESTORE it
-   */
-  struct GNUNET_NAMESTORE_ZoneIterator *list_it;
-
-  /**
-   * Private key for the zone
-   */
-  const struct GNUNET_CRYPTO_PrivateKey *zone_pkey;
-
-  /**
-   * IDENTITY Operation
-   */
-  struct EgoEntry *ego_entry;
-
-  /**
-   * IDENTITY Operation
-   */
-  struct GNUNET_IDENTITY_Operation *op;
-
-  /**
-   * Rest connection
-   */
-  struct GNUNET_REST_RequestHandle *rest_handle;
-
-  /**
-   * Desired timeout for the lookup (default is no timeout).
-   */
-  struct GNUNET_TIME_Relative timeout;
-
-  /**
-   * ID of a task associated with the resolution process.
-   */
-  struct GNUNET_SCHEDULER_Task *timeout_task;
-
-  /**
-   * The plugin result processor
-   */
-  GNUNET_REST_ResultProcessor proc;
-
-  /**
-   * The closure of the result processor
-   */
-  void *proc_cls;
-
-  /**
-   * The url
-   */
-  char *url;
-
-  /**
-   * Error code
-   */
-  enum GNUNET_ErrorCode ec;
-
-};
-
-/**
- * DLL
- */
-static struct RequestHandle *requests_head;
-
-/**
- * DLL
- */
-static struct RequestHandle *requests_tail;
-
-
-/**
- * Cleanup lookup handle
- * @param cls Handle to clean up
- */
-static void
-cleanup_handle (void *cls)
-{
-  struct RequestHandle *handle = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
-  if (NULL != handle->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
-    handle->timeout_task = NULL;
-  }
-  if (NULL != handle->record_name)
-    GNUNET_free (handle->record_name);
-  if (NULL != handle->url)
-    GNUNET_free (handle->url);
-  if (NULL != handle->rd)
-  {
-    for (int i = 0; i < handle->rd_count; i++)
-    {
-      if (NULL != handle->rd[i].data)
-        GNUNET_free_nz ((void *) handle->rd[i].data);
-    }
-    GNUNET_free (handle->rd);
-  }
-  if (NULL != handle->timeout_task)
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
-  if (NULL != handle->list_it)
-    GNUNET_NAMESTORE_zone_iteration_stop (handle->list_it);
-  if (NULL != handle->ns_qe)
-    GNUNET_NAMESTORE_cancel (handle->ns_qe);
-  if (NULL != handle->nc)
-    GNUNET_NAMESTORE_disconnect (handle->nc);
-  if (NULL != handle->resp_object)
-  {
-    json_decref (handle->resp_object);
-  }
-  GNUNET_CONTAINER_DLL_remove (requests_head,
-                               requests_tail,
-                               handle);
-  GNUNET_free (handle);
-}
-
-
-/**
- * Task run on errors.  Reports an error and cleans up everything.
- *
- * @param cls the `struct RequestHandle`
- */
-static void
-do_error (void *cls)
-{
-  struct RequestHandle *handle = cls;
-  struct MHD_Response *resp;
-  json_t *json_error = json_object ();
-  char *response;
-  const char* emsg;
-  int response_code;
-
-  emsg = GNUNET_ErrorCode_get_hint (handle->ec);
-  json_object_set_new (json_error, "error", json_string (emsg));
-  json_object_set_new (json_error, "error_code", json_integer (handle->ec));
-  response_code = GNUNET_ErrorCode_get_http_status (handle->ec);
-  if (0 == response_code)
-    response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
-  response = json_dumps (json_error, 0);
-  resp = GNUNET_REST_create_response (response);
-  GNUNET_assert (MHD_YES ==
-                 MHD_add_response_header (resp, "Content-Type",
-                                          "application/json"));
-  handle->proc (handle->proc_cls, resp, response_code);
-  json_decref (json_error);
-  GNUNET_free (response);
-  cleanup_handle (handle);
-}
-
-
-/**
- * Get EgoEntry from list with either a public key or a name
- * If public key and name are not NULL, it returns the public key result first
- *
- * @param handle the RequestHandle
- * @param pubkey the public key of an identity (only one can be NULL)
- * @param name the name of an identity (only one can be NULL)
- * @return EgoEntry or NULL if not found
- */
-struct EgoEntry *
-get_egoentry_namestore (struct RequestHandle *handle, char *name)
-{
-  struct EgoEntry *ego_entry;
-  char *copy = GNUNET_strdup (name);
-  char *tmp;
-
-  if (NULL == name)
-    return NULL;
-  tmp = strtok (copy, "/");
-  if (NULL == tmp)
-    return NULL;
-  for (ego_entry = ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next)
-  {
-    if (0 != strcasecmp (tmp, ego_entry->identifier))
-      continue;
-    GNUNET_free (copy);
-    return ego_entry;
-  }
-  GNUNET_free (copy);
-  return NULL;
-}
-
-
-/**
- * Does internal server error when iteration failed.
- *
- * @param cls the `struct RequestHandle`
- */
-static void
-namestore_iteration_error (void *cls)
-{
-  struct RequestHandle *handle = cls;
-
-  handle->ec = GNUNET_EC_NAMESTORE_ITERATION_FAILED;
-  GNUNET_SCHEDULER_add_now (&do_error, handle);
-  return;
-}
-
-
-static void
-create_finished (void *cls, enum GNUNET_ErrorCode ec)
-{
-  struct RequestHandle *handle = cls;
-  struct MHD_Response *resp;
-
-  handle->ns_qe = NULL;
-  handle->ec = ec;
-  if (GNUNET_EC_NONE != ec)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  resp = GNUNET_REST_create_response (NULL);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
-}
-
-
-static void
-del_finished (void *cls, enum GNUNET_ErrorCode ec)
-{
-  struct RequestHandle *handle = cls;
-
-  handle->ns_qe = NULL;
-  handle->ec = ec;
-  if (GNUNET_EC_NONE != ec)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->proc (handle->proc_cls,
-                GNUNET_REST_create_response (NULL),
-                MHD_HTTP_NO_CONTENT);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
-}
-
-
-/**
- * Iteration over all results finished, build final
- * response.
- *
- * @param cls the `struct RequestHandle`
- */
-static void
-namestore_list_finished (void *cls)
-{
-  struct RequestHandle *handle = cls;
-  char *result_str;
-  struct MHD_Response *resp;
-
-  handle->list_it = NULL;
-
-  if (NULL == handle->resp_object)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_EMPTY;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  result_str = json_dumps (handle->resp_object, 0);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
-  resp = GNUNET_REST_create_response (result_str);
-  GNUNET_assert (MHD_YES ==
-                 MHD_add_response_header (resp, "Content-Type",
-                                          "application/json"));
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free (result_str);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
-}
-
-
-/**
- * Create a response with requested records
- *
- * @param handle the RequestHandle
- */
-static void
-namestore_list_iteration (void *cls,
-                          const struct GNUNET_CRYPTO_PrivateKey *zone_key,
-                          const char *rname,
-                          unsigned int rd_len,
-                          const struct GNUNET_GNSRECORD_Data *rd,
-                          struct GNUNET_TIME_Absolute expiry)
-{
-  struct RequestHandle *handle = cls;
-  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
-  json_t *record_obj;
-  int i = 0;
-  int j = 0;
-
-  if (rd_len == 0)
-  {
-    /** skip **/
-    GNUNET_NAMESTORE_zone_iterator_next (handle->list_it, 1);
-    return;
-  }
-
-  for (i = 0; i < rd_len; i++)
-  {
-    if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
-        (rd[i].record_type != handle->record_type))
-      continue; /* Apply filter */
-    rd_filtered[j] = rd[i];
-    rd_filtered[j].data = rd[i].data;
-    j++;
-  }
-  /** Only add if not empty **/
-  if (j > 0)
-  {
-    if (NULL == handle->resp_object)
-      handle->resp_object = json_array ();
-    record_obj = GNUNET_GNSRECORD_JSON_from_gnsrecord (rname,
-                                                       rd_filtered,
-                                                       j);
-    json_array_append_new (handle->resp_object, record_obj);
-  }
-  GNUNET_NAMESTORE_zone_iterator_next (handle->list_it, 1);
-}
-
-
-/**
- * Handle lookup error
- *
- * @param cls the request handle
- */
-static void
-ns_lookup_error_cb (void *cls)
-{
-  struct RequestHandle *handle = cls;
-
-  handle->ec = GNUNET_EC_NAMESTORE_LOOKUP_ERROR;
-  GNUNET_SCHEDULER_add_now (&do_error, handle);
-}
-
-
-static void
-ns_get_lookup_cb (void *cls,
-                  const struct GNUNET_CRYPTO_PrivateKey *zone,
-                  const char *label,
-                  unsigned int rd_len,
-                  const struct GNUNET_GNSRECORD_Data *rd)
-{
-  struct RequestHandle *handle = cls;
-  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
-  int i = 0;
-  int j = 0;
-
-  handle->ns_qe = NULL;
-  for (i = 0; i < rd_len; i++)
-  {
-    if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
-        (rd[i].record_type != handle->record_type))
-      continue; /* Apply filter */
-    rd_filtered[j] = rd[i];
-    rd_filtered[j].data = rd[i].data;
-    j++;
-  }
-  /** Return 404 if no set was found **/
-  if (j == 0)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->resp_object = GNUNET_GNSRECORD_JSON_from_gnsrecord (label,
-                                                              rd_filtered,
-                                                              j);
-  GNUNET_SCHEDULER_add_now (&namestore_list_finished, handle);
-}
-
-
-/**
- * Handle namestore GET request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
-               const char *url,
-               void *cls)
-{
-  struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
-  struct GNUNET_HashCode key;
-  enum GNUNET_GNSRECORD_Filter filter_flags;
-  char *egoname;
-  char *labelname;
-  char *typename;
-  char *boolstring;
-
-  egoname = NULL;
-  ego_entry = NULL;
-
-  // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1  >= strlen (handle->url))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-  ego_entry = get_egoentry_namestore (handle, egoname);
-  if (NULL == ego_entry)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-
-  GNUNET_CRYPTO_hash ("record_type", strlen ("record_type"), &key);
-  handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
-  if (GNUNET_YES ==
-      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
-  {
-    typename = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
-                                                  &key);
-    if (NULL != typename)
-      handle->record_type = GNUNET_GNSRECORD_typename_to_number (typename);
-  }
-  GNUNET_CRYPTO_hash ("omit_private", strlen ("omit_private"), &key);
-  filter_flags = GNUNET_GNSRECORD_FILTER_NONE;
-  if (GNUNET_YES ==
-      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
-  {
-    boolstring = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
-                                                    &key);
-    if ((0 == strcmp (boolstring, "1")) ||
-        (0 == strcmp (boolstring, "yes")) ||
-        (0 == strcmp (boolstring, "true")))
-      filter_flags = GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE;
-  }
-  GNUNET_CRYPTO_hash ("include_maintenance", strlen ("include_maintenance"),
-                      &key);
-  if (GNUNET_YES ==
-      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
-  {
-    boolstring = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
-                                                    &key);
-    if ((0 == strcmp (boolstring, "1")) ||
-        (0 == strcmp (boolstring, "yes")) ||
-        (0 == strcmp (boolstring, "true")))
-      filter_flags |= GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE;
-  }
-  labelname = &egoname[strlen (ego_entry->identifier)];
-  if (1 >= strlen (labelname))
-  {
-    /* Iterate over all records */
-    handle->list_it =
-      GNUNET_NAMESTORE_zone_iteration_start2 (ns_handle,
-                                              handle->zone_pkey,
-                                              &namestore_iteration_error,
-                                              handle,
-                                              &namestore_list_iteration,
-                                              handle,
-                                              &namestore_list_finished,
-                                              handle,
-                                              filter_flags);
-    if (NULL == handle->list_it)
-    {
-      handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-      GNUNET_SCHEDULER_add_now (&do_error, handle);
-      return;
-    }
-    return;
-  }
-  handle->record_name = GNUNET_strdup (labelname + 1);
-  handle->ns_qe = GNUNET_NAMESTORE_records_lookup2 (ns_handle,
-                                                    handle->zone_pkey,
-                                                    handle->record_name,
-                                                    &ns_lookup_error_cb,
-                                                    handle,
-                                                    &ns_get_lookup_cb,
-                                                    handle,
-                                                    filter_flags);
-  if (NULL == handle->ns_qe)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-}
-
-
-static void
-ns_lookup_cb (void *cls,
-              const struct GNUNET_CRYPTO_PrivateKey *zone,
-              const char *label,
-              unsigned int rd_count,
-              const struct GNUNET_GNSRECORD_Data *rd)
-{
-  struct RequestHandle *handle = cls;
-  struct GNUNET_GNSRECORD_Data rd_new[rd_count + handle->rd_count];
-  int i = 0;
-  int j = 0;
-
-  if (UPDATE_STRATEGY_APPEND == handle->update_strategy)
-  {
-    for (i = 0; i < rd_count; i++)
-      rd_new[i] = rd[i];
-  }
-  for (j = 0; j < handle->rd_count; j++)
-    rd_new[i + j] = handle->rd[j];
-  handle->ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
-                                                  handle->zone_pkey,
-                                                  handle->record_name,
-                                                  i + j,
-                                                  rd_new,
-                                                  &create_finished,
-                                                  handle);
-  if (NULL == handle->ns_qe)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-}
-
-
-static void
-bulk_tx_commit_cb (void *cls, enum GNUNET_ErrorCode ec)
-{
-  struct RequestHandle *handle = cls;
-  struct MHD_Response *resp;
-
-  handle->ns_qe = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Commit finished (%d)\n", ec);
-  handle->ec = ec;
-  if (GNUNET_EC_NONE != ec)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  resp = GNUNET_REST_create_response (NULL);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
-}
-
-
-static void
-import_next_cb (void *cls, enum GNUNET_ErrorCode ec)
-{
-  struct RequestHandle *handle = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Import finished (%d)\n", ec);
-  handle->ns_qe = NULL;
-  handle->ec = ec;
-  if (GNUNET_EC_NONE != ec)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  unsigned int remaining = handle->rd_set_count - handle->rd_set_pos;
-  if (0 == remaining)
-  {
-    handle->ns_qe = GNUNET_NAMESTORE_transaction_commit (handle->nc,
-                                                         &bulk_tx_commit_cb,
-                                                         handle);
-    return;
-  }
-  unsigned int sent_rds = 0;
-  // Find the smallest set of records we can send with our message size
-  // restriction of 16 bit
-  handle->ns_qe = GNUNET_NAMESTORE_records_store2 (handle->nc,
-                                                   handle->zone_pkey,
-                                                   remaining,
-                                                   &handle->ri[handle->
-                                                               rd_set_pos],
-                                                   &sent_rds,
-                                                   &import_next_cb,
-                                                   handle);
-  if ((NULL == handle->ns_qe) && (0 == sent_rds))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->rd_set_pos += sent_rds;
-}
-
-static void
-bulk_tx_start (void *cls, enum GNUNET_ErrorCode ec)
-{
-  struct RequestHandle *handle = cls;
-  json_t *data_js;
-  json_error_t err;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transaction started...\n");
-  handle->ec = ec;
-  if (GNUNET_EC_NONE != ec)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  if (0 >= handle->rest_handle->data_size)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  char term_data[handle->rest_handle->data_size + 1];
-  term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy (term_data,
-                 handle->rest_handle->data,
-                 handle->rest_handle->data_size);
-  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
-  if (NULL == data_js)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error parsing data: %s", err.text);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  if (! json_is_array (data_js))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    json_decref (data_js);
-    return;
-  }
-  handle->rd_set_count = json_array_size (data_js);
-  handle->ri = GNUNET_malloc (handle->rd_set_count
-                              * sizeof (struct GNUNET_NAMESTORE_RecordInfo));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got record set of size %d\n", handle->rd_set_count);
-  char *albl;
-  size_t index;
-  json_t *value;
-  json_array_foreach (data_js, index, value) {
-    {
-      struct GNUNET_GNSRECORD_Data *rd;
-      struct GNUNET_JSON_Specification gnsspec[] =
-      { GNUNET_GNSRECORD_JSON_spec_gnsrecord (&rd,
-                                              &handle->ri[index].a_rd_count,
-                                              &albl),
-        GNUNET_JSON_spec_end () };
-      if (GNUNET_OK != GNUNET_JSON_parse (value, gnsspec, NULL, NULL))
-      {
-        handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
-        GNUNET_SCHEDULER_add_now (&do_error, handle);
-        json_decref (data_js);
-        return;
-      }
-      handle->ri[index].a_rd = rd;
-      handle->ri[index].a_label = albl;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Parsed record set for name %s\n",
-                  handle->ri[index].a_label);
-    }
-  }
-  // json_decref (data_js);
-
-  unsigned int sent_rds = 0;
-  // Find the smallest set of records we can send with our message size
-  // restriction of 16 bit
-  handle->ns_qe = GNUNET_NAMESTORE_records_store2 (handle->nc,
-                                                   handle->zone_pkey,
-                                                   handle->rd_set_count,
-                                                   handle->ri,
-                                                   &sent_rds,
-                                                   &import_next_cb,
-                                                   handle);
-  if ((NULL == handle->ns_qe) && (0 == sent_rds))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->rd_set_pos += sent_rds;
-}
-
-
-/**
- * Handle namestore POST import
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_import (struct GNUNET_REST_RequestHandle *con_handle,
-                  const char *url,
-                  void *cls)
-{
-  struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
-  char *egoname;
-
-  // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE_IMPORT) + 1 >= strlen (
-        handle->url))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  ego_entry = NULL;
-
-  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE_IMPORT) + 1];
-  ego_entry = get_egoentry_namestore (handle, egoname);
-
-  if (NULL == ego_entry)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-
-  // We need a per-client connection for a transactional bulk import
-  handle->nc = GNUNET_NAMESTORE_connect (cfg);
-  if (NULL == handle->nc)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->ns_qe = GNUNET_NAMESTORE_transaction_begin (handle->nc,
-                                                      &bulk_tx_start,
-                                                      handle);
-}
-
-/**
- * Handle namestore POST/PUT request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_add_or_update (struct GNUNET_REST_RequestHandle *con_handle,
-                         const char *url,
-                         void *cls)
-{
-  struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
-  char *egoname;
-  json_t *data_js;
-  json_error_t err;
-
-  char term_data[handle->rest_handle->data_size + 1];
-
-  if (0 >= handle->rest_handle->data_size)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy (term_data,
-                 handle->rest_handle->data,
-                 handle->rest_handle->data_size);
-  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
-  struct GNUNET_JSON_Specification gnsspec[] =
-  { GNUNET_GNSRECORD_JSON_spec_gnsrecord (&handle->rd, &handle->rd_count,
-                                          &handle->record_name),
-    GNUNET_JSON_spec_end () };
-  if (GNUNET_OK != GNUNET_JSON_parse (data_js, gnsspec, NULL, NULL))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    json_decref (data_js);
-    return;
-  }
-  GNUNET_JSON_parse_free (gnsspec);
-  if (0 >= strlen (handle->record_name))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    json_decref (data_js);
-    return;
-  }
-  json_decref (data_js);
-
-  egoname = NULL;
-  ego_entry = NULL;
-
-  // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-  ego_entry = get_egoentry_namestore (handle, egoname);
-
-  if (NULL == ego_entry)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  handle->ns_qe = GNUNET_NAMESTORE_records_lookup (ns_handle,
-                                                   handle->zone_pkey,
-                                                   handle->record_name,
-                                                   &ns_lookup_error_cb,
-                                                   handle,
-                                                   &ns_lookup_cb,
-                                                   handle);
-  if (NULL == handle->ns_qe)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-}
-
-
-/**
- * Handle namestore PUT request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_update (struct GNUNET_REST_RequestHandle *con_handle,
-                  const char *url,
-                  void *cls)
-{
-  struct RequestHandle *handle = cls;
-  handle->update_strategy = UPDATE_STRATEGY_REPLACE;
-  namestore_add_or_update (con_handle, url, cls);
-}
-
-
-/**
- * Handle namestore POST request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
-               const char *url,
-               void *cls)
-{
-  struct RequestHandle *handle = cls;
-  handle->update_strategy = UPDATE_STRATEGY_APPEND;
-  namestore_add_or_update (con_handle, url, cls);
-}
-
-
-/**
- * Handle namestore DELETE request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-void
-namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
-                  const char *url,
-                  void *cls)
-{
-  struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
-  char *egoname;
-  char *labelname;
-
-  egoname = NULL;
-  ego_entry = NULL;
-
-  // set zone to name if given
-  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
-  ego_entry = get_egoentry_namestore (handle, egoname);
-  if (NULL == ego_entry)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  labelname = &egoname[strlen (ego_entry->identifier)];
-  // set zone to name if given
-  if (1 >= strlen (labelname))
-  {
-    /* label is only "/" */
-    handle->ec = GNUNET_EC_NAMESTORE_NO_LABEL_GIVEN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-  }
-
-  handle->record_name = GNUNET_strdup (labelname + 1);
-  handle->ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
-                                                  handle->zone_pkey,
-                                                  handle->record_name,
-                                                  0,
-                                                  NULL,
-                                                  &del_finished,
-                                                  handle);
-  if (NULL == handle->ns_qe)
-  {
-    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-}
-
-
-/**
- * Respond to OPTIONS request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle,
-              const char *url,
-              void *cls)
-{
-  struct MHD_Response *resp;
-  struct RequestHandle *handle = cls;
-
-  // independent of path return all options
-  resp = GNUNET_REST_create_response (NULL);
-  GNUNET_assert (MHD_YES ==
-                 MHD_add_response_header (resp,
-                                          "Access-Control-Allow-Methods",
-                                          allow_methods));
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
-  return;
-}
-
-
-static void
-list_ego (void *cls,
-          struct GNUNET_IDENTITY_Ego *ego,
-          void **ctx,
-          const char *identifier)
-{
-  struct EgoEntry *ego_entry;
-  struct GNUNET_CRYPTO_PublicKey pk;
-
-  if ((NULL == ego) && (ID_REST_STATE_INIT == state))
-  {
-    state = ID_REST_STATE_POST_INIT;
-    return;
-  }
-  if (NULL == ego)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Called with NULL ego\n");
-    return;
-  }
-  if (ID_REST_STATE_INIT == state)
-  {
-    ego_entry = GNUNET_new (struct EgoEntry);
-    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
-    ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
-    ego_entry->ego = ego;
-    ego_entry->identifier = GNUNET_strdup (identifier);
-    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
-                                      ego_tail,
-                                      ego_entry);
-  }
-  /* Ego renamed or added */
-  if (identifier != NULL)
-  {
-    for (ego_entry = ego_head; NULL != ego_entry;
-         ego_entry = ego_entry->next)
-    {
-      if (ego_entry->ego == ego)
-      {
-        /* Rename */
-        GNUNET_free (ego_entry->identifier);
-        ego_entry->identifier = GNUNET_strdup (identifier);
-        break;
-      }
-    }
-    if (NULL == ego_entry)
-    {
-      /* Add */
-      ego_entry = GNUNET_new (struct EgoEntry);
-      GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
-      ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
-      ego_entry->ego = ego;
-      ego_entry->identifier = GNUNET_strdup (identifier);
-      GNUNET_CONTAINER_DLL_insert_tail (ego_head,
-                                        ego_tail,
-                                        ego_entry);
-    }
-  }
-  else
-  {
-    /* Delete */
-    for (ego_entry = ego_head; NULL != ego_entry;
-         ego_entry = ego_entry->next)
-    {
-      if (ego_entry->ego == ego)
-        break;
-    }
-    if (NULL == ego_entry)
-      return;   /* Not found */
-
-    GNUNET_CONTAINER_DLL_remove (ego_head,
-                                 ego_tail,
-                                 ego_entry);
-    GNUNET_free (ego_entry->identifier);
-    GNUNET_free (ego_entry->keystring);
-    GNUNET_free (ego_entry);
-    return;
-  }
-
-}
-
-
-/**
- * Function processing the REST call
- *
- * @param method HTTP method
- * @param url URL of the HTTP request
- * @param data body of the HTTP request (optional)
- * @param data_size length of the body
- * @param proc callback function for the result
- * @param proc_cls closure for callback function
- * @return GNUNET_OK if request accepted
- */
-static enum GNUNET_GenericReturnValue
-rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
-                      GNUNET_REST_ResultProcessor proc,
-                      void *proc_cls)
-{
-  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
-  struct GNUNET_REST_RequestHandlerError err;
-  static const struct GNUNET_REST_RequestHandler handlers[] =
-  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get },
-    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE_IMPORT,
-      &namestore_import },
-    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add },
-    { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_NAMESTORE, &namestore_update },
-    { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE,
-      &namestore_delete },
-    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &options_cont },
-    GNUNET_REST_HANDLER_END };
-
-  handle->ec = GNUNET_EC_NONE;
-  handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  handle->proc_cls = proc_cls;
-  handle->proc = proc;
-  handle->rest_handle = rest_handle;
-  handle->zone_pkey = NULL;
-  handle->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
-  handle->url = GNUNET_strdup (rest_handle->url);
-  if (handle->url[strlen (handle->url) - 1] == '/')
-    handle->url[strlen (handle->url) - 1] = '\0';
-  GNUNET_CONTAINER_DLL_insert (requests_head,
-                               requests_tail,
-                               handle);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
-  if (GNUNET_NO ==
-      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err,
-                                  handle))
-  {
-    cleanup_handle (handle);
-    return GNUNET_NO;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
-  return GNUNET_YES;
-}
-
-
-/**
- * Entry point for the plugin.
- *
- * @param cls Config info
- * @return NULL on error, otherwise the plugin context
- */
-void *
-libgnunet_plugin_rest_namestore_init (void *cls)
-{
-  static struct Plugin plugin;
-  struct GNUNET_REST_Plugin *api;
-
-  cfg = cls;
-  if (NULL != plugin.cfg)
-    return NULL;   /* can only initialize once! */
-  memset (&plugin, 0, sizeof(struct Plugin));
-  plugin.cfg = cfg;
-  api = GNUNET_new (struct GNUNET_REST_Plugin);
-  api->cls = &plugin;
-  api->name = GNUNET_REST_API_NS_NAMESTORE;
-  api->process_request = &rest_process_request;
-  state = ID_REST_STATE_INIT;
-  GNUNET_asprintf (&allow_methods,
-                   "%s, %s, %s, %s, %s",
-                   MHD_HTTP_METHOD_GET,
-                   MHD_HTTP_METHOD_POST,
-                   MHD_HTTP_METHOD_PUT,
-                   MHD_HTTP_METHOD_DELETE,
-                   MHD_HTTP_METHOD_OPTIONS);
-  ns_handle = GNUNET_NAMESTORE_connect (cfg);
-  identity_handle = GNUNET_IDENTITY_connect (cfg, &list_ego, NULL);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ (
-                "Namestore REST API initialized\n"));
-  return api;
-}
-
-
-/**
- * Exit point from the plugin.
- *
- * @param cls the plugin context (as returned by "init")
- * @return always NULL
- */
-void *
-libgnunet_plugin_rest_namestore_done (void *cls)
-{
-  struct GNUNET_REST_Plugin *api = cls;
-  struct Plugin *plugin = api->cls;
-  struct RequestHandle *request;
-  struct EgoEntry *ego_entry;
-  struct EgoEntry *ego_tmp;
-
-  plugin->cfg = NULL;
-  while (NULL != (request = requests_head))
-    do_error (request);
-  if (NULL != identity_handle)
-    GNUNET_IDENTITY_disconnect (identity_handle);
-  if (NULL != ns_handle)
-    GNUNET_NAMESTORE_disconnect (ns_handle);
-
-  for (ego_entry = ego_head; NULL != ego_entry;)
-  {
-    ego_tmp = ego_entry;
-    ego_entry = ego_entry->next;
-    GNUNET_free (ego_tmp->identifier);
-    GNUNET_free (ego_tmp->keystring);
-    GNUNET_free (ego_tmp);
-  }
-
-  GNUNET_free (allow_methods);
-  GNUNET_free (api);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore REST plugin is finished\n");
-  return NULL;
-}
-
-
-/* end of plugin_rest_namestore.c */
diff --git a/src/plugin/peerstore/Makefile.am b/src/plugin/peerstore/Makefile.am
new file mode 100644
index 000000000..225e9a71e
--- /dev/null
+++ b/src/plugin/peerstore/Makefile.am
@@ -0,0 +1,67 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+if HAVE_EXPERIMENTAL
+FLAT_PLUGIN = libgnunet_plugin_peerstore_flat.la
+FLAT_TESTS = test_plugin_peerstore_flat
+libgnunet_plugin_peerstore_flat_la_SOURCES = \
+  plugin_peerstore_flat.c
+libgnunet_plugin_peerstore_flat_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la $(XLIBS) \
+  $(LTLIBINTL)
+libgnunet_plugin_peerstore_flat_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+endif
+
+if HAVE_SQLITE
+SQLITE_PLUGIN = libgnunet_plugin_peerstore_sqlite.la
+SQLITE_TESTS = test_plugin_peerstore_sqlite
+libgnunet_plugin_peerstore_sqlite_la_SOURCES = \
+  plugin_peerstore_sqlite.c
+libgnunet_plugin_peerstore_sqlite_la_LIBADD = \
+  $(top_builddir)/src/lib/sq/libgnunetsq.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(XLIBS) -lsqlite3 \
+  $(LTLIBINTL)
+libgnunet_plugin_peerstore_sqlite_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+endif
+
+plugin_LTLIBRARIES = \
+  $(SQLITE_PLUGIN) \
+        $(FLAT_PLUGIN)
+
+test_plugin_peerstore_sqlite_SOURCES = \
+  test_plugin_peerstore.c
+test_plugin_peerstore_sqlite_LDADD = \
+        $(top_builddir)/src/service/testing/libgnunettesting.la \
+        $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_plugin_peerstore_flat_SOURCES = \
+  test_plugin_peerstore.c
+test_plugin_peerstore_flat_LDADD = \
+        $(top_builddir)/src/service/testing/libgnunettesting.la \
+        $(top_builddir)/src/lib/util/libgnunetutil.la
+
+check_PROGRAMS = \
+ $(SQLITE_TESTS) \
+ $(FLAT_TESTS)
+
+EXTRA_DIST = \
+ test_plugin_peerstore_flat.conf \
+ test_plugin_peerstore_sqlite.conf
+
+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
diff --git a/src/plugin/peerstore/meson.build b/src/plugin/peerstore/meson.build
new file mode 100644
index 000000000..1d22ca798
--- /dev/null
+++ b/src/plugin/peerstore/meson.build
@@ -0,0 +1,9 @@
+shared_module('gnunet_plugin_peerstore_sqlite',
+        ['plugin_peerstore_sqlite.c'],
+        dependencies: [libgnunetutil_dep,
+                       libgnunetsq_dep,
+                       sqlite_dep],
+        include_directories: [incdir,
+                              configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
diff --git a/src/plugin/peerstore/plugin_peerstore_flat.c b/src/plugin/peerstore/plugin_peerstore_flat.c
new file mode 100644
index 000000000..cc304d4db
--- /dev/null
+++ b/src/plugin/peerstore/plugin_peerstore_flat.c
@@ -0,0 +1,606 @@
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2015 Christian Grothoff (and other contributing authors)
+ *
+ * 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 peerstore/plugin_peerstore_flat.c
+ * @brief flat file-based peerstore backend
+ * @author Martin Schanzenbach
+ */
+
+#include "platform.h"
+#include "gnunet_peerstore_plugin.h"
+#include "gnunet_peerstore_service.h"
+#include "../../service/peerstore/peerstore.h"
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Configuration handle
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * HashMap
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *hm;
+
+  /**
+   * Iterator
+   */
+  GNUNET_PEERSTORE_Processor iter;
+
+  /**
+   * Iterator cls
+   */
+  void *iter_cls;
+
+  /**
+   * iterator key
+   */
+  const char *iter_key;
+
+  /**
+   * Iterator peer
+   */
+  const struct GNUNET_PeerIdentity *iter_peer;
+
+  /**
+   * Iterator subsystem
+   */
+  const char *iter_sub_system;
+
+  /**
+   * Iterator time
+   */
+  struct GNUNET_TIME_Absolute iter_now;
+
+  /**
+   * Deleted entries
+   */
+  uint64_t deleted_entries;
+
+  /**
+   * Expired entries
+   */
+  uint64_t exp_changes;
+
+  /**
+   * Database filename.
+   */
+  char *fn;
+
+  /**
+   * Result found bool
+   */
+  int iter_result_found;
+};
+
+
+static int
+delete_entries (void *cls,
+                const struct GNUNET_HashCode *key,
+                void *value)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PEERSTORE_Record *entry = value;
+
+  if (0 != strcmp (plugin->iter_key, entry->key))
+    return GNUNET_YES;
+  if (0 != memcmp (plugin->iter_peer,
+                   &entry->peer,
+                   sizeof(struct GNUNET_PeerIdentity)))
+    return GNUNET_YES;
+  if (0 != strcmp (plugin->iter_sub_system, entry->sub_system))
+    return GNUNET_YES;
+
+  GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
+  plugin->deleted_entries++;
+  return GNUNET_YES;
+}
+
+
+/**
+ * Delete records with the given key
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of sub system
+ * @param peer Peer identity (can be NULL)
+ * @param key entry key string (can be NULL)
+ * @return number of deleted records
+ */
+static int
+peerstore_flat_delete_records (void *cls, const char *sub_system,
+                               const struct GNUNET_PeerIdentity *peer,
+                               const char *key)
+{
+  struct Plugin *plugin = cls;
+
+  plugin->iter_sub_system = sub_system;
+  plugin->iter_peer = peer;
+  plugin->iter_key = key;
+  plugin->deleted_entries = 0;
+
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+                                         &delete_entries,
+                                         plugin);
+  return plugin->deleted_entries;
+}
+
+
+static int
+expire_entries (void *cls,
+                const struct GNUNET_HashCode *key,
+                void *value)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PEERSTORE_Record *entry = value;
+
+  if (entry->expiry.abs_value_us < plugin->iter_now.abs_value_us)
+  {
+    GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
+    plugin->exp_changes++;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Delete expired records (expiry < now)
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param now time to use as reference
+ * @param cont continuation called with the number of records expired
+ * @param cont_cls continuation closure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and cont is not
+ * called
+ */
+static int
+peerstore_flat_expire_records (void *cls, struct GNUNET_TIME_Absolute now,
+                               GNUNET_PEERSTORE_Continuation cont,
+                               void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+
+  plugin->exp_changes = 0;
+  plugin->iter_now = now;
+
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+                                         &expire_entries,
+                                         plugin);
+  if (NULL != cont)
+  {
+    cont (cont_cls, plugin->exp_changes);
+  }
+  return GNUNET_OK;
+}
+
+
+static int
+iterate_entries (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_PEERSTORE_Record *entry = value;
+
+  if ((NULL != plugin->iter_peer) &&
+      (0 != memcmp (plugin->iter_peer,
+                    &entry->peer,
+                    sizeof(struct GNUNET_PeerIdentity))))
+  {
+    return GNUNET_YES;
+  }
+  if ((NULL != plugin->iter_key) &&
+      (0 != strcmp (plugin->iter_key,
+                    entry->key)))
+  {
+    return GNUNET_YES;
+  }
+  if (NULL != plugin->iter)
+    plugin->iter (plugin->iter_cls, entry, NULL);
+  plugin->iter_result_found = GNUNET_YES;
+  return GNUNET_YES;
+}
+
+
+/**
+ * Iterate over the records given an optional peer id
+ * and/or key.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of sub system
+ * @param peer Peer identity (can be NULL)
+ * @param key entry key string (can be NULL)
+ * @param iter function to call asynchronously with the results, terminated
+ * by a NULL result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and iter is not
+ * called
+ */
+static int
+peerstore_flat_iterate_records (void *cls, const char *sub_system,
+                                const struct GNUNET_PeerIdentity *peer,
+                                const char *key,
+                                GNUNET_PEERSTORE_Processor iter,
+                                void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+
+  plugin->iter = iter;
+  plugin->iter_cls = iter_cls;
+  plugin->iter_peer = peer;
+  plugin->iter_sub_system = sub_system;
+  plugin->iter_key = key;
+
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+                                         &iterate_entries,
+                                         plugin);
+  if (NULL != iter)
+    iter (iter_cls, NULL, NULL);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Store a record in the peerstore.
+ * Key is the combination of sub system and peer identity.
+ * One key can store multiple values.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of the GNUnet sub system responsible
+ * @param peer peer identity
+ * @param key record key string
+ * @param value value to be stored
+ * @param size size of value to be stored
+ * @param expiry absolute time after which the record is (possibly) deleted
+ * @param options options related to the store operation
+ * @param cont continuation called when record is stored
+ * @param cont_cls continuation closure
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR and cont is not called
+ */
+static int
+peerstore_flat_store_record (void *cls, const char *sub_system,
+                             const struct GNUNET_PeerIdentity *peer,
+                             const char *key, const void *value, size_t size,
+                             struct GNUNET_TIME_Absolute expiry,
+                             enum GNUNET_PEERSTORE_StoreOption options,
+                             GNUNET_PEERSTORE_Continuation cont,
+                             void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_HashCode hkey;
+  struct GNUNET_PEERSTORE_Record *entry;
+  const char *peer_id;
+
+
+  entry = GNUNET_new (struct GNUNET_PEERSTORE_Record);
+  entry->sub_system = GNUNET_strdup (sub_system);
+  entry->key = GNUNET_strdup (key);
+  entry->value = GNUNET_malloc (size);
+  GNUNET_memcpy (entry->value, value, size);
+  entry->value_size = size;
+  entry->peer = *peer;
+  entry->expiry = expiry;
+
+  peer_id = GNUNET_i2s (peer);
+  GNUNET_CRYPTO_hash (peer_id,
+                      strlen (peer_id),
+                      &hkey);
+
+  if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
+  {
+    peerstore_flat_delete_records (cls, sub_system, peer, key);
+  }
+
+  GNUNET_CONTAINER_multihashmap_put (plugin->hm,
+                                     &hkey,
+                                     entry,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  if (NULL != cont)
+  {
+    cont (cont_cls, GNUNET_OK);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Initialize the database connections and associated
+ * data structures (create tables and indices
+ * as needed as well).
+ *
+ * @param plugin the plugin context (state for this module)
+ * @return GNUNET_OK on success
+ */
+static int
+database_setup (struct Plugin *plugin)
+{
+  char *afsdir;
+  char *key;
+  char *sub_system;
+  const char *peer_id;
+  char *peer;
+  char *value;
+  char *expiry;
+  struct GNUNET_DISK_FileHandle *fh;
+  struct GNUNET_PEERSTORE_Record *entry;
+  struct GNUNET_HashCode hkey;
+  uint64_t size;
+  char *buffer;
+  char *line;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "peerstore-flat",
+                                               "FILENAME", &afsdir))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "peerstore-flat",
+                               "FILENAME");
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
+    {
+      GNUNET_break (0);
+      GNUNET_free (afsdir);
+      return GNUNET_SYSERR;
+    }
+  }
+  /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
+  plugin->fn = afsdir;
+
+  fh = GNUNET_DISK_file_open (afsdir,
+                              GNUNET_DISK_OPEN_CREATE
+                              | GNUNET_DISK_OPEN_READWRITE,
+                              GNUNET_DISK_PERM_USER_WRITE
+                              | GNUNET_DISK_PERM_USER_READ);
+  if (NULL == fh)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unable to initialize file: %s.\n"),
+                afsdir);
+    return GNUNET_SYSERR;
+  }
+
+  /* Load data from file into hashmap */
+  plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
+                                                     GNUNET_NO);
+
+  if (GNUNET_SYSERR == GNUNET_DISK_file_size (afsdir,
+                                              &size,
+                                              GNUNET_YES,
+                                              GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unable to get filesize: %s.\n"),
+                afsdir);
+    return GNUNET_SYSERR;
+  }
+
+  buffer = GNUNET_malloc (size + 1);
+
+  if (GNUNET_SYSERR == GNUNET_DISK_file_read (fh,
+                                              buffer,
+                                              size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unable to read file: %s.\n"),
+                afsdir);
+    GNUNET_DISK_file_close (fh);
+    GNUNET_free (buffer);
+    return GNUNET_SYSERR;
+  }
+
+  buffer[size] = '\0';
+  GNUNET_DISK_file_close (fh);
+  if (0 < size)
+  {
+    line = strtok (buffer, "\n");
+    while (line != NULL)
+    {
+      sub_system = strtok (line, ",");
+      if (NULL == sub_system)
+        break;
+      peer = strtok (NULL, ",");
+      if (NULL == peer)
+        break;
+      key = strtok (NULL, ",");
+      if (NULL == key)
+        break;
+      value = strtok (NULL, ",");
+      if (NULL == value)
+        break;
+      expiry = strtok (NULL, ",");
+      if (NULL == expiry)
+        break;
+      entry = GNUNET_new (struct GNUNET_PEERSTORE_Record);
+      entry->sub_system = GNUNET_strdup (sub_system);
+      entry->key = GNUNET_strdup (key);
+      {
+        size_t s;
+        char *o;
+
+        o = NULL;
+        s = GNUNET_STRINGS_base64_decode (peer,
+                                          strlen (peer),
+                                          (void **) &o);
+        if (sizeof(struct GNUNET_PeerIdentity) == s)
+          GNUNET_memcpy (&entry->peer,
+                         o,
+                         s);
+        else
+          GNUNET_break (0);
+        GNUNET_free (o);
+      }
+      entry->value_size = GNUNET_STRINGS_base64_decode (value,
+                                                        strlen (value),
+                                                        (void **) &entry->value);
+      if (GNUNET_SYSERR ==
+          GNUNET_STRINGS_fancy_time_to_absolute (expiry,
+                                                 &entry->expiry))
+      {
+        GNUNET_free (entry->sub_system);
+        GNUNET_free (entry->key);
+        GNUNET_free (entry);
+        break;
+      }
+      peer_id = GNUNET_i2s (&entry->peer);
+      GNUNET_CRYPTO_hash (peer_id,
+                          strlen (peer_id),
+                          &hkey);
+
+      GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (plugin->hm,
+                                                                     &hkey,
+                                                                     entry,
+                                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+    }
+  }
+  GNUNET_free (buffer);
+  return GNUNET_OK;
+}
+
+
+static int
+store_and_free_entries (void *cls,
+                        const struct GNUNET_HashCode *key,
+                        void *value)
+{
+  struct GNUNET_DISK_FileHandle *fh = cls;
+  struct GNUNET_PEERSTORE_Record *entry = value;
+  char *line;
+  char *peer;
+  const char *expiry;
+  char *val;
+
+  GNUNET_STRINGS_base64_encode (entry->value,
+                                entry->value_size,
+                                &val);
+  expiry = GNUNET_STRINGS_absolute_time_to_string (entry->expiry);
+  GNUNET_STRINGS_base64_encode ((char *) &entry->peer,
+                                sizeof(struct GNUNET_PeerIdentity),
+                                &peer);
+  GNUNET_asprintf (&line,
+                   "%s,%s,%s,%s,%s",
+                   entry->sub_system,
+                   peer,
+                   entry->key,
+                   val,
+                   expiry);
+  GNUNET_free (val);
+  GNUNET_free (peer);
+  GNUNET_DISK_file_write (fh,
+                          line,
+                          strlen (line));
+  GNUNET_free (entry->sub_system);
+  GNUNET_free (entry->key);
+  GNUNET_free (entry->value);
+  GNUNET_free (entry);
+  GNUNET_free (line);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Shutdown database connection and associate data
+ * structures.
+ * @param plugin the plugin context (state for this module)
+ */
+static void
+database_shutdown (struct Plugin *plugin)
+{
+  struct GNUNET_DISK_FileHandle *fh;
+
+  fh = GNUNET_DISK_file_open (plugin->fn,
+                              GNUNET_DISK_OPEN_CREATE
+                              | GNUNET_DISK_OPEN_TRUNCATE
+                              | GNUNET_DISK_OPEN_READWRITE,
+                              GNUNET_DISK_PERM_USER_WRITE
+                              | GNUNET_DISK_PERM_USER_READ);
+  if (NULL == fh)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unable to initialize file: %s.\n"),
+                plugin->fn);
+    return;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+                                         &store_and_free_entries,
+                                         fh);
+  GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
+  GNUNET_DISK_file_close (fh);
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls The struct GNUNET_CONFIGURATION_Handle.
+ * @return NULL on error, otherwise the plugin context
+ */
+void *
+libgnunet_plugin_peerstore_flat_init (void *cls)
+{
+  static struct Plugin plugin;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_PEERSTORE_PluginFunctions *api;
+
+  if (NULL != plugin.cfg)
+    return NULL;                /* can only initialize once! */
+  memset (&plugin, 0, sizeof(struct Plugin));
+  plugin.cfg = cfg;
+  if (GNUNET_OK != database_setup (&plugin))
+  {
+    database_shutdown (&plugin);
+    return NULL;
+  }
+  api = GNUNET_new (struct GNUNET_PEERSTORE_PluginFunctions);
+  api->cls = &plugin;
+  api->store_record = &peerstore_flat_store_record;
+  api->iterate_records = &peerstore_flat_iterate_records;
+  api->expire_records = &peerstore_flat_expire_records;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Flat plugin is running\n");
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls The plugin context (as returned by "init")
+ * @return Always NULL
+ */
+void *
+libgnunet_plugin_peerstore_flat_done (void *cls)
+{
+  struct GNUNET_PEERSTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  database_shutdown (plugin);
+  plugin->cfg = NULL;
+  GNUNET_free (api);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Flat plugin is finished\n");
+  return NULL;
+}
+
+
+/* end of plugin_peerstore_sqlite.c */
diff --git a/src/plugin/peerstore/plugin_peerstore_sqlite.c b/src/plugin/peerstore/plugin_peerstore_sqlite.c
new file mode 100644
index 000000000..7d06d2c63
--- /dev/null
+++ b/src/plugin/peerstore/plugin_peerstore_sqlite.c
@@ -0,0 +1,702 @@
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2013, 2017 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 peerstore/plugin_peerstore_sqlite.c
+ * @brief sqlite-based peerstore backend
+ * @author Omar Tarabai
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_peerstore_plugin.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_sq_lib.h"
+#include "../../service/peerstore/peerstore.h"
+#include <sqlite3.h>
+
+/**
+ * After how many ms "busy" should a DB operation fail for good?  A
+ * low value makes sure that we are more responsive to requests
+ * (especially PUTs).  A high value guarantees a higher success rate
+ * (SELECTs in iterate can take several seconds despite LIMIT=1).
+ *
+ * The default value of 1s should ensure that users do not experience
+ * huge latencies while at the same time allowing operations to
+ * succeed with reasonable probability.
+ */
+#define BUSY_TIMEOUT_MS 1000
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' on file 'filename'
+ * with the message given by strerror(errno).
+ */
+#define LOG_SQLITE(db, level, cmd) do { GNUNET_log_from (level, \
+                                                         "peerstore-sqlite", _ ( \
+                                                           "`%s' failed at %s:%d with error: %s\n"), \
+                                                         cmd, \
+                                                         __FILE__, __LINE__, \
+                                                         sqlite3_errmsg ( \
+                                                           db->dbh)); \
+} while (0)
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "peerstore-sqlite", __VA_ARGS__)
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+  /**
+   * Configuration handle
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Database filename.
+   */
+  char *fn;
+
+  /**
+   * Native SQLite database handle.
+   */
+  sqlite3 *dbh;
+
+  /**
+   * Precompiled SQL for inserting into peerstoredata
+   */
+  sqlite3_stmt *insert_peerstoredata;
+
+  /**
+   * Precompiled SQL for selecting from peerstoredata
+   */
+  sqlite3_stmt *select_peerstoredata;
+
+  /**
+   * Precompiled SQL for selecting from peerstoredata
+   */
+  sqlite3_stmt *select_peerstoredata_by_pid;
+
+  /**
+   * Precompiled SQL for selecting from peerstoredata
+   */
+  sqlite3_stmt *select_peerstoredata_by_key;
+
+  /**
+   * Precompiled SQL for selecting from peerstoredata
+   */
+  sqlite3_stmt *select_peerstoredata_by_all;
+
+  /**
+   * Precompiled SQL for deleting expired
+   * records from peerstoredata
+   */
+  sqlite3_stmt *expire_peerstoredata;
+
+  /**
+   * Precompiled SQL for deleting records
+   * with given key
+   */
+  sqlite3_stmt *delete_peerstoredata;
+};
+
+
+/**
+ * Delete records with the given key
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of sub system
+ * @param peer Peer identity (can be NULL)
+ * @param key entry key string (can be NULL)
+ * @return number of deleted records, #GNUNE_SYSERR on error
+ */
+static int
+peerstore_sqlite_delete_records (void *cls,
+                                 const char *sub_system,
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 const char *key)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt = plugin->delete_peerstoredata;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_string (sub_system),
+    GNUNET_SQ_query_param_auto_from_type (peer),
+    GNUNET_SQ_query_param_string (key),
+    GNUNET_SQ_query_param_end
+  };
+  int ret;
+
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (stmt,
+                      params))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+    GNUNET_SQ_reset (plugin->dbh,
+                     stmt);
+    return GNUNET_SYSERR;
+  }
+  if (SQLITE_DONE !=
+      sqlite3_step (stmt))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    ret = GNUNET_SYSERR;
+  }
+  else
+  {
+    ret = sqlite3_changes (plugin->dbh);
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   stmt);
+  return ret;
+}
+
+
+/**
+ * Delete expired records (expiry < now)
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param now time to use as reference
+ * @param cont continuation called with the number of records expired
+ * @param cont_cls continuation closure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and cont is not
+ * called
+ */
+static int
+peerstore_sqlite_expire_records (void *cls, struct GNUNET_TIME_Absolute now,
+                                 GNUNET_PEERSTORE_Continuation cont,
+                                 void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt = plugin->expire_peerstoredata;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_absolute_time (&now),
+    GNUNET_SQ_query_param_end
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (stmt,
+                      params))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+    GNUNET_SQ_reset (plugin->dbh,
+                     stmt);
+    return GNUNET_SYSERR;
+  }
+  if (SQLITE_DONE != sqlite3_step (stmt))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    GNUNET_SQ_reset (plugin->dbh,
+                     stmt);
+    return GNUNET_SYSERR;
+  }
+  if (NULL != cont)
+    cont (cont_cls,
+          sqlite3_changes (plugin->dbh));
+  GNUNET_SQ_reset (plugin->dbh,
+                   stmt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterate over the records given an optional peer id
+ * and/or key.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of sub system
+ * @param peer Peer identity (can be NULL)
+ * @param key entry key string (can be NULL)
+ * @param iter function to call asynchronously with the results, terminated
+ * by a NULL result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and iter is not
+ * called
+ */
+static int
+peerstore_sqlite_iterate_records (void *cls,
+                                  const char *sub_system,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  const char *key,
+                                  GNUNET_PEERSTORE_Processor iter,
+                                  void *iter_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt;
+  int err = 0;
+  int sret;
+  struct GNUNET_PEERSTORE_Record rec;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Executing iterate request on sqlite db.\n");
+  if (NULL == peer)
+  {
+    if (NULL == key)
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_string (sub_system),
+        GNUNET_SQ_query_param_end
+      };
+
+      stmt = plugin->select_peerstoredata;
+      err = GNUNET_SQ_bind (stmt,
+                            params);
+    }
+    else
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_string (sub_system),
+        GNUNET_SQ_query_param_string (key),
+        GNUNET_SQ_query_param_end
+      };
+
+      stmt = plugin->select_peerstoredata_by_key;
+      err = GNUNET_SQ_bind (stmt,
+                            params);
+    }
+  }
+  else
+  {
+    if (NULL == key)
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_string (sub_system),
+        GNUNET_SQ_query_param_auto_from_type (peer),
+        GNUNET_SQ_query_param_end
+      };
+
+      stmt = plugin->select_peerstoredata_by_pid;
+      err = GNUNET_SQ_bind (stmt,
+                            params);
+    }
+    else
+    {
+      struct GNUNET_SQ_QueryParam params[] = {
+        GNUNET_SQ_query_param_string (sub_system),
+        GNUNET_SQ_query_param_auto_from_type (peer),
+        GNUNET_SQ_query_param_string (key),
+        GNUNET_SQ_query_param_end
+      };
+
+      stmt = plugin->select_peerstoredata_by_all;
+      err = GNUNET_SQ_bind (stmt,
+                            params);
+    }
+  }
+
+  if (GNUNET_OK != err)
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    GNUNET_SQ_reset (plugin->dbh,
+                     stmt);
+    return GNUNET_SYSERR;
+  }
+
+  err = 0;
+  while (SQLITE_ROW == (sret = sqlite3_step (stmt)))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Returning a matched record.\n");
+    struct GNUNET_SQ_ResultSpec rs[] = {
+      GNUNET_SQ_result_spec_string (&rec.sub_system),
+      GNUNET_SQ_result_spec_auto_from_type (&rec.peer),
+      GNUNET_SQ_result_spec_string (&rec.key),
+      GNUNET_SQ_result_spec_variable_size (&rec.value, &rec.value_size),
+      GNUNET_SQ_result_spec_absolute_time (&rec.expiry),
+      GNUNET_SQ_result_spec_end
+    };
+
+    if (GNUNET_OK !=
+        GNUNET_SQ_extract_result (stmt,
+                                  rs))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    if (NULL != iter)
+      iter (iter_cls,
+            &rec,
+            NULL);
+    GNUNET_SQ_cleanup_result (rs);
+  }
+  if (SQLITE_DONE != sret)
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite_step");
+    err = 1;
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   stmt);
+  if (NULL != iter)
+    iter (iter_cls,
+          NULL,
+          err ? "sqlite error" : NULL);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Store a record in the peerstore.
+ * Key is the combination of sub system and peer identity.
+ * One key can store multiple values.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param sub_system name of the GNUnet sub system responsible
+ * @param peer peer identity
+ * @param key record key string
+ * @param value value to be stored
+ * @param size size of value to be stored
+ * @param expiry absolute time after which the record is (possibly) deleted
+ * @param options options related to the store operation
+ * @param cont continuation called when record is stored
+ * @param cont_cls continuation closure
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR and cont is not called
+ */
+static int
+peerstore_sqlite_store_record (void *cls,
+                               const char *sub_system,
+                               const struct GNUNET_PeerIdentity *peer,
+                               const char *key,
+                               const void *value,
+                               size_t size,
+                               struct GNUNET_TIME_Absolute expiry,
+                               enum GNUNET_PEERSTORE_StoreOption options,
+                               GNUNET_PEERSTORE_Continuation cont,
+                               void *cont_cls)
+{
+  struct Plugin *plugin = cls;
+  sqlite3_stmt *stmt = plugin->insert_peerstoredata;
+  struct GNUNET_SQ_QueryParam params[] = {
+    GNUNET_SQ_query_param_string (sub_system),
+    GNUNET_SQ_query_param_auto_from_type (peer),
+    GNUNET_SQ_query_param_string (key),
+    GNUNET_SQ_query_param_fixed_size (value, size),
+    GNUNET_SQ_query_param_absolute_time (&expiry),
+    GNUNET_SQ_query_param_end
+  };
+
+  if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
+  {
+    peerstore_sqlite_delete_records (cls,
+                                     sub_system,
+                                     peer,
+                                     key);
+  }
+  if (GNUNET_OK !=
+      GNUNET_SQ_bind (stmt,
+                      params))
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
+  else if (SQLITE_DONE != sqlite3_step (stmt))
+  {
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+  }
+  GNUNET_SQ_reset (plugin->dbh,
+                   stmt);
+  if (NULL != cont)
+    cont (cont_cls,
+          GNUNET_OK);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Prepare a SQL statement
+ *
+ * @param dbh handle to the database
+ * @param sql SQL statement, UTF-8 encoded
+ * @return 0 on success
+ */
+static int
+sql_exec (sqlite3 *dbh,
+          const char *sql)
+{
+  int result;
+
+  result = sqlite3_exec (dbh,
+                         sql,
+                         NULL,
+                         NULL,
+                         NULL);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Executed `%s' / %d\n",
+       sql,
+       result);
+  if (SQLITE_OK != result)
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Error executing SQL query: %s\n  %s\n"),
+         sqlite3_errmsg (dbh),
+         sql);
+  return result;
+}
+
+
+/**
+ * @brief Prepare a SQL statement
+ *
+ * @param dbh handle to the database
+ * @param sql SQL statement, UTF-8 encoded
+ * @param stmt set to the prepared statement
+ * @return 0 on success
+ */
+static int
+sql_prepare (sqlite3 *dbh,
+             const char *sql,
+             sqlite3_stmt **stmt)
+{
+  char *tail;
+  int result;
+
+  result = sqlite3_prepare_v2 (dbh,
+                               sql,
+                               strlen (sql),
+                               stmt,
+                               (const char **) &tail);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Prepared `%s' / %p: %d\n",
+       sql,
+       *stmt,
+       result);
+  if (SQLITE_OK != result)
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Error preparing SQL query: %s\n  %s\n"),
+         sqlite3_errmsg (dbh),
+         sql);
+  return result;
+}
+
+
+/**
+ * Initialize the database connections and associated
+ * data structures (create tables and indices
+ * as needed as well).
+ *
+ * @param plugin the plugin context (state for this module)
+ * @return #GNUNET_OK on success
+ */
+static int
+database_setup (struct Plugin *plugin)
+{
+  char *filename;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
+                                               "peerstore-sqlite",
+                                               "FILENAME",
+                                               &filename))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "peerstore-sqlite",
+                               "FILENAME");
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != GNUNET_DISK_file_test (filename))
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (filename))
+    {
+      GNUNET_break (0);
+      GNUNET_free (filename);
+      return GNUNET_SYSERR;
+    }
+  }
+  /* filename should be UTF-8-encoded. If it isn't, it's a bug */
+  plugin->fn = filename;
+  /* Open database and precompile statements */
+  if (SQLITE_OK != sqlite3_open (plugin->fn,
+                                 &plugin->dbh))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Unable to initialize SQLite: %s.\n"),
+         sqlite3_errmsg (plugin->dbh));
+    return GNUNET_SYSERR;
+  }
+  sql_exec (plugin->dbh,
+            "PRAGMA temp_store=MEMORY");
+  sql_exec (plugin->dbh,
+            "PRAGMA synchronous=OFF");
+  sql_exec (plugin->dbh,
+            "PRAGMA legacy_file_format=OFF");
+  sql_exec (plugin->dbh,
+            "PRAGMA auto_vacuum=INCREMENTAL");
+  sql_exec (plugin->dbh,
+            "PRAGMA encoding=\"UTF-8\"");
+  sql_exec (plugin->dbh,
+            "PRAGMA page_size=4096");
+  sqlite3_busy_timeout (plugin->dbh,
+                        BUSY_TIMEOUT_MS);
+  /* Create tables */
+  sql_exec (plugin->dbh,
+            "CREATE TABLE IF NOT EXISTS peerstoredata (\n"
+            "  sub_system TEXT NOT NULL,\n"
+            "  peer_id BLOB NOT NULL,\n"
+            "  key TEXT NOT NULL,\n"
+            "  value BLOB NULL,\n"
+            "  expiry INT8 NOT NULL" ");");
+  /* Create Indices */
+  if (SQLITE_OK !=
+      sqlite3_exec (plugin->dbh,
+                    "CREATE INDEX IF NOT EXISTS peerstoredata_key_index ON peerstoredata (sub_system, peer_id, key)",
+                    NULL,
+                    NULL,
+                    NULL))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Unable to create indices: %s.\n"),
+         sqlite3_errmsg (plugin->dbh));
+    return GNUNET_SYSERR;
+  }
+  /* Prepare statements */
+
+  sql_prepare (plugin->dbh,
+               "INSERT INTO peerstoredata (sub_system, peer_id, key, value, expiry)"
+               " VALUES (?,?,?,?,?);",
+               &plugin->insert_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "SELECT sub_system,peer_id,key,value,expiry FROM peerstoredata"
+               " WHERE sub_system = ?",
+               &plugin->select_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "SELECT sub_system,peer_id,key,value,expiry FROM peerstoredata"
+               " WHERE sub_system = ?"
+               " AND peer_id = ?",
+               &plugin->select_peerstoredata_by_pid);
+  sql_prepare (plugin->dbh,
+               "SELECT sub_system,peer_id,key,value,expiry FROM peerstoredata"
+               " WHERE sub_system = ?"
+               " AND key = ?",
+               &plugin->select_peerstoredata_by_key);
+  sql_prepare (plugin->dbh,
+               "SELECT sub_system,peer_id,key,value,expiry FROM peerstoredata"
+               " WHERE sub_system = ?"
+               " AND peer_id = ?" " AND key = ?",
+               &plugin->select_peerstoredata_by_all);
+  sql_prepare (plugin->dbh,
+               "DELETE FROM peerstoredata"
+               " WHERE expiry < ?",
+               &plugin->expire_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "DELETE FROM peerstoredata"
+               " WHERE sub_system = ?"
+               " AND peer_id = ?" " AND key = ?",
+               &plugin->delete_peerstoredata);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown database connection and associate data
+ * structures.
+ * @param plugin the plugin context (state for this module)
+ */
+static void
+database_shutdown (struct Plugin *plugin)
+{
+  int result;
+  sqlite3_stmt *stmt;
+
+  while (NULL != (stmt = sqlite3_next_stmt (plugin->dbh,
+                                            NULL)))
+  {
+    result = sqlite3_finalize (stmt);
+    if (SQLITE_OK != result)
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Failed to close statement %p: %d\n",
+           stmt,
+           result);
+  }
+  if (SQLITE_OK != sqlite3_close (plugin->dbh))
+    LOG_SQLITE (plugin,
+                GNUNET_ERROR_TYPE_ERROR,
+                "sqlite3_close");
+  GNUNET_free (plugin->fn);
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls The struct GNUNET_CONFIGURATION_Handle.
+ * @return NULL on error, otherwise the plugin context
+ */
+void *
+libgnunet_plugin_peerstore_sqlite_init (void *cls)
+{
+  static struct Plugin plugin;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_PEERSTORE_PluginFunctions *api;
+
+  if (NULL != plugin.cfg)
+    return NULL;                /* can only initialize once! */
+  memset (&plugin,
+          0,
+          sizeof(struct Plugin));
+  plugin.cfg = cfg;
+  if (GNUNET_OK != database_setup (&plugin))
+  {
+    database_shutdown (&plugin);
+    return NULL;
+  }
+  api = GNUNET_new (struct GNUNET_PEERSTORE_PluginFunctions);
+  api->cls = &plugin;
+  api->store_record = &peerstore_sqlite_store_record;
+  api->iterate_records = &peerstore_sqlite_iterate_records;
+  api->expire_records = &peerstore_sqlite_expire_records;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sqlite plugin is running\n");
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls The plugin context (as returned by "init")
+ * @return Always NULL
+ */
+void *
+libgnunet_plugin_peerstore_sqlite_done (void *cls)
+{
+  struct GNUNET_PEERSTORE_PluginFunctions *api = cls;
+  struct Plugin *plugin = api->cls;
+
+  database_shutdown (plugin);
+  plugin->cfg = NULL;
+  GNUNET_free (api);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sqlite plugin is finished\n");
+  return NULL;
+}
+
+
+/* end of plugin_peerstore_sqlite.c */
diff --git a/src/plugin/peerstore/test_plugin_peerstore.c b/src/plugin/peerstore/test_plugin_peerstore.c
new file mode 100644
index 000000000..bce62dda9
--- /dev/null
+++ b/src/plugin/peerstore/test_plugin_peerstore.c
@@ -0,0 +1,224 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2015 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 namestore/test_plugin_namestore.c
+ * @brief Test for the namestore plugins
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_peerstore_plugin.h"
+#include "gnunet_testing_lib.h"
+
+
+static int ok;
+
+/**
+ * Name of plugin under test.
+ */
+static const char *plugin_name;
+
+
+static struct GNUNET_PEERSTORE_PluginFunctions *psp;
+
+static struct GNUNET_PeerIdentity p1;
+
+
+/**
+ * Function called when the service shuts down.  Unloads our namestore
+ * plugin.
+ *
+ * @param api api to unload
+ */
+static void
+unload_plugin (struct GNUNET_PEERSTORE_PluginFunctions *api)
+{
+  char *libname;
+
+  GNUNET_asprintf (&libname,
+                   "libgnunet_plugin_peer_%s",
+                   plugin_name);
+  GNUNET_break (NULL ==
+                GNUNET_PLUGIN_unload (libname,
+                                      api));
+  GNUNET_free (libname);
+}
+
+
+/**
+ * Load the namestore plugin.
+ *
+ * @param cfg configuration to pass
+ * @return NULL on error
+ */
+static struct GNUNET_PEERSTORE_PluginFunctions *
+load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_PEERSTORE_PluginFunctions *ret;
+  char *libname;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Loading `%s' peer plugin\n"),
+              plugin_name);
+  GNUNET_asprintf (&libname,
+                   "libgnunet_plugin_peerstore_%s",
+                   plugin_name);
+  if (NULL == (ret = GNUNET_PLUGIN_load (libname,
+                                         (void *) cfg)))
+  {
+    fprintf (stderr,
+             "Failed to load plugin `%s'!\n",
+             plugin_name);
+    GNUNET_free (libname);
+    return NULL;
+  }
+  GNUNET_free (libname);
+  return ret;
+}
+
+
+static void
+test_record (void *cls,
+             const struct GNUNET_PEERSTORE_Record *record,
+             const char *error)
+{
+  const struct GNUNET_PeerIdentity *id = cls;
+  const char*testval = "test_val";
+
+  if (NULL == record)
+  {
+    unload_plugin (psp);
+    return;
+  }
+  GNUNET_assert (0 == memcmp (&record->peer,
+                              id,
+                              sizeof(struct GNUNET_PeerIdentity)));
+  GNUNET_assert (0 == strcmp ("subsys",
+                              record->sub_system));
+  GNUNET_assert (0 == strcmp ("key",
+                              record->key));
+  GNUNET_assert (0 == memcmp (testval,
+                              record->value,
+                              strlen (testval)));
+  ok = 0;
+}
+
+
+static void
+get_record (struct GNUNET_PEERSTORE_PluginFunctions *psp,
+            const struct GNUNET_PeerIdentity *identity)
+{
+  GNUNET_assert (GNUNET_OK ==
+                 psp->iterate_records (psp->cls,
+                                       "subsys",
+                                       identity,
+                                       "key",
+                                       &test_record,
+                                       (void *) identity));
+}
+
+
+static void
+store_cont (void *cls,
+            int status)
+{
+  GNUNET_assert (GNUNET_OK == status);
+  get_record (psp,
+              &p1);
+}
+
+
+static void
+put_record (struct GNUNET_PEERSTORE_PluginFunctions *psp,
+            const struct GNUNET_PeerIdentity *identity)
+{
+  GNUNET_assert (GNUNET_OK ==
+                 psp->store_record (psp->cls,
+                                    "subsys",
+                                    identity,
+                                    "key",
+                                    "test_value",
+                                    strlen ("test_value"),
+                                    GNUNET_TIME_absolute_get (),
+                                    GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                                    &store_cont,
+                                    NULL));
+}
+
+
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  ok = 1;
+  psp = load_plugin (cfg);
+  if (NULL == psp)
+  {
+    fprintf (stderr,
+             "%s",
+             "Failed to initialize peerstore.  Database likely not setup, skipping test.\n");
+    return;
+  }
+  memset (&p1, 1, sizeof(p1));
+  put_record (psp,
+              &p1);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  char cfg_name[PATH_MAX];
+  char *const xargv[] = {
+    "test-plugin-peerstore",
+    "-c",
+    cfg_name,
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  GNUNET_log_setup ("test-plugin-peerstore",
+                    "WARNING",
+                    NULL);
+  plugin_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]);
+  GNUNET_snprintf (cfg_name,
+                   sizeof(cfg_name),
+                   "test_plugin_peerstore_%s.conf",
+                   plugin_name);
+  GNUNET_PROGRAM_run ((sizeof(xargv) / sizeof(char *)) - 1,
+                      xargv,
+                      "test-plugin-peerstore",
+                      "nohelp",
+                      options,
+                      &run,
+                      NULL);
+  if (ok != 0)
+    fprintf (stderr,
+             "Missed some testcases: %d\n",
+             ok);
+  return ok;
+}
+
+
+/* end of test_plugin_peerstore.c */
diff --git a/src/plugin/peerstore/test_plugin_peerstore_flat.conf b/src/plugin/peerstore/test_plugin_peerstore_flat.conf
new file mode 100644
index 000000000..c55b1e9d6
--- /dev/null
+++ b/src/plugin/peerstore/test_plugin_peerstore_flat.conf
@@ -0,0 +1,5 @@
+[peerstore-flat]
+FILENAME = $GNUNET_TMP/gnunet-test-plugin-namestore-flat/flatdb
+
+[peerstore]
+# PREFIX = valgrind --log-file=/home/schanzen/dev/gnunet/src/peerstore/vg_log
diff --git a/src/plugin/peerstore/test_plugin_peerstore_sqlite.conf b/src/plugin/peerstore/test_plugin_peerstore_sqlite.conf
new file mode 100644
index 000000000..dcf1fc1a4
--- /dev/null
+++ b/src/plugin/peerstore/test_plugin_peerstore_sqlite.conf
@@ -0,0 +1,2 @@
+[peerstore-sqlite]
+FILENAME = $GNUNET_TMP/gnunet-test-plugin-peerstore-sqlite/sqlite.db
diff --git a/src/plugin/reclaim/Makefile.am b/src/plugin/reclaim/Makefile.am
index 0b5159c6b..e8ac2f94d 100644
--- a/src/plugin/reclaim/Makefile.am
+++ b/src/plugin/reclaim/Makefile.am
@@ -59,11 +59,11 @@ endif
 
 
 libgnunet_plugin_reclaim_credential_jwt_la_SOURCES = \
-  plugin_reclaim_credential_jwt.c
+  plugin_reclaim_credential_jwt.c \
+        $(top_builddir)/src/service/reclaim/reclaim_attribute.c \
+        $(top_builddir)/src/service/reclaim/reclaim_credential.c
 libgnunet_plugin_reclaim_credential_jwt_la_LIBADD = \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la \
-  $(top_builddir)/src/service/reclaim/libgnunetreclaim.la \
   -ljansson\
   $(LTLIBINTL)
 libgnunet_plugin_reclaim_credential_jwt_la_LDFLAGS = \
diff --git a/src/plugin/reclaim/meson.build b/src/plugin/reclaim/meson.build
index 51346b108..df0289ca2 100644
--- a/src/plugin/reclaim/meson.build
+++ b/src/plugin/reclaim/meson.build
@@ -7,9 +7,7 @@ shared_module('gnunet_plugin_gnsrecord_reclaim',
 
 shared_module('gnunet_plugin_reclaim_attribute_basic',
               ['plugin_reclaim_attribute_basic.c'],
-              dependencies: [libgnunetrest_dep,
-                             libgnunetidentity_dep,
-                             libgnunetreclaim_dep,
+              dependencies: [
                              libgnunetjson_dep,
                              libgnunetutil_dep,
                              json_dep],
@@ -18,9 +16,7 @@ shared_module('gnunet_plugin_reclaim_attribute_basic',
               install_dir: get_option('libdir') / 'gnunet')
 shared_module('gnunet_plugin_reclaim_credential_jwt',
               ['plugin_reclaim_credential_jwt.c'],
-              dependencies: [libgnunetrest_dep,
-                             libgnunetidentity_dep,
-                             libgnunetreclaim_dep,
+              dependencies: [
                              libgnunetjson_dep,
                              libgnunetutil_dep,
                              json_dep],
diff --git a/src/plugin/regex/Makefile.am b/src/plugin/regex/Makefile.am
new file mode 100644
index 000000000..a39cfc927
--- /dev/null
+++ b/src/plugin/regex/Makefile.am
@@ -0,0 +1,40 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+lib_LTLIBRARIES = \
+  libgnunetregexblock.la
+
+libgnunetregexblock_la_SOURCES = \
+  regex_block_lib.c regex_block_lib.h
+libgnunetregexblock_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(XLIB) \
+  $(LTLIBINTL)
+libgnunetregexblock_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 1:0:0
+
+
+plugin_LTLIBRARIES = \
+ libgnunet_plugin_block_regex.la
+
+libgnunet_plugin_block_regex_la_SOURCES = \
+ plugin_block_regex.c
+libgnunet_plugin_block_regex_la_LIBADD = \
+ libgnunetregexblock.la \
+ $(top_builddir)/src/lib/block/libgnunetblock.la \
+ $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunet_plugin_block_regex_la_LDFLAGS = \
+ $(GN_LIBINTL) \
+ $(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/regex/meson.build b/src/plugin/regex/meson.build
new file mode 100644
index 000000000..0e1b4b08d
--- /dev/null
+++ b/src/plugin/regex/meson.build
@@ -0,0 +1,23 @@
+libgnunetregexblock_src = ['regex_block_lib.c']
+
+libgnunetregexblock = library('gnunetregexblock',
+        libgnunetregexblock_src,
+        soversion: '1',
+        version: '1.0.0',
+        dependencies: libgnunetutil_dep,
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetregexblock_dep = declare_dependency(link_with : libgnunetregexblock)
+
+shared_module('gnunet_plugin_block_regex',
+        ['plugin_block_regex.c'],
+        dependencies: [libgnunetutil_dep,
+                       libgnunetregexblock_dep,
+                       libgnunetblock_dep,
+                       libgnunetblockgroup_dep],
+        include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
+
+
diff --git a/src/plugin/regex/plugin_block_regex.c b/src/plugin/regex/plugin_block_regex.c
new file mode 100644
index 000000000..5f23a32df
--- /dev/null
+++ b/src/plugin/regex/plugin_block_regex.c
@@ -0,0 +1,380 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2013 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 regex/plugin_block_regex.c
+ * @brief blocks used for regex storage and search
+ * @author Bartlomiej Polot
+ */
+#include "platform.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+#include "block_regex.h"
+#include "regex_block_lib.h"
+#include "gnunet_signatures.h"
+
+
+/**
+ * Number of bits we set per entry in the bloomfilter.
+ * Do not change!
+ */
+#define BLOOMFILTER_K 16
+
+
+/**
+ * How big is the BF we use for REGEX blocks?
+ */
+#define REGEX_BF_SIZE 8
+
+
+/**
+ * Create a new block group.
+ *
+ * @param ctx block context in which the block group is created
+ * @param type type of the block for which we are creating the group
+ * @param raw_data optional serialized prior state of the group, NULL if unavailable/fresh
+ * @param raw_data_size number of bytes in @a raw_data, 0 if unavailable/fresh
+ * @param va variable arguments specific to @a type
+ * @return block group handle, NULL if block groups are not supported
+ *         by this @a type of block (this is not an error)
+ */
+static struct GNUNET_BLOCK_Group *
+block_plugin_regex_create_group (void *cls,
+                                 enum GNUNET_BLOCK_Type type,
+                                 const void *raw_data,
+                                 size_t raw_data_size,
+                                 va_list va)
+{
+  unsigned int bf_size;
+  const char *guard;
+
+  guard = va_arg (va, const char *);
+  if (0 == strcmp (guard,
+                   "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
+                                                                   int),
+                                                           BLOOMFILTER_K);
+  else if (0 == strcmp (guard,
+                        "filter-size"))
+    bf_size = va_arg (va, unsigned int);
+  else
+  {
+    GNUNET_break (0);
+    bf_size = REGEX_BF_SIZE;
+  }
+  GNUNET_break (NULL == va_arg (va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create (cls,
+                                       bf_size,
+                                       BLOOMFILTER_K,
+                                       type,
+                                       raw_data,
+                                       raw_data_size);
+}
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param ctx block context
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_regex_check_query (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const struct GNUNET_HashCode *query,
+                                const void *xquery,
+                                size_t xquery_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_REGEX:
+    if (0 != xquery_size)
+    {
+      const char *s;
+
+      s = (const char *) xquery;
+      if ('\0' != s[xquery_size - 1])     /* must be valid 0-terminated string */
+      {
+        GNUNET_break_op (0);
+        return GNUNET_NO;
+      }
+    }
+    return GNUNET_OK;
+  case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
+    if (0 != xquery_size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_regex_check_block (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const void *block,
+                                size_t block_size)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_REGEX:
+    if (GNUNET_SYSERR ==
+        REGEX_BLOCK_check (block,
+                           block_size,
+                           NULL,
+                           NULL))
+      return GNUNET_NO;
+    return GNUNET_OK;
+  case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
+    {
+      const struct RegexAcceptBlock *rba;
+
+      if (sizeof(struct RegexAcceptBlock) != block_size)
+      {
+        GNUNET_break_op (0);
+        return GNUNET_NO;
+      }
+      rba = block;
+      if (ntohl (rba->purpose.size) !=
+          sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+          + sizeof(struct GNUNET_TIME_AbsoluteNBO)
+          + sizeof(struct GNUNET_HashCode))
+      {
+        GNUNET_break_op (0);
+        return GNUNET_NO;
+      }
+      if (GNUNET_TIME_absolute_is_past (GNUNET_TIME_absolute_ntoh (
+                                          rba->expiration_time)))
+      {
+        return GNUNET_NO;
+      }
+      if (GNUNET_OK !=
+          GNUNET_CRYPTO_eddsa_verify_ (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT,
+                                       &rba->purpose,
+                                       &rba->signature,
+                                       &rba->peer.public_key))
+      {
+        GNUNET_break_op (0);
+        return GNUNET_NO;
+      }
+      return GNUNET_OK;
+    }
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_regex_check_reply (
+  void *cls,
+  enum GNUNET_BLOCK_Type type,
+  struct GNUNET_BLOCK_Group *group,
+  const struct GNUNET_HashCode *query,
+  const void *xquery,
+  size_t xquery_size,
+  const void *reply_block,
+  size_t reply_block_size)
+{
+  struct GNUNET_HashCode chash;
+
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_REGEX:
+    if (0 != xquery_size)
+    {
+      const char *s;
+
+      s = (const char *) xquery;
+      GNUNET_assert ('\0' == s[xquery_size - 1]);
+    }
+    switch (REGEX_BLOCK_check (reply_block,
+                               reply_block_size,
+                               query,
+                               xquery))
+    {
+    case GNUNET_SYSERR:
+      GNUNET_assert (0);
+    case GNUNET_NO:
+      /* xquery mismatch, can happen */
+      return GNUNET_BLOCK_REPLY_IRRELEVANT;
+    default:
+      break;
+    }
+    GNUNET_CRYPTO_hash (reply_block,
+                        reply_block_size,
+                        &chash);
+    if (GNUNET_YES ==
+        GNUNET_BLOCK_GROUP_bf_test_and_set (group,
+                                            &chash))
+      return GNUNET_BLOCK_REPLY_OK_DUPLICATE;
+    return GNUNET_BLOCK_REPLY_OK_MORE;
+  case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
+    {
+      const struct RegexAcceptBlock *rba;
+
+      GNUNET_assert (sizeof(struct RegexAcceptBlock) == reply_block_size);
+      rba = reply_block;
+      GNUNET_assert (ntohl (rba->purpose.size) ==
+                     sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+                     + sizeof(struct GNUNET_TIME_AbsoluteNBO)
+                     + sizeof(struct GNUNET_HashCode));
+      GNUNET_CRYPTO_hash (reply_block,
+                          reply_block_size,
+                          &chash);
+      if (GNUNET_YES ==
+          GNUNET_BLOCK_GROUP_bf_test_and_set (group,
+                                              &chash))
+        return GNUNET_BLOCK_REPLY_OK_DUPLICATE;
+      return GNUNET_BLOCK_REPLY_OK_MORE;
+    }
+  default:
+    GNUNET_break (0);
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  }
+  return GNUNET_BLOCK_REPLY_OK_MORE;
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in @a block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported,
+ *         #GNUNET_NO if extracting a key from a block of this type does not work
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_regex_get_key (void *cls,
+                            enum GNUNET_BLOCK_Type type,
+                            const void *block,
+                            size_t block_size,
+                            struct GNUNET_HashCode *key)
+{
+  switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_REGEX:
+    if (GNUNET_OK !=
+        REGEX_BLOCK_get_key (block,
+                             block_size,
+                             key))
+    {
+      GNUNET_break_op (0);
+      memset (key,
+              0,
+              sizeof (*key));
+      return GNUNET_OK;
+    }
+    return GNUNET_OK;
+  case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
+    if (sizeof(struct RegexAcceptBlock) != block_size)
+    {
+      GNUNET_break_op (0);
+      memset (key,
+              0,
+              sizeof (*key));
+      return GNUNET_OK;
+    }
+    *key = ((struct RegexAcceptBlock *) block)->key;
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_regex_init (void *cls)
+{
+  static const enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_REGEX,
+    GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_regex_get_key;
+  api->check_query = &block_plugin_regex_check_query;
+  api->check_block = &block_plugin_regex_check_block;
+  api->check_reply = &block_plugin_regex_check_reply;
+  api->create_group = &block_plugin_regex_create_group;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_regex_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_regex.c */
diff --git a/src/plugin/regex/regex_block_lib.c b/src/plugin/regex/regex_block_lib.c
new file mode 100644
index 000000000..048d6d743
--- /dev/null
+++ b/src/plugin/regex/regex_block_lib.c
@@ -0,0 +1,431 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012,2013 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 Bartlomiej Polot
+ * @file regex/regex_block_lib.c
+ * @brief functions for manipulating non-accept blocks stored for
+ *        regex in the DHT
+ */
+#include "platform.h"
+#include "regex_block_lib.h"
+#include "gnunet_constants.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "regex-bck", __VA_ARGS__)
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Information for each edge.
+ */
+struct EdgeInfo
+{
+  /**
+   * Index of the destination of this edge in the
+   * unique destinations array.
+   */
+  uint16_t destination_index GNUNET_PACKED;
+
+  /**
+   * Number of bytes the token for this edge takes in the
+   * token area.
+   */
+  uint16_t token_length GNUNET_PACKED;
+};
+
+
+/**
+ * @brief Block to announce a regex state.
+ */
+struct RegexBlock
+{
+  /**
+   * Length of the proof regex string.
+   */
+  uint16_t proof_len GNUNET_PACKED;
+
+  /**
+   * Is this state an accepting state?
+   */
+  int16_t is_accepting GNUNET_PACKED;
+
+  /**
+   * Number of edges parting from this state.
+   */
+  uint16_t num_edges GNUNET_PACKED;
+
+  /**
+   * Number of unique destinations reachable from this state.
+   */
+  uint16_t num_destinations GNUNET_PACKED;
+
+  /* followed by 'struct GNUNET_HashCode[num_destinations]' */
+
+  /* followed by 'struct EdgeInfo[edge_destination_indices]' */
+
+  /* followed by 'char proof[n_proof]', NOT 0-terminated */
+
+  /* followed by 'char tokens[num_edges][edge_info[k].token_length]';
+     essentially all of the tokens one after the other in the
+     order of the edges; tokens are NOT 0-terminated */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Test if this block is marked as being an accept state.
+ *
+ * @param block block to test
+ * @param size number of bytes in block
+ * @return #GNUNET_YES if the block is accepting, #GNUNET_NO if not
+ */
+int
+GNUNET_BLOCK_is_accepting (const struct RegexBlock *block,
+                           size_t size)
+{
+  if (size < sizeof(struct RegexBlock))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return ntohs (block->is_accepting);
+}
+
+
+int
+REGEX_BLOCK_check_proof (const char *proof,
+                         size_t proof_len,
+                         const struct GNUNET_HashCode *key)
+{
+  struct GNUNET_HashCode key_check;
+
+  if ((NULL == proof) || (NULL == key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Proof check failed, was NULL.\n");
+    return GNUNET_NO;
+  }
+  GNUNET_CRYPTO_hash (proof, proof_len, &key_check);
+  return (0 ==
+          GNUNET_CRYPTO_hash_cmp (key, &key_check)) ? GNUNET_OK : GNUNET_NO;
+}
+
+
+/**
+ * Struct to keep track of the xquery while iterating all the edges in a block.
+ */
+struct CheckEdgeContext
+{
+  /**
+   * Xquery: string we are looking for.
+   */
+  const char *xquery;
+
+  /**
+   * Has any edge matched the xquery so far? (GNUNET_OK / GNUNET_NO)
+   */
+  int found;
+};
+
+
+/**
+ * Iterator over all edges in a block, checking for a presence of a given query.
+ *
+ * @param cls Closure, (xquery context).
+ * @param token Token that follows to next state.
+ * @param len Length of token.
+ * @param key Hash of next state.
+ *
+ * @return #GNUNET_YES, to keep iterating
+ */
+static int
+check_edge (void *cls,
+            const char *token,
+            size_t len,
+            const struct GNUNET_HashCode *key)
+{
+  struct CheckEdgeContext *ctx = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "edge %.*s [%u]: %s\n",
+              (int) len,
+              token,
+              (unsigned int) len,
+              GNUNET_h2s (key));
+  if (NULL == ctx->xquery)
+    return GNUNET_YES;
+  if (strlen (ctx->xquery) < len)
+    return GNUNET_YES; /* too long */
+  if (0 == strncmp (ctx->xquery, token, len))
+    ctx->found = GNUNET_OK;
+  return GNUNET_YES; /* keep checking for malformed data! */
+}
+
+
+int
+REGEX_BLOCK_check (const struct RegexBlock *block,
+                   size_t size,
+                   const struct GNUNET_HashCode *query,
+                   const char *xquery)
+{
+  struct GNUNET_HashCode key;
+  struct CheckEdgeContext ctx;
+  int res;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Block check\n");
+  if (GNUNET_OK !=
+      REGEX_BLOCK_get_key (block, size,
+                           &key))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if ((NULL != query) &&
+      (0 != GNUNET_memcmp (&key,
+                           query)) )
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if ((GNUNET_YES == ntohs (block->is_accepting)) &&
+      ((NULL == xquery) || ('\0' == xquery[0])))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "  out! Is accepting: %u, xquery %p\n",
+         ntohs (block->is_accepting),
+         xquery);
+    return GNUNET_OK;
+  }
+  ctx.xquery = xquery;
+  ctx.found = GNUNET_NO;
+  res = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
+  if (GNUNET_SYSERR == res)
+    return GNUNET_SYSERR;
+  if (NULL == xquery)
+    return GNUNET_YES;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Result %d\n", ctx.found);
+  return ctx.found;
+}
+
+
+int
+REGEX_BLOCK_get_key (const struct RegexBlock *block,
+                     size_t block_len,
+                     struct GNUNET_HashCode *key)
+{
+  uint16_t len;
+  const struct GNUNET_HashCode *destinations;
+  const struct EdgeInfo *edges;
+  uint16_t num_destinations;
+  uint16_t num_edges;
+  size_t total;
+
+  if (block_len < sizeof(struct RegexBlock))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  num_destinations = ntohs (block->num_destinations);
+  num_edges = ntohs (block->num_edges);
+  len = ntohs (block->proof_len);
+  destinations = (const struct GNUNET_HashCode *) &block[1];
+  edges = (const struct EdgeInfo *) &destinations[num_destinations];
+  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
+                                                                GNUNET_HashCode)
+          + num_edges * sizeof(struct EdgeInfo) + len;
+  if (block_len < total)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CRYPTO_hash (&edges[num_edges], len, key);
+  return GNUNET_OK;
+}
+
+
+int
+REGEX_BLOCK_iterate (const struct RegexBlock *block,
+                     size_t size,
+                     REGEX_INTERNAL_EgdeIterator iterator,
+                     void *iter_cls)
+{
+  uint16_t len;
+  const struct GNUNET_HashCode *destinations;
+  const struct EdgeInfo *edges;
+  const char *aux;
+  uint16_t num_destinations;
+  uint16_t num_edges;
+  size_t total;
+  unsigned int n;
+  size_t off;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Block iterate\n");
+  if (size < sizeof(struct RegexBlock))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  num_destinations = ntohs (block->num_destinations);
+  num_edges = ntohs (block->num_edges);
+  len = ntohs (block->proof_len);
+  destinations = (const struct GNUNET_HashCode *) &block[1];
+  edges = (const struct EdgeInfo *) &destinations[num_destinations];
+  aux = (const char *) &edges[num_edges];
+  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
+                                                                GNUNET_HashCode)
+          + num_edges * sizeof(struct EdgeInfo) + len;
+  if (size < total)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  for (n = 0; n < num_edges; n++)
+    total += ntohs (edges[n].token_length);
+  if (size != total)
+  {
+    fprintf (stderr, "Expected %u, got %u\n",
+             (unsigned int) size,
+             (unsigned int) total);
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  off = len;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Start iterating block of size %lu, proof %u, off %lu edges %u\n",
+       (unsigned long) size, len, (unsigned long) off, n);
+  /* &aux[off] always points to our token */
+  for (n = 0; n < num_edges; n++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Edge %u/%u, off %lu tokenlen %u (%.*s)\n",
+         n + 1, num_edges, (unsigned long) off,
+         ntohs (edges[n].token_length), ntohs (edges[n].token_length),
+         &aux[off]);
+    if (NULL != iterator)
+      if (GNUNET_NO == iterator (iter_cls,
+                                 &aux[off],
+                                 ntohs (edges[n].token_length),
+                                 &destinations[ntohs (
+                                                 edges[n].destination_index)]))
+        return GNUNET_OK;
+    off += ntohs (edges[n].token_length);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Construct a regex block to be stored in the DHT.
+ *
+ * @param proof proof string for the block
+ * @param num_edges number of edges in the block
+ * @param edges the edges of the block
+ * @param accepting is this an accepting state
+ * @param rsize set to the size of the returned block (OUT-only)
+ * @return the regex block, NULL on error
+ */
+struct RegexBlock *
+REGEX_BLOCK_create (const char *proof,
+                    unsigned int num_edges,
+                    const struct REGEX_BLOCK_Edge *edges,
+                    int accepting,
+                    size_t *rsize)
+{
+  struct RegexBlock *block;
+  struct GNUNET_HashCode destinations[1024]; /* 1024 = 64k/64 bytes/key == absolute MAX */
+  uint16_t destination_indices[num_edges];
+  struct GNUNET_HashCode *dests;
+  struct EdgeInfo *edgeinfos;
+  size_t off;
+  size_t len;
+  size_t total;
+  size_t slen;
+  unsigned int unique_destinations;
+  unsigned int j;
+  unsigned int i;
+  char *aux;
+
+  len = strlen (proof);
+  if (len > UINT16_MAX)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  unique_destinations = 0;
+  total = sizeof(struct RegexBlock) + len;
+  for (i = 0; i < num_edges; i++)
+  {
+    slen = strlen (edges[i].label);
+    if (slen > UINT16_MAX)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+    total += slen;
+    for (j = 0; j < unique_destinations; j++)
+      if (0 == memcmp (&destinations[j],
+                       &edges[i].destination,
+                       sizeof(struct GNUNET_HashCode)))
+        break;
+    if (j >= 1024)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+    destination_indices[i] = j;
+    if (j == unique_destinations)
+      destinations[unique_destinations++] = edges[i].destination;
+  }
+  total += num_edges * sizeof(struct EdgeInfo) + unique_destinations
+           * sizeof(struct GNUNET_HashCode);
+  if (total >= GNUNET_CONSTANTS_MAX_BLOCK_SIZE)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  block = GNUNET_malloc (total);
+  block->proof_len = htons (len);
+  block->is_accepting = htons (accepting);
+  block->num_edges = htons (num_edges);
+  block->num_destinations = htons (unique_destinations);
+  dests = (struct GNUNET_HashCode *) &block[1];
+  GNUNET_memcpy (dests, destinations, sizeof(struct GNUNET_HashCode)
+                 * unique_destinations);
+  edgeinfos = (struct EdgeInfo *) &dests[unique_destinations];
+  aux = (char *) &edgeinfos[num_edges];
+  off = len;
+  GNUNET_memcpy (aux, proof, len);
+  for (i = 0; i < num_edges; i++)
+  {
+    slen = strlen (edges[i].label);
+    edgeinfos[i].token_length = htons ((uint16_t) slen);
+    edgeinfos[i].destination_index = htons (destination_indices[i]);
+    GNUNET_memcpy (&aux[off],
+                   edges[i].label,
+                   slen);
+    off += slen;
+  }
+  *rsize = total;
+  return block;
+}
+
+
+/* end of regex_block_lib.c */
diff --git a/src/plugin/regex/regex_block_lib.h b/src/plugin/regex/regex_block_lib.h
new file mode 100644
index 000000000..11029b9af
--- /dev/null
+++ b/src/plugin/regex/regex_block_lib.h
@@ -0,0 +1,193 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012,2013 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 Bartlomiej Polot
+ * @file regex/regex_block_lib.h
+ * @brief common function to manipulate blocks stored by regex in the DHT
+ */
+
+#ifndef REGEX_BLOCK_LIB_H_
+#define REGEX_BLOCK_LIB_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0
+/* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include "platform.h"
+#include "block_regex.h"
+
+
+/**
+ * Representation of a Regex node (and edges) in the DHT.
+ */
+struct RegexBlock;
+
+
+/**
+ * Edge representation.
+ */
+struct REGEX_BLOCK_Edge
+{
+  /**
+   * Label of the edge.  FIXME: might want to not consume exactly
+   * multiples of 8 bits, need length!
+   */
+  const char *label;
+
+  /**
+   * Destination of the edge.
+   */
+  struct GNUNET_HashCode destination;
+};
+
+
+/**
+ * Check if the given 'proof' matches the given 'key'.
+ *
+ * @param proof partial regex of a state
+ * @param proof_len number of bytes in @a proof
+ * @param key hash of a state.
+ * @return #GNUNET_OK if the proof is valid for the given key.
+ */
+int
+REGEX_BLOCK_check_proof (const char *proof,
+                         size_t proof_len,
+                         const struct GNUNET_HashCode *key);
+
+
+/**
+ * Check if the regex block is well formed, including all edges.
+ *
+ * @param block The start of the block.
+ * @param size The size of the @a block.
+ * @param query the query for the @a block
+ * @param xquery String describing the edge we are looking for.
+ *               Can be NULL in case this is a put block.
+ * @return #GNUNET_OK in case it's fine.
+ *         #GNUNET_NO in case the xquery exists and is not found (IRRELEVANT).
+ *         #GNUNET_SYSERR if the block is invalid.
+ */
+int
+REGEX_BLOCK_check (const struct RegexBlock *block,
+                   size_t size,
+                   const struct GNUNET_HashCode *query,
+                   const char *xquery);
+
+
+/* FIXME: might want to use 'struct REGEX_BLOCK_Edge' here instead of 3 arguments! */
+
+/**
+ * Iterator over edges in a block.
+ *
+ * @param cls Closure.
+ * @param token Token that follows to next state.
+ * @param len Length of token.
+ * @param key Hash of next state.
+ * @return #GNUNET_YES if should keep iterating, #GNUNET_NO otherwise.
+ */
+typedef int
+(*REGEX_INTERNAL_EgdeIterator)(void *cls,
+                               const char *token,
+                               size_t len,
+                               const struct GNUNET_HashCode *key);
+
+
+/**
+ * Iterate over all edges of a block of a regex state.
+ *
+ * @param block Block to iterate over.
+ * @param size Size of block.
+ * @param iterator Function to call on each edge in the block.
+ * @param iter_cls Closure for the @a iterator.
+ * @return #GNUNET_SYSERR if an error has been encountered.
+ *         #GNUNET_OK if no error has been encountered.
+ *           Note that if the iterator stops the iteration by returning
+ *         #GNUNET_NO, the block will no longer be checked for further errors.
+ *           The return value will be #GNUNET_OK meaning that no errors were
+ *         found until the edge last notified to the iterator, but there might
+ *         be errors in further edges.
+ */
+int
+REGEX_BLOCK_iterate (const struct RegexBlock *block,
+                     size_t size,
+                     REGEX_INTERNAL_EgdeIterator iterator,
+                     void *iter_cls);
+
+
+/**
+ * Obtain the key that a particular block is to be stored under.
+ *
+ * @param block block to get the key from
+ * @param block_len number of bytes in @a block
+ * @param key where to store the key
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the block is malformed
+ */
+int
+REGEX_BLOCK_get_key (const struct RegexBlock *block,
+                     size_t block_len,
+                     struct GNUNET_HashCode *key);
+
+
+/**
+ * Test if this block is marked as being an accept state.
+ *
+ * @param block block to test
+ * @param size number of bytes in block
+ * @return #GNUNET_YES if the block is accepting, #GNUNET_NO if not
+ */
+int
+GNUNET_BLOCK_is_accepting (const struct RegexBlock *block,
+                           size_t block_len);
+
+
+/**
+ * Construct a regex block to be stored in the DHT.
+ *
+ * @param proof proof string for the block
+ * @param num_edges number of edges in the block
+ * @param edges the edges of the block
+ * @param accepting is this an accepting state
+ * @param rsize set to the size of the returned block (OUT-only)
+ * @return the regex block, NULL on error
+ */
+struct RegexBlock *
+REGEX_BLOCK_create (const char *proof,
+                    unsigned int num_edges,
+                    const struct REGEX_BLOCK_Edge *edges,
+                    int accepting,
+                    size_t *rsize);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* ifndef REGEX_BLOCK_LIB_H */
+#endif
+/* end of regex_block_lib.h */
diff --git a/src/plugin/revocation/Makefile.am b/src/plugin/revocation/Makefile.am
index db6df02c9..99373f8d7 100644
--- a/src/plugin/revocation/Makefile.am
+++ b/src/plugin/revocation/Makefile.am
@@ -18,11 +18,10 @@ plugin_LTLIBRARIES = \
 libgnunet_plugin_block_revocation_la_SOURCES = \
   plugin_block_revocation.c
 libgnunet_plugin_block_revocation_la_LIBADD = \
-  $(top_builddir)/src/service/revocation/libgnunetrevocation.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
   $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
   $(top_builddir)/src/lib/block/libgnunetblock.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la  \
-  $(top_builddir)/src/service/identity/libgnunetidentity.la  \
   $(LTLIBINTL)
 libgnunet_plugin_block_revocation_la_LDFLAGS = \
  $(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/revocation/meson.build b/src/plugin/revocation/meson.build
index 7f8c8ec5e..c4405e9b8 100644
--- a/src/plugin/revocation/meson.build
+++ b/src/plugin/revocation/meson.build
@@ -1,8 +1,6 @@
 shared_module('gnunet_plugin_block_revocation',
               ['plugin_block_revocation.c'],
               dependencies: [libgnunetutil_dep,
-                             libgnunetidentity_dep,
-                             libgnunetrevocation_dep,
                              libgnunetblock_dep],
               include_directories: [incdir, configuration_inc],
               install: true,
diff --git a/src/plugin/revocation/plugin_block_revocation.c b/src/plugin/revocation/plugin_block_revocation.c
index 4c5991507..c4332184e 100644
--- a/src/plugin/revocation/plugin_block_revocation.c
+++ b/src/plugin/revocation/plugin_block_revocation.c
@@ -27,8 +27,8 @@
 #include "platform.h"
 #include "gnunet_signatures.h"
 #include "gnunet_block_plugin.h"
+#include "gnunet_gnsrecord_lib.h"
 #include "gnunet_block_group_lib.h"
-// FIXME try to avoid this include somehow
 #include "../../service/revocation/revocation.h"
 #include "gnunet_revocation_service.h"
 
@@ -93,8 +93,8 @@ block_plugin_revocation_check_block (void *cls,
 {
   struct InternalContext *ic = cls;
   const struct RevokeMessage *rm = block;
-  const struct GNUNET_REVOCATION_PowP *pow
-    = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
+  const struct GNUNET_GNSRECORD_PowP *pow
+    = (const struct GNUNET_GNSRECORD_PowP *) &rm[1];
   struct GNUNET_CRYPTO_PublicKey pk;
   size_t pklen;
   size_t left;
@@ -117,9 +117,9 @@ block_plugin_revocation_check_block (void *cls,
   left = block_size - sizeof (*rm) - sizeof (*pow);
   if (GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_public_key_from_buffer (&pow[1],
-                                                   left,
-                                                   &pk,
-                                                   &pklen))
+                                                 left,
+                                                 &pk,
+                                                 &pklen))
   {
     GNUNET_break_op (0);
     return GNUNET_NO;
@@ -130,9 +130,9 @@ block_plugin_revocation_check_block (void *cls,
     return GNUNET_NO;
   }
   if (GNUNET_YES !=
-      GNUNET_REVOCATION_check_pow (pow,
-                                   ic->matching_bits,
-                                   ic->epoch_duration))
+      GNUNET_GNSRECORD_check_pow (pow,
+                                  ic->matching_bits,
+                                  ic->epoch_duration))
   {
     GNUNET_break_op (0);
     return GNUNET_NO;
@@ -203,8 +203,8 @@ block_plugin_revocation_get_key (void *cls,
                                  struct GNUNET_HashCode *key)
 {
   const struct RevokeMessage *rm = block;
-  const struct GNUNET_REVOCATION_PowP *pow
-    = (const struct GNUNET_REVOCATION_PowP *) &rm[1];
+  const struct GNUNET_GNSRECORD_PowP *pow
+    = (const struct GNUNET_GNSRECORD_PowP *) &rm[1];
   struct GNUNET_CRYPTO_PublicKey pk;
   size_t pklen;
   size_t left;
@@ -226,9 +226,9 @@ block_plugin_revocation_get_key (void *cls,
   }
   left = block_size - sizeof (*rm) - sizeof (*pow);
   if (GNUNET_SYSERR == GNUNET_CRYPTO_read_public_key_from_buffer (&pow[1],
-                                                                    left,
-                                                                    &pk,
-                                                                    &pklen))
+                                                                  left,
+                                                                  &pk,
+                                                                  &pklen))
   {
     GNUNET_break_op (0);
     return GNUNET_NO;
diff --git a/src/plugin/seti/Makefile.am b/src/plugin/seti/Makefile.am
new file mode 100644
index 000000000..e6f579a65
--- /dev/null
+++ b/src/plugin/seti/Makefile.am
@@ -0,0 +1,25 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_seti_test.la
+
+libgnunet_plugin_block_seti_test_la_SOURCES = \
+  plugin_block_seti_test.c
+libgnunet_plugin_block_seti_test_la_LIBADD = \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_block_seti_test_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/seti/meson.build b/src/plugin/seti/meson.build
new file mode 100644
index 000000000..880936164
--- /dev/null
+++ b/src/plugin/seti/meson.build
@@ -0,0 +1,7 @@
+shared_module('gnunet_plugin_block_seti_test',
+              ['plugin_block_seti_test.c'],
+              dependencies: libgnunetutil_dep,
+              include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
+
diff --git a/src/plugin/seti/plugin_block_seti_test.c b/src/plugin/seti/plugin_block_seti_test.c
new file mode 100644
index 000000000..5b9196cef
--- /dev/null
+++ b/src/plugin/seti/plugin_block_seti_test.c
@@ -0,0 +1,197 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2017 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 seti/plugin_block_seti_test.c
+ * @brief set test block, recognizes elements with non-zero first byte as invalid
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param ctx block context
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_seti_test_check_query (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size)
+{
+  if (GNUNET_BLOCK_TYPE_SETI_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (0 != xquery_size)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_seti_test_check_block (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const void *block,
+                                    size_t block_size)
+{
+  (void) cls;
+  if (GNUNET_BLOCK_TYPE_SETI_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if ((NULL == block) ||
+      (0 == block_size) ||
+      (0 != ((char *) block)[0]))
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_seti_test_check_reply (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    struct GNUNET_BLOCK_Group *group,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size,
+                                    const void *reply_block,
+                                    size_t reply_block_size)
+{
+  (void) cls;
+  (void) xquery;
+  (void) xquery_size;
+  if (GNUNET_BLOCK_TYPE_SETI_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  }
+  if ( (NULL == reply_block) ||
+       (0 == reply_block_size) ||
+       (0 != ((char *) reply_block)[0]) )
+    GNUNET_assert (0);
+  return GNUNET_BLOCK_REPLY_OK_MORE;
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_seti_test_get_key (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const void *block,
+                                size_t block_size,
+                                struct GNUNET_HashCode *key)
+{
+  if (GNUNET_BLOCK_TYPE_SETI_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_seti_test_init (void *cls)
+{
+  static enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_SETI_TEST,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_seti_test_get_key;
+  api->check_query = &block_plugin_seti_test_check_query;
+  api->check_block = &block_plugin_seti_test_check_block;
+  api->check_reply = &block_plugin_seti_test_check_reply;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_seti_test_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_seti_test.c */
diff --git a/src/plugin/setu/Makefile.am b/src/plugin/setu/Makefile.am
new file mode 100644
index 000000000..90a14cce0
--- /dev/null
+++ b/src/plugin/setu/Makefile.am
@@ -0,0 +1,21 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_setu_test.la
+
+libgnunet_plugin_block_setu_test_la_SOURCES = \
+  plugin_block_setu_test.c
+libgnunet_plugin_block_setu_test_la_LIBADD = \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_block_setu_test_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
diff --git a/src/plugin/setu/meson.build b/src/plugin/setu/meson.build
new file mode 100644
index 000000000..e22738ab6
--- /dev/null
+++ b/src/plugin/setu/meson.build
@@ -0,0 +1,7 @@
+shared_module('gnunet_plugin_block_setu_test',
+              ['plugin_block_setu_test.c'],
+              dependencies: libgnunetutil_dep,
+              include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
+
diff --git a/src/plugin/setu/plugin_block_setu_test.c b/src/plugin/setu/plugin_block_setu_test.c
new file mode 100644
index 000000000..178ad3314
--- /dev/null
+++ b/src/plugin/setu/plugin_block_setu_test.c
@@ -0,0 +1,195 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2017 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 setu/plugin_block_setu_test.c
+ * @brief set test block, recognizes elements with non-zero first byte as invalid
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param ctx block context
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_setu_test_check_query (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size)
+{
+  if (GNUNET_BLOCK_TYPE_SETU_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (0 != xquery_size)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_setu_test_check_block (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const void *block,
+                                    size_t block_size)
+{
+  if (GNUNET_BLOCK_TYPE_SETU_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if ( (NULL == block) ||
+       (0 == block_size) ||
+       (0 != ((char *) block)[0]) )
+    return GNUNET_NO;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_setu_test_check_reply (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    struct GNUNET_BLOCK_Group *group,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size,
+                                    const void *reply_block,
+                                    size_t reply_block_size)
+{
+  (void) cls;
+  (void) xquery;
+  (void) xquery_size;
+  if (GNUNET_BLOCK_TYPE_SETU_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  }
+  if ( (NULL == reply_block) ||
+       (0 == reply_block_size) ||
+       (0 != ((char *) reply_block)[0]) )
+    GNUNET_assert (0);
+  return GNUNET_BLOCK_REPLY_OK_MORE;
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_setu_test_get_key (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const void *block,
+                                size_t block_size,
+                                struct GNUNET_HashCode *key)
+{
+  if (GNUNET_BLOCK_TYPE_SETU_TEST != type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_setu_test_init (void *cls)
+{
+  static enum GNUNET_BLOCK_Type types[] = {
+                                           GNUNET_BLOCK_TYPE_SETU_TEST,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_setu_test_get_key;
+  api->check_query = &block_plugin_setu_test_check_query;
+  api->check_block = &block_plugin_setu_test_check_block;
+  api->check_reply = &block_plugin_setu_test_check_reply;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_setu_test_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_setu_test.c */