36 files changed, 12796 insertions, 0 deletions

diff --git a/src/service/dht/.gitignore b/src/service/dht/.gitignore
new file mode 100644
index 000000000..939cf3f5f
--- /dev/null
+++ b/src/service/dht/.gitignore
@@ -0,0 +1,8 @@
+gnunet-service-dht
+test_dht_2dtorus
+test_dht_api
+test_dht_line
+test_dht_monitor
+test_dht_multipeer
+test_dht_tools.py
+test_dht_twopeer
diff --git a/src/service/dht/Makefile.am b/src/service/dht/Makefile.am
new file mode 100644
index 000000000..e16139650
--- /dev/null
+++ b/src/service/dht/Makefile.am
@@ -0,0 +1,77 @@
+# 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/
+
+pkgcfg_DATA = \
+  dht.conf
+
+dist_pkgcfg_DATA = \
+  dhtu.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = \
+ libgnunetdht.la
+
+libgnunetdht_la_SOURCES = \
+  dht_api.c dht.h
+libgnunetdht_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(XLIB) \
+  $(LTLIBINTL)
+libgnunetdht_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 4:0:0
+
+
+libexec_PROGRAMS = \
+ gnunet-service-dht
+
+gnunet_service_dht_SOURCES = \
+ gnunet-service-dht.c gnunet-service-dht.h \
+ plugin_dhtu_gnunet.h plugin_dhtu_ip.h \
+ plugin_dhtu_gnunet.c plugin_dhtu_ip.c \
+ gnunet-service-dht_datacache.c gnunet-service-dht_datacache.h \
+ gnunet-service-dht_neighbours.c gnunet-service-dht_neighbours.h \
+ gnunet-service-dht_routing.c gnunet-service-dht_routing.h
+gnunet_service_dht_LDADD = \
+  libgnunetdht.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/service/nse/libgnunetnse.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/service/transport/libgnunettransportapplication.la \
+  $(top_builddir)/src/service/datacache/libgnunetdatacache.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lm
+gnunet_service_dht_LDFLAGS = \
+  $(GN_LIBINTL)
+
+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;
+endif
+
+test_dht_api_SOURCES = \
+ test_dht_api.c
+test_dht_api_LDADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/hello/libgnunethello.la \
+ libgnunetdht.la
+
+EXTRA_DIST = \
+        gnunet-service-dht_clients.c \
+  dhtu_testbed_connect.sh \
+  dhtu_testbed_deploy.conf \
+  dhtu_testbed_deploy.sh
diff --git a/src/service/dht/dht.conf.in b/src/service/dht/dht.conf.in
new file mode 100644
index 000000000..405ef1917
--- /dev/null
+++ b/src/service/dht/dht.conf.in
@@ -0,0 +1,35 @@
+[dht]
+IMMEDIATE_START = YES
+START_ON_DEMAND = @START_ON_DEMAND@
+@JAVAPORT@PORT = 2095
+HOSTNAME = localhost
+BINARY = gnunet-service-dht
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+BUCKET_SIZE = 4
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-dht.sock
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+# DISABLE_SOCKET_FORWARDING = NO
+# USERNAME =
+# MAXBUF =
+# TIMEOUT =
+# DISABLEV6 =
+# BINDTO =
+# REJECT_FROM =
+# REJECT_FROM6 =
+# PREFIX =
+
+# Should the DHT cache results that we are routing in the DATACACHE as well?
+CACHE_RESULTS = YES
+
+# Special option to disable DHT calling 'try_connect' (for testing)
+DISABLE_TRY_CONNECT = NO
+
+
+[dhtcache]
+DATABASE = heap
+QUOTA = 50 MB
+
+# Disable RC-file for Bloom filter?  (for benchmarking with limited IO availability)
+DISABLE_BF_RC = NO
diff --git a/src/service/dht/dht.h b/src/service/dht/dht.h
new file mode 100644
index 000000000..6a137defe
--- /dev/null
+++ b/src/service/dht/dht.h
@@ -0,0 +1,427 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001, 2002, 2003, 2004, 2009, 2011, 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
+ * @author Nathan Evans
+ * @file dht/dht.h
+ */
+
+#ifndef DHT_H
+#define DHT_H
+
+
+/**
+ * Size of the bloom filter the DHT uses to filter peers.
+ */
+#define DHT_BLOOM_SIZE 128
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message which indicates the DHT should cancel outstanding
+ * requests and discard any state.
+ */
+struct GNUNET_DHT_ClientGetStopMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Unique ID identifying this request
+   */
+  uint64_t unique_id GNUNET_PACKED;
+
+  /**
+   * Key of this request
+   */
+  struct GNUNET_HashCode key;
+};
+
+
+/**
+ * DHT GET message sent from clients to service. Indicates that a GET
+ * request should be issued.
+ */
+struct GNUNET_DHT_ClientGetMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * Replication level for this message
+   */
+  uint32_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * The type for the data for the GET request; actually an 'enum
+   * GNUNET_BLOCK_Type'.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * The key to search for
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /**
+   * Unique ID identifying this request, if 0 then
+   * the client will not expect a response
+   */
+  uint64_t unique_id GNUNET_PACKED;
+
+  /* Possibly followed by xquery, copied to end of this dealy do */
+};
+
+
+/**
+ * DHT GET RESULTS KNOWN message sent from clients to service. Indicates that a GET
+ * request should exclude certain results which are already known.
+ */
+struct GNUNET_DHT_ClientGetResultSeenMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Reserved, always 0.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * The key we are searching for (to make it easy to find the corresponding
+   * GET inside the service).
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /**
+   * Unique ID identifying this request.
+   */
+  uint64_t unique_id GNUNET_PACKED;
+
+  /* Followed by an array of the hash codes of known results */
+};
+
+
+/**
+ * Reply to a GET send from the service to a client.
+ */
+struct GNUNET_DHT_ClientResultMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * The type for the data.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Reserved, always 0.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * Number of peers recorded in the outgoing path from source to the
+   * storgage location of this message.
+   */
+  uint32_t put_path_length GNUNET_PACKED;
+
+  /**
+   * The number of peer identities recorded from the storage location
+   * to this peer.
+   */
+  uint32_t get_path_length GNUNET_PACKED;
+
+  /**
+   * Unique ID of the matching GET request.
+   */
+  uint64_t unique_id GNUNET_PACKED;
+
+  /**
+   * When does this entry expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration;
+
+  /**
+   * The key that was searched for
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /* trunc_peer, put path, get path and actual data are copied to end of this dealy do */
+};
+
+
+/**
+ * Message to insert data into the DHT, sent from clients to DHT service.
+ */
+struct GNUNET_DHT_ClientPutMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * The type of data to insert.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * Replication level for this message
+   */
+  uint32_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * How long should this data persist?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration;
+
+  /**
+   * The key to store the value under.
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /* DATA copied to end of this message */
+};
+
+
+/**
+ * Message to monitor put requests going through peer, DHT service -> clients.
+ */
+struct GNUNET_DHT_MonitorPutMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * The type of data in the request.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Hop count so far.
+   */
+  uint32_t hop_count GNUNET_PACKED;
+
+  /**
+   * Replication level for this message
+   */
+  uint32_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * Number of peers recorded in the outgoing path from source to the
+   * storage location of this message.
+   */
+  uint32_t put_path_length GNUNET_PACKED;
+
+  /**
+   * How long should this data persist?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The key to store the value under.
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /* put path (if tracked) */
+
+  /* Payload */
+};
+
+
+/**
+ * Message to request monitoring messages, clients -> DHT service.
+ */
+struct GNUNET_DHT_MonitorStartStopMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_MONITOR_START or
+   * #GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * The type of data desired, GNUNET_BLOCK_TYPE_ANY for all.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Flag whether to notify about GET messages.
+   */
+  int16_t get GNUNET_PACKED;
+
+  /**
+   * Flag whether to notify about GET_REPONSE messages.
+   */
+  int16_t get_resp GNUNET_PACKED;
+
+  /**
+   * Flag whether to notify about PUT messages.
+   */
+  int16_t put GNUNET_PACKED;
+
+  /**
+   * Flag whether to use the provided key to filter messages.
+   */
+  int16_t filter_key GNUNET_PACKED;
+
+  /**
+   * The key to filter messages by.
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+};
+
+
+/**
+ * Message to monitor get requests going through peer, DHT service -> clients.
+ */
+struct GNUNET_DHT_MonitorGetMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * The type of data in the request.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Hop count
+   */
+  uint32_t hop_count GNUNET_PACKED;
+
+  /**
+   * Replication level for this message
+   */
+  uint32_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * The key to store the value under.
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /* get path (if tracked) */
+};
+
+/**
+ * Message to monitor get results going through peer, DHT service -> clients.
+ */
+struct GNUNET_DHT_MonitorGetRespMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Content type.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Reserved, always 0.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
+   */
+  uint32_t options GNUNET_PACKED;
+
+  /**
+   * Length of the PUT path that follows (if tracked).
+   */
+  uint32_t put_path_length GNUNET_PACKED;
+
+  /**
+   * Length of the GET path that follows (if tracked).
+   */
+  uint32_t get_path_length GNUNET_PACKED;
+
+  /**
+   * When does the content expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The key of the corresponding GET request.
+   */
+  struct GNUNET_HashCode key GNUNET_PACKED;
+
+  /* put path (if tracked) */
+
+  /* get path (if tracked) */
+
+  /* Payload */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/service/dht/dht_api.c b/src/service/dht/dht_api.c
new file mode 100644
index 000000000..6a218e29d
--- /dev/null
+++ b/src/service/dht/dht_api.c
@@ -0,0 +1,1501 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2012, 2016, 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 dht/dht_api.c
+ * @brief library to access the DHT service
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+
+#include "platform.h"
+#include "gnunet_constants.h"
+#include "gnunet_signatures.h"
+#include "gnunet_arm_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_dht_service.h"
+#include "dht.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "dht-api", __VA_ARGS__)
+
+
+/**
+ * Handle to a PUT request.
+ */
+struct GNUNET_DHT_PutHandle
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_DHT_PutHandle *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_DHT_PutHandle *prev;
+
+  /**
+   * Continuation to call when done.
+   */
+  GNUNET_SCHEDULER_TaskCallback cont;
+
+  /**
+   * Main handle to this DHT api
+   */
+  struct GNUNET_DHT_Handle *dht_handle;
+
+  /**
+   * Closure for @e cont.
+   */
+  void *cont_cls;
+
+  /**
+   * Envelope from the PUT operation.
+   */
+  struct GNUNET_MQ_Envelope *env;
+};
+
+/**
+ * Handle to a GET request
+ */
+struct GNUNET_DHT_GetHandle
+{
+  /**
+   * Iterator to call on data receipt
+   */
+  GNUNET_DHT_GetIterator iter;
+
+  /**
+   * Closure for @e iter.
+   */
+  void *iter_cls;
+
+  /**
+   * Main handle to this DHT api
+   */
+  struct GNUNET_DHT_Handle *dht_handle;
+
+  /**
+   * Array of hash codes over the results that we have already
+   * seen.
+   */
+  struct GNUNET_HashCode *seen_results;
+
+  /**
+   * Key that this get request is for
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint64_t unique_id;
+
+  /**
+   * Size of the extended query, allocated at the end of this struct.
+   */
+  size_t xquery_size;
+
+  /**
+   * Desired replication level.
+   */
+  uint32_t desired_replication_level;
+
+  /**
+   * Type of the block we are looking for.
+   */
+  enum GNUNET_BLOCK_Type type;
+
+  /**
+   * Routing options.
+   */
+  enum GNUNET_DHT_RouteOption options;
+
+  /**
+   * Size of the @e seen_results array.  Note that not
+   * all positions might be used (as we over-allocate).
+   */
+  unsigned int seen_results_size;
+
+  /**
+   * Offset into the @e seen_results array marking the
+   * end of the positions that are actually used.
+   */
+  unsigned int seen_results_end;
+};
+
+
+/**
+ * Handle to a monitoring request.
+ */
+struct GNUNET_DHT_MonitorHandle
+{
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_MonitorHandle *next;
+
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_MonitorHandle *prev;
+
+  /**
+   * Main handle to this DHT api.
+   */
+  struct GNUNET_DHT_Handle *dht_handle;
+
+  /**
+   * Type of block looked for.
+   */
+  enum GNUNET_BLOCK_Type type;
+
+  /**
+   * Key being looked for, NULL == all.
+   */
+  struct GNUNET_HashCode *key;
+
+  /**
+   * Callback for each received message of type get.
+   */
+  GNUNET_DHT_MonitorGetCB get_cb;
+
+  /**
+   * Callback for each received message of type get response.
+   */
+  GNUNET_DHT_MonitorGetRespCB get_resp_cb;
+
+  /**
+   * Callback for each received message of type put.
+   */
+  GNUNET_DHT_MonitorPutCB put_cb;
+
+  /**
+   * Closure for @e get_cb, @e put_cb and @e get_resp_cb.
+   */
+  void *cb_cls;
+};
+
+
+/**
+ * Handle to get a HELLO URL from the DHT for manual bootstrapping.
+ */
+struct GNUNET_DHT_HelloGetHandle
+{
+
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_HelloGetHandle *next;
+
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_HelloGetHandle *prev;
+
+  /**
+   * Function to call with the result.
+   */
+  GNUNET_DHT_HelloGetCallback cb;
+
+  /**
+   * Closure for @a cb.
+   */
+  void *cb_cls;
+
+  /**
+   * Connection to the DHT service.
+   */
+  struct GNUNET_DHT_Handle *dht_handle;
+
+};
+
+
+/**
+ * Connection to the DHT service.
+ */
+struct GNUNET_DHT_Handle
+{
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Connection to DHT service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Head of linked list of messages we would like to monitor.
+   */
+  struct GNUNET_DHT_MonitorHandle *monitor_head;
+
+  /**
+   * Tail of linked list of messages we would like to monitor.
+   */
+  struct GNUNET_DHT_MonitorHandle *monitor_tail;
+
+  /**
+   * Head of active PUT requests.
+   */
+  struct GNUNET_DHT_PutHandle *put_head;
+
+  /**
+   * Tail of active PUT requests.
+   */
+  struct GNUNET_DHT_PutHandle *put_tail;
+
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_HelloGetHandle *hgh_head;
+
+  /**
+   * DLL.
+   */
+  struct GNUNET_DHT_HelloGetHandle *hgh_tail;
+
+  /**
+   * Hash map containing the current outstanding unique GET requests
+   * (values are of type `struct GNUNET_DHT_GetHandle`).
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *active_requests;
+
+  /**
+   * Task for trying to reconnect.
+   */
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  /**
+   * How quickly should we retry?  Used for exponential back-off on
+   * connect-errors.
+   */
+  struct GNUNET_TIME_Relative retry_time;
+
+  /**
+   * Generator for unique ids.
+   */
+  uint64_t uid_gen;
+};
+
+
+/**
+ * Try to (re)connect to the DHT service.
+ *
+ * @param h DHT handle to reconnect
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
+ */
+static enum GNUNET_GenericReturnValue
+try_connect (struct GNUNET_DHT_Handle *h);
+
+
+/**
+ * Send GET message for a @a get_handle to DHT.
+ *
+ * @param gh GET to generate messages for.
+ */
+static void
+send_get (struct GNUNET_DHT_GetHandle *gh)
+{
+  struct GNUNET_DHT_Handle *h = gh->dht_handle;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_ClientGetMessage *get_msg;
+
+  env = GNUNET_MQ_msg_extra (get_msg,
+                             gh->xquery_size,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);
+  get_msg->options = htonl ((uint32_t) gh->options);
+  get_msg->desired_replication_level = htonl (gh->desired_replication_level);
+  get_msg->type = htonl (gh->type);
+  get_msg->key = gh->key;
+  get_msg->unique_id = gh->unique_id;
+  GNUNET_memcpy (&get_msg[1],
+                 &gh[1],
+                 gh->xquery_size);
+  GNUNET_MQ_send (h->mq,
+                  env);
+}
+
+
+/**
+ * Send GET message(s) for indicating which results are already known
+ * for a @a get_handle to DHT.  Complex as we need to send the list of
+ * known results, which means we may need multiple messages to block
+ * known results from the result set.
+ *
+ * @param gh GET to generate messages for
+ * @param transmission_offset_start at which offset should we start?
+ */
+static void
+send_get_known_results (struct GNUNET_DHT_GetHandle *gh,
+                        unsigned int transmission_offset_start)
+{
+  struct GNUNET_DHT_Handle *h = gh->dht_handle;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_ClientGetResultSeenMessage *msg;
+  unsigned int delta;
+  unsigned int max;
+  unsigned int transmission_offset;
+
+  max = (GNUNET_MAX_MESSAGE_SIZE - sizeof(*msg))
+        / sizeof(struct GNUNET_HashCode);
+  transmission_offset = transmission_offset_start;
+  while (transmission_offset < gh->seen_results_end)
+  {
+    delta = gh->seen_results_end - transmission_offset;
+    if (delta > max)
+      delta = max;
+    env = GNUNET_MQ_msg_extra (msg,
+                               delta * sizeof(struct GNUNET_HashCode),
+                               GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN);
+    msg->key = gh->key;
+    msg->unique_id = gh->unique_id;
+    GNUNET_memcpy (&msg[1],
+                   &gh->seen_results[transmission_offset],
+                   sizeof(struct GNUNET_HashCode) * delta);
+    GNUNET_MQ_send (h->mq,
+                    env);
+    transmission_offset += delta;
+  }
+}
+
+
+/**
+ * Add the GET request corresponding to the given route handle
+ * to the pending queue (if it is not already in there).
+ *
+ * @param cls the `struct GNUNET_DHT_Handle *`
+ * @param key key for the request (not used)
+ * @param value the `struct GNUNET_DHT_GetHandle *`
+ * @return #GNUNET_YES (always)
+ */
+static enum GNUNET_GenericReturnValue
+add_get_request_to_pending (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            void *value)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+  struct GNUNET_DHT_GetHandle *gh = value;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Retransmitting request related to %s to DHT %p\n",
+       GNUNET_h2s (key),
+       handle);
+  send_get (gh);
+  send_get_known_results (gh, 0);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Send #GNUNET_MESSAGE_TYPE_DHT_MONITOR_START message.
+ *
+ * @param mh monitor handle to generate start message for
+ */
+static void
+send_monitor_start (struct GNUNET_DHT_MonitorHandle *mh)
+{
+  struct GNUNET_DHT_Handle *h = mh->dht_handle;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_MonitorStartStopMessage *m;
+
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_START);
+  m->type = htonl (mh->type);
+  m->get = htons (NULL != mh->get_cb);
+  m->get_resp = htons (NULL != mh->get_resp_cb);
+  m->put = htons (NULL != mh->put_cb);
+  if (NULL != mh->key)
+  {
+    m->filter_key = htons (1);
+    m->key = *mh->key;
+  }
+  GNUNET_MQ_send (h->mq,
+                  env);
+}
+
+
+/**
+ * Try reconnecting to the dht service.
+ *
+ * @param cls a `struct GNUNET_DHT_Handle`
+ */
+static void
+try_reconnect (void *cls)
+{
+  struct GNUNET_DHT_Handle *h = cls;
+  struct GNUNET_DHT_MonitorHandle *mh;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Reconnecting with DHT %p\n",
+       h);
+  h->retry_time = GNUNET_TIME_STD_BACKOFF (h->retry_time);
+  h->reconnect_task = NULL;
+  if (GNUNET_YES != try_connect (h))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "DHT reconnect failed!\n");
+    h->reconnect_task
+      = GNUNET_SCHEDULER_add_delayed (h->retry_time,
+                                      &try_reconnect,
+                                      h);
+    return;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (h->active_requests,
+                                         &add_get_request_to_pending,
+                                         h);
+  for (mh = h->monitor_head; NULL != mh; mh = mh->next)
+    send_monitor_start (mh);
+}
+
+
+/**
+ * Try reconnecting to the DHT service.
+ *
+ * @param h handle to dht to (possibly) disconnect and reconnect
+ */
+static void
+do_disconnect (struct GNUNET_DHT_Handle *h)
+{
+  struct GNUNET_DHT_PutHandle *ph;
+  GNUNET_SCHEDULER_TaskCallback cont;
+  void *cont_cls;
+
+  if (NULL == h->mq)
+    return;
+  GNUNET_MQ_destroy (h->mq);
+  h->mq = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting from DHT service, will try to reconnect in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (h->retry_time,
+                                                      GNUNET_YES));
+  /* notify client about all PUTs that (may) have failed due to disconnect */
+  while (NULL != (ph = h->put_head))
+  {
+    cont = ph->cont;
+    cont_cls = ph->cont_cls;
+    ph->env = NULL;
+    GNUNET_DHT_put_cancel (ph);
+    if (NULL != cont)
+      cont (cont_cls);
+  }
+  GNUNET_assert (NULL == h->reconnect_task);
+  h->reconnect_task
+    = GNUNET_SCHEDULER_add_delayed (h->retry_time,
+                                    &try_reconnect,
+                                    h);
+}
+
+
+/**
+ * Generic error handler, called with the appropriate error code and
+ * the same closure specified at the creation of the message queue.
+ * Not every message queue implementation supports an error handler.
+ *
+ * @param cls closure with the `struct GNUNET_DHT_Handle *`
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_DHT_Handle *h = cls;
+
+  do_disconnect (h);
+}
+
+
+/**
+ * Process a get monitor message from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg Monitor get message from the service.
+ */
+static void
+handle_monitor_get (void *cls,
+                    const struct GNUNET_DHT_MonitorGetMessage *msg)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+
+  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
+       NULL != mh;
+       mh = mh->next)
+  {
+    if (NULL == mh->get_cb)
+      continue;
+    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
+         (mh->type != ntohl (msg->type)))
+      continue;
+    if ( (NULL != mh->key) &&
+         (0 != GNUNET_memcmp (mh->key,
+                              &msg->key)) )
+      continue;
+    mh->get_cb (mh->cb_cls,
+                ro,
+                (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                ntohl (msg->hop_count),
+                ntohl (msg->desired_replication_level),
+                &msg->key);
+  }
+}
+
+
+/**
+ * Validate a get response monitor message from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg monitor get response message from the service
+ * @return #GNUNET_OK if everything went fine,
+ *         #GNUNET_SYSERR if the message is malformed.
+ */
+static enum GNUNET_GenericReturnValue
+check_monitor_get_resp (void *cls,
+                        const struct GNUNET_DHT_MonitorGetRespMessage *msg)
+{
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t getl = ntohl (msg->get_path_length);
+  uint32_t putl = ntohl (msg->put_path_length);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+
+  if (truncated)
+  {
+    if (msize < sizeof (struct GNUNET_PeerIdentity))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    msize -= sizeof (struct GNUNET_PeerIdentity);
+  }
+  if ((getl + putl < getl) ||
+      ((msize / sizeof(struct GNUNET_DHT_PathElement)) < getl + putl))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Process a get response monitor message from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg monitor get response message from the service
+ */
+static void
+handle_monitor_get_resp (void *cls,
+                         const struct GNUNET_DHT_MonitorGetRespMessage *msg)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+  uint32_t getl = ntohl (msg->get_path_length);
+  uint32_t putl = ntohl (msg->put_path_length);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? (const struct GNUNET_PeerIdentity *) &msg[1]
+    : NULL;
+  const struct GNUNET_DHT_PathElement *path
+    = truncated
+    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
+    : (const struct GNUNET_DHT_PathElement *) &msg[1];
+
+  if (truncated)
+    msize -= sizeof (struct GNUNET_PeerIdentity);
+  msize -= sizeof(struct GNUNET_DHT_PathElement) * (putl + getl);
+  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
+       NULL != mh;
+       mh = mh->next)
+  {
+    if (NULL == mh->get_resp_cb)
+      continue;
+    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
+         (mh->type != ntohl (msg->type)) )
+      continue;
+    if ( (NULL != mh->key) &&
+         (0 != GNUNET_memcmp (mh->key,
+                              &msg->key)) )
+      continue;
+    mh->get_resp_cb (mh->cb_cls,
+                     (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                     trunc_peer,
+                     &path[putl],
+                     getl,
+                     path,
+                     putl,
+                     GNUNET_TIME_absolute_ntoh (msg->expiration_time),
+                     &msg->key,
+                     (const void *) &path[getl + putl],
+                     msize);
+  }
+}
+
+
+/**
+ * Check validity of a put monitor message from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg Monitor put message from the service.
+ * @return #GNUNET_OK if everything went fine,
+ *         #GNUNET_SYSERR if the message is malformed.
+ */
+static enum GNUNET_GenericReturnValue
+check_monitor_put (void *cls,
+                   const struct GNUNET_DHT_MonitorPutMessage *msg)
+{
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t putl = ntohl (msg->put_path_length);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+
+  if (truncated)
+  {
+    if (msize < sizeof (struct GNUNET_PeerIdentity))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    msize -= sizeof (struct GNUNET_PeerIdentity);
+  }
+  if ((msize / sizeof(struct GNUNET_DHT_PathElement)) < putl)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Process a put monitor message from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg Monitor put message from the service.
+ */
+static void
+handle_monitor_put (void *cls,
+                    const struct GNUNET_DHT_MonitorPutMessage *msg)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t putl = ntohl (msg->put_path_length);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? (const struct GNUNET_PeerIdentity *) &msg[1]
+    : NULL;
+  const struct GNUNET_DHT_PathElement *path
+    = truncated
+    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
+    : (const struct GNUNET_DHT_PathElement *) &msg[1];
+
+  if (truncated)
+    msize -= sizeof (struct GNUNET_PeerIdentity);
+  msize -= sizeof(struct GNUNET_DHT_PathElement) * putl;
+  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
+       NULL != mh;
+       mh = mh->next)
+  {
+    if (NULL == mh->put_cb)
+      continue;
+    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
+         (mh->type != ntohl (msg->type)) )
+      continue;
+    if ( (NULL != mh->key) &&
+         (0 != GNUNET_memcmp (mh->key,
+                              &msg->key)) )
+      continue;
+    mh->put_cb (mh->cb_cls,
+                ro,
+                (enum GNUNET_BLOCK_Type) ntohl (msg->type),
+                ntohl (msg->hop_count),
+                ntohl (msg->desired_replication_level),
+                trunc_peer,
+                putl,
+                path,
+                GNUNET_TIME_absolute_ntoh (msg->expiration_time),
+                &msg->key,
+                (const void *) &path[putl],
+                msize);
+  }
+}
+
+
+/**
+ * Verify that client result  message received from the service is well-formed.
+ *
+ * @param cls The DHT handle.
+ * @param msg Monitor put message from the service.
+ * @return #GNUNET_OK if everything went fine,
+ *         #GNUNET_SYSERR if the message is malformed.
+ */
+static enum GNUNET_GenericReturnValue
+check_client_result (void *cls,
+                     const struct GNUNET_DHT_ClientResultMessage *msg)
+{
+  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
+  uint32_t put_path_length = ntohl (msg->put_path_length);
+  uint32_t get_path_length = ntohl (msg->get_path_length);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (msg->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  size_t meta_length;
+
+  if (truncated)
+  {
+    if (msize < sizeof (struct GNUNET_PeerIdentity))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    msize -= sizeof (struct GNUNET_PeerIdentity);
+  }
+  meta_length = msize / sizeof(struct GNUNET_DHT_PathElement);
+  if ( (get_path_length + put_path_length >
+        meta_length) ||
+       (get_path_length + put_path_length <
+        get_path_length) )
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Process a given reply that might match the given request.
+ *
+ * @param cls the `struct GNUNET_DHT_ClientResultMessage`
+ * @param key query of the request
+ * @param value the `struct GNUNET_DHT_GetHandle` of a request matching the same key
+ * @return #GNUNET_YES to continue to iterate over all results
+ */
+static enum GNUNET_GenericReturnValue
+process_client_result (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
+{
+  const struct GNUNET_DHT_ClientResultMessage *crm = cls;
+  struct GNUNET_DHT_GetHandle *get_handle = value;
+  size_t msize = ntohs (crm->header.size) - sizeof(*crm);
+  uint16_t type = ntohl (crm->type);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohl (crm->options);
+  bool truncated
+    = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  uint32_t put_path_length
+    = ntohl (crm->put_path_length);
+  uint32_t get_path_length
+    = ntohl (crm->get_path_length);
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? (const struct GNUNET_PeerIdentity *) &crm[1]
+    : NULL;
+  const struct GNUNET_DHT_PathElement *put_path
+    = truncated
+    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
+    : (const struct GNUNET_DHT_PathElement *) &crm[1];
+  const struct GNUNET_DHT_PathElement *get_path
+    = &put_path[put_path_length];
+  const void *data
+    = &get_path[get_path_length];
+  size_t meta_length
+    = sizeof(struct GNUNET_DHT_PathElement)
+      * (get_path_length + put_path_length);
+  size_t data_length
+    = msize - meta_length;
+  struct GNUNET_HashCode hc;
+
+  if (truncated)
+    data_length -= sizeof (struct GNUNET_PeerIdentity);
+  if (crm->unique_id != get_handle->unique_id)
+  {
+    /* UID mismatch */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Ignoring reply for %s: UID mismatch: %llu/%llu\n",
+         GNUNET_h2s (key),
+         (unsigned long long) crm->unique_id,
+         (unsigned long long) get_handle->unique_id);
+    return GNUNET_YES;
+  }
+  if ( (get_handle->type != GNUNET_BLOCK_TYPE_ANY) &&
+       (get_handle->type != type) )
+  {
+    /* type mismatch */
+    GNUNET_break (0);
+    return GNUNET_YES;
+  }
+
+  {
+    char *pp;
+    char *gp;
+
+    gp = GNUNET_DHT_pp2s (get_path,
+                          get_path_length);
+    pp = GNUNET_DHT_pp2s (put_path,
+                          put_path_length);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Giving %u byte reply for %s to application (GP: %s, PP: %s)\n",
+         (unsigned int) data_length,
+         GNUNET_h2s (key),
+         gp,
+         pp);
+    GNUNET_free (gp);
+    GNUNET_free (pp);
+  }
+  /* remember that we've seen this result */
+  GNUNET_CRYPTO_hash (data,
+                      data_length,
+                      &hc);
+  if (get_handle->seen_results_size == get_handle->seen_results_end)
+    GNUNET_array_grow (get_handle->seen_results,
+                       get_handle->seen_results_size,
+                       get_handle->seen_results_size * 2 + 1);
+  get_handle->seen_results[get_handle->seen_results_end++] = hc;
+  /* no need to block it explicitly, service already knows about it! */
+  get_handle->iter (get_handle->iter_cls,
+                    GNUNET_TIME_absolute_ntoh (crm->expiration),
+                    key,
+                    trunc_peer,
+                    get_path,
+                    get_path_length,
+                    put_path,
+                    put_path_length,
+                    type,
+                    data_length,
+                    data);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Process a client result  message received from the service.
+ *
+ * @param cls The DHT handle.
+ * @param msg Monitor put message from the service.
+ */
+static void
+handle_client_result (void *cls,
+                      const struct GNUNET_DHT_ClientResultMessage *msg)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests,
+                                              &msg->key,
+                                              &process_client_result,
+                                              (void *) msg);
+}
+
+
+/**
+ * Process a client HELLO message received from the service.
+ *
+ * @param cls The DHT handle.
+ * @param hdr HELLO URL message from the service.
+ * @return #GNUNET_OK if @a hdr is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_client_hello (void *cls,
+                    const struct GNUNET_MessageHeader *hdr)
+{
+  uint16_t len = ntohs (hdr->size);
+  const char *buf = (const char *) &hdr[1];
+
+  (void) cls;
+  if ('\0' != buf[len - sizeof (*hdr) - 1])
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Process a client HELLO message received from the service.
+ *
+ * @param cls The DHT handle.
+ * @param hdr HELLO URL message from the service.
+ */
+static void
+handle_client_hello (void *cls,
+                     const struct GNUNET_MessageHeader *hdr)
+{
+  struct GNUNET_DHT_Handle *handle = cls;
+  const char *url = (const char *) &hdr[1];
+  struct GNUNET_DHT_HelloGetHandle *hgh;
+
+  while (NULL != (hgh = handle->hgh_head))
+  {
+    hgh->cb (hgh->cb_cls,
+             url);
+    GNUNET_DHT_hello_get_cancel (hgh);
+  }
+}
+
+
+/**
+ * Process a MQ PUT transmission notification.
+ *
+ * @param cls The DHT handle.
+ */
+static void
+handle_put_cont (void *cls)
+{
+  struct GNUNET_DHT_PutHandle *ph = cls;
+  GNUNET_SCHEDULER_TaskCallback cont;
+  void *cont_cls;
+
+  cont = ph->cont;
+  cont_cls = ph->cont_cls;
+  ph->env = NULL;
+  GNUNET_DHT_put_cancel (ph);
+  if (NULL != cont)
+    cont (cont_cls);
+}
+
+
+/**
+ * Try to (re)connect to the DHT service.
+ *
+ * @param h DHT handle to reconnect
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
+ */
+static enum GNUNET_GenericReturnValue
+try_connect (struct GNUNET_DHT_Handle *h)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (monitor_get,
+                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET,
+                             struct GNUNET_DHT_MonitorGetMessage,
+                             h),
+    GNUNET_MQ_hd_var_size (monitor_get_resp,
+                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP,
+                           struct GNUNET_DHT_MonitorGetRespMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (monitor_put,
+                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT,
+                           struct GNUNET_DHT_MonitorPutMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (client_result,
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT,
+                           struct GNUNET_DHT_ClientResultMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (client_hello,
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL,
+                           struct GNUNET_MessageHeader,
+                           h),
+    GNUNET_MQ_handler_end ()
+  };
+
+  if (NULL != h->mq)
+    return GNUNET_OK;
+  h->mq = GNUNET_CLIENT_connect (h->cfg,
+                                 "dht",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL == h->mq)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Failed to connect to the DHT service!\n");
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+struct GNUNET_DHT_Handle *
+GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                    unsigned int ht_len)
+{
+  struct GNUNET_DHT_Handle *handle;
+
+  handle = GNUNET_new (struct GNUNET_DHT_Handle);
+  handle->cfg = cfg;
+  handle->uid_gen
+    = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                UINT64_MAX);
+  handle->active_requests
+    = GNUNET_CONTAINER_multihashmap_create (ht_len,
+                                            GNUNET_YES);
+  if (GNUNET_NO == try_connect (handle))
+  {
+    GNUNET_DHT_disconnect (handle);
+    return NULL;
+  }
+  return handle;
+}
+
+
+void
+GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
+{
+  struct GNUNET_DHT_PutHandle *ph;
+
+  GNUNET_assert (0 ==
+                 GNUNET_CONTAINER_multihashmap_size (handle->active_requests));
+  while (NULL != (ph = handle->put_head))
+  {
+    if (NULL != ph->cont)
+      ph->cont (ph->cont_cls);
+    GNUNET_DHT_put_cancel (ph);
+  }
+  if (NULL != handle->mq)
+  {
+    GNUNET_MQ_destroy (handle->mq);
+    handle->mq = NULL;
+  }
+  if (NULL != handle->reconnect_task)
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
+  GNUNET_free (handle);
+}
+
+
+struct GNUNET_DHT_PutHandle *
+GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
+                const struct GNUNET_HashCode *key,
+                uint32_t desired_replication_level,
+                enum GNUNET_DHT_RouteOption options,
+                enum GNUNET_BLOCK_Type type,
+                size_t size,
+                const void *data,
+                struct GNUNET_TIME_Absolute exp,
+                GNUNET_SCHEDULER_TaskCallback cont,
+                void *cont_cls)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_ClientPutMessage *put_msg;
+  size_t msize;
+  struct GNUNET_DHT_PutHandle *ph;
+
+  msize = sizeof(struct GNUNET_DHT_ClientPutMessage) + size;
+  if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
+      (size >= GNUNET_MAX_MESSAGE_SIZE))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  if (NULL == handle->mq)
+    return NULL;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending PUT for %s to DHT via %p\n",
+       GNUNET_h2s (key),
+       handle);
+  ph = GNUNET_new (struct GNUNET_DHT_PutHandle);
+  ph->dht_handle = handle;
+  ph->cont = cont;
+  ph->cont_cls = cont_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (handle->put_head,
+                                    handle->put_tail,
+                                    ph);
+  env = GNUNET_MQ_msg_extra (put_msg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);
+  GNUNET_MQ_notify_sent (env,
+                         &handle_put_cont,
+                         ph);
+  ph->env = env;
+  put_msg->type = htonl ((uint32_t) type);
+  put_msg->options = htonl ((uint32_t) options);
+  put_msg->desired_replication_level = htonl (desired_replication_level);
+  put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
+  put_msg->key = *key;
+  GNUNET_memcpy (&put_msg[1],
+                 data,
+                 size);
+  GNUNET_MQ_send (handle->mq,
+                  env);
+  return ph;
+}
+
+
+void
+GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph)
+{
+  struct GNUNET_DHT_Handle *handle = ph->dht_handle;
+
+  if (NULL != ph->env)
+    GNUNET_MQ_notify_sent (ph->env,
+                           NULL,
+                           NULL);
+  GNUNET_CONTAINER_DLL_remove (handle->put_head,
+                               handle->put_tail,
+                               ph);
+  GNUNET_free (ph);
+}
+
+
+struct GNUNET_DHT_GetHandle *
+GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
+                      enum GNUNET_BLOCK_Type type,
+                      const struct GNUNET_HashCode *key,
+                      uint32_t desired_replication_level,
+                      enum GNUNET_DHT_RouteOption options,
+                      const void *xquery,
+                      size_t xquery_size,
+                      GNUNET_DHT_GetIterator iter,
+                      void *iter_cls)
+{
+  struct GNUNET_DHT_GetHandle *gh;
+  size_t msize;
+
+  msize = sizeof(struct GNUNET_DHT_ClientGetMessage) + xquery_size;
+  if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
+      (xquery_size >= GNUNET_MAX_MESSAGE_SIZE))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending query for %s to DHT %p\n",
+       GNUNET_h2s (key),
+       handle);
+  gh = GNUNET_malloc (sizeof(struct GNUNET_DHT_GetHandle)
+                      + xquery_size);
+  gh->iter = iter;
+  gh->iter_cls = iter_cls;
+  gh->dht_handle = handle;
+  gh->key = *key;
+  gh->unique_id = ++handle->uid_gen;
+  gh->xquery_size = xquery_size;
+  gh->desired_replication_level = desired_replication_level;
+  gh->type = type;
+  gh->options = options;
+  GNUNET_memcpy (&gh[1],
+                 xquery,
+                 xquery_size);
+  GNUNET_CONTAINER_multihashmap_put (handle->active_requests,
+                                     &gh->key,
+                                     gh,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  if (NULL != handle->mq)
+    send_get (gh);
+  return gh;
+}
+
+
+void
+GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle,
+                                     unsigned int num_results,
+                                     const struct GNUNET_HashCode *results)
+{
+  unsigned int needed;
+  unsigned int had;
+
+  had = get_handle->seen_results_end;
+  needed = had + num_results;
+  if (needed > get_handle->seen_results_size)
+    GNUNET_array_grow (get_handle->seen_results,
+                       get_handle->seen_results_size,
+                       needed);
+  GNUNET_memcpy (&get_handle->seen_results[get_handle->seen_results_end],
+                 results,
+                 num_results * sizeof(struct GNUNET_HashCode));
+  get_handle->seen_results_end += num_results;
+  if (NULL != get_handle->dht_handle->mq)
+    send_get_known_results (get_handle,
+                            had);
+}
+
+
+void
+GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
+{
+  struct GNUNET_DHT_Handle *handle = get_handle->dht_handle;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending STOP for %s to DHT via %p\n",
+       GNUNET_h2s (&get_handle->key),
+       handle);
+  if (NULL != handle->mq)
+  {
+    struct GNUNET_MQ_Envelope *env;
+    struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
+
+    env = GNUNET_MQ_msg (stop_msg,
+                         GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
+    stop_msg->reserved = htonl (0);
+    stop_msg->unique_id = get_handle->unique_id;
+    stop_msg->key = get_handle->key;
+    GNUNET_MQ_send (handle->mq,
+                    env);
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,
+                                                       &get_handle->key,
+                                                       get_handle));
+  GNUNET_array_grow (get_handle->seen_results,
+                     get_handle->seen_results_end,
+                     0);
+  GNUNET_free (get_handle);
+}
+
+
+struct GNUNET_DHT_MonitorHandle *
+GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle,
+                          enum GNUNET_BLOCK_Type type,
+                          const struct GNUNET_HashCode *key,
+                          GNUNET_DHT_MonitorGetCB get_cb,
+                          GNUNET_DHT_MonitorGetRespCB get_resp_cb,
+                          GNUNET_DHT_MonitorPutCB put_cb,
+                          void *cb_cls)
+{
+  struct GNUNET_DHT_MonitorHandle *mh;
+
+  mh = GNUNET_new (struct GNUNET_DHT_MonitorHandle);
+  mh->get_cb = get_cb;
+  mh->get_resp_cb = get_resp_cb;
+  mh->put_cb = put_cb;
+  mh->cb_cls = cb_cls;
+  mh->type = type;
+  mh->dht_handle = handle;
+  if (NULL != key)
+  {
+    mh->key = GNUNET_new (struct GNUNET_HashCode);
+    *mh->key = *key;
+  }
+  GNUNET_CONTAINER_DLL_insert (handle->monitor_head,
+                               handle->monitor_tail,
+                               mh);
+  if (NULL != handle->mq)
+    send_monitor_start (mh);
+  return mh;
+}
+
+
+void
+GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *mh)
+{
+  struct GNUNET_DHT_Handle *handle = mh->dht_handle;
+  struct GNUNET_DHT_MonitorStartStopMessage *m;
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_CONTAINER_DLL_remove (handle->monitor_head,
+                               handle->monitor_tail,
+                               mh);
+  env = GNUNET_MQ_msg (m,
+                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP);
+  m->type = htonl (mh->type);
+  m->get = htons (NULL != mh->get_cb);
+  m->get_resp = htons (NULL != mh->get_resp_cb);
+  m->put = htons (NULL != mh->put_cb);
+  if (NULL != mh->key)
+  {
+    m->filter_key = htons (1);
+    m->key = *mh->key;
+  }
+  GNUNET_MQ_send (handle->mq,
+                  env);
+  GNUNET_free (mh->key);
+  GNUNET_free (mh);
+}
+
+
+char *
+GNUNET_DHT_pp2s (const struct GNUNET_DHT_PathElement *path,
+                 unsigned int path_len)
+{
+  char *buf;
+  size_t off;
+  size_t plen = path_len * 5 + 1;
+
+  GNUNET_assert (path_len < UINT32_MAX / 5);
+  off = 0;
+  buf = GNUNET_malloc (plen);
+  for (unsigned int i = 0; i < path_len; i++)
+  {
+    off += GNUNET_snprintf (&buf[off],
+                            plen - off,
+                            "%s%s",
+                            GNUNET_i2s (&path[i].pred),
+                            (i == path_len - 1) ? "" : "-");
+  }
+  return buf;
+}
+
+
+unsigned int
+GNUNET_DHT_verify_path (const void *data,
+                        size_t data_size,
+                        struct GNUNET_TIME_Absolute exp_time,
+                        const struct GNUNET_PeerIdentity *bpid,
+                        const struct GNUNET_DHT_PathElement *put_path,
+                        unsigned int put_path_len,
+                        const struct GNUNET_DHT_PathElement *get_path,
+                        unsigned int get_path_len,
+                        const struct GNUNET_PeerIdentity *me)
+{
+  static struct GNUNET_PeerIdentity zero;
+  struct GNUNET_DHT_HopSignature hs = {
+    .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DHT_HOP),
+    .purpose.size = htonl (sizeof (hs)),
+    .expiration_time = GNUNET_TIME_absolute_hton (exp_time)
+  };
+  unsigned int i;
+
+  if (0 == get_path_len + put_path_len)
+    return 0;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%s is verifying signatures with GPL: %u PPL: %u!\n",
+              GNUNET_i2s (me),
+              get_path_len,
+              put_path_len);
+  for (unsigned int j = 0; j<put_path_len; j++)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "PP%u=%s\n",
+                j,
+                GNUNET_i2s (&put_path[j].pred));
+  for (unsigned int j = 0; j<get_path_len; j++)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GP%u=%s\n",
+                j,
+                GNUNET_i2s (&get_path[j].pred));
+  GNUNET_CRYPTO_hash (data,
+                      data_size,
+                      &hs.h_data);
+  i = put_path_len + get_path_len;
+  while (i > 0)
+  {
+    const struct GNUNET_PeerIdentity *pred;
+    const struct GNUNET_PeerIdentity *succ;
+    const struct GNUNET_DHT_PathElement *pe;
+
+    i--;
+    if (0 == i)
+    {
+      pred = (NULL == bpid) ? &zero : bpid;
+    }
+    else
+    {
+      unsigned int off = i - 1;
+
+      pred = (off >= put_path_len)
+        ? &get_path[off - put_path_len].pred
+        : &put_path[off].pred;
+    }
+    if (i == get_path_len + put_path_len - 1)
+    {
+      succ = me;
+    }
+    else
+    {
+      unsigned int off = i + 1;
+
+      succ = (off >= put_path_len)
+        ? &get_path[off - put_path_len].pred
+        : &put_path[off].pred;
+    }
+    hs.pred = *pred;
+    hs.succ = *succ;
+    pe = (i >= put_path_len)
+      ? &get_path[i - put_path_len]
+      : &put_path[i];
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_eddsa_verify (
+          GNUNET_SIGNATURE_PURPOSE_DHT_HOP,
+          &hs,
+          &pe->sig,
+          &pe->pred.public_key))
+    {
+      GNUNET_break_op (0);
+      return i + 1;
+    }
+  }
+  return i;
+}
+
+
+struct GNUNET_DHT_HelloGetHandle *
+GNUNET_DHT_hello_get (struct GNUNET_DHT_Handle *dht_handle,
+                      GNUNET_DHT_HelloGetCallback cb,
+                      void *cb_cls)
+{
+  struct GNUNET_DHT_HelloGetHandle *hgh;
+  struct GNUNET_MessageHeader *hdr;
+  struct GNUNET_MQ_Envelope *env;
+
+  hgh = GNUNET_new (struct GNUNET_DHT_HelloGetHandle);
+  hgh->cb = cb;
+  hgh->cb_cls = cb_cls;
+  hgh->dht_handle = dht_handle;
+  GNUNET_CONTAINER_DLL_insert (dht_handle->hgh_head,
+                               dht_handle->hgh_tail,
+                               hgh);
+  env = GNUNET_MQ_msg (hdr,
+                       GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET);
+  GNUNET_MQ_send (dht_handle->mq,
+                  env);
+  return hgh;
+}
+
+
+void
+GNUNET_DHT_hello_get_cancel (struct GNUNET_DHT_HelloGetHandle *hgh)
+{
+  struct GNUNET_DHT_Handle *dht_handle = hgh->dht_handle;
+
+  GNUNET_CONTAINER_DLL_remove (dht_handle->hgh_head,
+                               dht_handle->hgh_tail,
+                               hgh);
+  GNUNET_free (hgh);
+}
+
+
+void
+GNUNET_DHT_hello_offer (struct GNUNET_DHT_Handle *dht_handle,
+                        const char *url,
+                        GNUNET_SCHEDULER_TaskCallback cb,
+                        void *cb_cls)
+{
+  struct GNUNET_MessageHeader *hdr;
+  size_t slen = strlen (url) + 1;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra (hdr,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL);
+  memcpy (&hdr[1],
+          url,
+          slen);
+  GNUNET_MQ_notify_sent (env,
+                         cb,
+                         cb_cls);
+  GNUNET_MQ_send (dht_handle->mq,
+                  env);
+}
+
+
+/* end of dht_api.c */
diff --git a/src/service/dht/dhtu.conf b/src/service/dht/dhtu.conf
new file mode 100644
index 000000000..ea5ade752
--- /dev/null
+++ b/src/service/dht/dhtu.conf
@@ -0,0 +1,7 @@
+[dhtu-gnunet]
+ENABLED = YES
+
+[dhtu-ip]
+ENABLED = NO
+NSE = 4
+UDP_PORT = 6666
diff --git a/src/service/dht/dhtu_testbed_connect.sh b/src/service/dht/dhtu_testbed_connect.sh
new file mode 100755
index 000000000..b0ba474bf
--- /dev/null
+++ b/src/service/dht/dhtu_testbed_connect.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+# This file is in the public domain.
+
+set -eu
+
+GNUNET_TMP="$(gnunet-config -f -s PATHS -o GNUNET_TMP)"
+
+# Helper script for dhtu_testbed_deploy.sh.
+# Do not invoke directly.
+
+n=$1
+CFG="$GNUNET_TMP/deployment/${n}.conf"
+HELLO=`gnunet-dht-hello -c $CFG`
+
+# Create dense topology:
+#for OFF in `seq 1 $MAX`
+#do
+#    TCFG="$GNUNET_TMP/deployment/${OFF}.conf"
+#    gnunet-dht-hello -c $TCFG $HELLO
+#done
+#exit 0
+
+# Create sparse topology:
+R=1
+while test `expr $R \* $R \* $R` -lt $MAX
+do
+    END=`expr $R \* $R`
+    for M in `seq $R $R $END`
+    do
+        OFF=`expr \( $n + $M \) % $MAX`
+        TCFG="$GNUNET_TMP/deployment/${OFF}.conf"
+        gnunet-dht-hello -c $TCFG $HELLO
+    done
+    R=`expr $R + 1`
+done
diff --git a/src/service/dht/dhtu_testbed_deploy.conf b/src/service/dht/dhtu_testbed_deploy.conf
new file mode 100644
index 000000000..efabd97d3
--- /dev/null
+++ b/src/service/dht/dhtu_testbed_deploy.conf
@@ -0,0 +1,26 @@
+# This file is in the public domain.
+
+# Simple configuration template to deploy a DHT testbed
+# with peers using the IP underlay.
+
+[paths]
+GNUNET_DATA_HOME=$GNUNET_TMP/%N%
+
+[dht]
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-dht-%N%.sock
+
+[dhtu-ip]
+ENABLED = YES
+NSE = 10
+UDP_PORT = %N%
+
+[dhtu-gnunet]
+ENABLED = NO
+
+[statistics]
+DISABLE = YES
+
+[dhtcache]
+DATABASE = heap
+QUOTA = 50 MB
+DISABLE_BF_RC = YES
diff --git a/src/service/dht/dhtu_testbed_deploy.sh b/src/service/dht/dhtu_testbed_deploy.sh
new file mode 100755
index 000000000..e8ac8d5d1
--- /dev/null
+++ b/src/service/dht/dhtu_testbed_deploy.sh
@@ -0,0 +1,95 @@
+#!/bin/bash
+# This file is in the public domain.
+
+# Getting location for temporary files
+GNUNET_TMP="$(gnunet-config -f -s PATHS -o GNUNET_TMP)"
+
+# We will use UDP ports above this number.
+MINPORT=10000
+
+# Cleanup to run whenever we exit
+function cleanup()
+{
+    for n in `jobs -p`
+    do
+        kill $n 2> /dev/null || true
+    done
+    wait
+}
+
+# Install cleanup handler (except for kill -9)
+trap cleanup EXIT
+
+if test -z "$1"
+then
+    echo "Call with the number of peers to launch."
+    exit 1
+fi
+
+echo -n "Testing for GNU parallel ..."
+
+if test ! -x `which parallel`
+then
+    echo "This script requires GNU parallel"
+    exit 1
+fi
+
+parallel -V | grep "GNU parallel" > /dev/null || exit 1
+
+echo " OK"
+
+
+
+if test ! -x `which gnunet-service-dht`
+then
+    echo "This script requires gnunet-service-dht in \$PATH"
+    exit 1
+fi
+
+if test ! -x `which gnunet-dht-hello`
+then
+    echo "This script requires gnunet-dht-hello in \$PATH"
+    exit 1
+fi
+
+MAX=`expr $1 - 1`
+
+export GNUNET_FORCE_LOG="dht*;;;;DEBUG"
+
+echo -n "Starting $1 peers "
+mkdir -p "$GNUNET_TMP/deployment"
+for n in `seq 0 $MAX`
+do
+    PORT=`expr $MINPORT + $n`
+    CFG="$GNUNET_TMP/deployment/${n}.conf"
+    cat dhtu_testbed_deploy.conf | sed -e "s/%N%/$PORT/" > $CFG
+    gnunet-service-dht -c $CFG -L DEBUG &> "$GNUNET_TMP/deployment/$n.log" &
+    echo -n "."
+done
+
+echo ""
+echo "$1 peers ready".
+
+unset GNUNET_FORCE_LOG
+
+function connect()
+{
+  n=$1
+}
+
+echo -n "Connecting peers ..."
+
+export MAX
+if test 0 != $MAX
+then
+  seq 0 $MAX | parallel ./dhtu_testbed_connect.sh :::
+fi
+
+
+echo ""
+echo "Network ready. Press ENTER to terminate the testbed!"
+echo "Interact with peers using '-c $GNUNET_TMP/deployment/\$N.conf'"
+
+read
+
+exit 0
diff --git a/src/service/dht/gnunet-service-dht.c b/src/service/dht/gnunet-service-dht.c
new file mode 100644
index 000000000..4579bfc2b
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht.c
@@ -0,0 +1,562 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 2016 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/gnunet-service-dht.c
+ * @brief GNUnet DHT service
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_block_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_hello_uri_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet-service-dht.h"
+#include "gnunet-service-dht_datacache.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "gnunet-service-dht_routing.h"
+#include "plugin_dhtu_ip.h"
+#include "plugin_dhtu_gnunet.h"
+
+/**
+ * How often do we broadcast our HELLO to neighbours if
+ * nothing special happens?
+ */
+#define HELLO_FREQUENCY GNUNET_TIME_UNIT_HOURS
+
+
+/**
+ * Information we keep per underlay.
+ */
+struct GDS_Underlay
+{
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GDS_Underlay *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GDS_Underlay *prev;
+
+  /**
+   * Environment for this underlay.
+   */
+  struct GNUNET_DHTU_PluginEnvironment env;
+
+  /**
+   * Underlay API handle.
+   */
+  struct GNUNET_DHTU_PluginFunctions *dhtu;
+
+  /**
+   * current network size estimate for this underlay.
+   */
+  double network_size_estimate;
+
+  /**
+   * Name of the underlay (i.e. "gnunet" or "ip").
+   */
+  char *name;
+};
+
+
+/**
+ * An address of this peer.
+ */
+struct MyAddress
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct MyAddress *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct MyAddress *prev;
+
+  /**
+   * Underlay handle for the address.
+   */
+  struct GNUNET_DHTU_Source *source;
+
+  /**
+   * Textual representation of the address.
+   */
+  char *url;
+
+  /**
+   * Underlay of this address.
+   */
+  struct GDS_Underlay *u;
+};
+
+
+/**
+ * Our HELLO
+ */
+struct GNUNET_HELLO_Builder *GDS_my_hello;
+
+/**
+ * Identity of this peer.
+ */
+struct GNUNET_PeerIdentity GDS_my_identity;
+
+/**
+ * Hash of the identity of this peer.
+ */
+struct GNUNET_HashCode GDS_my_identity_hash;
+
+/**
+ * Our private key.
+ */
+struct GNUNET_CRYPTO_EddsaPrivateKey GDS_my_private_key;
+
+/**
+ * Task broadcasting our HELLO.
+ */
+static struct GNUNET_SCHEDULER_Task *hello_task;
+
+/**
+ * Handles for the DHT underlays.
+ */
+static struct GDS_Underlay *u_head;
+
+/**
+ * Handles for the DHT underlays.
+ */
+static struct GDS_Underlay *u_tail;
+
+/**
+ * Head of addresses of this peer.
+ */
+static struct MyAddress *a_head;
+
+/**
+ * Tail of addresses of this peer.
+ */
+static struct MyAddress *a_tail;
+
+/**
+ * log of the current network size estimate, used as the point where
+ * we switch between random and deterministic routing.
+ */
+static double log_of_network_size_estimate;
+
+
+/**
+ * Callback that is called when network size estimate is updated.
+ *
+ * @param cls a `struct GDS_Underlay`
+ * @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
+update_network_size_estimate (void *cls,
+                              struct GNUNET_TIME_Absolute timestamp,
+                              double logestimate,
+                              double std_dev)
+{
+  struct GDS_Underlay *u = cls;
+  double sum = 0.0;
+
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# Network size estimates received",
+                            1,
+                            GNUNET_NO);
+  /* do not allow estimates < 0.5 */
+  u->network_size_estimate = pow (2.0,
+                                  GNUNET_MAX (0.5,
+                                              logestimate));
+  for (struct GDS_Underlay *p = u_head; NULL != p; p = p->next)
+    sum += p->network_size_estimate;
+  if (sum <= 2.0)
+    log_of_network_size_estimate = 0.5;
+  else
+    log_of_network_size_estimate = log2 (sum);
+}
+
+
+/**
+ * Return the current NSE
+ *
+ * @return the current NSE as a logarithm
+ */
+double
+GDS_NSE_get (void)
+{
+  return log_of_network_size_estimate;
+}
+
+
+#include "gnunet-service-dht_clients.c"
+
+
+/**
+ * Task run periodically to broadcast our HELLO.
+ *
+ * @param cls NULL
+ */
+static void
+broadcast_hello (void *cls)
+{
+  struct GNUNET_MessageHeader *hello;
+
+  (void) cls;
+  /* TODO: randomize! */
+  hello_task = GNUNET_SCHEDULER_add_delayed (HELLO_FREQUENCY,
+                                             &broadcast_hello,
+                                             NULL);
+  hello = GNUNET_HELLO_builder_to_dht_hello_msg (GDS_my_hello,
+                                                 &GDS_my_private_key,
+                                                 GNUNET_TIME_UNIT_ZERO);
+  if (NULL == hello)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GDS_NEIGHBOURS_broadcast (hello);
+  GNUNET_free (hello);
+}
+
+
+/**
+ * Function to call with new addresses of this peer.
+ *
+ * @param cls the closure
+ * @param address address under which we are likely reachable,
+ *           pointer will remain valid until @e address_del_cb is called; to be used for HELLOs. Example: "ip+udp://$PID/1.1.1.1:2086/"
+ * @param source handle for sending from this address, NULL if we can only receive
+ * @param[out] ctx storage space for DHT to use in association with this address
+ */
+static void
+u_address_add (void *cls,
+               const char *address,
+               struct GNUNET_DHTU_Source *source,
+               void **ctx)
+{
+  struct GDS_Underlay *u = cls;
+  struct MyAddress *a;
+  enum GNUNET_GenericReturnValue add_success;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Underlay adds address %s for this peer\n",
+              address);
+  if (GNUNET_OK != (add_success = GNUNET_HELLO_builder_add_address (
+                      GDS_my_hello,
+                      address)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Adding address `%s' from underlay %s\n",
+                address,
+                GNUNET_NO == add_success ? "not done" : "failed");
+    return;
+  }
+  a = GNUNET_new (struct MyAddress);
+  a->source = source;
+  a->url = GNUNET_strdup (address);
+  a->u = u;
+  GNUNET_CONTAINER_DLL_insert (a_head,
+                               a_tail,
+                               a);
+  *ctx = a;
+
+  if (NULL != hello_task)
+    GNUNET_SCHEDULER_cancel (hello_task);
+  hello_task = GNUNET_SCHEDULER_add_now (&broadcast_hello,
+                                         NULL);
+}
+
+
+/**
+ * Function to call with expired addresses of this peer.
+ *
+ * @param[in] ctx storage space used by the DHT in association with this address
+ */
+static void
+u_address_del (void *ctx)
+{
+  struct MyAddress *a = ctx;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Underlay deletes address %s for this peer\n",
+              a->url);
+  GNUNET_HELLO_builder_del_address (GDS_my_hello,
+                                    a->url);
+  GNUNET_CONTAINER_DLL_remove (a_head,
+                               a_tail,
+                               a);
+  GNUNET_free (a->url);
+  GNUNET_free (a);
+  if (NULL != hello_task)
+    GNUNET_SCHEDULER_cancel (hello_task);
+  hello_task = GNUNET_SCHEDULER_add_now (&broadcast_hello,
+                                         NULL);
+}
+
+
+void
+GDS_u_try_connect (const struct GNUNET_PeerIdentity *pid,
+                   const char *address)
+{
+  for (struct GDS_Underlay *u = u_head;
+       NULL != u;
+       u = u->next)
+    u->dhtu->try_connect (u->dhtu->cls,
+                          pid,
+                          address);
+}
+
+
+void
+GDS_u_send (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_Target *target,
+            const void *msg,
+            size_t msg_size,
+            GNUNET_SCHEDULER_TaskCallback finished_cb,
+            void *finished_cb_cls)
+{
+  u->dhtu->send (u->dhtu->cls,
+                 target,
+                 msg,
+                 msg_size,
+                 finished_cb,
+                 finished_cb_cls);
+}
+
+
+void
+GDS_u_drop (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_PreferenceHandle *ph)
+{
+  u->dhtu->drop (ph);
+}
+
+
+struct GNUNET_DHTU_PreferenceHandle *
+GDS_u_hold (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_Target *target)
+{
+  return u->dhtu->hold (u->dhtu->cls,
+                        target);
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  struct GDS_Underlay *u;
+
+  while (NULL != (u = u_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (u_head,
+                                 u_tail,
+                                 u);
+    if (0 == strcmp (u->name, "gnunet"))
+    {
+      DHTU_gnunet_done (u->dhtu);
+    }
+    else if (0 == strcmp (u->name, "ip"))
+    {
+      DHTU_ip_done (u->dhtu);
+    }
+    else
+    {
+      GNUNET_assert (0);
+    }
+    GNUNET_free (u->name);
+    GNUNET_free (u);
+  }
+  GDS_NEIGHBOURS_done ();
+  GDS_DATACACHE_done ();
+  GDS_ROUTING_done ();
+  if (NULL != GDS_block_context)
+  {
+    GNUNET_BLOCK_context_destroy (GDS_block_context);
+    GDS_block_context = NULL;
+  }
+  GDS_CLIENTS_stop ();
+  if (NULL != GDS_stats)
+  {
+    GNUNET_STATISTICS_destroy (GDS_stats,
+                               GNUNET_YES);
+    GDS_stats = NULL;
+  }
+  if (NULL != GDS_my_hello)
+  {
+    GNUNET_HELLO_builder_free (GDS_my_hello);
+    GDS_my_hello = NULL;
+  }
+  if (NULL != hello_task)
+  {
+    GNUNET_SCHEDULER_cancel (hello_task);
+    hello_task = NULL;
+  }
+}
+
+
+/**
+ * Function iterating over all configuration sections.
+ * Loads plugins for enabled DHT underlays.
+ *
+ * @param cls NULL
+ * @param section configuration section to inspect
+ */
+static void
+load_underlay (void *cls,
+               const char *section)
+{
+  struct GDS_Underlay *u;
+
+  (void) cls;
+  if (0 != strncasecmp (section,
+                        "dhtu-",
+                        strlen ("dhtu-")))
+    return;
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
+                                            section,
+                                            "ENABLED"))
+    return;
+  section += strlen ("dhtu-");
+  u = GNUNET_new (struct GDS_Underlay);
+  u->env.cls = u;
+  u->env.cfg = GDS_cfg;
+  u->env.address_add_cb = &u_address_add;
+  u->env.address_del_cb = &u_address_del;
+  u->env.network_size_cb = &update_network_size_estimate;
+  u->env.connect_cb = &GDS_u_connect;
+  u->env.disconnect_cb = &GDS_u_disconnect;
+  u->env.receive_cb = &GDS_u_receive;
+
+  /** NOTE: This is not pretty, but it allows us to avoid
+      dynamically loading plugins **/
+  if (0 == strcmp (section, "gnunet"))
+  {
+    u->dhtu = DHTU_gnunet_init (&u->env);
+  }
+  else if (0 == strcmp (section, "ip"))
+  {
+    u->dhtu = DHTU_ip_init (&u->env);
+  }
+  if (NULL == u->dhtu)
+  {
+    GNUNET_free (u);
+    return;
+  }
+  u->name = GNUNET_strdup (section);
+  GNUNET_CONTAINER_DLL_insert (u_head,
+                               u_tail,
+                               u);
+}
+
+
+/**
+ * Process dht requests.
+ *
+ * @param cls closure
+ * @param c configuration to use
+ * @param service the initialized service
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
+{
+  GDS_cfg = c;
+  GDS_service = service;
+  {
+    char *keyfile;
+
+    if (GNUNET_OK !=
+        GNUNET_CONFIGURATION_get_value_filename (GDS_cfg,
+                                                 "PEER",
+                                                 "PRIVATE_KEY",
+                                                 &keyfile))
+    {
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                                 "PEER",
+                                 "PRIVATE_KEY");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (GNUNET_SYSERR ==
+        GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
+                                           GNUNET_YES,
+                                           &GDS_my_private_key))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to setup peer's private key\n");
+      GNUNET_free (keyfile);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    GNUNET_free (keyfile);
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (&GDS_my_private_key,
+                                      &GDS_my_identity.public_key);
+  GDS_my_hello = GNUNET_HELLO_builder_new (&GDS_my_identity);
+  GNUNET_CRYPTO_hash (&GDS_my_identity,
+                      sizeof(struct GNUNET_PeerIdentity),
+                      &GDS_my_identity_hash);
+  GDS_block_context = GNUNET_BLOCK_context_create (GDS_cfg);
+  GDS_stats = GNUNET_STATISTICS_create ("dht",
+                                        GDS_cfg);
+  GDS_CLIENTS_init ();
+  GDS_ROUTING_init ();
+  GDS_DATACACHE_init ();
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+  if (GNUNET_OK !=
+      GDS_NEIGHBOURS_init ())
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_CONFIGURATION_iterate_sections (GDS_cfg,
+                                         &load_underlay,
+                                         NULL);
+  if (NULL == u_head)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No DHT underlays configured!\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/* Finally, define the main method */
+GDS_DHT_SERVICE_INIT ("dht", &run);
+
+
+/* end of gnunet-service-dht.c */
diff --git a/src/service/dht/gnunet-service-dht.h b/src/service/dht/gnunet-service-dht.h
new file mode 100644
index 000000000..893c90109
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht.h
@@ -0,0 +1,212 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2016 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/gnunet-service-dht.h
+ * @brief GNUnet DHT globals
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_DHT_H
+#define GNUNET_SERVICE_DHT_H
+
+#include "gnunet-service-dht_datacache.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "gnunet_statistics_service.h"
+
+
+#define DEBUG_DHT GNUNET_EXTRA_LOGGING
+
+/**
+ * Information we keep per underlay.
+ */
+struct GDS_Underlay;
+
+/**
+ * Configuration we use.
+ */
+extern const struct GNUNET_CONFIGURATION_Handle *GDS_cfg;
+
+/**
+ * Handle for the service.
+ */
+extern struct GNUNET_SERVICE_Handle *GDS_service;
+
+/**
+ * Our handle to the BLOCK library.
+ */
+extern struct GNUNET_BLOCK_Context *GDS_block_context;
+
+/**
+ * Handle for the statistics service.
+ */
+extern struct GNUNET_STATISTICS_Handle *GDS_stats;
+
+/**
+ * Our HELLO builder.
+ */
+extern struct GNUNET_HELLO_Builder *GDS_my_hello;
+
+/**
+ * Identity of this peer.
+ */
+extern struct GNUNET_PeerIdentity GDS_my_identity;
+
+/**
+ * Hash of the identity of this peer.
+ */
+extern struct GNUNET_HashCode GDS_my_identity_hash;
+
+/**
+ * Our private key.
+ */
+extern struct GNUNET_CRYPTO_EddsaPrivateKey GDS_my_private_key;
+
+
+/**
+ * Ask all underlays to connect to peer @a pid at @a address.
+ *
+ * @param pid identity of the peer we would connect to
+ * @param address an address of @a pid
+ */
+void
+GDS_u_try_connect (const struct GNUNET_PeerIdentity *pid,
+                   const char *address);
+
+
+/**
+ * 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 u underlay to use for transmission
+ * @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
+ */
+void
+GDS_u_send (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_Target *target,
+            const void *msg,
+            size_t msg_size,
+            GNUNET_SCHEDULER_TaskCallback finished_cb,
+            void *finished_cb_cls);
+
+
+/**
+ * Drop a hold @a ph from underlay @a u.
+ *
+ * @param u the underlay controlling the hold
+ * @param ph the preference handle
+ */
+void
+GDS_u_drop (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_PreferenceHandle *ph);
+
+
+/**
+ * Create a hold on @a target at underlay @a u.
+ *
+ * @param u the underlay controlling the target
+ * @param target the peer to hold the connection to
+ */
+struct GNUNET_DHTU_PreferenceHandle *
+GDS_u_hold (struct GDS_Underlay *u,
+            struct GNUNET_DHTU_Target *target);
+
+
+/**
+ * Handle a reply we've received from another peer.  If the reply
+ * matches any of our pending queries, forward it to the respective
+ * client(s).
+ *
+ * @param bd block details
+ * @param query_hash hash of the original query, might not match key in @a bd
+ * @param get_path_length number of entries in @a get_path
+ * @param get_path path the reply has taken
+ * @return true on success, false on failures
+ */
+bool
+GDS_CLIENTS_handle_reply (const struct GNUNET_DATACACHE_Block *bd,
+                          const struct GNUNET_HashCode *query_hash,
+                          unsigned int get_path_length,
+                          const struct GNUNET_DHT_PathElement *get_path);
+
+
+/**
+ * Check if some client is monitoring GET messages and notify
+ * them in that case.  If tracked, @a path should include the local peer.
+ *
+ *
+ * @param options Options, for instance RecordRoute, DemultiplexEverywhere.
+ * @param type The type of data in the request.
+ * @param hop_count Hop count so far.
+ * @param desired_replication_level Desired replication level.
+ * @param key Key of the requested data.
+ */
+void
+GDS_CLIENTS_process_get (enum GNUNET_DHT_RouteOption options,
+                         enum GNUNET_BLOCK_Type type,
+                         uint32_t hop_count,
+                         uint32_t desired_replication_level,
+                         const struct GNUNET_HashCode *key);
+
+
+/**
+ * Check if some client is monitoring GET RESP messages and notify
+ * them in that case.
+ *
+ * @param bd block details
+ * @param get_path Peers on GET path (or NULL if not recorded).
+ * @param get_path_length number of entries in @a get_path.
+ */
+void
+GDS_CLIENTS_process_get_resp (const struct GNUNET_DATACACHE_Block *bd,
+                              const struct GNUNET_DHT_PathElement *get_path,
+                              unsigned int get_path_length);
+
+
+/**
+ * Check if some client is monitoring PUT messages and notify
+ * them in that case. The @a path should include our own
+ * peer ID (if recorded).
+ *
+ * @param bd details about the block
+ * @param hop_count Hop count so far.
+ * @param desired_replication_level Desired replication level.
+ */
+void
+GDS_CLIENTS_process_put (const struct GNUNET_DATACACHE_Block *bd,
+                         uint32_t hop_count,
+                         uint32_t desired_replication_level);
+
+/**
+ * Return the current NSE
+ *
+ * @return the current NSE as a logarithm
+ */
+double
+GDS_NSE_get (void);
+
+#endif
diff --git a/src/service/dht/gnunet-service-dht_clients.c b/src/service/dht/gnunet-service-dht_clients.c
new file mode 100644
index 000000000..c666265fe
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_clients.c
@@ -0,0 +1,1705 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 2016, 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/gnunet-service-dht_clients.c
+ * @brief GNUnet DHT service's client management code
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_constants.h"
+#include "gnunet_protocols.h"
+#include "gnunet_hello_uri_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet-service-dht.h"
+#include "gnunet-service-dht_datacache.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "dht.h"
+
+
+/**
+ * Enable slow sanity checks to debug issues.
+ * 0: do not check
+ * 1: check all external inputs
+ * 2: check internal computations as well
+ */
+#define SANITY_CHECKS 0
+
+/**
+ * Should routing details be logged to stderr (for debugging)?
+ */
+#define LOG_TRAFFIC(kind, ...) GNUNET_log_from (kind, "dht-traffic", \
+                                                __VA_ARGS__)
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "dht-clients", __VA_ARGS__)
+
+
+/**
+ * Struct containing information about a client,
+ * handle to connect to it, and any pending messages
+ * that need to be sent to it.
+ */
+struct ClientHandle;
+
+
+/**
+ * Entry in the local forwarding map for a client's GET request.
+ */
+struct ClientQueryRecord
+{
+  /**
+   * The key this request was about
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Kept in a DLL with @e client.
+   */
+  struct ClientQueryRecord *next;
+
+  /**
+   * Kept in a DLL with @e client.
+   */
+  struct ClientQueryRecord *prev;
+
+  /**
+   * Client responsible for the request.
+   */
+  struct ClientHandle *ch;
+
+  /**
+   * Extended query (see gnunet_block_lib.h), allocated at the end of this struct.
+   */
+  const void *xquery;
+
+  /**
+   * Array of (hashes of) replies we have already seen for this request.
+   */
+  struct GNUNET_HashCode *seen_replies;
+
+  /**
+   * Pointer to this nodes heap location in the retry-heap (for fast removal)
+   */
+  struct GNUNET_CONTAINER_HeapNode *hnode;
+
+  /**
+   * What's the delay between re-try operations that we currently use for this
+   * request?
+   */
+  struct GNUNET_TIME_Relative retry_frequency;
+
+  /**
+   * What's the next time we should re-try this request?
+   */
+  struct GNUNET_TIME_Absolute retry_time;
+
+  /**
+   * The unique identifier of this request
+   */
+  uint64_t unique_id;
+
+  /**
+   * Number of bytes in xquery.
+   */
+  size_t xquery_size;
+
+  /**
+   * Number of entries in @e seen_replies.
+   */
+  unsigned int seen_replies_count;
+
+  /**
+   * Desired replication level
+   */
+  uint32_t replication;
+
+  /**
+   * Any message options for this request
+   */
+  enum GNUNET_DHT_RouteOption msg_options;
+
+  /**
+   * The type for the data for the GET request.
+   */
+  enum GNUNET_BLOCK_Type type;
+};
+
+
+/**
+ * Struct containing parameters of monitoring requests.
+ */
+struct ClientMonitorRecord
+{
+  /**
+   * Next element in DLL.
+   */
+  struct ClientMonitorRecord *next;
+
+  /**
+   * Previous element in DLL.
+   */
+  struct ClientMonitorRecord *prev;
+
+  /**
+   * Client to notify of these requests.
+   */
+  struct ClientHandle *ch;
+
+  /**
+   * Key of data of interest. All bits zero for 'all'.
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Type of blocks that are of interest
+   */
+  enum GNUNET_BLOCK_Type type;
+
+  /**
+   * Flag whether to notify about GET messages.
+   */
+  int16_t get;
+
+  /**
+   * Flag whether to notify about GET_REPONSE messages.
+   */
+  int16_t get_resp;
+
+  /**
+   * Flag whether to notify about PUT messages.
+   */
+  uint16_t put;
+
+};
+
+
+/**
+ * Struct containing information about a client,
+ * handle to connect to it, and any pending messages
+ * that need to be sent to it.
+ */
+struct ClientHandle
+{
+  /**
+   * Linked list of active queries of this client.
+   */
+  struct ClientQueryRecord *cqr_head;
+
+  /**
+   * Linked list of active queries of this client.
+   */
+  struct ClientQueryRecord *cqr_tail;
+
+  /**
+   * The handle to this client
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * The message queue to this client
+   */
+  struct GNUNET_MQ_Handle *mq;
+};
+
+
+/**
+ * Our handle to the BLOCK library.
+ */
+struct GNUNET_BLOCK_Context *GDS_block_context;
+
+/**
+ * Handle for the statistics service.
+ */
+struct GNUNET_STATISTICS_Handle *GDS_stats;
+
+/**
+ * Handle for the service.
+ */
+struct GNUNET_SERVICE_Handle *GDS_service;
+
+/**
+ * The configuration the DHT service is running with
+ */
+const struct GNUNET_CONFIGURATION_Handle *GDS_cfg;
+
+/**
+ * List of active monitoring requests.
+ */
+static struct ClientMonitorRecord *monitor_head;
+
+/**
+ * List of active monitoring requests.
+ */
+static struct ClientMonitorRecord *monitor_tail;
+
+/**
+ * Hashmap for fast key based lookup, maps keys to `struct ClientQueryRecord` entries.
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *forward_map;
+
+/**
+ * Heap with all of our client's request, sorted by retry time (earliest on top).
+ */
+static struct GNUNET_CONTAINER_Heap *retry_heap;
+
+/**
+ * Task that re-transmits requests (using retry_heap).
+ */
+static struct GNUNET_SCHEDULER_Task *retry_task;
+
+
+/**
+ * Free data structures associated with the given query.
+ *
+ * @param record record to remove
+ */
+static void
+remove_client_query_record (struct ClientQueryRecord *record)
+{
+  struct ClientHandle *ch = record->ch;
+
+  GNUNET_CONTAINER_DLL_remove (ch->cqr_head,
+                               ch->cqr_tail,
+                               record);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (forward_map,
+                                                       &record->key,
+                                                       record));
+  if (NULL != record->hnode)
+    GNUNET_CONTAINER_heap_remove_node (record->hnode);
+  GNUNET_array_grow (record->seen_replies,
+                     record->seen_replies_count,
+                     0);
+  GNUNET_free (record);
+}
+
+
+/**
+ * Functions with this signature are called whenever a local client is
+ * connects to us.
+ *
+ * @param cls closure (NULL for dht)
+ * @param client identification of the client
+ * @param mq message queue for talking to @a client
+ * @return our `struct ClientHandle` for @a client
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct ClientHandle *ch;
+
+  (void) cls;
+  ch = GNUNET_new (struct ClientHandle);
+  ch->client = client;
+  ch->mq = mq;
+  return ch;
+}
+
+
+/**
+ * Functions with this signature are called whenever a client
+ * is disconnected on the network level.
+ *
+ * @param cls closure (NULL for dht)
+ * @param client identification of the client
+ * @param app_ctx our `struct ClientHandle` for @a client
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
+{
+  struct ClientHandle *ch = app_ctx;
+
+  (void) cls;
+  (void) client;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local client %p disconnects\n",
+              ch);
+  {
+    struct ClientMonitorRecord *next;
+
+    for (struct ClientMonitorRecord *monitor = monitor_head;
+         NULL != monitor;
+         monitor = next)
+    {
+      next = monitor->next;
+      if (monitor->ch != ch)
+        continue;
+      GNUNET_CONTAINER_DLL_remove (monitor_head,
+                                   monitor_tail,
+                                   monitor);
+      GNUNET_free (monitor);
+    }
+  }
+
+  {
+    struct ClientQueryRecord *cqr;
+
+    while (NULL != (cqr = ch->cqr_head))
+      remove_client_query_record (cqr);
+  }
+  GNUNET_free (ch);
+}
+
+
+/**
+ * Route the given request via the DHT.  This includes updating
+ * the bloom filter and retransmission times, building the P2P
+ * message and initiating the routing operation.
+ *
+ * @param cqr request to transmit
+ */
+static void
+transmit_request (struct ClientQueryRecord *cqr)
+{
+  struct GNUNET_BLOCK_Group *bg;
+  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
+
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET requests from clients injected",
+                            1,
+                            GNUNET_NO);
+  bg = GNUNET_BLOCK_group_create (GDS_block_context,
+                                  cqr->type,
+                                  NULL, /* raw data */
+                                  0, /* raw data size */
+                                  "seen-set-size",
+                                  cqr->seen_replies_count,
+                                  NULL);
+  GNUNET_BLOCK_group_set_seen (bg,
+                               cqr->seen_replies,
+                               cqr->seen_replies_count);
+  peer_bf
+    = GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                         DHT_BLOOM_SIZE,
+                                         GNUNET_CONSTANTS_BLOOMFILTER_K);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Initiating GET for %s, replication %u, already have %u replies\n",
+       GNUNET_h2s (&cqr->key),
+       cqr->replication,
+       cqr->seen_replies_count);
+  GDS_NEIGHBOURS_handle_get (cqr->type,
+                             cqr->msg_options,
+                             cqr->replication,
+                             0 /* hop count */,
+                             &cqr->key,
+                             cqr->xquery,
+                             cqr->xquery_size,
+                             bg,
+                             peer_bf);
+  GNUNET_BLOCK_group_destroy (bg);
+  GNUNET_CONTAINER_bloomfilter_free (peer_bf);
+
+  /* Exponential back-off for retries.
+   * max. is #GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD (15 min) */
+  cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF (cqr->retry_frequency);
+  cqr->retry_time = GNUNET_TIME_relative_to_absolute (cqr->retry_frequency);
+}
+
+
+/**
+ * Task that looks at the #retry_heap and transmits all of the requests
+ * on the heap that are ready for transmission.  Then re-schedules
+ * itself (unless the heap is empty).
+ *
+ * @param cls unused
+ */
+static void
+transmit_next_request_task (void *cls)
+{
+  struct ClientQueryRecord *cqr;
+
+  (void) cls;
+  retry_task = NULL;
+  while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root (retry_heap)))
+  {
+    cqr->hnode = NULL;
+    if (! GNUNET_TIME_absolute_is_past (cqr->retry_time))
+    {
+      cqr->hnode
+        = GNUNET_CONTAINER_heap_insert (retry_heap,
+                                        cqr,
+                                        cqr->retry_time.abs_value_us);
+      retry_task
+        = GNUNET_SCHEDULER_add_at (cqr->retry_time,
+                                   &transmit_next_request_task,
+                                   NULL);
+      return;
+    }
+    transmit_request (cqr);
+    cqr->hnode
+      = GNUNET_CONTAINER_heap_insert (retry_heap,
+                                      cqr,
+                                      cqr->retry_time.abs_value_us);
+  }
+}
+
+
+/**
+ * Check DHT PUT messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param dht_msg the actual message received
+ * @return #GNUNET_OK (always)
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_local_put (void *cls,
+                     const struct GNUNET_DHT_ClientPutMessage *dht_msg)
+{
+  uint32_t replication_level = ntohl (dht_msg->desired_replication_level);
+
+  (void) cls;
+  if (replication_level > GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for PUT messages.
+ *
+ * @param cls the client we received this message from
+ * @param dht_msg the actual message received
+ */
+static void
+handle_dht_local_put (void *cls,
+                      const struct GNUNET_DHT_ClientPutMessage *dht_msg)
+{
+  struct ClientHandle *ch = cls;
+  uint16_t size = ntohs (dht_msg->header.size);
+  uint32_t replication_level
+    = ntohl (dht_msg->desired_replication_level);
+  struct GNUNET_DATACACHE_Block bd = {
+    .key = dht_msg->key,
+    .expiration_time = GNUNET_TIME_absolute_ntoh (dht_msg->expiration),
+    .data = &dht_msg[1],
+    .data_size = size - sizeof (*dht_msg),
+    .type = ntohl (dht_msg->type),
+    .ro = (enum GNUNET_DHT_RouteOption) ntohl (dht_msg->options)
+  };
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handling local PUT of %lu-bytes for query %s of type %u\n",
+       (unsigned long) (size - sizeof(struct GNUNET_DHT_ClientPutMessage)),
+       GNUNET_h2s (&dht_msg->key),
+       (unsigned int) bd.type);
+#if SANITY_CHECKS > 0
+  if (GNUNET_OK !=
+      GNUNET_BLOCK_check_block (GDS_block_context,
+                                bd.type,
+                                bd.data,
+                                bd.data_size))
+  {
+    GNUNET_break (0);
+    return;
+  }
+#endif
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# PUT requests received from clients",
+                            1,
+                            GNUNET_NO);
+  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
+               "CLIENT-PUT %s\n",
+               GNUNET_h2s_full (&dht_msg->key));
+  /* give to local clients */
+  GNUNET_break (GDS_CLIENTS_handle_reply (&bd,
+                                          &bd.key,
+                                          0, NULL /* get path */));
+
+  {
+    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
+
+    peer_bf
+      = GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                           DHT_BLOOM_SIZE,
+                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
+    /* store locally */
+    if ( (0 != (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
+         (GDS_am_closest_peer (&dht_msg->key,
+                               peer_bf)))
+      GDS_DATACACHE_handle_put (&bd);
+    /* route to other peers */
+    if (GNUNET_OK !=
+        GDS_NEIGHBOURS_handle_put (&bd,
+                                   replication_level,
+                                   0 /* hop count */,
+                                   peer_bf))
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Local PUT requests not routed",
+                                1,
+                                GNUNET_NO);
+    }
+    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
+  }
+  GDS_CLIENTS_process_put (
+    &bd,
+    0,  /* hop count */
+    replication_level);
+  GNUNET_SERVICE_client_continue (ch->client);
+}
+
+
+/**
+ * Handle a result from local datacache for a GET operation.
+ *
+ * @param cls the `struct ClientHandle` of the client doing the query
+ * @param bd details about the block that was found
+ */
+static void
+handle_local_result (void *cls,
+                     const struct GNUNET_DATACACHE_Block *bd)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Datacache provided result for query key %s\n",
+              GNUNET_h2s (&bd->key));
+  GNUNET_break (GDS_CLIENTS_handle_reply (bd,
+                                          &bd->key,
+                                          0, NULL /* get_path */));
+}
+
+
+/**
+ * Check DHT GET messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param get the actual message received
+ * @return #GNUNET_OK (always)
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_local_get (void *cls,
+                     const struct GNUNET_DHT_ClientGetMessage *get)
+{
+  (void) cls;
+  (void) get;
+  /* always well-formed */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for DHT GET messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param get the actual message received
+ */
+static void
+handle_dht_local_get (void *cls,
+                      const struct GNUNET_DHT_ClientGetMessage *get)
+{
+  struct ClientHandle *ch = cls;
+  struct ClientQueryRecord *cqr;
+  uint16_t size = ntohs (get->header.size);
+  const char *xquery = (const char *) &get[1];
+  size_t xquery_size = size - sizeof(struct GNUNET_DHT_ClientGetMessage);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received GET request for %s from local client %p, xq: %.*s\n",
+       GNUNET_h2s (&get->key),
+       ch->client,
+       (int) xquery_size,
+       xquery);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET requests received from clients",
+                            1,
+                            GNUNET_NO);
+  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
+               "CLIENT-GET %s\n",
+               GNUNET_h2s_full (&get->key));
+
+  cqr = GNUNET_malloc (sizeof(struct ClientQueryRecord) + xquery_size);
+  cqr->key = get->key;
+  cqr->ch = ch;
+  cqr->xquery = (const void *) &cqr[1];
+  GNUNET_memcpy (&cqr[1],
+                 xquery,
+                 xquery_size);
+  cqr->hnode = GNUNET_CONTAINER_heap_insert (retry_heap,
+                                             cqr,
+                                             0);
+  cqr->retry_frequency = GNUNET_TIME_UNIT_SECONDS;
+  cqr->retry_time = GNUNET_TIME_absolute_get ();
+  cqr->unique_id = get->unique_id;
+  cqr->xquery_size = xquery_size;
+  cqr->replication = ntohl (get->desired_replication_level);
+  cqr->msg_options = (enum GNUNET_DHT_RouteOption) ntohl (get->options);
+  cqr->type = ntohl (get->type);
+  GNUNET_CONTAINER_DLL_insert (ch->cqr_head,
+                               ch->cqr_tail,
+                               cqr);
+  GNUNET_CONTAINER_multihashmap_put (forward_map,
+                                     &cqr->key,
+                                     cqr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GDS_CLIENTS_process_get (cqr->msg_options,
+                           cqr->type,
+                           0, /* hop count */
+                           cqr->replication,
+                           &get->key);
+  /* start remote requests */
+  if (NULL != retry_task)
+    GNUNET_SCHEDULER_cancel (retry_task);
+  retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task,
+                                         NULL);
+  /* perform local lookup */
+  GDS_DATACACHE_handle_get (&get->key,
+                            cqr->type,
+                            cqr->xquery,
+                            xquery_size,
+                            NULL,
+                            &handle_local_result,
+                            ch);
+  GNUNET_SERVICE_client_continue (ch->client);
+}
+
+
+/**
+ * Closure for #find_by_unique_id().
+ */
+struct FindByUniqueIdContext
+{
+  /**
+   * Where to store the result, if found.
+   */
+  struct ClientQueryRecord *cqr;
+
+  /**
+   * Unique ID to look for.
+   */
+  uint64_t unique_id;
+};
+
+
+/**
+ * Function called for each existing DHT record for the given
+ * query.  Checks if it matches the UID given in the closure
+ * and if so returns the entry as a result.
+ *
+ * @param cls the search context
+ * @param key query for the lookup (not used)
+ * @param value the `struct ClientQueryRecord`
+ * @return #GNUNET_YES to continue iteration (result not yet found)
+ */
+static enum GNUNET_GenericReturnValue
+find_by_unique_id (void *cls,
+                   const struct GNUNET_HashCode *key,
+                   void *value)
+{
+  struct FindByUniqueIdContext *fui_ctx = cls;
+  struct ClientQueryRecord *cqr = value;
+
+  if (cqr->unique_id != fui_ctx->unique_id)
+    return GNUNET_YES;
+  fui_ctx->cqr = cqr;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Check "GET result seen" messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param seen the actual message received
+ * @return #GNUNET_OK if @a seen is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_local_get_result_seen (
+  void *cls,
+  const struct GNUNET_DHT_ClientGetResultSeenMessage *seen)
+{
+  uint16_t size = ntohs (seen->header.size);
+  unsigned int hash_count =
+    (size - sizeof(*seen))
+    / sizeof(struct GNUNET_HashCode);
+
+  if (size != sizeof(*seen) + hash_count * sizeof(struct GNUNET_HashCode))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for "GET result seen" messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param seen the actual message received
+ */
+static void
+handle_dht_local_get_result_seen (
+  void *cls,
+  const struct GNUNET_DHT_ClientGetResultSeenMessage *seen)
+{
+  struct ClientHandle *ch = cls;
+  uint16_t size = ntohs (seen->header.size);
+  unsigned int hash_count = (size - sizeof(*seen))
+                            / sizeof(struct GNUNET_HashCode);
+  const struct GNUNET_HashCode *hc = (const struct GNUNET_HashCode*) &seen[1];
+  struct FindByUniqueIdContext fui_ctx = {
+    .unique_id = seen->unique_id
+  };
+  unsigned int old_count;
+  struct ClientQueryRecord *cqr;
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
+                                              &seen->key,
+                                              &find_by_unique_id,
+                                              &fui_ctx);
+  if (NULL == (cqr = fui_ctx.cqr))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (ch->client);
+    return;
+  }
+  /* finally, update 'seen' list */
+  old_count = cqr->seen_replies_count;
+  GNUNET_array_grow (cqr->seen_replies,
+                     cqr->seen_replies_count,
+                     cqr->seen_replies_count + hash_count);
+  GNUNET_memcpy (&cqr->seen_replies[old_count],
+                 hc,
+                 sizeof(struct GNUNET_HashCode) * hash_count);
+}
+
+
+/**
+ * Closure for #remove_by_unique_id().
+ */
+struct RemoveByUniqueIdContext
+{
+  /**
+   * Client that issued the removal request.
+   */
+  struct ClientHandle *ch;
+
+  /**
+   * Unique ID of the request.
+   */
+  uint64_t unique_id;
+};
+
+
+/**
+ * Iterator over hash map entries that frees all entries
+ * that match the given client and unique ID.
+ *
+ * @param cls unique ID and client to search for in source routes
+ * @param key current key code
+ * @param value value in the hash map, a ClientQueryRecord
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static enum GNUNET_GenericReturnValue
+remove_by_unique_id (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
+{
+  const struct RemoveByUniqueIdContext *ctx = cls;
+  struct ClientQueryRecord *cqr = value;
+
+  if (cqr->unique_id != ctx->unique_id)
+    return GNUNET_YES;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Removing client %p's record for key %s (by unique id)\n",
+              ctx->ch->client,
+              GNUNET_h2s (key));
+  remove_client_query_record (cqr);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Handler for any generic DHT stop messages, calls the appropriate handler
+ * depending on message type (if processed locally)
+ *
+ * @param cls client we received this message from
+ * @param dht_stop_msg the actual message received
+ *
+ */
+static void
+handle_dht_local_get_stop (
+  void *cls,
+  const struct GNUNET_DHT_ClientGetStopMessage *dht_stop_msg)
+{
+  struct ClientHandle *ch = cls;
+  struct RemoveByUniqueIdContext ctx;
+
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET STOP requests received from clients",
+                            1,
+                            GNUNET_NO);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received GET STOP request for %s from local client %p\n",
+       GNUNET_h2s (&dht_stop_msg->key),
+       ch->client);
+  ctx.ch = ch;
+  ctx.unique_id = dht_stop_msg->unique_id;
+  GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
+                                              &dht_stop_msg->key,
+                                              &remove_by_unique_id,
+                                              &ctx);
+  GNUNET_SERVICE_client_continue (ch->client);
+}
+
+
+/**
+ * Closure for #forward_reply()
+ */
+struct ForwardReplyContext
+{
+  /**
+   * Block details.
+   */
+  const struct GNUNET_DATACACHE_Block *bd;
+
+  /**
+   * GET path taken.
+   */
+  const struct GNUNET_DHT_PathElement *get_path;
+
+  /**
+   * Number of entries in @e get_path.
+   */
+  unsigned int get_path_length;
+
+};
+
+
+/**
+ * Iterator over hash map entries that send a given reply to
+ * each of the matching clients.  With some tricky recycling
+ * of the buffer.
+ *
+ * @param cls the `struct ForwardReplyContext`
+ * @param query_hash hash of the query for which this may be a reply
+ * @param value value in the hash map, a ClientQueryRecord
+ * @return #GNUNET_YES (we should continue to iterate),
+ *         if the result is mal-formed, #GNUNET_NO
+ */
+static enum GNUNET_GenericReturnValue
+forward_reply (void *cls,
+               const struct GNUNET_HashCode *query_hash,
+               void *value)
+{
+  struct ForwardReplyContext *frc = cls;
+  struct ClientQueryRecord *record = value;
+  const struct GNUNET_DATACACHE_Block *bd = frc->bd;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_ClientResultMessage *reply;
+  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
+  bool do_free;
+  struct GNUNET_HashCode ch;
+  struct GNUNET_DHT_PathElement *paths;
+  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
+  size_t xsize = bd->data_size;
+
+  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
+               "CLIENT-RESULT %s\n",
+               GNUNET_h2s_full (&bd->key));
+  if ( (record->type != GNUNET_BLOCK_TYPE_ANY) &&
+       (record->type != bd->type) )
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Record type mismatch, not passing request for key %s to local client\n",
+         GNUNET_h2s (&bd->key));
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Key match, type mismatches in REPLY to CLIENT",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_YES;          /* type mismatch */
+  }
+  if ( (0 == (record->msg_options & GNUNET_DHT_RO_FIND_APPROXIMATE)) &&
+       (0 != GNUNET_memcmp (&bd->key,
+                            query_hash)) )
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Inexact key match, but exact match required",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_YES;          /* type mismatch */
+  }
+  GNUNET_CRYPTO_hash (bd->data,
+                      bd->data_size,
+                      &ch);
+  for (unsigned int i = 0; i < record->seen_replies_count; i++)
+    if (0 ==
+        GNUNET_memcmp (&record->seen_replies[i],
+                       &ch))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Duplicate reply, not passing request for key %s to local client\n",
+           GNUNET_h2s (&bd->key));
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Duplicate REPLIES to CLIENT request dropped",
+                                1,
+                                GNUNET_NO);
+      return GNUNET_YES;        /* duplicate */
+    }
+  eval
+    = GNUNET_BLOCK_check_reply (GDS_block_context,
+                                record->type,
+                                NULL,
+                                &bd->key,
+                                record->xquery,
+                                record->xquery_size,
+                                bd->data,
+                                bd->data_size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Evaluation result is %d for key %s for local client's query\n",
+       (int) eval,
+       GNUNET_h2s (&bd->key));
+  switch (eval)
+  {
+  case GNUNET_BLOCK_REPLY_OK_LAST:
+    do_free = true;
+    break;
+  case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
+  case GNUNET_BLOCK_REPLY_OK_MORE:
+    GNUNET_array_append (record->seen_replies,
+                         record->seen_replies_count,
+                         ch);
+    do_free = false;
+    break;
+  case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
+    /* should be impossible to encounter here */
+    GNUNET_break (0);
+    return GNUNET_YES;
+  case GNUNET_BLOCK_REPLY_IRRELEVANT:
+    return GNUNET_YES;
+  default:
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# RESULTS queued for clients",
+                            1,
+                            GNUNET_NO);
+  xsize += (frc->get_path_length + bd->put_path_length)
+           * sizeof(struct GNUNET_DHT_PathElement);
+  if (truncated)
+    xsize += sizeof (struct GNUNET_PeerIdentity);
+
+#if SUPER_REDUNDANT_CHECK
+  GNUNET_break (0 ==
+                GNUNET_DHT_verify_path (bd->data,
+                                        bd->data_size,
+                                        bd->expiration_time,
+                                        truncated
+                                        ? &bd->trunc_peer
+                                        : NULL,
+                                        bd->put_path,
+                                        bd->put_path_length,
+                                        frc->get_path,
+                                        frc->get_path_length,
+                                        &GDS_my_identity));
+#endif
+
+  env = GNUNET_MQ_msg_extra (reply,
+                             xsize,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT);
+  reply->type = htonl (bd->type);
+  reply->options = htonl (bd->ro);
+  reply->get_path_length = htonl (frc->get_path_length);
+  reply->put_path_length = htonl (bd->put_path_length);
+  reply->unique_id = record->unique_id;
+  reply->expiration = GNUNET_TIME_absolute_hton (bd->expiration_time);
+  reply->key = *query_hash;
+  if (truncated)
+  {
+    void *tgt = &reply[1];
+
+    GNUNET_memcpy (tgt,
+                   &bd->trunc_peer,
+                   sizeof (struct GNUNET_PeerIdentity));
+    paths = (struct GNUNET_DHT_PathElement *)
+            (tgt + sizeof (struct GNUNET_PeerIdentity));
+  }
+  else
+  {
+    paths = (struct GNUNET_DHT_PathElement *) &reply[1];
+  }
+  GNUNET_memcpy (paths,
+                 bd->put_path,
+                 sizeof(struct GNUNET_DHT_PathElement)
+                 * bd->put_path_length);
+  GNUNET_memcpy (&paths[bd->put_path_length],
+                 frc->get_path,
+                 sizeof(struct GNUNET_DHT_PathElement)
+                 * frc->get_path_length);
+  GNUNET_memcpy (&paths[frc->get_path_length + bd->put_path_length],
+                 bd->data,
+                 bd->data_size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending reply to query %s for client %p\n",
+       GNUNET_h2s (query_hash),
+       record->ch->client);
+  GNUNET_MQ_send (record->ch->mq,
+                  env);
+  if (GNUNET_YES == do_free)
+    remove_client_query_record (record);
+  return GNUNET_YES;
+}
+
+
+bool
+GDS_CLIENTS_handle_reply (const struct GNUNET_DATACACHE_Block *bd,
+                          const struct GNUNET_HashCode *query_hash,
+                          unsigned int get_path_length,
+                          const struct GNUNET_DHT_PathElement *get_path)
+{
+  struct ForwardReplyContext frc;
+  size_t msize = sizeof (struct GNUNET_DHT_ClientResultMessage)
+                 + bd->data_size
+                 + (get_path_length + bd->put_path_length)
+                 * sizeof(struct GNUNET_DHT_PathElement);
+#if SANITY_CHECKS > 1
+  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
+#endif
+
+  if (msize >= GNUNET_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return false;
+  }
+#if SANITY_CHECKS > 1
+  if (0 !=
+      GNUNET_DHT_verify_path (bd->data,
+                              bd->data_size,
+                              bd->expiration_time,
+                              truncated
+                              ? &bd->trunc_peer
+                              : NULL,
+                              bd->put_path,
+                              bd->put_path_length,
+                              get_path,
+                              get_path_length,
+                              &GDS_my_identity))
+  {
+    GNUNET_break (0);
+    return false;
+  }
+#endif
+  frc.bd = bd;
+  frc.get_path = get_path;
+  frc.get_path_length = get_path_length;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Forwarding reply for query hash %s with GPL %u and PPL %u to client\n",
+       GNUNET_h2s (query_hash),
+       get_path_length,
+       bd->put_path_length);
+  if (0 ==
+      GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
+                                                  query_hash,
+                                                  &forward_reply,
+                                                  &frc))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No matching client for reply for query %s\n",
+         GNUNET_h2s (query_hash));
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# REPLIES ignored for CLIENTS (no match)",
+                              1,
+                              GNUNET_NO);
+  }
+  return true;
+}
+
+
+/* **************** HELLO logic ***************** */
+
+/**
+ * Handler for HELLO GET message. Reply to client
+ * with a URL of our HELLO.
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ *
+ */
+static void
+handle_dht_local_hello_get (void *cls,
+                            const struct GNUNET_MessageHeader *msg)
+{
+  struct ClientHandle *ch = cls;
+  char *url = GNUNET_HELLO_builder_to_url (GDS_my_hello,
+                                           &GDS_my_private_key);
+  size_t slen = strlen (url) + 1;
+  struct GNUNET_MessageHeader *hdr;
+  struct GNUNET_MQ_Envelope *env;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Handling request from local client for my HELLO\n");
+  env = GNUNET_MQ_msg_extra (hdr,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL);
+  memcpy (&hdr[1],
+          url,
+          slen);
+  GNUNET_free (url);
+  GNUNET_MQ_send (ch->mq,
+                  env);
+  GNUNET_SERVICE_client_continue (ch->client);
+}
+
+
+/**
+ * Process a client HELLO message received from the service.
+ *
+ * @param cls the client we received this message from
+ * @param hdr HELLO URL message from the service.
+ * @return #GNUNET_OK if @a hdr is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_local_hello_offer (void *cls,
+                             const struct GNUNET_MessageHeader *hdr)
+{
+  uint16_t len = ntohs (hdr->size);
+  const char *buf = (const char *) &hdr[1];
+
+  (void) cls;
+  if ('\0' != buf[len - sizeof (*hdr) - 1])
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for HELLO OFFER message.  Try to use the
+ * HELLO to connect to another peer.
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ */
+static void
+handle_dht_local_hello_offer (void *cls,
+                              const struct GNUNET_MessageHeader *msg)
+{
+  struct ClientHandle *ch = cls;
+  const char *url = (const char *) &msg[1];
+  struct GNUNET_HELLO_Builder *b;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local client provided HELLO URL %s\n",
+              url);
+  b = GNUNET_HELLO_builder_from_url (url);
+  if (NULL == b)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (ch->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (ch->client);
+  GNUNET_HELLO_builder_iterate (b,
+                                &GDS_try_connect,
+                                NULL);
+  GNUNET_HELLO_builder_free (b);
+}
+
+
+/* ************* logic for monitors ************** */
+
+
+/**
+ * Handler for monitor start messages
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ *
+ */
+static void
+handle_dht_local_monitor (void *cls,
+                          const struct GNUNET_DHT_MonitorStartStopMessage *msg)
+{
+  struct ClientHandle *ch = cls;
+  struct ClientMonitorRecord *r;
+
+  r = GNUNET_new (struct ClientMonitorRecord);
+  r->ch = ch;
+  r->type = ntohl (msg->type);
+  r->get = ntohs (msg->get);
+  r->get_resp = ntohs (msg->get_resp);
+  r->put = ntohs (msg->put);
+  if (0 != ntohs (msg->filter_key))
+    r->key = msg->key;
+  GNUNET_CONTAINER_DLL_insert (monitor_head,
+                               monitor_tail,
+                               r);
+  GNUNET_SERVICE_client_continue (ch->client);
+}
+
+
+/**
+ * Handler for monitor stop messages
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ */
+static void
+handle_dht_local_monitor_stop (
+  void *cls,
+  const struct GNUNET_DHT_MonitorStartStopMessage *msg)
+{
+  struct ClientHandle *ch = cls;
+
+  GNUNET_SERVICE_client_continue (ch->client);
+  for (struct ClientMonitorRecord *r = monitor_head;
+       NULL != r;
+       r = r->next)
+  {
+    bool keys_match;
+
+    keys_match =
+      (GNUNET_is_zero (&r->key))
+      ? (0 == ntohs (msg->filter_key))
+      : ( (0 != ntohs (msg->filter_key)) &&
+          (! GNUNET_memcmp (&r->key,
+                            &msg->key)) );
+    if ( (ch == r->ch) &&
+         (ntohl (msg->type) == r->type) &&
+         (r->get == msg->get) &&
+         (r->get_resp == msg->get_resp) &&
+         (r->put == msg->put) &&
+         keys_match)
+    {
+      GNUNET_CONTAINER_DLL_remove (monitor_head,
+                                   monitor_tail,
+                                   r);
+      GNUNET_free (r);
+      return;     /* Delete only ONE entry */
+    }
+  }
+}
+
+
+/**
+ * Function to call by #for_matching_monitors().
+ *
+ * @param cls closure
+ * @param m a matching monitor
+ */
+typedef void
+(*MonitorAction)(void *cls,
+                 struct ClientMonitorRecord *m);
+
+
+/**
+ * Call @a cb on all monitors that watch for blocks of @a type
+ * and key @a key.
+ *
+ * @param type the type to match
+ * @param key the key to match
+ * @param cb function to call
+ * @param cb_cls closure for @a cb
+ */
+static void
+for_matching_monitors (enum GNUNET_BLOCK_Type type,
+                       const struct GNUNET_HashCode *key,
+                       MonitorAction cb,
+                       void *cb_cls)
+{
+  struct ClientHandle **cl = NULL;
+  unsigned int cl_size = 0;
+
+  for (struct ClientMonitorRecord *m = monitor_head;
+       NULL != m;
+       m = m->next)
+  {
+    bool found = false;
+
+    if ( (GNUNET_BLOCK_TYPE_ANY != m->type) &&
+         (m->type != type) )
+      continue;
+    if ( (! GNUNET_is_zero (&m->key)) &&
+         (0 ==
+          GNUNET_memcmp (key,
+                         &m->key)) )
+      continue;
+    /* Don't send duplicates */
+    for (unsigned i = 0; i < cl_size; i++)
+      if (cl[i] == m->ch)
+      {
+        found = true;
+        break;
+      }
+    if (found)
+      continue;
+    GNUNET_array_append (cl,
+                         cl_size,
+                         m->ch);
+    cb (cb_cls,
+        m);
+  }
+  GNUNET_free (cl);
+}
+
+
+/**
+ * Closure for #get_action();
+ */
+struct GetActionContext
+{
+  enum GNUNET_DHT_RouteOption options;
+  enum GNUNET_BLOCK_Type type;
+  uint32_t hop_count;
+  uint32_t desired_replication_level;
+  struct GNUNET_PeerIdentity trunc_peer;
+  const struct GNUNET_HashCode *key;
+};
+
+
+/**
+ * Function called on monitors that match a GET.
+ * Sends the GET notification to the monitor.
+ *
+ * @param cls a `struct GetActionContext`
+ * @param m a matching monitor
+ */
+static void
+get_action (void *cls,
+            struct ClientMonitorRecord *m)
+{
+  struct GetActionContext *gac = cls;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_MonitorGetMessage *mmsg;
+
+  env = GNUNET_MQ_msg (mmsg,
+                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET);
+  mmsg->options = htonl (gac->options);
+  mmsg->type = htonl (gac->type);
+  mmsg->hop_count = htonl (gac->hop_count);
+  mmsg->desired_replication_level = htonl (gac->desired_replication_level);
+  mmsg->key = *gac->key;
+  GNUNET_MQ_send (m->ch->mq,
+                  env);
+}
+
+
+void
+GDS_CLIENTS_process_get (enum GNUNET_DHT_RouteOption options,
+                         enum GNUNET_BLOCK_Type type,
+                         uint32_t hop_count,
+                         uint32_t desired_replication_level,
+                         const struct GNUNET_HashCode *key)
+{
+  struct GetActionContext gac = {
+    .options = options,
+    .type = type,
+    .hop_count = hop_count,
+    .desired_replication_level = desired_replication_level,
+    .key = key
+  };
+
+  for_matching_monitors (type,
+                         key,
+                         &get_action,
+                         &gac);
+}
+
+
+/**
+ * Closure for response_action().
+ */
+struct ResponseActionContext
+{
+  const struct GNUNET_DATACACHE_Block *bd;
+  const struct GNUNET_DHT_PathElement *get_path;
+  unsigned int get_path_length;
+};
+
+
+/**
+ * Function called on monitors that match a response.
+ * Sends the response notification to the monitor.
+ *
+ * @param cls a `struct ResponseActionContext`
+ * @param m a matching monitor
+ */
+static void
+response_action (void *cls,
+                 struct ClientMonitorRecord *m)
+{
+  const struct ResponseActionContext *resp_ctx = cls;
+  const struct GNUNET_DATACACHE_Block *bd = resp_ctx->bd;
+  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_MonitorGetRespMessage *mmsg;
+  struct GNUNET_DHT_PathElement *path;
+  size_t msize;
+
+  msize = bd->data_size;
+  msize += (resp_ctx->get_path_length + bd->put_path_length)
+           * sizeof(struct GNUNET_DHT_PathElement);
+  if (truncated)
+    msize += sizeof (struct GNUNET_PeerIdentity);
+  env = GNUNET_MQ_msg_extra (mmsg,
+                             msize,
+                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP);
+  mmsg->type = htonl (bd->type);
+  mmsg->put_path_length = htonl (bd->put_path_length);
+  mmsg->get_path_length = htonl (resp_ctx->get_path_length);
+  mmsg->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
+  mmsg->key = bd->key;
+  if (truncated)
+  {
+    void *tgt = &mmsg[1];
+
+    GNUNET_memcpy (tgt,
+                   &bd->trunc_peer,
+                   sizeof (struct GNUNET_PeerIdentity));
+    path = (struct GNUNET_DHT_PathElement *)
+           (tgt + sizeof (struct GNUNET_PeerIdentity));
+  }
+  else
+  {
+    path = (struct GNUNET_DHT_PathElement *) &mmsg[1];
+  }
+  GNUNET_memcpy (path,
+                 bd->put_path,
+                 bd->put_path_length * sizeof(struct GNUNET_DHT_PathElement));
+  GNUNET_memcpy (path,
+                 resp_ctx->get_path,
+                 resp_ctx->get_path_length
+                 * sizeof(struct GNUNET_DHT_PathElement));
+  GNUNET_memcpy (&path[resp_ctx->get_path_length],
+                 bd->data,
+                 bd->data_size);
+  GNUNET_MQ_send (m->ch->mq,
+                  env);
+}
+
+
+void
+GDS_CLIENTS_process_get_resp (const struct GNUNET_DATACACHE_Block *bd,
+                              const struct GNUNET_DHT_PathElement *get_path,
+                              unsigned int get_path_length)
+{
+  struct ResponseActionContext rac = {
+    .bd = bd,
+    .get_path = get_path,
+    .get_path_length = get_path_length
+  };
+
+  for_matching_monitors (bd->type,
+                         &bd->key,
+                         &response_action,
+                         &rac);
+}
+
+
+/**
+ * Closure for put_action().
+ */
+struct PutActionContext
+{
+  const struct GNUNET_DATACACHE_Block *bd;
+  uint32_t hop_count;
+  uint32_t desired_replication_level;
+};
+
+
+/**
+ * Function called on monitors that match a PUT.
+ * Sends the PUT notification to the monitor.
+ *
+ * @param cls a `struct PutActionContext`
+ * @param m a matching monitor
+ */
+static void
+put_action (void *cls,
+            struct ClientMonitorRecord *m)
+{
+  const struct PutActionContext *put_ctx = cls;
+  const struct GNUNET_DATACACHE_Block *bd = put_ctx->bd;
+  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_DHT_MonitorPutMessage *mmsg;
+  struct GNUNET_DHT_PathElement *msg_path;
+  size_t msize;
+
+  msize = bd->data_size
+          + bd->put_path_length
+          * sizeof(struct GNUNET_DHT_PathElement);
+  if (truncated)
+    msize += sizeof (struct GNUNET_PeerIdentity);
+  env = GNUNET_MQ_msg_extra (mmsg,
+                             msize,
+                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT);
+  mmsg->options = htonl (bd->ro);
+  mmsg->type = htonl (bd->type);
+  mmsg->hop_count = htonl (put_ctx->hop_count);
+  mmsg->desired_replication_level = htonl (put_ctx->desired_replication_level);
+  mmsg->put_path_length = htonl (bd->put_path_length);
+  mmsg->key = bd->key;
+  mmsg->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
+  if (truncated)
+  {
+    void *tgt = &mmsg[1];
+
+    GNUNET_memcpy (tgt,
+                   &bd->trunc_peer,
+                   sizeof (struct GNUNET_PeerIdentity));
+    msg_path = (struct GNUNET_DHT_PathElement *)
+               (tgt + sizeof (struct GNUNET_PeerIdentity));
+  }
+  else
+  {
+    msg_path = (struct GNUNET_DHT_PathElement *) &mmsg[1];
+  }
+  GNUNET_memcpy (msg_path,
+                 bd->put_path,
+                 bd->put_path_length * sizeof(struct GNUNET_DHT_PathElement));
+  GNUNET_memcpy (&msg_path[bd->put_path_length],
+                 bd->data,
+                 bd->data_size);
+  GNUNET_MQ_send (m->ch->mq,
+                  env);
+}
+
+
+void
+GDS_CLIENTS_process_put (const struct GNUNET_DATACACHE_Block *bd,
+                         uint32_t hop_count,
+                         uint32_t desired_replication_level)
+{
+  struct PutActionContext put_ctx = {
+    .bd = bd,
+    .hop_count = hop_count,
+    .desired_replication_level = desired_replication_level
+  };
+
+  for_matching_monitors (bd->type,
+                         &bd->key,
+                         &put_action,
+                         &put_ctx);
+}
+
+
+/* ********************** Initialization logic ***************** */
+
+
+/**
+ * Initialize client subsystem.
+ */
+static void
+GDS_CLIENTS_init (void)
+{
+  forward_map
+    = GNUNET_CONTAINER_multihashmap_create (1024,
+                                            GNUNET_YES);
+  retry_heap
+    = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+}
+
+
+/**
+ * Shutdown client subsystem.
+ */
+static void
+GDS_CLIENTS_stop (void)
+{
+  if (NULL != retry_task)
+  {
+    GNUNET_SCHEDULER_cancel (retry_task);
+    retry_task = NULL;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ *
+ * @param name name of the service, like "dht" or "xdht"
+ * @param run name of the initializaton method for the service
+ */
+#define GDS_DHT_SERVICE_INIT(name, run)          \
+  GNUNET_SERVICE_MAIN \
+    (name, \
+    GNUNET_SERVICE_OPTION_NONE, \
+    run, \
+    &client_connect_cb, \
+    &client_disconnect_cb, \
+    NULL, \
+    GNUNET_MQ_hd_var_size (dht_local_put, \
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT, \
+                           struct GNUNET_DHT_ClientPutMessage, \
+                           NULL), \
+    GNUNET_MQ_hd_var_size (dht_local_get, \
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET, \
+                           struct GNUNET_DHT_ClientGetMessage, \
+                           NULL), \
+    GNUNET_MQ_hd_fixed_size (dht_local_get_stop, \
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP, \
+                             struct GNUNET_DHT_ClientGetStopMessage, \
+                             NULL), \
+    GNUNET_MQ_hd_fixed_size (dht_local_monitor, \
+                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_START, \
+                             struct GNUNET_DHT_MonitorStartStopMessage, \
+                             NULL), \
+    GNUNET_MQ_hd_fixed_size (dht_local_monitor_stop, \
+                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP, \
+                             struct GNUNET_DHT_MonitorStartStopMessage, \
+                             NULL), \
+    GNUNET_MQ_hd_var_size (dht_local_get_result_seen, \
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, \
+                           struct GNUNET_DHT_ClientGetResultSeenMessage, \
+                           NULL), \
+    GNUNET_MQ_hd_fixed_size (dht_local_hello_get,              \
+                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET, \
+                             struct GNUNET_MessageHeader, \
+                             NULL), \
+    GNUNET_MQ_hd_var_size (dht_local_hello_offer, \
+                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL, \
+                           struct GNUNET_MessageHeader, \
+                           NULL), \
+    GNUNET_MQ_handler_end ())
+
+
+/**
+ * MINIMIZE heap size (way below 128k) since this process doesn't need much.
+ */
+void __attribute__ ((destructor))
+GDS_CLIENTS_done ()
+{
+  if (NULL != retry_heap)
+  {
+    GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (retry_heap));
+    GNUNET_CONTAINER_heap_destroy (retry_heap);
+    retry_heap = NULL;
+  }
+  if (NULL != forward_map)
+  {
+    GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (forward_map));
+    GNUNET_CONTAINER_multihashmap_destroy (forward_map);
+    forward_map = NULL;
+  }
+}
+
+
+/* end of gnunet-service-dht_clients.c */
diff --git a/src/service/dht/gnunet-service-dht_datacache.c b/src/service/dht/gnunet-service-dht_datacache.c
new file mode 100644
index 000000000..dcb6308a9
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_datacache.c
@@ -0,0 +1,291 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 2015, 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/gnunet-service-dht_datacache.c
+ * @brief GNUnet DHT service's datacache integration
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_datacache_lib.h"
+#include "gnunet-service-dht_datacache.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "gnunet-service-dht_routing.h"
+#include "gnunet-service-dht.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "dht-dhtcache", __VA_ARGS__)
+
+/**
+ * How many "closest" results to we return for migration when
+ * asked (at most)?
+ */
+#define NUM_CLOSEST 4
+
+
+/**
+ * Handle to the datacache service (for inserting/retrieving data)
+ */
+static struct GNUNET_DATACACHE_Handle *datacache;
+
+
+void
+GDS_DATACACHE_handle_put (const struct GNUNET_DATACACHE_Block *bd)
+{
+  struct GNUNET_HashCode xor;
+  enum GNUNET_GenericReturnValue r;
+
+  if (NULL == datacache)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "PUT request received, but have no datacache!\n");
+    return;
+  }
+  if (bd->data_size >= GNUNET_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  /* Put size is actual data size plus struct overhead plus path length (if any) */
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# ITEMS stored in datacache",
+                            1,
+                            GNUNET_NO);
+  GNUNET_CRYPTO_hash_xor (&bd->key,
+                          &GDS_my_identity_hash,
+                          &xor);
+  r = GNUNET_DATACACHE_put (datacache,
+                            GNUNET_CRYPTO_hash_count_leading_zeros (&xor),
+                            bd);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "DATACACHE PUT for key %s [%lu] completed (%d) after %u hops\n",
+       GNUNET_h2s (&bd->key),
+       (unsigned long) bd->data_size,
+       r,
+       bd->put_path_length);
+}
+
+
+/**
+ * Context containing information about a GET request.
+ */
+struct GetRequestContext
+{
+  /**
+   * extended query (see gnunet_block_lib.h).
+   */
+  const void *xquery;
+
+  /**
+   * The key this request was about
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Block group to use to evaluate replies (updated)
+   */
+  struct GNUNET_BLOCK_Group *bg;
+
+  /**
+   * Function to call on results.
+   */
+  GDS_DATACACHE_GetCallback gc;
+
+  /**
+   * Closure for @e gc.
+   */
+  void *gc_cls;
+
+  /**
+   * Number of bytes in xquery.
+   */
+  size_t xquery_size;
+
+  /**
+   * Return value to give back.
+   */
+  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
+};
+
+
+/**
+ * Iterator for local get request results,
+ *
+ * @param cls closure for iterator, a `struct GetRequestContext`
+ * @param bd block data
+ * @return #GNUNET_OK to continue iteration, anything else
+ * to stop iteration.
+ */
+static enum GNUNET_GenericReturnValue
+datacache_get_iterator (void *cls,
+                        const struct GNUNET_DATACACHE_Block *bd)
+{
+  struct GetRequestContext *ctx = cls;
+  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
+
+  if (GNUNET_TIME_absolute_is_past (bd->expiration_time))
+  {
+    GNUNET_break (0);  /* why does datacache return expired values? */
+    return GNUNET_OK;   /* skip expired record */
+  }
+  eval
+    = GNUNET_BLOCK_check_reply (GDS_block_context,
+                                bd->type,
+                                ctx->bg,
+                                &bd->key,
+                                ctx->xquery,
+                                ctx->xquery_size,
+                                bd->data,
+                                bd->data_size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Evaluated reply for query %s in datacache, result is %d\n",
+       GNUNET_h2s (&bd->key),
+       (int) eval);
+  ctx->eval = eval;
+  switch (eval)
+  {
+  case GNUNET_BLOCK_REPLY_OK_MORE:
+  case GNUNET_BLOCK_REPLY_OK_LAST:
+  case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
+    /* forward to initiator */
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Good RESULTS found in datacache",
+                              1,
+                              GNUNET_NO);
+    ctx->gc (ctx->gc_cls,
+             bd);
+    break;
+  case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Duplicate RESULTS found in datacache",
+                              1,
+                              GNUNET_NO);
+    break;
+  case GNUNET_BLOCK_REPLY_IRRELEVANT:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Irrelevant RESULTS found in datacache",
+                              1,
+                              GNUNET_NO);
+    break;
+  }
+  return (eval == GNUNET_BLOCK_REPLY_OK_LAST) ? GNUNET_NO : GNUNET_OK;
+}
+
+
+enum GNUNET_BLOCK_ReplyEvaluationResult
+GDS_DATACACHE_handle_get (const struct GNUNET_HashCode *key,
+                          enum GNUNET_BLOCK_Type type,
+                          const void *xquery,
+                          size_t xquery_size,
+                          struct GNUNET_BLOCK_Group *bg,
+                          GDS_DATACACHE_GetCallback gc,
+                          void *gc_cls)
+{
+  struct GetRequestContext ctx = {
+    .eval = GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
+    .key = *key,
+    .xquery = xquery,
+    .xquery_size = xquery_size,
+    .bg = bg,
+    .gc = gc,
+    .gc_cls = gc_cls
+  };
+  unsigned int r;
+
+  if (NULL == datacache)
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET requests given to datacache",
+                            1,
+                            GNUNET_NO);
+  r = GNUNET_DATACACHE_get (datacache,
+                            key,
+                            type,
+                            &datacache_get_iterator,
+                            &ctx);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "DATACACHE GET for key %s completed (%d). %u results found.\n",
+       GNUNET_h2s (key),
+       ctx.eval,
+       r);
+  return ctx.eval;
+}
+
+
+enum GNUNET_BLOCK_ReplyEvaluationResult
+GDS_DATACACHE_get_closest (const struct GNUNET_HashCode *key,
+                           enum GNUNET_BLOCK_Type type,
+                           const void *xquery,
+                           size_t xquery_size,
+                           struct GNUNET_BLOCK_Group *bg,
+                           GDS_DATACACHE_GetCallback cb,
+                           void *cb_cls)
+{
+  struct GetRequestContext ctx = {
+    .eval = GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
+    .key = *key,
+    .xquery = xquery,
+    .xquery_size = xquery_size,
+    .bg = bg,
+    .gc = cb,
+    .gc_cls = cb_cls
+  };
+  unsigned int r;
+
+  if (NULL == datacache)
+    return GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED;
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET closest requests given to datacache",
+                            1,
+                            GNUNET_NO);
+  r = GNUNET_DATACACHE_get_closest (datacache,
+                                    key,
+                                    type,
+                                    NUM_CLOSEST,
+                                    &datacache_get_iterator,
+                                    &ctx);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "DATACACHE approximate GET for key %s completed (%d). %u results found.\n",
+       GNUNET_h2s (key),
+       ctx.eval,
+       r);
+  return ctx.eval;
+}
+
+
+void
+GDS_DATACACHE_init ()
+{
+  datacache = GNUNET_DATACACHE_create (GDS_cfg,
+                                       "dhtcache");
+}
+
+
+void
+GDS_DATACACHE_done ()
+{
+  if (NULL != datacache)
+  {
+    GNUNET_DATACACHE_destroy (datacache);
+    datacache = NULL;
+  }
+}
+
+
+/* end of gnunet-service-dht_datacache.c */
diff --git a/src/service/dht/gnunet-service-dht_datacache.h b/src/service/dht/gnunet-service-dht_datacache.h
new file mode 100644
index 000000000..b15e5378f
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_datacache.h
@@ -0,0 +1,115 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 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/gnunet-service-dht_datacache.h
+ * @brief GNUnet DHT service's datacache integration
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#ifndef GNUNET_SERVICE_DHT_DATACACHE_H
+#define GNUNET_SERVICE_DHT_DATACACHE_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_block_lib.h"
+#include "gnunet_dht_service.h"
+#include "gnunet_datacache_lib.h"
+
+
+/**
+ * Handle a datum we've received from another peer.  Cache if
+ * possible.
+ *
+ * @param bd block data to cache
+ */
+void
+GDS_DATACACHE_handle_put (const struct GNUNET_DATACACHE_Block *bd);
+
+
+/**
+ * Handle a result for a GET operation.
+ *
+ * @param cls closure
+ * @param bd block details
+ */
+typedef void
+(*GDS_DATACACHE_GetCallback)(void *cls,
+                             const struct GNUNET_DATACACHE_Block *bd);
+
+
+/**
+ * Handle a GET request we've received from another peer.
+ *
+ * @param key the query
+ * @param type requested data type
+ * @param xquery extended query
+ * @param xquery_size number of bytes in xquery
+ * @param bg block group to use for evaluation of replies
+ * @param gc function to call on the results
+ * @param gc_cls closure for @a gc
+ * @return evaluation result for the local replies
+ */
+enum GNUNET_BLOCK_ReplyEvaluationResult
+GDS_DATACACHE_handle_get (const struct GNUNET_HashCode *key,
+                          enum GNUNET_BLOCK_Type type,
+                          const void *xquery,
+                          size_t xquery_size,
+                          struct GNUNET_BLOCK_Group *bg,
+                          GDS_DATACACHE_GetCallback gc,
+                          void *gc_cls);
+
+
+/**
+ * Handle a request for data close to a key that we have received from
+ * another peer.
+ *
+ * @param key the location at which the peer is looking for data that is close
+ * @param type requested data type
+ * @param xquery extended query
+ * @param xquery_size number of bytes in xquery
+ * @param bg block group to use for evaluation of replies
+ * @param cb function to call with the result
+ * @param cb_cls closure for @a cb
+ * @return evaluation result for the local replies
+ */
+enum GNUNET_BLOCK_ReplyEvaluationResult
+GDS_DATACACHE_get_closest (const struct GNUNET_HashCode *key,
+                           enum GNUNET_BLOCK_Type type,
+                           const void *xquery,
+                           size_t xquery_size,
+                           struct GNUNET_BLOCK_Group *bg,
+                           GDS_DATACACHE_GetCallback cb,
+                           void *cb_cls);
+
+
+/**
+ * Initialize datacache subsystem.
+ */
+void
+GDS_DATACACHE_init (void);
+
+
+/**
+ * Shutdown datacache subsystem.
+ */
+void
+GDS_DATACACHE_done (void);
+
+#endif
diff --git a/src/service/dht/gnunet-service-dht_neighbours.c b/src/service/dht/gnunet-service-dht_neighbours.c
new file mode 100644
index 000000000..15a4b21f7
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_neighbours.c
@@ -0,0 +1,3009 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2017, 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
+ */
+
+/**
+ * @file dht/gnunet-service-dht_neighbours.c
+ * @brief GNUnet DHT service's bucket and neighbour management code
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_constants.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "gnunet_hello_uri_lib.h"
+#include "gnunet-service-dht.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "gnunet-service-dht_routing.h"
+#include "dht.h"
+
+#define LOG_TRAFFIC(kind, ...) GNUNET_log_from (kind, "dht-traffic", \
+                                                __VA_ARGS__)
+
+/**
+ * Enable slow sanity checks to debug issues.
+ *
+ * TODO: might want to eventually implement probabilistic
+ * load-based path verification, but for now it is all or nothing
+ * based on this define.
+ *
+ * 0: do not check -- if signatures become performance critical
+ * 1: check all external inputs -- normal production for now
+ * 2: check internal computations as well -- for debugging
+ */
+#define SANITY_CHECKS 2
+
+/**
+ * How many buckets will we allow in total.
+ */
+#define MAX_BUCKETS sizeof(struct GNUNET_HashCode) * 8
+
+/**
+ * What is the maximum number of peers in a given bucket.
+ */
+#define DEFAULT_BUCKET_SIZE 8
+
+/**
+ * Desired replication level for FIND PEER requests
+ */
+#define FIND_PEER_REPLICATION_LEVEL 4
+
+/**
+ * Maximum allowed number of pending messages per peer.
+ */
+#define MAXIMUM_PENDING_PER_PEER 64
+
+/**
+ * How long at least to wait before sending another find peer request.
+ * This is basically the frequency at which we will usually send out
+ * requests when we are 'perfectly' connected.
+ */
+#define DHT_MINIMUM_FIND_PEER_INTERVAL GNUNET_TIME_relative_multiply ( \
+          GNUNET_TIME_UNIT_MINUTES, 2)
+
+
+/**
+ * How long to additionally wait on average per #bucket_size to send out the
+ * FIND PEER requests if we did successfully connect (!) to a a new peer and
+ * added it to a bucket (as counted in #newly_found_peers).  This time is
+ * Multiplied by 100 * newly_found_peers / bucket_size to get the new delay
+ * for finding peers (the #DHT_MINIMUM_FIND_PEER_INTERVAL is still added on
+ * top).  Also the range in which we randomize, so the effective value
+ * is half of the number given here.
+ */
+#define DHT_AVG_FIND_PEER_INTERVAL GNUNET_TIME_relative_multiply (    \
+          GNUNET_TIME_UNIT_SECONDS, 6)
+
+/**
+ * How long at most to wait for transmission of a GET request to another peer?
+ */
+#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * P2P PUT message
+ */
+struct PeerPutMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_P2P_PUT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Content type, must not be zero.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Processing options
+   */
+  uint16_t options GNUNET_PACKED;
+
+  /**
+   * Hop count
+   */
+  uint16_t hop_count GNUNET_PACKED;
+
+  /**
+   * Replication level for this message
+   */
+  uint16_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * Length of the PUT path that follows (if tracked).
+   */
+  uint16_t put_path_length GNUNET_PACKED;
+
+  /**
+   * When does the content expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * Bloomfilter (for peer identities) to stop circular routes
+   */
+  char bloomfilter[DHT_BLOOM_SIZE];
+
+  /**
+   * The key we are storing under.
+   */
+  struct GNUNET_HashCode key;
+
+  /* trunc_peer (if truncated) */
+
+  /* put path (if tracked) */
+
+  /* sender_sig (if path tracking is on) */
+
+  /* Payload */
+};
+
+
+/**
+ * P2P Result message
+ */
+struct PeerResultMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Content type.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Always 0.
+   */
+  uint16_t reserved GNUNET_PACKED;
+
+  /**
+   * Message options, actually an 'enum GNUNET_DHT_RouteOption' value in NBO.
+   */
+  uint16_t options GNUNET_PACKED;
+
+  /**
+   * Length of the PUT path that follows (if tracked).
+   */
+  uint16_t put_path_length GNUNET_PACKED;
+
+  /**
+   * Length of the GET path that follows (if tracked).
+   */
+  uint16_t get_path_length GNUNET_PACKED;
+
+  /**
+   * When does the content expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The key of the corresponding GET request.
+   */
+  struct GNUNET_HashCode key;
+
+  /* trunc_peer (if truncated) */
+
+  /* put path (if tracked) */
+
+  /* get path (if tracked) */
+
+  /* sender_sig (if path tracking is on) */
+
+  /* Payload */
+};
+
+
+/**
+ * P2P GET message
+ */
+struct PeerGetMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_DHT_P2P_GET
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Desired content type.
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Processing options
+   */
+  uint16_t options GNUNET_PACKED;
+
+  /**
+   * Hop count
+   */
+  uint16_t hop_count GNUNET_PACKED;
+
+  /**
+   * Desired replication level for this request.
+   */
+  uint16_t desired_replication_level GNUNET_PACKED;
+
+  /**
+   * Size of the result filter.
+   */
+  uint16_t result_filter_size GNUNET_PACKED;
+
+  /**
+   * Bloomfilter (for peer identities) to stop circular routes
+   */
+  char bloomfilter[DHT_BLOOM_SIZE];
+
+  /**
+   * The key we are looking for.
+   */
+  struct GNUNET_HashCode key;
+
+  /* result bloomfilter */
+
+  /* xquery */
+
+};
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Entry for a peer in a bucket.
+ */
+struct PeerInfo;
+
+
+/**
+ * List of targets that we can use to reach this peer.
+ */
+struct Target
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct Target *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct Target *prev;
+
+  /**
+   * Handle for sending messages to this peer.
+   */
+  struct GNUNET_DHTU_Target *utarget;
+
+  /**
+   * Underlay providing this target.
+   */
+  struct GDS_Underlay *u;
+
+  /**
+   * Peer this is a target for.
+   */
+  struct PeerInfo *pi;
+
+  /**
+   * Handle used to 'hold' the connection to this peer.
+   */
+  struct GNUNET_DHTU_PreferenceHandle *ph;
+
+  /**
+   * Set to number of messages are waiting for the transmission to finish.
+   */
+  unsigned int load;
+
+  /**
+   * Set to @a true if the target was dropped, but we could not clean
+   * up yet because @e busy was also true.
+   */
+  bool dropped;
+
+};
+
+
+/**
+ * Entry for a peer in a bucket.
+ */
+struct PeerInfo
+{
+  /**
+   * What is the identity of the peer?
+   */
+  struct GNUNET_PeerIdentity id;
+
+  /**
+   * Hash of @e id.
+   */
+  struct GNUNET_HashCode phash;
+
+  /**
+   * When does our HELLO from this peer expire?
+   */
+  struct GNUNET_TIME_Absolute hello_expiration;
+
+  /**
+   * Next peer entry (DLL)
+   */
+  struct PeerInfo *next;
+
+  /**
+   *  Prev peer entry (DLL)
+   */
+  struct PeerInfo *prev;
+
+  /**
+   * Head of DLL of targets for this peer.
+   */
+  struct Target *t_head;
+
+  /**
+   * Tail of DLL of targets for this peer.
+   */
+  struct Target *t_tail;
+
+  /**
+   * Block with a HELLO of this peer.
+   */
+  void *hello;
+
+  /**
+   * Number of bytes in @e hello.
+   */
+  size_t hello_size;
+
+  /**
+   * Which bucket is this peer in?
+   */
+  int peer_bucket;
+};
+
+
+/**
+ * Peers are grouped into buckets.
+ */
+struct PeerBucket
+{
+  /**
+   * Head of DLL
+   */
+  struct PeerInfo *head;
+
+  /**
+   * Tail of DLL
+   */
+  struct PeerInfo *tail;
+
+  /**
+   * Number of peers in the bucket.
+   */
+  unsigned int peers_size;
+};
+
+
+/**
+ * Do we cache all results that we are routing in the local datacache?
+ */
+static int cache_results;
+
+/**
+ * The lowest currently used bucket, initially 0 (for 0-bits matching bucket).
+ */
+static unsigned int closest_bucket;
+
+/**
+ * How many peers have we added since we sent out our last
+ * find peer request?
+ */
+static unsigned int newly_found_peers;
+
+/**
+ * Option for testing that disables the 'connect' function of the DHT.
+ */
+static int disable_try_connect;
+
+/**
+ * The buckets.  Array of size #MAX_BUCKETS.  Offset 0 means 0 bits matching.
+ */
+static struct PeerBucket k_buckets[MAX_BUCKETS];
+
+/**
+ * Hash map of all CORE-connected peers, for easy removal from
+ * #k_buckets on disconnect.  Values are of type `struct PeerInfo`.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *all_connected_peers;
+
+/**
+ * Maximum size for each bucket.
+ */
+static unsigned int bucket_size = DEFAULT_BUCKET_SIZE;
+
+/**
+ * Task that sends FIND PEER requests.
+ */
+static struct GNUNET_SCHEDULER_Task *find_peer_task;
+
+
+/**
+ * Function called whenever we finished sending to a target.
+ * Marks the transmission as finished (and the target as ready
+ * for the next message).
+ *
+ * @param cls a `struct Target *`
+ */
+static void
+send_done_cb (void *cls)
+{
+  struct Target *t = cls;
+  struct PeerInfo *pi = t->pi; /* NULL if t->dropped! */
+
+  GNUNET_assert (t->load > 0);
+  t->load--;
+  if (0 < t->load)
+    return;
+  if (t->dropped)
+  {
+    GNUNET_free (t);
+    return;
+  }
+  /* move target back to the front */
+  GNUNET_CONTAINER_DLL_remove (pi->t_head,
+                               pi->t_tail,
+                               t);
+  GNUNET_CONTAINER_DLL_insert (pi->t_head,
+                               pi->t_tail,
+                               t);
+}
+
+
+/**
+ * Send @a msg to @a pi.
+ *
+ * @param pi where to send the message
+ * @param msg message to send
+ */
+static void
+do_send (struct PeerInfo *pi,
+         const struct GNUNET_MessageHeader *msg)
+{
+  struct Target *t;
+
+  for (t = pi->t_head;
+       NULL != t;
+       t = t->next)
+    if (t->load < MAXIMUM_PENDING_PER_PEER)
+      break;
+  if (NULL == t)
+  {
+    /* all targets busy, drop message */
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# messages dropped (underlays busy)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  t->load++;
+  /* rotate busy targets to the end */
+  if (MAXIMUM_PENDING_PER_PEER == t->load)
+  {
+    GNUNET_CONTAINER_DLL_remove (pi->t_head,
+                                 pi->t_tail,
+                                 t);
+    GNUNET_CONTAINER_DLL_insert_tail (pi->t_head,
+                                      pi->t_tail,
+                                      t);
+  }
+  GDS_u_send (t->u,
+              t->utarget,
+              msg,
+              ntohs (msg->size),
+              &send_done_cb,
+              t);
+}
+
+
+/**
+ * Sign that we are routing a message from @a pred to @a succ.
+ * (So the route is $PRED->us->$SUCC).
+ *
+ * @param data payload (the block)
+ * @param data_size number of bytes in @a data
+ * @param exp_time expiration time of @a data
+ * @param pred predecessor peer ID
+ * @param succ successor peer ID
+ * @param[out] sig where to write the signature
+ *      (of purpose #GNUNET_SIGNATURE_PURPOSE_DHT_PUT_HOP)
+ */
+static void
+sign_path (const void *data,
+           size_t data_size,
+           struct GNUNET_TIME_Absolute exp_time,
+           const struct GNUNET_PeerIdentity *pred,
+           const struct GNUNET_PeerIdentity *succ,
+           struct GNUNET_CRYPTO_EddsaSignature *sig)
+{
+  struct GNUNET_DHT_HopSignature hs = {
+    .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DHT_HOP),
+    .purpose.size = htonl (sizeof (hs)),
+    .expiration_time = GNUNET_TIME_absolute_hton (exp_time),
+    .succ = *succ
+  };
+
+  if (NULL != pred)
+    hs.pred = *pred;
+  GNUNET_CRYPTO_hash (data,
+                      data_size,
+                      &hs.h_data);
+  GNUNET_CRYPTO_eddsa_sign (&GDS_my_private_key,
+                            &hs,
+                            sig);
+}
+
+
+/**
+ * Find the optimal bucket for this key.
+ *
+ * @param hc the hashcode to compare our identity to
+ * @return the proper bucket index, or -1
+ *         on error (same hashcode)
+ */
+static int
+find_bucket (const struct GNUNET_HashCode *hc)
+{
+  struct GNUNET_HashCode xor;
+  unsigned int bits;
+
+  GNUNET_CRYPTO_hash_xor (hc,
+                          &GDS_my_identity_hash,
+                          &xor);
+  bits = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
+  if (bits == MAX_BUCKETS)
+  {
+    /* How can all bits match? Got my own ID? */
+    GNUNET_break (0);
+    return -1;
+  }
+  return MAX_BUCKETS - bits - 1;
+}
+
+
+/**
+ * Add each of the peers we already know to the Bloom filter of
+ * the request so that we don't get duplicate HELLOs.
+ *
+ * @param cls the `struct GNUNET_BLOCK_Group`
+ * @param key peer identity to add to the bloom filter
+ * @param value the peer information
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static enum GNUNET_GenericReturnValue
+add_known_to_bloom (void *cls,
+                    const struct GNUNET_PeerIdentity *key,
+                    void *value)
+{
+  struct GNUNET_BLOCK_Group *bg = cls;
+  struct PeerInfo *pi = value;
+
+  GNUNET_BLOCK_group_set_seen (bg,
+                               &pi->phash,
+                               1);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding known peer (%s) to Bloom filter for FIND PEER\n",
+              GNUNET_i2s (key));
+  return GNUNET_YES;
+}
+
+
+/**
+ * Task to send a find peer message for our own peer identifier
+ * so that we can find the closest peers in the network to ourselves
+ * and attempt to connect to them.
+ *
+ * @param cls closure for this task, NULL
+ */
+static void
+send_find_peer_message (void *cls)
+{
+  (void) cls;
+
+  /* Compute when to do this again (and if we should
+     even send a message right now) */
+  {
+    struct GNUNET_TIME_Relative next_send_time;
+    bool done_early;
+
+    find_peer_task = NULL;
+    done_early = (newly_found_peers > bucket_size);
+    /* schedule next round, taking longer if we found more peers
+       in the last round. */
+    next_send_time.rel_value_us =
+      DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value_us
+      + GNUNET_CRYPTO_random_u64 (
+        GNUNET_CRYPTO_QUALITY_WEAK,
+        GNUNET_TIME_relative_multiply (
+          DHT_AVG_FIND_PEER_INTERVAL,
+          1 + 100 * (1 + newly_found_peers) / bucket_size).rel_value_us);
+    newly_found_peers = 0;
+    GNUNET_assert (NULL == find_peer_task);
+    find_peer_task =
+      GNUNET_SCHEDULER_add_delayed (next_send_time,
+                                    &send_find_peer_message,
+                                    NULL);
+    if (done_early)
+      return;
+  }
+
+  /* actually send 'find peer' request */
+  {
+    struct GNUNET_BLOCK_Group *bg;
+    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
+
+    bg = GNUNET_BLOCK_group_create (GDS_block_context,
+                                    GNUNET_BLOCK_TYPE_DHT_HELLO,
+                                    NULL,
+                                    0,
+                                    "seen-set-size",
+                                    GNUNET_CONTAINER_multipeermap_size (
+                                      all_connected_peers),
+                                    NULL);
+    GNUNET_CONTAINER_multipeermap_iterate (all_connected_peers,
+                                           &add_known_to_bloom,
+                                           bg);
+    peer_bf
+      = GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                           DHT_BLOOM_SIZE,
+                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
+    if (GNUNET_OK !=
+        GDS_NEIGHBOURS_handle_get (GNUNET_BLOCK_TYPE_DHT_HELLO,
+                                   GNUNET_DHT_RO_FIND_APPROXIMATE
+                                   | GNUNET_DHT_RO_RECORD_ROUTE,
+                                   FIND_PEER_REPLICATION_LEVEL,
+                                   0, /* hop count */
+                                   &GDS_my_identity_hash,
+                                   NULL, 0, /* xquery */
+                                   bg,
+                                   peer_bf))
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Failed to initiate FIND PEER lookup",
+                                1,
+                                GNUNET_NO);
+    }
+    else
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# FIND PEER messages initiated",
+                                1,
+                                GNUNET_NO);
+    }
+    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
+    GNUNET_BLOCK_group_destroy (bg);
+  }
+}
+
+
+/**
+ * The list of the first #bucket_size peers of @a bucket
+ * changed. We should thus make sure we have called 'hold'
+ * all of the first bucket_size peers!
+ *
+ * @param[in,out] bucket the bucket where the peer set changed
+ */
+static void
+update_hold (struct PeerBucket *bucket)
+{
+  unsigned int off = 0;
+
+  /* find the peer -- we just go over all of them, should
+     be hardly any more expensive than just finding the 'right'
+     one. */
+  for (struct PeerInfo *pos = bucket->head;
+       NULL != pos;
+       pos = pos->next)
+  {
+    if (off > bucket_size)
+      break;   /* We only hold up to #bucket_size peers per bucket */
+    off++;
+    for (struct Target *tp = pos->t_head;
+         NULL != tp;
+         tp = tp->next)
+      if (NULL == tp->ph)
+        tp->ph = GDS_u_hold (tp->u,
+                             tp->utarget);
+  }
+}
+
+
+void
+GDS_u_connect (void *cls,
+               struct GNUNET_DHTU_Target *target,
+               const struct GNUNET_PeerIdentity *pid,
+               void **ctx)
+{
+  struct GDS_Underlay *u = cls;
+  struct PeerInfo *pi;
+  struct PeerBucket *bucket;
+  bool do_hold = false;
+
+  /* Check for connect to self message */
+  if (0 == GNUNET_memcmp (&GDS_my_identity,
+                          pid))
+    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Connected to peer %s\n",
+              GNUNET_i2s (pid));
+  pi = GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
+                                          pid);
+  if (NULL == pi)
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# peers connected",
+                              1,
+                              GNUNET_NO);
+    pi = GNUNET_new (struct PeerInfo);
+    pi->id = *pid;
+    GNUNET_CRYPTO_hash (pid,
+                        sizeof(*pid),
+                        &pi->phash);
+    pi->peer_bucket = find_bucket (&pi->phash);
+    GNUNET_assert ( (pi->peer_bucket >= 0) &&
+                    ((unsigned int) pi->peer_bucket < MAX_BUCKETS));
+    bucket = &k_buckets[pi->peer_bucket];
+    GNUNET_CONTAINER_DLL_insert_tail (bucket->head,
+                                      bucket->tail,
+                                      pi);
+    bucket->peers_size++;
+    closest_bucket = GNUNET_MAX (closest_bucket,
+                                 (unsigned int) pi->peer_bucket + 1);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (all_connected_peers,
+                                                      &pi->id,
+                                                      pi,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    if (bucket->peers_size <= bucket_size)
+    {
+      newly_found_peers++;
+      do_hold = true;
+    }
+    if ( (1 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
+         (GNUNET_YES != disable_try_connect) )
+    {
+      /* got a first connection, good time to start with FIND PEER requests... */
+      GNUNET_assert (NULL == find_peer_task);
+      find_peer_task = GNUNET_SCHEDULER_add_now (&send_find_peer_message,
+                                                 NULL);
+    }
+  }
+  {
+    struct Target *t;
+
+    t = GNUNET_new (struct Target);
+    t->u = u;
+    t->utarget = target;
+    t->pi = pi;
+    GNUNET_CONTAINER_DLL_insert (pi->t_head,
+                                 pi->t_tail,
+                                 t);
+    *ctx = t;
+
+  }
+  if (do_hold)
+    update_hold (bucket);
+}
+
+
+void
+GDS_u_disconnect (void *ctx)
+{
+  struct Target *t = ctx;
+  struct PeerInfo *pi;
+  struct PeerBucket *bucket;
+  bool was_held = false;
+
+  /* Check for disconnect from self message (on shutdown) */
+  if (NULL == t)
+    return;
+  pi = t->pi;
+  GNUNET_CONTAINER_DLL_remove (pi->t_head,
+                               pi->t_tail,
+                               t);
+  if (NULL != t->ph)
+  {
+    GDS_u_drop (t->u,
+                t->ph);
+    t->ph = NULL;
+    was_held = true;
+  }
+  if (t->load > 0)
+  {
+    t->dropped = true;
+    t->pi = NULL;
+  }
+  else
+  {
+    GNUNET_free (t);
+  }
+  if (NULL != pi->t_head)
+    return; /* got other connections still */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnected from peer %s\n",
+              GNUNET_i2s (&pi->id));
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# peers connected",
+                            -1,
+                            GNUNET_NO);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (all_connected_peers,
+                                                       &pi->id,
+                                                       pi));
+  if ( (0 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
+       (GNUNET_YES != disable_try_connect))
+  {
+    GNUNET_SCHEDULER_cancel (find_peer_task);
+    find_peer_task = NULL;
+  }
+  GNUNET_assert (pi->peer_bucket >= 0);
+  bucket = &k_buckets[pi->peer_bucket];
+  GNUNET_CONTAINER_DLL_remove (bucket->head,
+                               bucket->tail,
+                               pi);
+  GNUNET_assert (bucket->peers_size > 0);
+  bucket->peers_size--;
+  if ( (was_held) &&
+       (bucket->peers_size >= bucket_size - 1) )
+    update_hold (bucket);
+  while ( (closest_bucket > 0) &&
+          (0 == k_buckets[closest_bucket - 1].peers_size))
+    closest_bucket--;
+  GNUNET_free (pi->hello);
+  GNUNET_free (pi);
+}
+
+
+/**
+ * To how many peers should we (on average) forward the request to
+ * obtain the desired target_replication count (on average).
+ *
+ * @param hop_count number of hops the message has traversed
+ * @param target_replication the number of total paths desired
+ * @return Some number of peers to forward the message to
+ */
+static unsigned int
+get_forward_count (uint16_t hop_count,
+                   uint16_t target_replication)
+{
+  uint32_t random_value;
+  uint32_t forward_count;
+  float target_value;
+  float rm1;
+
+  if (hop_count > GDS_NSE_get () * 4.0)
+  {
+    /* forcefully terminate */
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# requests TTL-dropped",
+                              1,
+                              GNUNET_NO);
+    return 0;
+  }
+  if (hop_count > GDS_NSE_get () * 2.0)
+  {
+    /* Once we have reached our ideal number of hops, only forward to 1 peer */
+    return 1;
+  }
+  /* bound by system-wide maximum and minimum */
+  if (0 == target_replication)
+    target_replication = 1; /* 0 is verboten */
+  target_replication =
+    GNUNET_MIN (GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL,
+                target_replication);
+  rm1 = target_replication - 1.0;
+  target_value =
+    1 + (rm1) / (GDS_NSE_get () + (rm1 * hop_count));
+
+  /* Set forward count to floor of target_value */
+  forward_count = (uint32_t) target_value;
+  /* Subtract forward_count (floor) from target_value (yields value between 0 and 1) */
+  target_value = target_value - forward_count;
+  random_value = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                           UINT32_MAX);
+  if (random_value < (target_value * UINT32_MAX))
+    forward_count++;
+  return GNUNET_MIN (forward_count,
+                     GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL);
+}
+
+
+/**
+ * Check whether my identity is closer than any known peers.  If a
+ * non-null bloomfilter is given, check if this is the closest peer
+ * that hasn't already been routed to.
+ *
+ * @param key hash code to check closeness to
+ * @param bloom bloomfilter, exclude these entries from the decision
+ * @return #GNUNET_YES if node location is closest,
+ *         #GNUNET_NO otherwise.
+ */
+enum GNUNET_GenericReturnValue
+GDS_am_closest_peer (const struct GNUNET_HashCode *key,
+                     const struct GNUNET_CONTAINER_BloomFilter *bloom)
+{
+  if (0 == GNUNET_memcmp (&GDS_my_identity_hash,
+                          key))
+    return GNUNET_YES;
+  for (int bucket_num = find_bucket (key);
+       bucket_num < closest_bucket;
+       bucket_num++)
+  {
+    unsigned int count = 0;
+
+    GNUNET_assert (bucket_num >= 0);
+    for (struct PeerInfo *pos = k_buckets[bucket_num].head;
+         NULL != pos;
+         pos = pos->next)
+    {
+      if (count >= bucket_size)
+        break; /* we only consider first #bucket_size entries per bucket */
+      count++;
+      if ( (NULL != bloom) &&
+           (GNUNET_YES ==
+            GNUNET_CONTAINER_bloomfilter_test (bloom,
+                                               &pos->phash)) )
+        continue;               /* Ignore filtered peers */
+      /* All peers in this bucket must be closer than us, as
+         they mismatch with our PID on the pivotal bit. So
+         because an unfiltered peer exists, we are not the
+         closest. */
+      int delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
+                                             &GDS_my_identity_hash,
+                                             key);
+      switch (delta)
+      {
+      case -1: /* pos closer */
+        return GNUNET_NO;
+      case 0: /* identical, impossible! */
+        GNUNET_assert (0);
+        break;
+      case 1: /* I am closer */
+        break;
+      }
+    }
+  }
+  /* No closer (unfiltered) peers found; we must be the closest! */
+  return GNUNET_YES;
+}
+
+
+/**
+ * Select a peer from the routing table that would be a good routing
+ * destination for sending a message for @a key.  The resulting peer
+ * must not be in the set of @a bloom blocked peers.
+ *
+ * Note that we should not ALWAYS select the closest peer to the
+ * target, we do a "random" peer selection if the number of @a hops
+ * is below the logarithm of the network size estimate.
+ *
+ * In all cases, we only consider at most the first #bucket_size peers of any
+ * #k_buckets. The other peers in the bucket are there because GNUnet doesn't
+ * really allow the DHT to "reject" connections, but we only use the first
+ * #bucket_size, even if more exist. (The idea is to ensure that those
+ * connections are frequently used, and for others to be not used by the DHT,
+ * and thus possibly dropped by transport due to disuse).
+ *
+ * @param key the key we are selecting a peer to route to
+ * @param bloom a Bloom filter containing entries this request has seen already
+ * @param hops how many hops has this message traversed thus far
+ * @return Peer to route to, or NULL on error
+ */
+static struct PeerInfo *
+select_peer (const struct GNUNET_HashCode *key,
+             const struct GNUNET_CONTAINER_BloomFilter *bloom,
+             uint32_t hops)
+{
+  if (0 == closest_bucket)
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Peer selection failed",
+                              1,
+                              GNUNET_NO);
+    return NULL; /* we have zero connections */
+  }
+  if (hops >= GDS_NSE_get ())
+  {
+    /* greedy selection (closest peer that is not in Bloom filter) */
+    struct PeerInfo *chosen = NULL;
+    int best_bucket;
+    int bucket_offset;
+
+    {
+      struct GNUNET_HashCode xor;
+
+      GNUNET_CRYPTO_hash_xor (key,
+                              &GDS_my_identity_hash,
+                              &xor);
+      best_bucket = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
+    }
+    if (best_bucket >= closest_bucket)
+      bucket_offset = closest_bucket - 1;
+    else
+      bucket_offset = best_bucket;
+    while (-1 != bucket_offset)
+    {
+      struct PeerBucket *bucket = &k_buckets[bucket_offset];
+      unsigned int count = 0;
+
+      for (struct PeerInfo *pos = bucket->head;
+           NULL != pos;
+           pos = pos->next)
+      {
+        if (count >= bucket_size)
+          break; /* we only consider first #bucket_size entries per bucket */
+        count++;
+        if ( (NULL != bloom) &&
+             (GNUNET_YES ==
+              GNUNET_CONTAINER_bloomfilter_test (bloom,
+                                                 &pos->phash)) )
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Excluded peer `%s' due to BF match in greedy routing for %s\n",
+                      GNUNET_i2s (&pos->id),
+                      GNUNET_h2s (key));
+          continue;
+        }
+        if (NULL == chosen)
+        {
+          /* First candidate */
+          chosen = pos;
+        }
+        else
+        {
+          int delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
+                                                 &chosen->phash,
+                                                 key);
+          switch (delta)
+          {
+          case -1: /* pos closer */
+            chosen = pos;
+            break;
+          case 0: /* identical, impossible! */
+            GNUNET_assert (0);
+            break;
+          case 1: /* chosen closer */
+            break;
+          }
+        }
+        count++;
+      } /* for all (#bucket_size) peers in bucket */
+      if (NULL != chosen)
+        break;
+
+      /* If we chose nothing in first iteration, first go through deeper
+         buckets (best chance to find a good match), and if we still found
+         nothing, then to shallower buckets.  Terminate on any match in the
+         current bucket, as this search order guarantees that it can only get
+         worse as we keep going. */
+      if (bucket_offset > best_bucket)
+      {
+        /* Go through more deeper buckets */
+        bucket_offset++;
+        if (bucket_offset == closest_bucket)
+        {
+          /* Can't go any deeper, if nothing selected,
+             go for shallower buckets */
+          bucket_offset = best_bucket - 1;
+        }
+      }
+      else
+      {
+        /* We're either at the 'best_bucket' or already moving
+           on to shallower buckets. */
+        if (bucket_offset == best_bucket)
+          bucket_offset++; /* go for deeper buckets */
+        else
+          bucket_offset--; /* go for shallower buckets */
+      }
+    } /* for applicable buckets (starting at best match) */
+    if (NULL == chosen)
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Peer selection failed",
+                                1,
+                                GNUNET_NO);
+      return NULL;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Selected peer `%s' in greedy routing for %s\n",
+                GNUNET_i2s (&chosen->id),
+                GNUNET_h2s (key));
+    return chosen;
+  } /* end of 'greedy' peer selection */
+
+  /* select "random" peer */
+  /* count number of peers that are available and not filtered,
+     but limit to at most #bucket_size peers, starting with
+     those 'furthest' from us. */
+  {
+    unsigned int total = 0;
+    unsigned int selected;
+
+    for (unsigned int bc = 0; bc < closest_bucket; bc++)
+    {
+      struct PeerBucket *bucket = &k_buckets[bc];
+      unsigned int count = 0;
+
+      for (struct PeerInfo *pos = bucket->head;
+           NULL != pos;
+           pos = pos->next)
+      {
+        count++;
+        if (count > bucket_size)
+          break; /* limits search to #bucket_size peers per bucket */
+        if ( (NULL != bloom) &&
+             (GNUNET_YES ==
+              GNUNET_CONTAINER_bloomfilter_test (bloom,
+                                                 &pos->phash)) )
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Excluded peer `%s' due to BF match in random routing for %s\n",
+                      GNUNET_i2s (&pos->id),
+                      GNUNET_h2s (key));
+          continue;             /* Ignore filtered peers */
+        }
+        total++;
+      } /* for all peers in bucket */
+    } /* for all buckets */
+    if (0 == total)             /* No peers to select from! */
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Peer selection failed",
+                                1,
+                                GNUNET_NO);
+      return NULL;
+    }
+
+    /* Now actually choose a peer */
+    selected = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         total);
+    for (unsigned int bc = 0; bc < closest_bucket; bc++)
+    {
+      unsigned int count = 0;
+
+      for (struct PeerInfo *pos = k_buckets[bc].head;
+           pos != NULL;
+           pos = pos->next)
+      {
+        count++;
+        if (count > bucket_size)
+          break; /* limits search to #bucket_size peers per bucket */
+
+        if ( (NULL != bloom) &&
+             (GNUNET_YES ==
+              GNUNET_CONTAINER_bloomfilter_test (bloom,
+                                                 &pos->phash)) )
+          continue;             /* Ignore bloomfiltered peers */
+        if (0 == selected--)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Selected peer `%s' in random routing for %s\n",
+                      GNUNET_i2s (&pos->id),
+                      GNUNET_h2s (key));
+          return pos;
+        }
+      } /* for peers in bucket */
+    } /* for all buckets */
+  } /* random peer selection scope */
+  GNUNET_break (0);
+  return NULL;
+}
+
+
+/**
+ * Compute the set of peers that the given request should be
+ * forwarded to.
+ *
+ * @param key routing key
+ * @param[in,out] bloom Bloom filter excluding peers as targets,
+ *        all selected peers will be added to the Bloom filter
+ * @param hop_count number of hops the request has traversed so far
+ * @param target_replication desired number of replicas
+ * @param[out] targets where to store an array of target peers (to be
+ *         free()ed by the caller)
+ * @return number of peers returned in @a targets.
+ */
+static unsigned int
+get_target_peers (const struct GNUNET_HashCode *key,
+                  struct GNUNET_CONTAINER_BloomFilter *bloom,
+                  uint16_t hop_count,
+                  uint16_t target_replication,
+                  struct PeerInfo ***targets)
+{
+  unsigned int target;
+  unsigned int off;
+  struct PeerInfo **rtargets;
+
+  GNUNET_assert (NULL != bloom);
+  target = get_forward_count (hop_count,
+                              target_replication);
+  if (0 == target)
+  {
+    *targets = NULL;
+    return 0;
+  }
+  rtargets = GNUNET_new_array (target,
+                               struct PeerInfo *);
+  for (off = 0; off < target; off++)
+  {
+    struct PeerInfo *nxt;
+
+    nxt = select_peer (key,
+                       bloom,
+                       hop_count);
+    if (NULL == nxt)
+      break;
+    rtargets[off] = nxt;
+    GNUNET_break (GNUNET_NO ==
+                  GNUNET_CONTAINER_bloomfilter_test (bloom,
+                                                     &nxt->phash));
+    GNUNET_CONTAINER_bloomfilter_add (bloom,
+                                      &nxt->phash);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Selected %u/%u peers at hop %u for %s (target was %u)\n",
+              off,
+              GNUNET_CONTAINER_multipeermap_size (all_connected_peers),
+              (unsigned int) hop_count,
+              GNUNET_h2s (key),
+              target);
+  if (0 == off)
+  {
+    GNUNET_free (rtargets);
+    *targets = NULL;
+    return 0;
+  }
+  *targets = rtargets;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding query `%s' to %u peers (goal was %u peers)\n",
+              GNUNET_h2s (key),
+              off,
+              target);
+  return off;
+}
+
+
+/**
+ * If we got a HELLO, consider it for our own routing table
+ *
+ * @param bd block data we got
+ */
+static void
+hello_check (const struct GNUNET_DATACACHE_Block *bd)
+{
+  struct GNUNET_HELLO_Builder *b;
+
+  if (GNUNET_BLOCK_TYPE_DHT_HELLO != bd->type)
+    return;
+
+  b = GNUNET_HELLO_builder_from_block (bd->data,
+                                       bd->data_size);
+  if (GNUNET_YES != disable_try_connect)
+  {
+    GNUNET_HELLO_builder_iterate (b,
+                                  &GDS_try_connect,
+                                  NULL);
+  }
+  GNUNET_HELLO_builder_free (b);
+}
+
+
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_handle_put (const struct GNUNET_DATACACHE_Block *bd,
+                           uint16_t desired_replication_level,
+                           uint16_t hop_count,
+                           struct GNUNET_CONTAINER_BloomFilter *bf)
+{
+  unsigned int target_count;
+  struct PeerInfo **targets;
+  size_t msize;
+  unsigned int skip_count;
+  enum GNUNET_DHT_RouteOption ro = bd->ro;
+  unsigned int put_path_length = bd->put_path_length;
+  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  bool tracking = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? &bd->trunc_peer
+    : NULL;
+
+#if SANITY_CHECKS > 1
+  unsigned int failure_offset;
+
+  failure_offset
+    = GNUNET_DHT_verify_path (bd->data,
+                              bd->data_size,
+                              bd->expiration_time,
+                              trunc_peer,
+                              put_path,
+                              put_path_length,
+                              NULL, 0,    /* get_path */
+                              &GDS_my_identity);
+  if (0 != failure_offset)
+  {
+    GNUNET_break_op (0);
+    truncated = true;
+    trunc_peer = &put_path[failure_offset - 1].pred;
+    put_path = &put_path[failure_offset];
+    put_path_length = put_path_length - failure_offset;
+    ro |= GNUNET_DHT_RO_TRUNCATED;
+  }
+#endif
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding myself (%s) to PUT bloomfilter for %s with RO(%s/%s)\n",
+              GNUNET_i2s (&GDS_my_identity),
+              GNUNET_h2s (&bd->key),
+              (bd->ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
+              (bd->ro & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
+
+  /* if we got a HELLO, consider it for our own routing table */
+  hello_check (bd);
+  GNUNET_assert (NULL != bf);
+  GNUNET_CONTAINER_bloomfilter_add (bf,
+                                    &GDS_my_identity_hash);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# PUT requests routed",
+                            1,
+                            GNUNET_NO);
+  if (bd->data_size
+      > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
+      - sizeof(struct PeerPutMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  msize = bd->data_size + sizeof(struct PeerPutMessage);
+  if (tracking)
+  {
+    if (msize + sizeof (struct GNUNET_CRYPTO_EddsaSignature)
+        > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Discarding message that is too large due to tracking\n");
+      return GNUNET_NO;
+    }
+    msize += sizeof (struct GNUNET_CRYPTO_EddsaSignature);
+  }
+  else
+  {
+    /* If tracking is disabled, also discard any path we might have
+       gotten from some broken peer */
+    GNUNET_break_op (0 == put_path_length);
+    put_path_length = 0;
+  }
+  if (truncated)
+    msize += sizeof (struct GNUNET_PeerIdentity);
+  if (msize + put_path_length * sizeof(struct GNUNET_DHT_PathElement)
+      > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
+  {
+    unsigned int mlen;
+    unsigned int ppl;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Truncating path that is too large due\n");
+    mlen = GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE - msize;
+    if (! truncated)
+    {
+      /* We need extra space for the truncation, consider that,
+         too! */
+      truncated = true;
+      mlen -= sizeof (struct GNUNET_PeerIdentity);
+      msize += sizeof (struct GNUNET_PeerIdentity);
+    }
+    /* compute maximum length of path we can keep */
+    ppl = mlen / sizeof (struct GNUNET_DHT_PathElement);
+    GNUNET_assert (put_path_length - ppl > 0);
+    trunc_peer = &put_path[put_path_length - ppl - 1].pred;
+    put_path = &put_path[put_path_length - ppl];
+    put_path_length = ppl;
+    ro |= GNUNET_DHT_RO_TRUNCATED;
+  }
+  else
+  {
+    msize += bd->put_path_length * sizeof(struct GNUNET_DHT_PathElement);
+  }
+  target_count
+    = get_target_peers (&bd->key,
+                        bf,
+                        hop_count,
+                        desired_replication_level,
+                        &targets);
+  if (0 == target_count)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Routing PUT for %s terminates after %u hops at %s\n",
+                GNUNET_h2s (&bd->key),
+                (unsigned int) hop_count,
+                GNUNET_i2s (&GDS_my_identity));
+    return GNUNET_NO;
+  }
+  skip_count = 0;
+  for (unsigned int i = 0; i < target_count; i++)
+  {
+    struct PeerInfo *target = targets[i];
+    struct PeerPutMessage *ppm;
+    char buf[msize] GNUNET_ALIGN;
+    struct GNUNET_DHT_PathElement *pp;
+    void *data;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Routing PUT for %s after %u hops to %s\n",
+                GNUNET_h2s (&bd->key),
+                (unsigned int) hop_count,
+                GNUNET_i2s (&target->id));
+    ppm = (struct PeerPutMessage *) buf;
+    ppm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_PUT);
+    ppm->header.size = htons (sizeof (buf));
+    ppm->type = htonl (bd->type);
+    ppm->options = htons (ro);
+    ppm->hop_count = htons (hop_count + 1);
+    ppm->desired_replication_level = htons (desired_replication_level);
+    ppm->put_path_length = htons (put_path_length);
+    ppm->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_bloomfilter_test (bf,
+                                                     &target->phash));
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_bloomfilter_get_raw_data (bf,
+                                                              ppm->bloomfilter,
+                                                              DHT_BLOOM_SIZE));
+    ppm->key = bd->key;
+    if (truncated)
+    {
+      void *tgt = &ppm[1];
+
+      GNUNET_memcpy (tgt,
+                     trunc_peer,
+                     sizeof (struct GNUNET_PeerIdentity));
+      pp = (struct GNUNET_DHT_PathElement *)
+           (tgt + sizeof (struct GNUNET_PeerIdentity));
+    }
+    else
+    {
+      pp = (struct GNUNET_DHT_PathElement *) &ppm[1];
+    }
+    GNUNET_memcpy (pp,
+                   put_path,
+                   sizeof (struct GNUNET_DHT_PathElement) * put_path_length);
+    if (tracking)
+    {
+      void *tgt = &pp[put_path_length];
+      struct GNUNET_CRYPTO_EddsaSignature last_sig;
+
+      if (0 == put_path_length)
+      {
+        /* Note that the signature in 'put_path' was not initialized before,
+           so this is crucial to avoid sending garbage. */
+        sign_path (bd->data,
+                   bd->data_size,
+                   bd->expiration_time,
+                   trunc_peer,
+                   &target->id,
+                   &last_sig);
+      }
+      else
+      {
+        sign_path (bd->data,
+                   bd->data_size,
+                   bd->expiration_time,
+                   &pp[put_path_length - 1].pred,
+                   &target->id,
+                   &last_sig);
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Signing PUT PATH %u => %s\n",
+                  put_path_length,
+                  GNUNET_B2S (&last_sig));
+      memcpy (tgt,
+              &last_sig,
+              sizeof (last_sig));
+      data = tgt + sizeof (last_sig);
+    }
+    else /* ! tracking */
+    {
+      data = &ppm[1];
+    }
+    GNUNET_memcpy (data,
+                   bd->data,
+                   bd->data_size);
+    do_send (target,
+             &ppm->header);
+  }
+  GNUNET_free (targets);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# PUT messages queued for transmission",
+                            target_count - skip_count,
+                            GNUNET_NO);
+  return (skip_count < target_count) ? GNUNET_OK : GNUNET_NO;
+}
+
+
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type type,
+                           enum GNUNET_DHT_RouteOption options,
+                           uint16_t desired_replication_level,
+                           uint16_t hop_count,
+                           const struct GNUNET_HashCode *key,
+                           const void *xquery,
+                           size_t xquery_size,
+                           struct GNUNET_BLOCK_Group *bg,
+                           struct GNUNET_CONTAINER_BloomFilter *peer_bf)
+{
+  unsigned int target_count;
+  struct PeerInfo **targets;
+  size_t msize;
+  size_t result_filter_size;
+  void *result_filter;
+  unsigned int skip_count;
+
+  GNUNET_assert (NULL != peer_bf);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET requests routed",
+                            1,
+                            GNUNET_NO);
+  target_count = get_target_peers (key,
+                                   peer_bf,
+                                   hop_count,
+                                   desired_replication_level,
+                                   &targets);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding myself (%s) to GET bloomfilter for %s with RO(%s/%s)\n",
+              GNUNET_i2s (&GDS_my_identity),
+              GNUNET_h2s (key),
+              (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
+              (options & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
+
+  GNUNET_CONTAINER_bloomfilter_add (peer_bf,
+                                    &GDS_my_identity_hash);
+  if (0 == target_count)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Routing GET for %s terminates after %u hops at %s\n",
+                GNUNET_h2s (key),
+                (unsigned int) hop_count,
+                GNUNET_i2s (&GDS_my_identity));
+    return GNUNET_NO;
+  }
+  if (GNUNET_OK !=
+      GNUNET_BLOCK_group_serialize (bg,
+                                    &result_filter,
+                                    &result_filter_size))
+  {
+    result_filter = NULL;
+    result_filter_size = 0;
+  }
+  msize = xquery_size + result_filter_size;
+  if (msize + sizeof(struct PeerGetMessage) >= GNUNET_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    GNUNET_free (result_filter);
+    GNUNET_free (targets);
+    return GNUNET_NO;
+  }
+  /* forward request */
+  skip_count = 0;
+  for (unsigned int i = 0; i < target_count; i++)
+  {
+    struct PeerInfo *target = targets[i];
+    struct PeerGetMessage *pgm;
+    char buf[sizeof (*pgm) + msize] GNUNET_ALIGN;
+    char *rf;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Routing GET for %s after %u hops to %s\n",
+                GNUNET_h2s (key),
+                (unsigned int) hop_count,
+                GNUNET_i2s (&target->id));
+    pgm = (struct PeerGetMessage *) buf;
+    pgm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_GET);
+    pgm->header.size = htons (sizeof (buf));
+    pgm->type = htonl (type);
+    pgm->options = htons (options);
+    pgm->hop_count = htons (hop_count + 1);
+    pgm->desired_replication_level = htons (desired_replication_level);
+    pgm->result_filter_size = htons ((uint16_t) result_filter_size);
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_bloomfilter_test (peer_bf,
+                                                     &target->phash));
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_bloomfilter_get_raw_data (peer_bf,
+                                                              pgm->bloomfilter,
+                                                              DHT_BLOOM_SIZE));
+    pgm->key = *key;
+    rf = (char *) &pgm[1];
+    GNUNET_memcpy (rf,
+                   result_filter,
+                   result_filter_size);
+    GNUNET_memcpy (&rf[result_filter_size],
+                   xquery,
+                   xquery_size);
+    do_send (target,
+             &pgm->header);
+  }
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# GET messages queued for transmission",
+                            target_count - skip_count,
+                            GNUNET_NO);
+  GNUNET_free (targets);
+  GNUNET_free (result_filter);
+  return (skip_count < target_count) ? GNUNET_OK : GNUNET_NO;
+}
+
+
+struct PeerInfo *
+GDS_NEIGHBOURS_lookup_peer (const struct GNUNET_PeerIdentity *target)
+{
+  return GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
+                                            target);
+}
+
+
+bool
+GDS_NEIGHBOURS_handle_reply (struct PeerInfo *pi,
+                             const struct GNUNET_DATACACHE_Block *bd,
+                             const struct GNUNET_HashCode *query_hash,
+                             unsigned int get_path_length,
+                             const struct GNUNET_DHT_PathElement *get_path)
+{
+  struct GNUNET_DHT_PathElement *paths;
+  size_t msize;
+  unsigned int ppl = bd->put_path_length;
+  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
+  enum GNUNET_DHT_RouteOption ro = bd->ro;
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? &bd->trunc_peer
+    : NULL;
+  bool tracking = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+#if SANITY_CHECKS > 1
+  unsigned int failure_offset;
+
+  failure_offset
+    = GNUNET_DHT_verify_path (bd->data,
+                              bd->data_size,
+                              bd->expiration_time,
+                              trunc_peer,
+                              put_path,
+                              ppl,
+                              get_path,
+                              get_path_length,
+                              &GDS_my_identity);
+  if (0 != failure_offset)
+  {
+    GNUNET_assert (failure_offset <= ppl + get_path_length);
+    GNUNET_break_op (0);
+    if (failure_offset < ppl)
+    {
+      trunc_peer = &put_path[failure_offset - 1].pred;
+      put_path += failure_offset;
+      ppl -= failure_offset;
+      truncated = true;
+      ro |= GNUNET_DHT_RO_TRUNCATED;
+    }
+    else
+    {
+      failure_offset -= ppl;
+      if (0 == failure_offset)
+        trunc_peer = &put_path[ppl - 1].pred;
+      else
+        trunc_peer = &get_path[failure_offset - 1].pred;
+      ppl = 0;
+      put_path = NULL;
+      truncated = true;
+      ro |= GNUNET_DHT_RO_TRUNCATED;
+      get_path += failure_offset;
+      get_path_length -= failure_offset;
+    }
+  }
+#endif
+  msize = bd->data_size + sizeof (struct PeerResultMessage);
+  if (msize > GNUNET_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break_op (0);
+    return false;
+  }
+  if (truncated)
+    msize += sizeof (struct GNUNET_PeerIdentity);
+  if (tracking)
+    msize += sizeof (struct GNUNET_CRYPTO_EddsaSignature);
+  if (msize < bd->data_size)
+  {
+    GNUNET_break_op (0);
+    return false;
+  }
+  if ( (GNUNET_MAX_MESSAGE_SIZE - msize)
+       / sizeof(struct GNUNET_DHT_PathElement)
+       < (get_path_length + ppl) )
+  {
+    get_path_length = 0;
+    ppl = 0;
+  }
+  if ( (get_path_length > UINT16_MAX) ||
+       (ppl > UINT16_MAX) )
+  {
+    GNUNET_break (0);
+    get_path_length = 0;
+    ppl = 0;
+  }
+  msize += (get_path_length + ppl)
+           * sizeof(struct GNUNET_DHT_PathElement);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding reply for key %s to peer %s\n",
+              GNUNET_h2s (query_hash),
+              GNUNET_i2s (&pi->id));
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# RESULT messages queued for transmission",
+                            1,
+                            GNUNET_NO);
+  {
+    struct PeerResultMessage *prm;
+    char buf[msize] GNUNET_ALIGN;
+    void *data;
+
+    prm = (struct PeerResultMessage *) buf;
+    prm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT);
+    prm->header.size = htons (sizeof (buf));
+    prm->type = htonl ((uint32_t) bd->type);
+    prm->reserved = htons (0);
+    prm->options = htons ((uint16_t) ro);
+    prm->put_path_length = htons ((uint16_t) ppl);
+    prm->get_path_length = htons ((uint16_t) get_path_length);
+    prm->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
+    prm->key = *query_hash;
+    if (truncated)
+    {
+      void *tgt = &prm[1];
+
+      GNUNET_memcpy (tgt,
+                     trunc_peer,
+                     sizeof (struct GNUNET_PeerIdentity));
+      paths = (struct GNUNET_DHT_PathElement *)
+              (tgt + sizeof (struct GNUNET_PeerIdentity));
+    }
+    else
+    {
+      paths = (struct GNUNET_DHT_PathElement *) &prm[1];
+    }
+    if (NULL != put_path)
+    {
+      GNUNET_memcpy (paths,
+                     put_path,
+                     ppl * sizeof(struct GNUNET_DHT_PathElement));
+    }
+    else
+    {
+      GNUNET_assert (0 == ppl);
+    }
+    if (NULL != get_path)
+    {
+      GNUNET_memcpy (&paths[ppl],
+                     get_path,
+                     get_path_length * sizeof(struct GNUNET_DHT_PathElement));
+    }
+    else
+    {
+      GNUNET_assert (0 == get_path_length);
+    }
+    if (tracking)
+    {
+      struct GNUNET_CRYPTO_EddsaSignature sig;
+      void *tgt = &paths[get_path_length + ppl];
+      const struct GNUNET_PeerIdentity *pred;
+
+      if (ppl + get_path_length > 0)
+        pred = &paths[ppl + get_path_length - 1].pred;
+      else if (truncated)
+        pred = trunc_peer;
+      else
+        pred = NULL; /* we are first! */
+      /* Note that the last signature in 'paths' was not initialized before,
+         so this is crucial to avoid sending garbage. */
+      sign_path (bd->data,
+                 bd->data_size,
+                 bd->expiration_time,
+                 pred,
+                 &pi->id,
+                 &sig);
+      memcpy (tgt,
+              &sig,
+              sizeof (sig));
+      data = tgt + sizeof (sig);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Signing GET PATH %u/%u of %s => %s\n",
+                  ppl,
+                  get_path_length,
+                  GNUNET_h2s (query_hash),
+                  GNUNET_B2S (&sig));
+#if SANITY_CHECKS > 1
+      {
+        struct GNUNET_DHT_PathElement xpaths[get_path_length + 1];
+
+        memcpy (xpaths,
+                &paths[ppl],
+                get_path_length * sizeof (struct GNUNET_DHT_PathElement));
+        xpaths[get_path_length].sig = sig;
+        xpaths[get_path_length].pred = GDS_my_identity;
+        if (0 !=
+            GNUNET_DHT_verify_path (bd->data,
+                                    bd->data_size,
+                                    bd->expiration_time,
+                                    trunc_peer,
+                                    paths,
+                                    ppl,
+                                    xpaths,
+                                    get_path_length + 1,
+                                    &pi->id))
+        {
+          GNUNET_break (0);
+          return false;
+        }
+      }
+#endif
+    }
+    else
+    {
+      data = &prm[1];
+    }
+    GNUNET_memcpy (data,
+                   bd->data,
+                   bd->data_size);
+    do_send (pi,
+             &prm->header);
+  }
+  return true;
+}
+
+
+/**
+ * Check validity of a p2p put request.
+ *
+ * @param cls closure with the `struct PeerInfo` of the sender
+ * @param put message
+ * @return #GNUNET_OK if the message is valid
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_p2p_put (void *cls,
+                   const struct PeerPutMessage *put)
+{
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohs (put->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+  uint16_t msize = ntohs (put->header.size);
+  uint16_t putlen = ntohs (put->put_path_length);
+  size_t xsize = (has_path
+                  ? sizeof (struct GNUNET_CRYPTO_EddsaSignature)
+                  : 0)
+                 + (truncated
+                    ? sizeof (struct GNUNET_PeerIdentity)
+                    : 0);
+  size_t var_meta_size
+    = putlen * sizeof(struct GNUNET_DHT_PathElement)
+      + xsize;
+
+  (void) cls;
+  if ( (msize <
+        sizeof (struct PeerPutMessage) + var_meta_size) ||
+       (putlen >
+        (GNUNET_MAX_MESSAGE_SIZE
+         - sizeof (struct PeerPutMessage)
+         - xsize)
+        / sizeof(struct GNUNET_DHT_PathElement)) )
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_BLOCK_TYPE_ANY == htonl (put->type))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Core handler for p2p put requests.
+ *
+ * @param cls closure with the `struct Target` of the sender
+ * @param put message
+ */
+static void
+handle_dht_p2p_put (void *cls,
+                    const struct PeerPutMessage *put)
+{
+  struct Target *t = cls;
+  struct PeerInfo *peer = t->pi;
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohs (put->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+  uint16_t msize = ntohs (put->header.size);
+  uint16_t putlen = ntohs (put->put_path_length);
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? (const struct GNUNET_PeerIdentity *) &put[1]
+    : NULL;
+  const struct GNUNET_DHT_PathElement *put_path
+    = truncated
+    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
+    : (const struct GNUNET_DHT_PathElement *) &put[1];
+  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
+    = has_path
+    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &put_path[putlen]
+    : NULL;
+  const char *data
+    = has_path
+    ? (const char *) &last_sig[1]
+    : (const char *) &put_path[putlen];
+  size_t var_meta_size
+    = putlen * sizeof(struct GNUNET_DHT_PathElement)
+      + (has_path ? sizeof (*last_sig) : 0)
+      + (truncated ? sizeof (*trunc_peer) : 0);
+  struct GNUNET_DATACACHE_Block bd = {
+    .key = put->key,
+    .expiration_time = GNUNET_TIME_absolute_ntoh (put->expiration_time),
+    .type = ntohl (put->type),
+    .ro = ro,
+    .data_size = msize - sizeof(*put) - var_meta_size,
+    .data = data
+  };
+
+  if (NULL != trunc_peer)
+    bd.trunc_peer = *trunc_peer;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "PUT for `%s' from %s with RO (%s/%s)\n",
+              GNUNET_h2s (&put->key),
+              GNUNET_i2s (&peer->id),
+              (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
+              has_path ? "R" : "-");
+  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Expired PUTs discarded",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  {
+    /* Only call 'check_block' if that keeps our CPU load (from
+       the cryptography) below 50% on average */
+    static struct GNUNET_TIME_Relative avg_latency;
+    static struct GNUNET_TIME_Absolute next_time;
+
+    if (GNUNET_TIME_absolute_is_past (next_time))
+    {
+      struct GNUNET_TIME_Absolute now
+        = GNUNET_TIME_absolute_get ();
+      struct GNUNET_TIME_Relative latency;
+      struct GNUNET_TIME_Relative delta;
+
+      if (GNUNET_NO ==
+          GNUNET_BLOCK_check_block (GDS_block_context,
+                                    bd.type,
+                                    bd.data,
+                                    bd.data_size))
+      {
+        GNUNET_break_op (0);
+        return;
+      }
+      latency = GNUNET_TIME_absolute_get_duration (now);
+      /* Use *moving average* to estimate check_block latency */
+      avg_latency
+        = GNUNET_TIME_relative_divide (
+            GNUNET_TIME_relative_add (
+              GNUNET_TIME_relative_multiply (avg_latency,
+                                             7),
+              latency),
+            8);
+      /* average delay = 50% of avg_latency => 50% CPU load from crypto (at most) */
+      delta.rel_value_us
+        = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    avg_latency.rel_value_us > 0
+                                        ? avg_latency.rel_value_us
+                                        : 1LLU);
+      next_time = GNUNET_TIME_relative_to_absolute (delta);
+    }
+  }
+  if (! has_path)
+    putlen = 0;
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P PUT requests received",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P PUT bytes received",
+                            msize,
+                            GNUNET_NO);
+  {
+    struct GNUNET_HashCode test_key;
+    enum GNUNET_GenericReturnValue ret;
+
+    ret = GNUNET_BLOCK_get_key (GDS_block_context,
+                                bd.type,
+                                bd.data,
+                                bd.data_size,
+                                &test_key);
+    switch (ret)
+    {
+    case GNUNET_YES:
+      if (0 != GNUNET_memcmp (&test_key,
+                              &bd.key))
+      {
+        GNUNET_break_op (0);
+        return;
+      }
+      break;
+    case GNUNET_NO:
+      /* cannot verify, good luck */
+      break;
+    case GNUNET_SYSERR:
+      /* block type not supported, good luck */
+      break;
+    }
+  }
+
+  {
+    struct GNUNET_CONTAINER_BloomFilter *bf;
+    struct GNUNET_DHT_PathElement pp[putlen + 1];
+
+    bf = GNUNET_CONTAINER_bloomfilter_init (put->bloomfilter,
+                                            DHT_BLOOM_SIZE,
+                                            GNUNET_CONSTANTS_BLOOMFILTER_K);
+    GNUNET_break_op (GNUNET_YES ==
+                     GNUNET_CONTAINER_bloomfilter_test (bf,
+                                                        &peer->phash));
+    /* extend 'put path' by sender */
+    bd.put_path = pp;
+    bd.put_path_length = putlen + 1;
+    if (has_path)
+    {
+      unsigned int failure_offset;
+
+      GNUNET_memcpy (pp,
+                     put_path,
+                     putlen * sizeof(struct GNUNET_DHT_PathElement));
+      pp[putlen].pred = peer->id;
+      pp[putlen].sig = *last_sig;
+#if SANITY_CHECKS
+      /* TODO: might want to eventually implement probabilistic
+         load-based path verification, but for now it is all or nothing */
+      failure_offset
+        = GNUNET_DHT_verify_path (bd.data,
+                                  bd.data_size,
+                                  bd.expiration_time,
+                                  trunc_peer,
+                                  pp,
+                                  putlen + 1,
+                                  NULL, 0,   /* get_path */
+                                  &GDS_my_identity);
+#else
+      failure_offset = 0;
+#endif
+      if (0 != failure_offset)
+      {
+        GNUNET_break_op (0);
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Recorded put path invalid at offset %u, truncating\n",
+                    failure_offset);
+        GNUNET_assert (failure_offset <= putlen + 1);
+        bd.put_path = &pp[failure_offset];
+        bd.put_path_length = (putlen + 1) - failure_offset;
+        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
+        bd.trunc_peer = pp[failure_offset - 1].pred;
+      }
+    }
+    else
+    {
+      bd.put_path_length = 0;
+    }
+
+    /* give to local clients */
+    GNUNET_break (GDS_CLIENTS_handle_reply (&bd,
+                                            &bd.key,
+                                            0, NULL /* get path */));
+
+    /* store locally */
+    if ( (0 != (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
+         (GDS_am_closest_peer (&put->key,
+                               bf)) )
+      GDS_DATACACHE_handle_put (&bd);
+    {
+      enum GNUNET_GenericReturnValue forwarded;
+
+      /* route to other peers */
+      forwarded
+        = GDS_NEIGHBOURS_handle_put (&bd,
+                                     ntohs (put->desired_replication_level),
+                                     ntohs (put->hop_count),
+                                     bf);
+      /* notify monitoring clients */
+      bd.ro |= ((GNUNET_OK == forwarded)
+                ? GNUNET_DHT_RO_LAST_HOP
+                : 0);
+      GDS_CLIENTS_process_put (&bd,
+                               ntohs (put->hop_count),
+                               ntohs (put->desired_replication_level));
+    }
+    GNUNET_CONTAINER_bloomfilter_free (bf);
+  }
+}
+
+
+/**
+ * We have received a request for a HELLO.  Sends our
+ * HELLO back.
+ *
+ * @param pi sender of the request
+ * @param key peers close to this key are desired
+ * @param bg group for filtering peers
+ */
+static void
+handle_find_my_hello (struct PeerInfo *pi,
+                      const struct GNUNET_HashCode *query_hash,
+                      struct GNUNET_BLOCK_Group *bg)
+{
+  size_t block_size = 0;
+
+  /* TODO: consider caching our HELLO block for a bit, to
+     avoid signing too often here... */
+  GNUNET_break (GNUNET_NO ==
+                GNUNET_HELLO_builder_to_block (GDS_my_hello,
+                                               &GDS_my_private_key,
+                                               NULL,
+                                               &block_size,
+                                               GNUNET_TIME_UNIT_ZERO));
+  {
+    char block[block_size];
+
+    if (GNUNET_OK !=
+        GNUNET_HELLO_builder_to_block (GDS_my_hello,
+                                       &GDS_my_private_key,
+                                       block,
+                                       &block_size,
+                                       GNUNET_TIME_UNIT_ZERO))
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# FIND PEER requests ignored due to lack of HELLO",
+                                1,
+                                GNUNET_NO);
+    }
+    else if (GNUNET_BLOCK_REPLY_OK_MORE ==
+             GNUNET_BLOCK_check_reply (GDS_block_context,
+                                       GNUNET_BLOCK_TYPE_DHT_HELLO,
+                                       bg,
+                                       &GDS_my_identity_hash,
+                                       NULL, 0,
+                                       block,
+                                       block_size))
+    {
+      struct GNUNET_DATACACHE_Block bd = {
+        .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
+        .expiration_time
+          = GNUNET_TIME_relative_to_absolute (
+              GNUNET_HELLO_ADDRESS_EXPIRATION),
+        .key = GDS_my_identity_hash,
+        .data = block,
+        .data_size = block_size
+      };
+
+      GNUNET_break (GDS_NEIGHBOURS_handle_reply (pi,
+                                                 &bd,
+                                                 query_hash,
+                                                 0, NULL /* get path */));
+    }
+    else
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# FIND PEER requests ignored due to Bloomfilter",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+}
+
+
+/**
+ * We have received a request for nearby HELLOs.  Sends matching
+ * HELLOs back.
+ *
+ * @param pi sender of the request
+ * @param key peers close to this key are desired
+ * @param bg group for filtering peers
+ */
+static void
+handle_find_local_hello (struct PeerInfo *pi,
+                         const struct GNUNET_HashCode *query_hash,
+                         struct GNUNET_BLOCK_Group *bg)
+{
+  /* Force non-random selection by hop count */
+  struct PeerInfo *peer;
+
+  peer = select_peer (query_hash,
+                      NULL,
+                      GDS_NSE_get () + 1);
+  if ( (NULL != peer->hello) &&
+       (! GNUNET_TIME_absolute_is_past (peer->hello_expiration)) &&
+       (GNUNET_BLOCK_REPLY_OK_MORE ==
+        GNUNET_BLOCK_check_reply (
+          GDS_block_context,
+          GNUNET_BLOCK_TYPE_DHT_HELLO,
+          bg,
+          &peer->phash,
+          NULL, 0,        /* xquery */
+          peer->hello,
+          peer->hello_size)) )
+  {
+    struct GNUNET_DATACACHE_Block bd = {
+      .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
+      .expiration_time = peer->hello_expiration,
+      .key = peer->phash,
+      .data = peer->hello,
+      .data_size = peer->hello_size
+    };
+
+    GNUNET_break (GDS_NEIGHBOURS_handle_reply (pi,
+                                               &bd,
+                                               query_hash,
+                                               0, NULL /* get path */));
+  }
+}
+
+
+/**
+ * Handle an exact result from local datacache for a GET operation.
+ *
+ * @param cls the `struct PeerInfo` for which this is a reply
+ * @param bd details about the block we found locally
+ */
+static void
+handle_local_result (void *cls,
+                     const struct GNUNET_DATACACHE_Block *bd)
+{
+  struct PeerInfo *peer = cls;
+
+  GNUNET_break (GDS_NEIGHBOURS_handle_reply (peer,
+                                             bd,
+                                             &bd->key,
+                                             0, NULL /* get path */));
+}
+
+
+/**
+ * Check validity of p2p get request.
+ *
+ * @param cls closure with the `struct Target` of the sender
+ * @param get the message
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_p2p_get (void *cls,
+                   const struct PeerGetMessage *get)
+{
+  uint16_t msize = ntohs (get->header.size);
+  uint16_t result_filter_size = ntohs (get->result_filter_size);
+
+  (void) cls;
+  if (msize < sizeof(*get) + result_filter_size)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Core handler for p2p get requests.
+ *
+ * @param cls closure with the `struct Target` of the sender
+ * @param get the message
+ */
+static void
+handle_dht_p2p_get (void *cls,
+                    const struct PeerGetMessage *get)
+{
+  struct Target *t = cls;
+  struct PeerInfo *peer = t->pi;
+  uint16_t msize = ntohs (get->header.size);
+  uint16_t result_filter_size = ntohs (get->result_filter_size);
+  uint16_t hop_count = ntohs (get->hop_count);
+  enum GNUNET_BLOCK_Type type = (enum GNUNET_BLOCK_Type) ntohl (get->type);
+  enum GNUNET_DHT_RouteOption options = (enum GNUNET_DHT_RouteOption)  ntohs (
+    get->options);
+  enum GNUNET_BLOCK_ReplyEvaluationResult eval = GNUNET_BLOCK_REPLY_OK_MORE;
+  const void *result_filter = (const void *) &get[1];
+  const void *xquery = result_filter + result_filter_size;
+  size_t xquery_size = msize - sizeof (*get) - result_filter_size;
+
+  /* parse and validate message */
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P GET requests received",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P GET bytes received",
+                            msize,
+                            GNUNET_NO);
+  if (GNUNET_NO ==
+      GNUNET_BLOCK_check_query (GDS_block_context,
+                                type,
+                                &get->key,
+                                xquery,
+                                xquery_size))
+  {
+    /* request invalid */
+    GNUNET_break_op (0);
+    return;
+  }
+
+  {
+    struct GNUNET_BLOCK_Group *bg;
+    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
+
+    peer_bf = GNUNET_CONTAINER_bloomfilter_init (get->bloomfilter,
+                                                 DHT_BLOOM_SIZE,
+                                                 GNUNET_CONSTANTS_BLOOMFILTER_K);
+    GNUNET_break_op (GNUNET_YES ==
+                     GNUNET_CONTAINER_bloomfilter_test (peer_bf,
+                                                        &peer->phash));
+    bg = GNUNET_BLOCK_group_create (GDS_block_context,
+                                    type,
+                                    result_filter,
+                                    result_filter_size,
+                                    "filter-size",
+                                    result_filter_size,
+                                    NULL);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "GET for %s at %s after %u hops\n",
+                GNUNET_h2s (&get->key),
+                GNUNET_i2s (&GDS_my_identity),
+                (unsigned int) hop_count);
+    /* local lookup (this may update the bg) */
+    if ( (0 != (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
+         (GDS_am_closest_peer (&get->key,
+                               peer_bf)) )
+    {
+      if ( (GNUNET_BLOCK_TYPE_DHT_HELLO == type) ||
+           (GNUNET_BLOCK_TYPE_ANY == type) )
+      {
+        GNUNET_STATISTICS_update (GDS_stats,
+                                  "# P2P HELLO lookup requests processed",
+                                  1,
+                                  GNUNET_NO);
+        handle_find_my_hello (peer,
+                              &get->key,
+                              bg);
+        if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
+          handle_find_local_hello (peer,
+                                   &get->key,
+                                   bg);
+      }
+      if (GNUNET_BLOCK_TYPE_DHT_HELLO != type)
+      {
+        if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
+          eval = GDS_DATACACHE_get_closest (&get->key,
+                                            type,
+                                            xquery,
+                                            xquery_size,
+                                            bg,
+                                            &handle_local_result,
+                                            peer);
+        else
+          eval = GDS_DATACACHE_handle_get (&get->key,
+                                           type,
+                                           xquery,
+                                           xquery_size,
+                                           bg,
+                                           &handle_local_result,
+                                           peer);
+      }
+    }
+    else
+    {
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# P2P GET requests ONLY routed",
+                                1,
+                                GNUNET_NO);
+    }
+
+    /* remember request for routing replies
+       TODO: why should we do this if GNUNET_BLOCK_REPLY_OK_LAST == eval?
+    */
+    GDS_ROUTING_add (&peer->id,
+                     type,
+                     bg,      /* bg now owned by routing, but valid at least until end of this function! */
+                     options,
+                     &get->key,
+                     xquery,
+                     xquery_size);
+
+    /* P2P forwarding */
+    {
+      bool forwarded = false;
+      uint16_t desired_replication_level = ntohs (
+        get->desired_replication_level);
+
+      if (eval != GNUNET_BLOCK_REPLY_OK_LAST)
+        forwarded = (GNUNET_OK ==
+                     GDS_NEIGHBOURS_handle_get (type,
+                                                options,
+                                                desired_replication_level,
+                                                hop_count,
+                                                &get->key,
+                                                xquery,
+                                                xquery_size,
+                                                bg,
+                                                peer_bf));
+      GDS_CLIENTS_process_get (
+        options
+        | (forwarded
+         ? 0
+         : GNUNET_DHT_RO_LAST_HOP),
+        type,
+        hop_count,
+        desired_replication_level,
+        &get->key);
+    }
+    /* clean up; note that 'bg' is owned by routing now! */
+    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
+  }
+}
+
+
+/**
+ * Process a reply, after the @a get_path has been updated.
+ *
+ * @param bd block details
+ * @param query_hash hash of the original query, might not match key in @a bd
+ * @param get_path_length number of entries in @a get_path
+ * @param get_path path the reply has taken
+ * @return true on success
+ */
+static bool
+process_reply_with_path (const struct GNUNET_DATACACHE_Block *bd,
+                         const struct GNUNET_HashCode *query_hash,
+                         unsigned int get_path_length,
+                         const struct GNUNET_DHT_PathElement *get_path)
+{
+  /* forward to local clients */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding reply to local clients\n");
+  if (! GDS_CLIENTS_handle_reply (bd,
+                                  query_hash,
+                                  get_path_length,
+                                  get_path))
+  {
+    GNUNET_break (0);
+    return false;
+  }
+  GDS_CLIENTS_process_get_resp (bd,
+                                get_path,
+                                get_path_length);
+  if (GNUNET_YES == cache_results)
+  {
+    struct GNUNET_DHT_PathElement xput_path[GNUNET_NZL (get_path_length
+                                                        + bd->put_path_length)];
+    struct GNUNET_DATACACHE_Block bdx = *bd;
+
+    if (NULL != bd->put_path)
+      GNUNET_memcpy (xput_path,
+                     bd->put_path,
+                     bd->put_path_length * sizeof(struct
+                                                  GNUNET_DHT_PathElement));
+    GNUNET_memcpy (&xput_path[bd->put_path_length],
+                   get_path,
+                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
+    bdx.put_path = xput_path;
+    bdx.put_path_length += get_path_length;
+    GDS_DATACACHE_handle_put (&bdx);
+  }
+  /* forward to other peers */
+  GDS_ROUTING_process (bd,
+                       query_hash,
+                       get_path_length,
+                       get_path);
+  return true;
+}
+
+
+/**
+ * Check validity of p2p result message.
+ *
+ * @param cls closure
+ * @param prm message
+ * @return #GNUNET_YES if the message is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_p2p_result (void *cls,
+                      const struct PeerResultMessage *prm)
+{
+  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohs (prm->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+
+  uint16_t get_path_length = ntohs (prm->get_path_length);
+  uint16_t put_path_length = ntohs (prm->put_path_length);
+  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
+                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
+
+  (void) cls;
+  if ( (msize < vsize) ||
+       (msize - vsize <
+        (get_path_length + put_path_length)
+        * sizeof(struct GNUNET_DHT_PathElement)) ||
+       (get_path_length >
+        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) ||
+       (put_path_length >
+        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) )
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Core handler for p2p result messages.
+ *
+ * @param cls closure
+ * @param prm message
+ */
+static void
+handle_dht_p2p_result (void *cls,
+                       const struct PeerResultMessage *prm)
+{
+  struct Target *t = cls;
+  struct PeerInfo *peer = t->pi;
+  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
+  enum GNUNET_DHT_RouteOption ro
+    = (enum GNUNET_DHT_RouteOption) ntohs (prm->options);
+  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
+  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
+  uint16_t get_path_length = ntohs (prm->get_path_length);
+  uint16_t put_path_length = ntohs (prm->put_path_length);
+  const struct GNUNET_PeerIdentity *trunc_peer
+    = truncated
+    ? (const struct GNUNET_PeerIdentity *) &prm[1]
+    : NULL;
+  const struct GNUNET_DHT_PathElement *put_path
+    = truncated
+    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
+    : (const struct GNUNET_DHT_PathElement *) &prm[1];
+  const struct GNUNET_DHT_PathElement *get_path
+    = &put_path[put_path_length];
+  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
+    = tracked
+    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &get_path[get_path_length]
+    : NULL;
+  const void *data
+    = tracked
+    ? (const void *) &last_sig[1]
+    : (const void *) &get_path[get_path_length];
+  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
+                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
+  struct GNUNET_DATACACHE_Block bd = {
+    .expiration_time  = GNUNET_TIME_absolute_ntoh (prm->expiration_time),
+    .put_path = put_path,
+    .put_path_length = put_path_length,
+    .key = prm->key,
+    .type = ntohl (prm->type),
+    .ro = ro,
+    .data = data,
+    .data_size = msize - vsize - (get_path_length + put_path_length)
+                 * sizeof(struct GNUNET_DHT_PathElement)
+  };
+
+  /* parse and validate message */
+  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Expired results discarded",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_BLOCK_check_block (GDS_block_context,
+                                bd.type,
+                                bd.data,
+                                bd.data_size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P RESULTS received",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# P2P RESULT bytes received",
+                            msize,
+                            GNUNET_NO);
+  {
+    enum GNUNET_GenericReturnValue ret;
+
+    ret = GNUNET_BLOCK_get_key (GDS_block_context,
+                                bd.type,
+                                bd.data,
+                                bd.data_size,
+                                &bd.key);
+    if (GNUNET_NO == ret)
+      bd.key = prm->key;
+  }
+
+  /* if we got a HELLO, consider it for our own routing table */
+  hello_check (&bd);
+
+  /* Need to append 'peer' to 'get_path' */
+  if (tracked)
+  {
+    struct GNUNET_DHT_PathElement xget_path[get_path_length + 1];
+    struct GNUNET_DHT_PathElement *gp = xget_path;
+    unsigned int failure_offset;
+
+    GNUNET_memcpy (xget_path,
+                   get_path,
+                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
+    xget_path[get_path_length].pred = peer->id;
+    /* use memcpy(), as last_sig may not be aligned */
+    memcpy (&xget_path[get_path_length].sig,
+            last_sig,
+            sizeof (*last_sig));
+#if SANITY_CHECKS
+    /* TODO: might want to eventually implement probabilistic
+       load-based path verification, but for now it is all or nothing */
+    failure_offset
+      = GNUNET_DHT_verify_path (bd.data,
+                                bd.data_size,
+                                bd.expiration_time,
+                                trunc_peer,
+                                put_path,
+                                put_path_length,
+                                gp,
+                                get_path_length + 1,
+                                &GDS_my_identity);
+#else
+    failure_offset = 0;
+#endif
+    if (0 != failure_offset)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Recorded path invalid at offset %u, truncating\n",
+                  failure_offset);
+      GNUNET_assert (failure_offset <= bd.put_path_length + get_path_length
+                     + 1);
+      if (failure_offset < bd.put_path_length)
+      {
+        /* failure on put path */
+        trunc_peer = &bd.put_path[failure_offset - 1].pred;
+        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
+        bd.put_path = &bd.put_path[failure_offset];
+        bd.put_path_length -= failure_offset;
+        truncated = true;
+      }
+      else
+      {
+        /* failure on get path */
+        failure_offset -= bd.put_path_length;
+        if (0 == failure_offset)
+          trunc_peer = &bd.put_path[bd.put_path_length - 1].pred;
+        else
+          trunc_peer = &gp[failure_offset - 1].pred;
+        get_path_length -= failure_offset;
+        gp = &gp[failure_offset];
+        bd.put_path_length = 0;
+        bd.put_path = NULL;
+        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
+        truncated = true;
+      }
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Extending GET path of length %u with %s\n",
+                get_path_length,
+                GNUNET_i2s (&peer->id));
+    if (truncated)
+    {
+      GNUNET_assert (NULL != trunc_peer);
+      bd.trunc_peer = *trunc_peer;
+    }
+    GNUNET_break (process_reply_with_path (&bd,
+                                           &prm->key,
+                                           get_path_length + 1,
+                                           gp));
+  }
+  else
+  {
+    if (truncated)
+    {
+      GNUNET_assert (NULL != trunc_peer);
+      bd.trunc_peer = *trunc_peer;
+    }
+    GNUNET_break (process_reply_with_path (&bd,
+                                           &prm->key,
+                                           0,
+                                           NULL));
+  }
+}
+
+
+/**
+ * Check validity of a p2p hello message.
+ *
+ * @param cls closure
+ * @param hello message
+ * @return #GNUNET_YES if the message is well-formed
+ */
+static enum GNUNET_GenericReturnValue
+check_dht_p2p_hello (void *cls,
+                     const struct GNUNET_MessageHeader *hello)
+{
+  struct Target *t = cls;
+  struct PeerInfo *peer = t->pi;
+  enum GNUNET_GenericReturnValue ret;
+  size_t hellob_size;
+  void *hellob;
+  struct GNUNET_TIME_Absolute expiration;
+
+  ret = GNUNET_HELLO_dht_msg_to_block (hello,
+                                       &peer->id,
+                                       &hellob,
+                                       &hellob_size,
+                                       &expiration);
+  GNUNET_free (hellob);
+  return ret;
+}
+
+
+/**
+ * Core handler for p2p HELLO messages.
+ *
+ * @param cls closure
+ * @param hello message
+ */
+static void
+handle_dht_p2p_hello (void *cls,
+                      const struct GNUNET_MessageHeader *hello)
+{
+  struct Target *t = cls;
+  struct PeerInfo *peer = t->pi;
+
+  GNUNET_free (peer->hello);
+  peer->hello_size = 0;
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_HELLO_dht_msg_to_block (hello,
+                                               &peer->id,
+                                               &peer->hello,
+                                               &peer->hello_size,
+                                               &peer->hello_expiration));
+}
+
+
+void
+GDS_u_receive (void *cls,
+               void **tctx,
+               void **sctx,
+               const void *message,
+               size_t message_size)
+{
+  struct Target *t = *tctx;
+  struct GNUNET_MQ_MessageHandler core_handlers[] = {
+    GNUNET_MQ_hd_var_size (dht_p2p_get,
+                           GNUNET_MESSAGE_TYPE_DHT_P2P_GET,
+                           struct PeerGetMessage,
+                           t),
+    GNUNET_MQ_hd_var_size (dht_p2p_put,
+                           GNUNET_MESSAGE_TYPE_DHT_P2P_PUT,
+                           struct PeerPutMessage,
+                           t),
+    GNUNET_MQ_hd_var_size (dht_p2p_result,
+                           GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT,
+                           struct PeerResultMessage,
+                           t),
+    GNUNET_MQ_hd_var_size (dht_p2p_hello,
+                           GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO,
+                           struct GNUNET_MessageHeader,
+                           t),
+    GNUNET_MQ_handler_end ()
+  };
+  const struct GNUNET_MessageHeader *mh = message;
+
+  (void) cls; /* the 'struct GDS_Underlay' */
+  (void) sctx; /* our receiver address */
+  if (NULL == t)
+  {
+    /* Received message claiming to originate from myself?
+       Ignore! */
+    GNUNET_break_op (0);
+    return;
+  }
+  if (message_size < sizeof (*mh))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (message_size != ntohs (mh->size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Handling message of type %u from peer %s\n",
+              ntohs (mh->type),
+              GNUNET_i2s (&t->pi->id));
+  if (GNUNET_OK !=
+      GNUNET_MQ_handle_message (core_handlers,
+                                mh))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+}
+
+
+/**
+ * Callback function used to extract URIs from a builder.
+ * Called when we should consider connecting to a peer.
+ *
+ * @param cls closure pointing to a `struct GNUNET_PeerIdentity *`
+ * @param uri one of the URIs
+ */
+void
+GDS_try_connect (void *cls,
+                 const struct GNUNET_PeerIdentity *pid,
+                 const char *uri)
+{
+  (void) cls;
+  struct GNUNET_HashCode phash;
+  int peer_bucket;
+  struct PeerBucket *bucket;
+
+  if (0 == GNUNET_memcmp (&GDS_my_identity,
+                          pid))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got a HELLO for my own PID, ignoring it\n");
+    return; /* that's us! */
+  }
+  GNUNET_CRYPTO_hash (pid,
+                      sizeof(*pid),
+                      &phash);
+  peer_bucket = find_bucket (&phash);
+  GNUNET_assert ( (peer_bucket >= 0) &&
+                  ((unsigned int) peer_bucket < MAX_BUCKETS));
+  bucket = &k_buckets[peer_bucket];
+  for (struct PeerInfo *pi = bucket->head;
+       NULL != pi;
+       pi = pi->next)
+    if (0 ==
+        GNUNET_memcmp (&pi->id,
+                       pid))
+    {
+      /* already connected */
+      GDS_u_try_connect (pid,
+                         uri);
+      return;
+    }
+  if (bucket->peers_size >= bucket_size)
+    return; /* do not care */
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Discovered peer %s at %s suitable for bucket %d (%u/%u), trying to connect\n",
+              GNUNET_i2s (pid),
+              uri,
+              peer_bucket,
+              bucket->peers_size,
+              bucket_size);
+  /* new peer that we like! */
+  GDS_u_try_connect (pid,
+                     uri);
+}
+
+
+/**
+ * Send @a msg to all peers in our buckets.
+ *
+ * @param msg message to broadcast
+ */
+void
+GDS_NEIGHBOURS_broadcast (const struct GNUNET_MessageHeader *msg)
+{
+  for (unsigned int bc = 0; bc<closest_bucket; bc++)
+  {
+    struct PeerBucket *bucket = &k_buckets[bc];
+    unsigned int count = 0;
+
+    for (struct PeerInfo *pos = bucket->head;
+         NULL != pos;
+         pos = pos->next)
+    {
+      if (count >= bucket_size)
+        break;   /* we only consider first #bucket_size entries per bucket */
+      count++;
+      do_send (pos,
+               msg);
+    }
+  }
+}
+
+
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_init ()
+{
+
+  unsigned long long temp_config_num;
+
+  disable_try_connect
+    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
+                                            "DHT",
+                                            "DISABLE_TRY_CONNECT");
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_number (GDS_cfg,
+                                             "DHT",
+                                             "bucket_size",
+                                             &temp_config_num))
+    bucket_size = (unsigned int) temp_config_num;
+  cache_results
+    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
+                                            "DHT",
+                                            "CACHE_RESULTS");
+  all_connected_peers = GNUNET_CONTAINER_multipeermap_create (256,
+                                                              GNUNET_YES);
+  return GNUNET_OK;
+}
+
+
+void
+GDS_NEIGHBOURS_done ()
+{
+  if (NULL == all_connected_peers)
+    return;
+  GNUNET_assert (0 ==
+                 GNUNET_CONTAINER_multipeermap_size (all_connected_peers));
+  GNUNET_CONTAINER_multipeermap_destroy (all_connected_peers);
+  all_connected_peers = NULL;
+  GNUNET_assert (NULL == find_peer_task);
+}
+
+
+struct GNUNET_PeerIdentity *
+GDS_NEIGHBOURS_get_id ()
+{
+  return &GDS_my_identity;
+}
+
+
+/* end of gnunet-service-dht_neighbours.c */
diff --git a/src/service/dht/gnunet-service-dht_neighbours.h b/src/service/dht/gnunet-service-dht_neighbours.h
new file mode 100644
index 000000000..7a6788068
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_neighbours.h
@@ -0,0 +1,226 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 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/gnunet-service-dht_neighbours.h
+ * @brief GNUnet DHT routing code
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#ifndef GNUNET_SERVICE_DHT_NEIGHBOURS_H
+#define GNUNET_SERVICE_DHT_NEIGHBOURS_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_block_lib.h"
+#include "gnunet_dht_service.h"
+#include "gnunet_dhtu_plugin.h"
+#include "gnunet-service-dht_datacache.h"
+
+
+struct PeerInfo;
+
+/**
+ * Lookup peer by peer's identity.
+ *
+ * @param target peer to look up
+ * @return NULL if we are not connected to @a target
+ */
+struct PeerInfo *
+GDS_NEIGHBOURS_lookup_peer (const struct GNUNET_PeerIdentity *target);
+
+
+/**
+ * Perform a PUT operation.  Forwards the given request to other
+ * peers.   Does not store the data locally.  Does not give the
+ * data to local clients.  May do nothing if this is the only
+ * peer in the network (or if we are the closest peer in the
+ * network).
+ *
+ * @param bd data about the block
+ * @param desired_replication_level desired replication level
+ * @param hop_count how many hops has this message traversed so far
+ * @param bf Bloom filter of peers this PUT has already traversed
+ * @return #GNUNET_OK if the request was forwarded, #GNUNET_NO if not
+ */
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_handle_put (const struct GNUNET_DATACACHE_Block *bd,
+                           uint16_t desired_replication_level,
+                           uint16_t hop_count,
+                           struct GNUNET_CONTAINER_BloomFilter *bf);
+
+
+/**
+ * Perform a GET operation.  Forwards the given request to other
+ * peers.  Does not lookup the key locally.  May do nothing if this is
+ * the only peer in the network (or if we are the closest peer in the
+ * network).
+ *
+ * @param type type of the block
+ * @param options routing options
+ * @param desired_replication_level desired replication count
+ * @param hop_count how many hops did this request traverse so far?
+ * @param key key for the content
+ * @param xquery extended query
+ * @param xquery_size number of bytes in @a xquery
+ * @param bg block group to filter replies
+ * @param peer_bf filter for peers not to select (again, updated)
+ * @return #GNUNET_OK if the request was forwarded, #GNUNET_NO if not
+ */
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type type,
+                           enum GNUNET_DHT_RouteOption options,
+                           uint16_t desired_replication_level,
+                           uint16_t hop_count,
+                           const struct GNUNET_HashCode *key,
+                           const void *xquery,
+                           size_t xquery_size,
+                           struct GNUNET_BLOCK_Group *bg,
+                           struct GNUNET_CONTAINER_BloomFilter *peer_bf);
+
+
+/**
+ * Handle a reply (route to origin).  Only forwards the reply back to
+ * other peers waiting for it.  Does not do local caching or
+ * forwarding to local clients.
+ *
+ * @param pi neighbour that should receive the block
+ * @param bd details about the reply
+ * @param query_hash query that was used for the request
+ * @param get_path_length number of entries in put_path
+ * @param get_path peers this reply has traversed so far (if tracked)
+ * @return true on success
+ */
+bool
+GDS_NEIGHBOURS_handle_reply (struct PeerInfo *pi,
+                             const struct GNUNET_DATACACHE_Block *bd,
+                             const struct GNUNET_HashCode *query_hash,
+                             unsigned int get_path_length,
+                             const struct GNUNET_DHT_PathElement *get_path);
+
+
+/**
+ * Check whether my identity is closer than any known peers.  If a
+ * non-null bloomfilter is given, check if this is the closest peer
+ * that hasn't already been routed to.
+ *
+ * @param key hash code to check closeness to
+ * @param bloom bloomfilter, exclude these entries from the decision
+ * @return #GNUNET_YES if node location is closest,
+ *         #GNUNET_NO otherwise.
+ */
+enum GNUNET_GenericReturnValue
+GDS_am_closest_peer (const struct GNUNET_HashCode *key,
+                     const struct GNUNET_CONTAINER_BloomFilter *bloom);
+
+
+/**
+ * Callback function used to extract URIs from a builder.
+ * Called when we should consider connecting to a peer.
+ *
+ * @param cls closure
+ * @param pid pointing to a `struct GNUNET_PeerIdentity *`
+ * @param uri one of the URIs
+ */
+void
+GDS_try_connect (void *cls,
+                 const struct GNUNET_PeerIdentity *pid,
+                 const char *uri);
+
+
+/**
+ * Function to call when we connect to a peer and can henceforth transmit to
+ * that peer.
+ *
+ * @param cls the closure, must be a `struct GDS_Underlay`
+ * @param target handle to the target,
+ *    pointer will remain valid until @e disconnect_cb is called
+ * @param pid peer identity,
+ *    pointer will remain valid until @e disconnect_cb is called
+ * @param[out] ctx storage space for DHT to use in association with this target
+ */
+void
+GDS_u_connect (void *cls,
+               struct GNUNET_DHTU_Target *target,
+               const struct GNUNET_PeerIdentity *pid,
+               void **ctx);
+
+
+/**
+ * Function to call when we disconnected from a peer and can henceforth
+ * cannot transmit to that peer anymore.
+ *
+ * @param[in] ctx storage space used by the DHT in association with this target
+ */
+void
+GDS_u_disconnect (void *ctx);
+
+
+/**
+ * Function to call when we receive a message.
+ *
+ * @param cls the closure
+ * @param[in,out] tctx ctx of target address where we received the message from
+ * @param[in,out] sctx ctx of our own source address at which we received the message
+ * @param message the message we received @param message_size number of
+ * bytes in @a message
+ */
+void
+GDS_u_receive (void *cls,
+               void **tctx,
+               void **sctx,
+               const void *message,
+               size_t message_size);
+
+
+/**
+ * Send @a msg to all peers in our buckets.
+ *
+ * @param msg message to broadcast
+ */
+void
+GDS_NEIGHBOURS_broadcast (const struct GNUNET_MessageHeader *msg);
+
+
+/**
+ * Initialize neighbours subsystem.
+ *
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+enum GNUNET_GenericReturnValue
+GDS_NEIGHBOURS_init (void);
+
+
+/**
+ * Shutdown neighbours subsystem.
+ */
+void
+GDS_NEIGHBOURS_done (void);
+
+
+/**
+ * Get the ID of the local node.
+ *
+ * @return identity of the local node
+ */
+struct GNUNET_PeerIdentity *
+GDS_NEIGHBOURS_get_id (void);
+
+
+#endif
diff --git a/src/service/dht/gnunet-service-dht_routing.c b/src/service/dht/gnunet-service-dht_routing.c
new file mode 100644
index 000000000..d81a2b2e1
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_routing.c
@@ -0,0 +1,429 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2011, 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/gnunet-service-dht_routing.c
+ * @brief GNUnet DHT tracking of requests for routing replies
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet-service-dht_neighbours.h"
+#include "gnunet-service-dht_routing.h"
+#include "gnunet-service-dht.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Number of requests we track at most (for routing replies).
+ * TODO: make configurable!
+ */
+#define DHT_MAX_RECENT (1024 * 128)
+
+
+/**
+ * Information we keep about all recent GET requests
+ * so that we can route replies.
+ */
+struct RecentRequest
+{
+  /**
+   * The peer this request was received from.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * Key of this request.
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Position of this node in the min heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *heap_node;
+
+  /**
+   * Block group for filtering replies.
+   */
+  struct GNUNET_BLOCK_Group *bg;
+
+  /**
+   * extended query (see gnunet_block_lib.h).  Allocated at the
+   * end of this struct.
+   */
+  const void *xquery;
+
+  /**
+   * Number of bytes in xquery.
+   */
+  size_t xquery_size;
+
+  /**
+   * Type of the requested block.
+   */
+  enum GNUNET_BLOCK_Type type;
+
+  /**
+   * Request options.
+   */
+  enum GNUNET_DHT_RouteOption options;
+};
+
+
+/**
+ * Recent requests by time inserted.
+ */
+static struct GNUNET_CONTAINER_Heap *recent_heap;
+
+/**
+ * Recently seen requests by key.
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *recent_map;
+
+
+/**
+ * Closure for the process() function.
+ */
+struct ProcessContext
+{
+  /**
+   * Block data.
+   */
+  const struct GNUNET_DATACACHE_Block *bd;
+
+  /**
+   * Path of the reply.
+   */
+  const struct GNUNET_DHT_PathElement *get_path;
+
+  /**
+   * Number of entries in @e get_path.
+   */
+  unsigned int get_path_length;
+
+};
+
+
+/**
+ * Forward the result to the given peer if it matches the request.
+ *
+ * @param cls the `struct ProcessContext` with the result
+ * @param query_hash the hash from the original query
+ * @param value the `struct RecentRequest` with the request
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static enum GNUNET_GenericReturnValue
+process (void *cls,
+         const struct GNUNET_HashCode *query_hash,
+         void *value)
+{
+  struct ProcessContext *pc = cls;
+  struct RecentRequest *rr = value;
+  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
+  unsigned int get_path_length;
+  struct GNUNET_DATACACHE_Block bdx = *pc->bd;
+
+  if ( (rr->type != GNUNET_BLOCK_TYPE_ANY) &&
+       (rr->type != pc->bd->type) )
+    return GNUNET_OK;           /* type mismatch */
+  if (0 != (rr->options & GNUNET_DHT_RO_RECORD_ROUTE))
+  {
+    get_path_length = pc->get_path_length;
+  }
+  else
+  {
+    get_path_length = 0;
+    bdx.put_path_length = 0;
+    bdx.put_path = NULL;
+  }
+  if ( (0 == (rr->options & GNUNET_DHT_RO_FIND_APPROXIMATE)) &&
+       (0 != GNUNET_memcmp (query_hash,
+                            &bdx.key)) )
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Inexact matches discarded in exact search",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_OK; /* exact search, but inexact match */
+  }
+  eval = GNUNET_BLOCK_check_reply (GDS_block_context,
+                                   bdx.type,
+                                   rr->bg,
+                                   &bdx.key,
+                                   rr->xquery,
+                                   rr->xquery_size,
+                                   bdx.data,
+                                   bdx.data_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Result for %s of type %d was evaluated as %d\n",
+              GNUNET_h2s (&bdx.key),
+              bdx.type,
+              eval);
+  if (GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED == eval)
+  {
+    /* If we do not know the block type, we still filter
+       exact duplicates by the block content */
+    struct GNUNET_HashCode chash;
+    
+    GNUNET_CRYPTO_hash (bdx.data,
+                        bdx.data_size,
+                        &chash);
+    if (GNUNET_YES ==
+        GNUNET_BLOCK_GROUP_bf_test_and_set (rr->bg,
+                                            &chash))
+      eval = GNUNET_BLOCK_REPLY_OK_DUPLICATE;
+    else
+      eval = GNUNET_BLOCK_REPLY_OK_MORE;
+  }
+  switch (eval)
+  {
+  case GNUNET_BLOCK_REPLY_OK_MORE:
+  case GNUNET_BLOCK_REPLY_OK_LAST:
+  case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
+    {
+      struct PeerInfo *pi;
+
+      GNUNET_STATISTICS_update (GDS_stats,
+                                "# Good REPLIES matched against routing table",
+                                1,
+                                GNUNET_NO);
+      pi = GDS_NEIGHBOURS_lookup_peer (&rr->peer);
+      if (NULL == pi)
+      {
+        /* peer disconnected in the meantime, drop reply */
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "No matching peer for reply for key %s\n",
+                    GNUNET_h2s (query_hash));
+        return GNUNET_OK;
+      }
+      GNUNET_break (GDS_NEIGHBOURS_handle_reply (pi,
+                                                 &bdx,
+                                                 query_hash,
+                                                 get_path_length,
+                                                 pc->get_path));
+    }
+    break;
+  case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Duplicate REPLIES matched against routing table",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_OK;
+  case GNUNET_BLOCK_REPLY_IRRELEVANT:
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# Irrelevant REPLIES matched against routing table",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a reply (route to origin).  Only forwards the reply back to
+ * other peers waiting for it.  Does not do local caching or
+ * forwarding to local clients.  Essentially calls
+ * GDS_NEIGHBOURS_handle_reply() for all peers that sent us a matching
+ * request recently.
+ *
+ * @param bd block details
+ * @param query_hash query used in the inquiry
+ * @param get_path_length number of entries in @a get_path
+ * @param get_path peers this reply has traversed so far (if tracked)
+ */
+void
+GDS_ROUTING_process (const struct GNUNET_DATACACHE_Block *bd,
+                     const struct GNUNET_HashCode *query_hash,
+                     unsigned int get_path_length,
+                     const struct GNUNET_DHT_PathElement *get_path)
+{
+  struct ProcessContext pc = {
+    .bd = bd,
+    .get_path = get_path,
+    .get_path_length = get_path_length
+  };
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (recent_map,
+                                              query_hash,
+                                              &process,
+                                              &pc);
+}
+
+
+/**
+ * Remove the oldest entry from the DHT routing table.  Must only
+ * be called if it is known that there is at least one entry
+ * in the heap and hashmap.
+ */
+static void
+expire_oldest_entry (void)
+{
+  struct RecentRequest *recent_req;
+
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# Old entries removed from routing table",
+                            1,
+                            GNUNET_NO);
+  recent_req = GNUNET_CONTAINER_heap_peek (recent_heap);
+  GNUNET_assert (recent_req != NULL);
+  GNUNET_CONTAINER_heap_remove_node (recent_req->heap_node);
+  GNUNET_BLOCK_group_destroy (recent_req->bg);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (recent_map,
+                                                       &recent_req->key,
+                                                       recent_req));
+  GNUNET_free (recent_req);
+}
+
+
+/**
+ * Try to combine multiple recent requests for the same value
+ * (if they come from the same peer).
+ *
+ * @param cls the new `struct RecentRequest` (to discard upon successful combination)
+ * @param key the query
+ * @param value the existing `struct RecentRequest` (to update upon successful combination)
+ * @return #GNUNET_OK (continue to iterate),
+ *         #GNUNET_SYSERR if the request was successfully combined
+ */
+static enum GNUNET_GenericReturnValue
+try_combine_recent (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct RecentRequest *in = cls;
+  struct RecentRequest *rr = value;
+
+  if ( (0 != GNUNET_memcmp (&in->peer,
+                            &rr->peer)) ||
+       (in->type != rr->type) ||
+       (in->xquery_size != rr->xquery_size) ||
+       (0 != memcmp (in->xquery,
+                     rr->xquery,
+                     in->xquery_size) ) )
+    return GNUNET_OK;
+  GNUNET_break (GNUNET_SYSERR !=
+                GNUNET_BLOCK_group_merge (in->bg,
+                                          rr->bg));
+  rr->bg = in->bg;
+  GNUNET_free (in);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Add a new entry to our routing table.
+ *
+ * @param sender peer that originated the request
+ * @param type type of the block
+ * @param[in] bg block group for filtering duplicate replies
+ * @param options options for processing
+ * @param key key for the content
+ * @param xquery extended query
+ * @param xquery_size number of bytes in @a xquery
+ */
+void
+GDS_ROUTING_add (const struct GNUNET_PeerIdentity *sender,
+                 enum GNUNET_BLOCK_Type type,
+                 struct GNUNET_BLOCK_Group *bg,
+                 enum GNUNET_DHT_RouteOption options,
+                 const struct GNUNET_HashCode *key,
+                 const void *xquery,
+                 size_t xquery_size)
+{
+  struct RecentRequest *recent_req;
+
+  while (GNUNET_CONTAINER_heap_get_size (recent_heap) >= DHT_MAX_RECENT)
+    expire_oldest_entry ();
+  GNUNET_STATISTICS_update (GDS_stats,
+                            "# Entries added to routing table",
+                            1,
+                            GNUNET_NO);
+  recent_req = GNUNET_malloc (sizeof(struct RecentRequest) + xquery_size);
+  recent_req->peer = *sender;
+  recent_req->key = *key;
+  recent_req->bg = bg;
+  recent_req->type = type;
+  recent_req->options = options;
+  recent_req->xquery = &recent_req[1];
+  GNUNET_memcpy (&recent_req[1],
+                 xquery,
+                 xquery_size);
+  recent_req->xquery_size = xquery_size;
+  if (GNUNET_SYSERR ==
+      GNUNET_CONTAINER_multihashmap_get_multiple (recent_map,
+                                                  key,
+                                                  &try_combine_recent,
+                                                  recent_req))
+  {
+    GNUNET_STATISTICS_update (GDS_stats,
+                              "# DHT requests combined",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  recent_req->heap_node
+    = GNUNET_CONTAINER_heap_insert (
+        recent_heap,
+        recent_req,
+        GNUNET_TIME_absolute_get ().abs_value_us);
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    recent_map,
+    key,
+    recent_req,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+}
+
+
+/**
+ * Initialize routing subsystem.
+ */
+void
+GDS_ROUTING_init ()
+{
+  recent_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  recent_map = GNUNET_CONTAINER_multihashmap_create (DHT_MAX_RECENT * 4 / 3,
+                                                     GNUNET_NO);
+}
+
+
+/**
+ * Shutdown routing subsystem.
+ */
+void
+GDS_ROUTING_done ()
+{
+  while (GNUNET_CONTAINER_heap_get_size (recent_heap) > 0)
+    expire_oldest_entry ();
+  GNUNET_assert (0 ==
+                 GNUNET_CONTAINER_heap_get_size (recent_heap));
+  GNUNET_CONTAINER_heap_destroy (recent_heap);
+  recent_heap = NULL;
+  GNUNET_assert (0 ==
+                 GNUNET_CONTAINER_multihashmap_size (recent_map));
+  GNUNET_CONTAINER_multihashmap_destroy (recent_map);
+  recent_map = NULL;
+}
+
+
+/* end of gnunet-service-dht_routing.c */
diff --git a/src/service/dht/gnunet-service-dht_routing.h b/src/service/dht/gnunet-service-dht_routing.h
new file mode 100644
index 000000000..08c7de870
--- /dev/null
+++ b/src/service/dht/gnunet-service-dht_routing.h
@@ -0,0 +1,87 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2011, 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/gnunet-service-dht_routing.h
+ * @brief GNUnet DHT tracking of requests for routing replies
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_DHT_ROUTING_H
+#define GNUNET_SERVICE_DHT_ROUTING_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_block_lib.h"
+#include "gnunet_dht_service.h"
+
+
+/**
+ * Handle a reply (route to origin).  Only forwards the reply back to
+ * other peers waiting for it.  Does not do local caching or
+ * forwarding to local clients.  Essentially calls
+ * GDS_NEIGHBOURS_handle_reply() for all peers that sent us a matching
+ * request recently.
+ *
+ * @param bd block details
+ * @param query_hash query used in the inquiry
+ * @param get_path_length number of entries in @a get_path
+ * @param get_path peers this reply has traversed so far (if tracked)
+ */
+void
+GDS_ROUTING_process (const struct GNUNET_DATACACHE_Block *bd,
+                     const struct GNUNET_HashCode *query_hash,
+                     unsigned int get_path_length,
+                     const struct GNUNET_DHT_PathElement *get_path);
+
+
+/**
+ * Add a new entry to our routing table.
+ *
+ * @param sender peer that originated the request
+ * @param type type of the block
+ * @param bg block group to evaluate replies, henceforth owned by routing
+ * @param options options for processing
+ * @param key key for the content
+ * @param xquery extended query
+ * @param xquery_size number of bytes in @a xquery
+ */
+void
+GDS_ROUTING_add (const struct GNUNET_PeerIdentity *sender,
+                 enum GNUNET_BLOCK_Type type,
+                 struct GNUNET_BLOCK_Group *bg,
+                 enum GNUNET_DHT_RouteOption options,
+                 const struct GNUNET_HashCode *key,
+                 const void *xquery,
+                 size_t xquery_size);
+
+
+/**
+ * Initialize routing subsystem.
+ */
+void
+GDS_ROUTING_init (void);
+
+
+/**
+ * Shutdown routing subsystem.
+ */
+void
+GDS_ROUTING_done (void);
+
+#endif
diff --git a/src/service/dht/gnunet_dht_profiler.c b/src/service/dht/gnunet_dht_profiler.c
new file mode 100644
index 000000000..55a34bdf0
--- /dev/null
+++ b/src/service/dht/gnunet_dht_profiler.c
@@ -0,0 +1,1032 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2014, 2018 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/gnunet_dht_profiler.c
+ * @brief Profiler for GNUnet DHT
+ * @author Sree Harsha Totakura <sreeharsha@totakura.in>
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testbed_service.h"
+#include "gnunet_dht_service.h"
+#include "gnunet_constants.h"
+
+
+#define MESSAGE(...)                                       \
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, __VA_ARGS__)
+
+#define DEBUG(...)                                           \
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+
+/**
+ * Number of peers which should perform a PUT out of 100 peers
+ */
+static unsigned int put_probability = 100;
+
+/**
+ * Configuration
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Name of the file with the hosts to run the test over
+ */
+static char *hosts_file;
+
+/**
+ * Context for a peer which actively does DHT PUT/GET
+ */
+struct ActiveContext;
+
+/**
+ * Context to hold data of peer
+ */
+struct Context
+{
+  /**
+   * The testbed peer this context belongs to
+   */
+  struct GNUNET_TESTBED_Peer *peer;
+
+  /**
+   * Testbed operation acting on this peer
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+  /**
+   * Active context; NULL if this peer is not an active peer
+   */
+  struct ActiveContext *ac;
+};
+
+
+/**
+ * Context for a peer which actively does DHT PUT/GET
+ */
+struct ActiveContext
+{
+  /**
+   * The linked peer context
+   */
+  struct Context *ctx;
+
+  /**
+   * Handler to the DHT service
+   */
+  struct GNUNET_DHT_Handle *dht;
+
+  /**
+   * The active context used for our DHT GET
+   */
+  struct ActiveContext *get_ac;
+
+  /**
+   * The put handle
+   */
+  struct GNUNET_DHT_PutHandle *dht_put;
+
+  /**
+   * The get handle
+   */
+  struct GNUNET_DHT_GetHandle *dht_get;
+
+  /**
+   * The hashes of the values stored via this activity context.
+   * Array of length #num_puts_per_peer.
+   */
+  struct GNUNET_HashCode *hash;
+
+  /**
+   * Delay task
+   */
+  struct GNUNET_SCHEDULER_Task *delay_task;
+
+  /**
+   * How many puts should we still issue?
+   */
+  unsigned int put_count;
+
+  /**
+   * The number of peers currently doing GET on our data
+   */
+  uint16_t nrefs;
+};
+
+
+/**
+ * An array of contexts.  The size of this array should be equal to @a num_peers
+ */
+static struct Context *a_ctx;
+
+/**
+ * Array of active peers
+ */
+static struct ActiveContext *a_ac;
+
+/**
+ * The delay between rounds for collecting statistics
+ */
+static struct GNUNET_TIME_Relative delay_stats;
+
+/**
+ * The delay to start puts.
+ */
+static struct GNUNET_TIME_Relative delay_put;
+
+/**
+ * The delay to start puts.
+ */
+static struct GNUNET_TIME_Relative delay_get;
+
+/**
+ * The timeout for GET and PUT
+ */
+static struct GNUNET_TIME_Relative timeout;
+
+/**
+ * Number of peers
+ */
+static unsigned int num_peers;
+
+/**
+ * Number of active peers
+ */
+static unsigned int n_active;
+
+/**
+ * Number of DHT service connections we currently have
+ */
+static unsigned int n_dht;
+
+/**
+ * Number of DHT PUTs made
+ */
+static unsigned long long n_puts;
+
+/**
+ * Number of DHT PUTs to be made per peer.
+ */
+static unsigned int num_puts_per_peer = 1;
+
+/**
+ * Number of DHT PUTs succeeded
+ */
+static unsigned long long n_puts_ok;
+
+/**
+ * Number of DHT GETs made
+ */
+static unsigned int n_gets;
+
+/**
+ * Number of DHT GETs succeeded
+ */
+static unsigned int n_gets_ok;
+
+/**
+ * Number of DHT GETs succeeded
+ */
+static unsigned int n_gets_fail;
+
+/**
+ * Replication degree
+ */
+static unsigned int replication;
+
+/**
+ * Testbed Operation (to get stats).
+ */
+static struct GNUNET_TESTBED_Operation *bandwidth_stats_op;
+
+/**
+ * Testbed peer handles.
+ */
+static struct GNUNET_TESTBED_Peer **testbed_handles;
+
+/**
+ * Total number of messages sent by peer.
+ */
+static uint64_t outgoing_bandwidth;
+
+/**
+ * Total number of messages received by peer.
+ */
+static uint64_t incoming_bandwidth;
+
+/**
+ * Average number of hops taken to do put.
+ */
+static double average_put_path_length;
+
+/**
+ * Average number of hops taken to do get.
+ */
+static double average_get_path_length;
+
+/**
+ * Total put path length across all peers.
+ */
+static unsigned int total_put_path_length;
+
+/**
+ * Total get path length across all peers.
+ */
+static unsigned int total_get_path_length;
+
+/**
+ * Counter to keep track of peers added to peer_context lists.
+ */
+static int peers_started = 0;
+
+/**
+ * Should we do a PUT (mode = 0) or GET (mode = 1);
+ */
+static enum
+{
+  MODE_PUT = 0,
+
+  MODE_GET = 1
+} mode;
+
+
+/**
+ * Are we shutting down
+ */
+static int in_shutdown = 0;
+
+
+/**
+ * Connect to DHT services of active peers
+ */
+static void
+start_profiling (void);
+
+
+/**
+ * Shutdown task.  Cleanup all resources and operations.
+ *
+ * @param cls NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  struct ActiveContext *ac;
+
+  in_shutdown = GNUNET_YES;
+  if (NULL != a_ctx)
+  {
+    for (unsigned int cnt = 0; cnt < num_peers; cnt++)
+    {
+      /* Cleanup active context if this peer is an active peer */
+      ac = a_ctx[cnt].ac;
+      if (NULL != ac)
+      {
+        if (NULL != ac->delay_task)
+          GNUNET_SCHEDULER_cancel (ac->delay_task);
+        if (NULL != ac->hash)
+          free (ac->hash);
+        if (NULL != ac->dht_put)
+          GNUNET_DHT_put_cancel (ac->dht_put);
+        if (NULL != ac->dht_get)
+          GNUNET_DHT_get_stop (ac->dht_get);
+      }
+      /* Cleanup testbed operation handle at the last as this operation may
+         contain service connection to DHT */
+      if (NULL != a_ctx[cnt].op)
+        GNUNET_TESTBED_operation_done (a_ctx[cnt].op);
+    }
+    GNUNET_free (a_ctx);
+    a_ctx = NULL;
+  }
+  // FIXME: Should we collect stats only for put/get not for other messages.
+  if (NULL != bandwidth_stats_op)
+  {
+    GNUNET_TESTBED_operation_done (bandwidth_stats_op);
+    bandwidth_stats_op = NULL;
+  }
+  GNUNET_free (a_ac);
+}
+
+
+/**
+ * Stats callback. Finish the stats testbed operation and when all stats have
+ * been iterated, shutdown the test.
+ *
+ * @param cls closure
+ * @param op the operation that has been finished
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+bandwidth_stats_cont (void *cls,
+                      struct GNUNET_TESTBED_Operation *op,
+                      const char *emsg)
+{
+  MESSAGE ("# Outgoing (core) bandwidth: %llu bytes\n",
+           (unsigned long long) outgoing_bandwidth);
+  MESSAGE ("# Incoming (core) bandwidth: %llu bytes\n",
+           (unsigned long long) incoming_bandwidth);
+  fprintf (stderr,
+           "Benchmark done. Collect data via gnunet-statistics, then press ENTER to exit.\n");
+  (void) getchar ();
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Process statistic values.
+ *
+ * @param cls closure
+ * @param peer the peer the statistic belong to
+ * @param subsystem name of subsystem that created the statistic
+ * @param name the name of the datum
+ * @param value the current value
+ * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
+ * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
+ */
+static int
+bandwidth_stats_iterator (void *cls,
+                          const struct GNUNET_TESTBED_Peer *peer,
+                          const char *subsystem,
+                          const char *name,
+                          uint64_t value,
+                          int is_persistent)
+{
+  static const char *s_sent = "# bytes encrypted";
+  static const char *s_recv = "# bytes decrypted";
+
+  if (0 == strncmp (s_sent, name, strlen (s_sent)))
+    outgoing_bandwidth = outgoing_bandwidth + value;
+  else if (0 == strncmp (s_recv, name, strlen (s_recv)))
+    incoming_bandwidth = incoming_bandwidth + value;
+  return GNUNET_OK;
+}
+
+
+static void
+summarize ()
+{
+  MESSAGE ("# PUTS started: %llu\n",
+           n_puts);
+  MESSAGE ("# PUTS succeeded: %llu\n",
+           n_puts_ok);
+  MESSAGE ("# GETS made: %u\n",
+           n_gets);
+  MESSAGE ("# GETS succeeded: %u\n",
+           n_gets_ok);
+  MESSAGE ("# GETS failed: %u\n",
+           n_gets_fail);
+  MESSAGE ("# average_put_path_length: %f\n",
+           average_put_path_length);
+  MESSAGE ("# average_get_path_length: %f\n",
+           average_get_path_length);
+
+  if (NULL == testbed_handles)
+  {
+    MESSAGE ("No peers found\n");
+    return;
+  }
+  /* Collect Stats*/
+  bandwidth_stats_op = GNUNET_TESTBED_get_statistics (n_active,
+                                                      testbed_handles,
+                                                      "core",
+                                                      NULL,
+                                                      &bandwidth_stats_iterator,
+                                                      &bandwidth_stats_cont,
+                                                      NULL);
+}
+
+
+/**
+ * Task to cancel DHT GET.
+ *
+ * @param cls NULL
+ */
+static void
+cancel_get (void *cls)
+{
+  struct ActiveContext *ac = cls;
+  struct Context *ctx = ac->ctx;
+
+  ac->delay_task = NULL;
+  GNUNET_assert (NULL != ac->dht_get);
+  GNUNET_DHT_get_stop (ac->dht_get);
+  ac->dht_get = NULL;
+  n_gets_fail++;
+  GNUNET_assert (NULL != ctx->op);
+  GNUNET_TESTBED_operation_done (ctx->op);
+  ctx->op = NULL;
+
+  /* If profiling is complete, summarize */
+  if (n_active == n_gets_fail + n_gets_ok)
+  {
+    average_put_path_length = (double) total_put_path_length
+                              / (double) n_active;
+    average_get_path_length = (double) total_get_path_length
+                              / (double ) n_gets_ok;
+    summarize ();
+  }
+}
+
+
+/**
+ * Iterator called on each result obtained for a DHT
+ * operation that expects a reply
+ *
+ * @param cls closure
+ * @param exp when will this value expire
+ * @param key key of the result
+ * @param trunc_peer peer the path was truncated at, or NULL
+ * @param get_path peers on reply path (or NULL if not recorded)
+ *                 [0] = datastore's first neighbor, [length - 1] = local peer
+ * @param get_path_length number of entries in @a get_path
+ * @param put_path peers on the PUT path (or NULL if not recorded)
+ *                 [0] = origin, [length - 1] = datastore
+ * @param put_path_length number of entries in @a put_path
+ * @param type type of the result
+ * @param size number of bytes in @a data
+ * @param data pointer to the result data
+ */
+static void
+get_iter (void *cls,
+          struct GNUNET_TIME_Absolute exp,
+          const struct GNUNET_HashCode *key,
+          const struct GNUNET_PeerIdentity *trunc_peer,
+          const struct GNUNET_DHT_PathElement *get_path,
+          unsigned int get_path_length,
+          const struct GNUNET_DHT_PathElement *put_path,
+          unsigned int put_path_length,
+          enum GNUNET_BLOCK_Type type,
+          size_t size,
+          const void *data)
+{
+  struct ActiveContext *ac = cls;
+  struct ActiveContext *get_ac = ac->get_ac;
+  struct Context *ctx = ac->ctx;
+
+  /* we found the data we are looking for */
+  DEBUG ("We found a GET request; %u remaining\n",
+         n_gets - (n_gets_fail + n_gets_ok)); // FIXME: It always prints 1.
+  n_gets_ok++;
+  get_ac->nrefs--;
+  GNUNET_DHT_get_stop (ac->dht_get);
+  ac->dht_get = NULL;
+  if (ac->delay_task != NULL)
+    GNUNET_SCHEDULER_cancel (ac->delay_task);
+  ac->delay_task = NULL;
+  GNUNET_assert (NULL != ctx->op);
+  GNUNET_TESTBED_operation_done (ctx->op);
+  ctx->op = NULL;
+
+  total_put_path_length = total_put_path_length + (double) put_path_length;
+  total_get_path_length = total_get_path_length + (double) get_path_length;
+  DEBUG ("total_put_path_length = %u,put_path \n",
+         total_put_path_length);
+  /* Summarize if profiling is complete */
+  if (n_active == n_gets_fail + n_gets_ok)
+  {
+    average_put_path_length = (double) total_put_path_length
+                              / (double) n_active;
+    average_get_path_length = (double) total_get_path_length
+                              / (double ) n_gets_ok;
+    summarize ();
+  }
+}
+
+
+/**
+ * Task to do DHT GETs
+ *
+ * @param cls the active context
+ */
+static void
+delayed_get (void *cls)
+{
+  struct ActiveContext *ac = cls;
+  struct ActiveContext *get_ac;
+  unsigned int r;
+
+  ac->delay_task = NULL;
+  get_ac = NULL;
+  while (1)
+  {
+    r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  n_active);
+    get_ac = &a_ac[r];
+    if (NULL != get_ac->hash)
+      break;
+  }
+  get_ac->nrefs++;
+  ac->get_ac = get_ac;
+  r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                num_puts_per_peer);
+  DEBUG ("GET_REQUEST_START key %s \n",
+         GNUNET_h2s (&get_ac->hash[r]));
+  ac->dht_get = GNUNET_DHT_get_start (ac->dht,
+                                      GNUNET_BLOCK_TYPE_TEST,
+                                      &get_ac->hash[r],
+                                      1, /* replication level */
+                                      GNUNET_DHT_RO_NONE,
+                                      NULL,
+                                      0, /* extended query and size */
+                                      &get_iter,
+                                      ac); /* GET iterator and closure */
+  n_gets++;
+
+  /* schedule the timeout task for GET */
+  ac->delay_task = GNUNET_SCHEDULER_add_delayed (timeout,
+                                                 &cancel_get,
+                                                 ac);
+}
+
+
+/**
+ * Task to do DHT PUTs.  If the "put_count" hits zero,
+ * we stop the TESTBED operation (connection to DHT)
+ * so that others PUTs have a chance.
+ *
+ * @param cls the active context
+ */
+static void
+delayed_put (void *cls);
+
+
+/**
+ * Conclude individual PUT operation, schedule the
+ * next one.
+ *
+ * @param cls the active context
+ */
+static void
+put_cont (void *cls)
+{
+  struct ActiveContext *ac = cls;
+
+  ac->dht_put = NULL;
+  n_puts_ok++;
+  ac->delay_task = GNUNET_SCHEDULER_add_now (&delayed_put,
+                                             ac);
+}
+
+
+/**
+ * Task to do DHT PUTs.  If the "put_count" hits zero,
+ * we stop the TESTBED operation (connection to DHT)
+ * so that others PUTs have a chance.
+ *
+ * @param cls the active context
+ */
+static void
+delayed_put (void *cls)
+{
+  struct ActiveContext *ac = cls;
+  char block[65536];
+  size_t block_size;
+
+  ac->delay_task = NULL;
+  if (0 == ac->put_count)
+  {
+    struct Context *ctx = ac->ctx;
+    struct GNUNET_TESTBED_Operation *op;
+
+    GNUNET_assert (NULL != ctx);
+    op = ctx->op;
+    ctx->op = NULL;
+    GNUNET_TESTBED_operation_done (op);
+    return;
+  }
+
+
+  /* Generate and DHT PUT some random data */
+  block_size = 16; /* minimum */
+  /* make random payload, reserve 512 - 16 bytes for DHT headers */
+  block_size += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                          GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
+                                          - 512);
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                              block,
+                              block_size);
+  ac->put_count--;
+  GNUNET_CRYPTO_hash (block,
+                      block_size,
+                      &ac->hash[ac->put_count]);
+  DEBUG ("PUT_REQUEST_START key %s\n",
+         GNUNET_h2s (&ac->hash[ac->put_count]));
+  ac->dht_put = GNUNET_DHT_put (ac->dht,
+                                &ac->hash[ac->put_count],
+                                replication,
+                                GNUNET_DHT_RO_RECORD_ROUTE,
+                                GNUNET_BLOCK_TYPE_TEST,
+                                block_size,
+                                block,
+                                GNUNET_TIME_UNIT_FOREVER_ABS, /* expiration time */
+                                &put_cont,
+                                ac);                /* continuation and its closure */
+  n_puts++;
+}
+
+
+/**
+ * Connection to DHT has been established.  Call the delay task.
+ *
+ * @param cls the active context
+ * @param op the operation that has been finished
+ * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+dht_connected (void *cls,
+               struct GNUNET_TESTBED_Operation *op,
+               void *ca_result,
+               const char *emsg)
+{
+  struct ActiveContext *ac = cls;
+  struct Context *ctx = ac->ctx;
+
+  GNUNET_assert (NULL != ctx);  // FIXME: Fails
+  GNUNET_assert (NULL != ctx->op);
+  GNUNET_assert (ctx->op == op);
+  ac->dht = (struct GNUNET_DHT_Handle *) ca_result;
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Connection to DHT service failed: %s\n",
+                emsg);
+    GNUNET_TESTBED_operation_done (ctx->op);  /* Calls dht_disconnect() */
+    ctx->op = NULL;
+    return;
+  }
+  switch (mode)
+  {
+  case MODE_PUT:
+    {
+      struct GNUNET_TIME_Relative peer_delay_put;
+
+      peer_delay_put.rel_value_us =
+        GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  delay_put.rel_value_us);
+      ac->put_count = num_puts_per_peer;
+      ac->hash = calloc (ac->put_count,
+                         sizeof(struct GNUNET_HashCode));
+      if (NULL == ac->hash)
+      {
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                             "calloc");
+        GNUNET_SCHEDULER_shutdown ();
+        return;
+      }
+      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_put,
+                                                     &delayed_put,
+                                                     ac);
+      break;
+    }
+
+  case MODE_GET:
+    {
+      struct GNUNET_TIME_Relative peer_delay_get;
+
+      peer_delay_get.rel_value_us =
+        delay_get.rel_value_us
+        + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    delay_get.rel_value_us);
+      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_get,
+                                                     &delayed_get,
+                                                     ac);
+      break;
+    }
+  }
+}
+
+
+/**
+ * Connect to DHT service and return the DHT client handler
+ *
+ * @param cls the active context
+ * @param cfg configuration of the peer to connect to; will be available until
+ *          GNUNET_TESTBED_operation_done() is called on the operation returned
+ *          from GNUNET_TESTBED_service_connect()
+ * @return service handle to return in 'op_result', NULL on error
+ */
+static void *
+dht_connect (void *cls,
+             const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  n_dht++;
+  return GNUNET_DHT_connect (cfg,
+                             10);
+}
+
+
+/**
+ * Adapter function called to destroy a connection to
+ * a service.
+ *
+ * @param cls the active context
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+dht_disconnect (void *cls,
+                void *op_result)
+{
+  struct ActiveContext *ac = cls;
+
+  GNUNET_assert (NULL != ac->dht);
+  GNUNET_assert (ac->dht == op_result);
+  GNUNET_DHT_disconnect (ac->dht);
+  ac->dht = NULL;
+  n_dht--;
+  if (0 != n_dht)
+    return;
+  if (GNUNET_YES == in_shutdown)
+    return;
+  switch (mode)
+  {
+  case MODE_PUT:
+    if (n_puts_ok != ((unsigned long long) n_active) * num_puts_per_peer)
+      return;
+    /* Start GETs if all PUTs have been made */
+    mode = MODE_GET;
+    start_profiling ();
+    return;
+
+  case MODE_GET:
+    if ((n_gets_ok + n_gets_fail) != n_active)
+      return;
+    break;
+  }
+}
+
+
+/**
+ * Connect to DHT services of active peers
+ */
+static void
+start_profiling ()
+{
+  struct Context *ctx;
+
+  DEBUG ("GNUNET_TESTBED_service_connect\n");
+  GNUNET_break (GNUNET_YES != in_shutdown);
+  for (unsigned int i = 0; i < n_active; i++)
+  {
+    struct ActiveContext *ac = &a_ac[i];
+    GNUNET_assert (NULL != (ctx = ac->ctx));
+    GNUNET_assert (NULL == ctx->op);
+    ctx->op = GNUNET_TESTBED_service_connect (ctx,
+                                              ctx->peer,
+                                              "dht",
+                                              &dht_connected, ac,
+                                              &dht_connect,
+                                              &dht_disconnect,
+                                              ac);
+  }
+}
+
+
+/**
+ * Callback called when DHT service on the peer is started
+ *
+ * @param cls the context
+ * @param op the operation that has been finished
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+service_started (void *cls,
+                 struct GNUNET_TESTBED_Operation *op,
+                 const char *emsg)
+{
+  struct Context *ctx = cls;
+
+  GNUNET_assert (NULL != ctx);
+  GNUNET_assert (NULL != ctx->op);
+  GNUNET_TESTBED_operation_done (ctx->op);
+  ctx->op = NULL;
+  peers_started++;
+  DEBUG ("Peers Started = %d; num_peers = %d \n",
+         peers_started,
+         num_peers);
+  if (peers_started == num_peers)
+    start_profiling ();
+}
+
+
+/**
+ * Signature of a main function for a testcase.
+ *
+ * @param cls closure
+ * @param h the run handle
+ * @param num_peers number of peers in 'peers'
+ * @param peers handle to peers run in the testbed
+ * @param links_succeeded the number of overlay link connection attempts that
+ *          succeeded
+ * @param links_failed the number of overlay link
+ */
+static void
+test_run (void *cls,
+          struct GNUNET_TESTBED_RunHandle *h,
+          unsigned int num_peers,
+          struct GNUNET_TESTBED_Peer **peers,
+          unsigned int links_succeeded,
+          unsigned int links_failed)
+{
+  unsigned int ac_cnt;
+
+  testbed_handles = peers;
+  if (NULL == peers)
+  {
+    /* exit */
+    GNUNET_assert (0);
+  }
+  MESSAGE ("%u peers started, %u/%u links up\n",
+           num_peers,
+           links_succeeded,
+           links_succeeded + links_failed);
+  a_ctx = GNUNET_new_array (num_peers,
+                            struct Context);
+  /* select the peers which actively participate in profiling */
+  n_active = num_peers * put_probability / 100;
+  if (0 == n_active)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (a_ctx);
+    a_ctx = NULL;
+    return;
+  }
+
+  a_ac = GNUNET_new_array (n_active,
+                           struct ActiveContext);
+  ac_cnt = 0;
+  for (unsigned int cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++)
+  {
+    if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  100) >= put_probability)
+      continue;
+
+    a_ctx[cnt].ac = &a_ac[ac_cnt];
+    a_ac[ac_cnt].ctx = &a_ctx[cnt];
+    ac_cnt++;
+  }
+  n_active = ac_cnt;
+
+  /* start DHT service on all peers */
+  for (unsigned int cnt = 0; cnt < num_peers; cnt++)
+  {
+    a_ctx[cnt].peer = peers[cnt];
+    a_ctx[cnt].op = GNUNET_TESTBED_peer_manage_service (&a_ctx[cnt],
+                                                        peers[cnt],
+                                                        "dht",
+                                                        &service_started,
+                                                        &a_ctx[cnt],
+                                                        1);
+  }
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param config configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *config)
+{
+  uint64_t event_mask;
+
+  if (0 == num_peers)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Exiting as the number of peers is %u\n"),
+                num_peers);
+    return;
+  }
+  cfg = config;
+  event_mask = 0;
+  GNUNET_TESTBED_run (hosts_file,
+                      cfg,
+                      num_peers,
+                      event_mask,
+                      NULL,
+                      NULL,
+                      &test_run,
+                      NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+}
+
+
+/**
+ * Main function.
+ *
+ * @return 0 on success
+ */
+int
+main (int argc,
+      char *const *argv)
+{
+  int rc;
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_uint ('n',
+                               "peers",
+                               "COUNT",
+                               gettext_noop ("number of peers to start"),
+                               &num_peers),
+    GNUNET_GETOPT_option_uint ('p',
+                               "peer-put-count",
+                               "COUNT",
+                               gettext_noop (
+                                 "number of PUTs to perform per peer"),
+                               &num_puts_per_peer),
+    GNUNET_GETOPT_option_string ('H',
+                                 "hosts",
+                                 "FILENAME",
+                                 gettext_noop (
+                                   "name of the file with the login information for the testbed"),
+                                 &hosts_file),
+    GNUNET_GETOPT_option_relative_time ('D',
+                                        "delay",
+                                        "DELAY",
+                                        gettext_noop (
+                                          "delay between rounds for collecting statistics (default: 30 sec)"),
+                                        &delay_stats),
+    GNUNET_GETOPT_option_relative_time ('P',
+                                        "PUT-delay",
+                                        "DELAY",
+                                        gettext_noop (
+                                          "delay to start doing PUTs (default: 1 sec)"),
+                                        &delay_put),
+    GNUNET_GETOPT_option_relative_time ('G',
+                                        "GET-delay",
+                                        "DELAY",
+                                        gettext_noop (
+                                          "delay to start doing GETs (default: 5 min)"),
+                                        &delay_get),
+    GNUNET_GETOPT_option_uint ('r',
+                               "replication",
+                               "DEGREE",
+                               gettext_noop ("replication degree for DHT PUTs"),
+                               &replication),
+    GNUNET_GETOPT_option_uint ('R',
+                               "random-chance",
+                               "PROBABILITY",
+                               gettext_noop (
+                                 "chance that a peer is selected at random for PUTs"),
+                               &put_probability),
+    GNUNET_GETOPT_option_relative_time ('t',
+                                        "timeout",
+                                        "TIMEOUT",
+                                        gettext_noop (
+                                          "timeout for DHT PUT and GET requests (default: 1 min)"),
+                                        &timeout),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+  /* set default delays */
+  delay_stats = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
+  delay_put = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
+  delay_get = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
+  replication = 1;      /* default replication */
+  rc = 0;
+  if (GNUNET_OK !=
+      GNUNET_PROGRAM_run (argc,
+                          argv,
+                          "gnunet-dht-profiler",
+                          gettext_noop (
+                            "Measure quality and performance of the DHT service."),
+                          options,
+                          &run,
+                          NULL))
+    rc = 1;
+  return rc;
+}
diff --git a/src/service/dht/meson.build b/src/service/dht/meson.build
new file mode 100644
index 000000000..45157243d
--- /dev/null
+++ b/src/service/dht/meson.build
@@ -0,0 +1,97 @@
+libgnunetdht_src = ['dht_api.c']
+
+gnunetservicedht_src = ['gnunet-service-dht.c',
+                        'plugin_dhtu_gnunet.c',
+                        'plugin_dhtu_ip.c',
+                        'gnunet-service-dht_datacache.c',
+                        'gnunet-service-dht_neighbours.c',
+                        'gnunet-service-dht_routing.c']
+
+configure_file(input : 'dht.conf.in',
+               output : 'dht.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+configure_file(input : 'dhtu.conf',
+               output : 'dhtu.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+if get_option('monolith')
+  foreach p : libgnunetdht_src + gnunetservicedht_src
+    gnunet_src += 'dht/' + p
+  endforeach
+endif
+
+libgnunetdht = library('gnunetdht',
+        libgnunetdht_src,
+        soversion: '4',
+        version: '4.0.0',
+        dependencies: libgnunetutil_dep,
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetdht_dep = declare_dependency(link_with : libgnunetdht)
+pkg.generate(libgnunetdht, url: 'https://www.gnunet.org',
+           description : 'Provides API for the R5N distributed hash table')
+
+executable ('gnunet-service-dht',
+            gnunetservicedht_src,
+            dependencies: [libgnunetdht_dep, libgnunetutil_dep,
+                           libgnunetblock_dep,
+                           libgnunetcore_dep,
+                           libgnunetnse_dep,
+                           libgnunettransportapplication_dep,
+                           libgnunetpeerstore_dep,
+                           m_dep,
+                           libgnunetdatacache_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetblockgroup_dep,
+                           libgnunethello_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir')/'gnunet'/'libexec')
+
+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)
+
+configure_file(input : 'test_dht_api_data.conf',
+               output : 'test_dht_api_data.conf',
+               copy: true)
+
+testdht_api = executable ('test_dht_api',
+            ['test_dht_api.c'],
+            dependencies: [libgnunetdht_dep,
+                           libgnunetutil_dep,
+                           libgnunettesting_dep,
+                           libgnunethello_dep],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+
+test('test_dht_api', testdht_api, suite: 'dht',
+     workdir: meson.current_build_dir())
+
+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/service/dht/plugin_dhtu_gnunet.c b/src/service/dht/plugin_dhtu_gnunet.c
new file mode 100644
index 000000000..99d1a0fda
--- /dev/null
+++ b/src/service/dht/plugin_dhtu_gnunet.c
@@ -0,0 +1,627 @@
+/*
+     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"
+#include "plugin_dhtu_gnunet.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_Monitor *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 struct GNUNET_PeerIdentity *pid,
+          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_PEERSTORE_Record *record,
+             const char *emsg)
+{
+  struct Plugin *plugin = cls;
+  struct GNUNET_HELLO_Builder *builder;
+  struct GNUNET_MessageHeader *hello;
+
+  hello = record->value;
+  if (NULL == hello)
+    return;
+  if (0 !=
+      GNUNET_memcmp (&record->peer,
+                     &plugin->my_identity))
+  {
+    GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
+    return;
+  }
+  builder = GNUNET_HELLO_builder_from_msg (hello);
+  GNUNET_HELLO_builder_iterate (builder,
+                                add_addr,
+                                plugin);
+  GNUNET_HELLO_builder_free (builder);
+  GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
+}
+
+
+static void
+error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring\n");
+}
+
+
+static void
+sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring\n");
+}
+
+
+/**
+ * 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_monitor_start (plugin->env->cfg,
+                                                             GNUNET_YES,
+                                                             "peerstore",
+                                                             NULL,
+                                                             GNUNET_PEERSTORE_HELLO_KEY,
+                                                             &error_cb,
+                                                             NULL,
+                                                             &sync_cb,
+                                                             NULL,
+                                                             &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 *
+DHTU_gnunet_done (struct GNUNET_DHTU_PluginFunctions *api)
+{
+  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_monitor_stop (plugin->peerstore_notify);
+  if (NULL != plugin->peerstore)
+    GNUNET_PEERSTORE_disconnect (plugin->peerstore);
+  // 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
+ */
+struct GNUNET_DHTU_PluginFunctions *
+DHTU_gnunet_init (struct GNUNET_DHTU_PluginEnvironment *env)
+{
+  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);
+    DHTU_gnunet_done (api);
+    return NULL;
+  }
+  // GPI_plugins_load (env->cfg);
+  return api;
+}
diff --git a/src/service/dht/plugin_dhtu_gnunet.h b/src/service/dht/plugin_dhtu_gnunet.h
new file mode 100644
index 000000000..a4a594742
--- /dev/null
+++ b/src/service/dht/plugin_dhtu_gnunet.h
@@ -0,0 +1,44 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2024 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+#ifndef PLUGIN_DHTU_GNUNET_H
+#define PLUGIN_DHTU_GNUNET_H
+#include "gnunet_dhtu_plugin.h"
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return NULL
+ */
+void *
+DHTU_gnunet_done (struct GNUNET_DHTU_PluginFunctions *p);
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct GNUNET_DHTU_PluginEnvironment`)
+ * @return the plugin's API
+ */
+struct GNUNET_DHTU_PluginFunctions *
+DHTU_gnunet_init (struct GNUNET_DHTU_PluginEnvironment *e);
+
+#endif
diff --git a/src/service/dht/plugin_dhtu_ip.c b/src/service/dht/plugin_dhtu_ip.c
new file mode 100644
index 000000000..3c01257dc
--- /dev/null
+++ b/src/service/dht/plugin_dhtu_ip.c
@@ -0,0 +1,1170 @@
+/*
+     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"
+#include "plugin_dhtu_ip.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
+ */
+struct GNUNET_DHTU_PluginFunctions *
+DHTU_ip_init (struct GNUNET_DHTU_PluginEnvironment *env)
+{
+  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 *
+DHTU_ip_done (struct GNUNET_DHTU_PluginFunctions *api)
+{
+  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/service/dht/plugin_dhtu_ip.h b/src/service/dht/plugin_dhtu_ip.h
new file mode 100644
index 000000000..f240f5559
--- /dev/null
+++ b/src/service/dht/plugin_dhtu_ip.h
@@ -0,0 +1,44 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2024 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+#ifndef PLUGIN_DHTU_IP_H
+#define PLUGIN_DHTU_IP_H
+#include "gnunet_dhtu_plugin.h"
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls closure (our `struct Plugin`)
+ * @return NULL
+ */
+void *
+DHTU_ip_done (struct GNUNET_DHTU_PluginFunctions *p);
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls closure (the `struct IP_DHTU_PluginEnvironment`)
+ * @return the plugin's API
+ */
+struct GNUNET_DHTU_PluginFunctions *
+DHTU_ip_init (struct GNUNET_DHTU_PluginEnvironment *env);
+
+#endif
diff --git a/src/service/dht/test_dht_2dtorus.conf b/src/service/dht/test_dht_2dtorus.conf
new file mode 100644
index 000000000..ed3d1301e
--- /dev/null
+++ b/src/service/dht/test_dht_2dtorus.conf
@@ -0,0 +1,37 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+@INLINE@ ../../../contrib/conf/gnunet/no_autostart_above_core.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test_dht_2dtorus/
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[nat]
+DISABLEV6 = YES
+RETURN_LOCAL_ADDRESSES = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[testbed]
+OVERLAY_TOPOLOGY = 2D_TORUS
+
+[nse]
+START_ON_DEMAND = YES
+WORKDELAY = 500 ms
+INTERVAL = 60 s
+WORKBITS = 0
+
+[transport]
+PLUGINS = unix
diff --git a/src/service/dht/test_dht_api.c b/src/service/dht/test_dht_api.c
new file mode 100644
index 000000000..0b51477fe
--- /dev/null
+++ b/src/service/dht/test_dht_api.c
@@ -0,0 +1,193 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2015, 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 dht/test_dht_api.c
+ * @brief base test case for dht api
+ * @author Christian Grothoff
+ *
+ * This test case tests DHT api to DUMMY DHT service communication.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_dht_service.h"
+
+
+/**
+ * How long until we really give up on a particular testcase portion?
+ */
+#define TOTAL_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                     60)
+
+static struct GNUNET_DHT_Handle *dht_handle;
+
+static struct GNUNET_DHT_GetHandle *get_handle;
+
+static struct GNUNET_DHT_PutHandle *put_handle;
+
+static int ok = 1;
+
+static struct GNUNET_SCHEDULER_Task *die_task;
+
+
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != die_task)
+  {
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = NULL;
+  }
+  if (NULL != put_handle)
+  {
+    GNUNET_DHT_put_cancel (put_handle);
+    put_handle = NULL;
+  }
+  if (NULL != get_handle)
+  {
+    GNUNET_DHT_get_stop (get_handle);
+    get_handle = NULL;
+  }
+  GNUNET_DHT_disconnect (dht_handle);
+  dht_handle = NULL;
+}
+
+
+static void
+end_badly (void *cls)
+{
+  die_task = NULL;
+  fprintf (stderr,
+           "%s",
+           "Ending on an unhappy note.\n");
+  GNUNET_SCHEDULER_shutdown ();
+  ok = 1;
+}
+
+
+static void
+test_get_iterator (void *cls,
+                   struct GNUNET_TIME_Absolute exp,
+                   const struct GNUNET_HashCode *key,
+                   const struct GNUNET_PeerIdentity *trunc_peer,
+                   const struct GNUNET_DHT_PathElement *get_path,
+                   unsigned int get_path_length,
+                   const struct GNUNET_DHT_PathElement *put_path,
+                   unsigned int put_path_length,
+                   enum GNUNET_BLOCK_Type type,
+                   size_t size,
+                   const void *data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "test_get_iterator called (we got a result), stopping get request!\n");
+  GNUNET_SCHEDULER_shutdown ();
+  ok = 0;
+}
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+test_get (void *cls)
+{
+  struct GNUNET_HashCode hash;
+
+  put_handle = NULL;
+  memset (&hash,
+          42,
+          sizeof(struct GNUNET_HashCode));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Called test_get!\n");
+  GNUNET_assert (dht_handle != NULL);
+  get_handle = GNUNET_DHT_get_start (dht_handle,
+                                     GNUNET_BLOCK_TYPE_TEST,
+                                     &hash,
+                                     1,
+                                     GNUNET_DHT_RO_NONE,
+                                     NULL,
+                                     0,
+                                     &test_get_iterator,
+                                     NULL);
+
+  if (NULL == get_handle)
+  {
+    GNUNET_break (0);
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  struct GNUNET_HashCode hash;
+  char *data;
+  size_t data_size = 42;
+
+  GNUNET_assert (ok == 1);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT,
+                                           &end_badly,
+                                           NULL);
+  memset (&hash,
+          42,
+          sizeof(struct GNUNET_HashCode));
+  data = GNUNET_malloc (data_size);
+  memset (data, 43, data_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Called test_put!\n");
+  dht_handle = GNUNET_DHT_connect (cfg,
+                                   100);
+  GNUNET_assert (NULL != dht_handle);
+  put_handle = GNUNET_DHT_put (dht_handle,
+                               &hash,
+                               1,
+                               GNUNET_DHT_RO_NONE,
+                               GNUNET_BLOCK_TYPE_TEST,
+                               data_size,
+                               data,
+                               GNUNET_TIME_relative_to_absolute (TOTAL_TIMEOUT),
+                               &test_get,
+                               NULL);
+  GNUNET_free (data);
+}
+
+
+int
+main (int argc,
+      char *argv[])
+{
+  if (0 != GNUNET_TESTING_peer_run ("test-dht-api",
+                                    "test_dht_api_data.conf",
+                                    &run, NULL))
+    return 1;
+  return ok;
+}
+
+
+/* end of test_dht_api.c */
diff --git a/src/service/dht/test_dht_api_data.conf b/src/service/dht/test_dht_api_data.conf
new file mode 100644
index 000000000..90a02d452
--- /dev/null
+++ b/src/service/dht/test_dht_api_data.conf
@@ -0,0 +1,44 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+@INLINE@ ../../../contrib/conf/gnunet/no_autostart_above_core.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-dht-api/
+
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[topology]
+TARGET-CONNECTION-COUNT = 16
+AUTOCONNECT = YES
+FRIENDS-ONLY = NO
+MINIMUM-FRIENDS = 0
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[transport]
+plugins = tcp
+NEIGHBOUR_LIMIT = 50
+PORT = 2091
+
+[transport-tcp]
+TIMEOUT = 300 s
+
+[nat]
+DISABLEV6 = YES
+BINDTO = 127.0.0.1
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[nse]
+START_ON_DEMAND = YES
+WORKBITS = 1
diff --git a/src/service/dht/test_dht_api_peer1.conf b/src/service/dht/test_dht_api_peer1.conf
new file mode 100644
index 000000000..b802b2fed
--- /dev/null
+++ b/src/service/dht/test_dht_api_peer1.conf
@@ -0,0 +1,41 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+@INLINE@ ../../../contrib/conf/gnunet/no_autostart_above_core.conf
+
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[transport]
+PLUGINS = tcp
+ACCEPT_FROM6 = ::1;
+ACCEPT_FROM = 127.0.0.1;
+NEIGHBOUR_LIMIT = 50
+PORT = 12365
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[transport-tcp]
+TIMEOUT = 300 s
+BINDTO = 127.0.0.1
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-dht-peer-1/
+
+[nat]
+DISABLEV6 = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+USE_LOCALADDR = NO
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[nse]
+START_ON_DEMAND = YES
+WORKBITS = 1
diff --git a/src/service/dht/test_dht_line.conf b/src/service/dht/test_dht_line.conf
new file mode 100644
index 000000000..6e4da8021
--- /dev/null
+++ b/src/service/dht/test_dht_line.conf
@@ -0,0 +1,38 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+@INLINE@ ../../../contrib/conf/gnunet/no_autostart_above_core.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test_dht_line/
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[nat]
+DISABLEV6 = YES
+RETURN_LOCAL_ADDRESSES = YES
+USE_LOCALADDR = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[testbed]
+OVERLAY_TOPOLOGY = LINE
+
+[transport]
+plugins = unix
+
+[nse]
+START_ON_DEMAND = YES
+WORKDELAY = 500 ms
+INTERVAL = 60 s
+WORKBITS = 0
diff --git a/src/service/dht/test_dht_multipeer.conf b/src/service/dht/test_dht_multipeer.conf
new file mode 100644
index 000000000..29bd0d9bd
--- /dev/null
+++ b/src/service/dht/test_dht_multipeer.conf
@@ -0,0 +1,40 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+@INLINE@ ../../../contrib/conf/gnunet/no_autostart_above_core.conf
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[transport]
+PLUGINS = unix
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[testbed]
+OVERLAY_TOPOLOGY = FROM_FILE
+OVERLAY_TOPOLOGY_FILE = test_dht_multipeer_topology.dat
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-dht-multipeer/
+
+[nat]
+DISABLEV6 = YES
+RETURN_LOCAL_ADDRESSES = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+USE_LOCALADDR = YES
+
+[nse]
+START_ON_DEMAND = YES
+WORKDELAY = 500 ms
+INTERVAL = 60 s
+WORKBITS = 0
diff --git a/src/service/dht/test_dht_multipeer_topology.dat b/src/service/dht/test_dht_multipeer_topology.dat
new file mode 100644
index 000000000..2268c85cb
--- /dev/null
+++ b/src/service/dht/test_dht_multipeer_topology.dat
@@ -0,0 +1,11 @@
+0:1|6|8
+1:2|7|9
+2:0|3|8
+3:1|4|9
+4:0|2|5
+5:1|3|6
+6:2|4|7
+7:3|5|8
+8:4|6|9
+9:0|5|7
+
diff --git a/src/service/dht/test_dht_tools.conf b/src/service/dht/test_dht_tools.conf
new file mode 100644
index 000000000..05f7cc0e6
--- /dev/null
+++ b/src/service/dht/test_dht_tools.conf
@@ -0,0 +1,157 @@
+[dhtcache]
+QUOTA = 1 MB
+DATABASE = heap
+
+[transport]
+PLUGINS = tcp
+ACCEPT_FROM6 = ::1;
+ACCEPT_FROM = 127.0.0.1;
+NEIGHBOUR_LIMIT = 50
+PORT = 12365
+
+[ats]
+WAN_QUOTA_IN = 1 GB
+WAN_QUOTA_OUT = 1 GB
+
+[transport-tcp]
+TIMEOUT = 300 s
+BINDTO = 127.0.0.1
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-dht-peer-1/
+
+[nat]
+DISABLEV6 = YES
+ENABLE_UPNP = NO
+BEHIND_NAT = NO
+ALLOW_NAT = NO
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+USE_LOCALADDR = NO
+
+[dht]
+START_ON_DEMAND = YES
+IMMEDIATE_START = YES
+
+[nse]
+START_ON_DEMAND = YES
+WORKBITS = 1
+# Configuration to disable autostarting of
+# all services above the 'core' level.
+# (including resolver)
+
+[dns]
+START_ON_DEMAND = NO
+
+[cadet]
+START_ON_DEMAND = NO
+
+[datastore]
+START_ON_DEMAND = NO
+
+[fs]
+START_ON_DEMAND = NO
+
+[dv]
+START_ON_DEMAND = NO
+
+[vpn]
+START_ON_DEMAND = NO
+
+[consensus]
+START_ON_DEMAND = NO
+
+[resolver]
+START_ON_DEMAND = NO
+
+[namestore]
+START_ON_DEMAND = NO
+
+[namecache]
+START_ON_DEMAND = NO
+
+[identity]
+START_ON_DEMAND = NO
+
+[revocation]
+START_ON_DEMAND = NO
+
+[conversation]
+START_ON_DEMAND = NO
+
+[peerstore]
+START_ON_DEMAND = NO
+
+[psycstore]
+START_ON_DEMAND = NO
+
+[gns]
+START_ON_DEMAND = NO
+
+[regex]
+START_ON_DEMAND = NO
+
+[set]
+START_ON_DEMAND = NO
+
+[scalarproduct-bob]
+START_ON_DEMAND = NO
+
+[scalarproduct-alice]
+START_ON_DEMAND = NO
+
+[social]
+START_ON_DEMAND = NO
+
+[psyc]
+START_ON_DEMAND = NO
+
+[rps]
+START_ON_DEMAND = NO
+
+[multicast]
+START_ON_DEMAND = NO
+
+[sensordashboard]
+START_ON_DEMAND = NO
+
+[sensor]
+START_ON_DEMAND = NO
+# Configuration file that can be included to prevent ANY of the usual
+# IMMEDIATE_START = YES to be set.  Also disables NSE POW calculation.
+#
+# This configuration is included from various configuration test files.
+# Whenever a new service is added that has IMMEDIATE_START = YES for
+# production should be disabled for (most) test suites, the option should
+# be added here instead of all over the place ;-).
+
+[core]
+IMMEDIATE_START = NO
+
+[fs]
+IMMEDIATE_START = NO
+
+[dht]
+IMMEDIATE_START = NO
+
+[cadet]
+IMMEDIATE_START = NO
+
+[nse]
+IMMEDIATE_START = NO
+WORKBITS = 0
+
+[revocation]
+IMMEDIATE_START = NO
+
+[topology]
+IMMEDIATE_START = NO
+
+[hostlist]
+IMMEDIATE_START = NO
+
+[gns]
+IMMEDIATE_START = NO
+
+[zonemaster]
+IMMEDIATE_START = NO
diff --git a/src/service/dht/test_dht_tools.py.in b/src/service/dht/test_dht_tools.py.in
new file mode 100644
index 000000000..84e297081
--- /dev/null
+++ b/src/service/dht/test_dht_tools.py.in
@@ -0,0 +1,149 @@
+#!@PYTHONEXE@
+#
+# This testcase simply checks that the DHT command-line tools work.
+# It launches a single peer, stores a value "testdata" under "testkey",
+# and then gives the system 50 ms to fetch it.
+#
+# This could fail if
+# - command line tool interfaces fail
+# - DHT plugins for storage are not installed / working
+# - block plugins for verification (the test plugin) is not installed
+#
+# The code does NOT depend on DHT routing or any actual P2P functionality.
+#
+
+import os
+import sys
+import shutil
+import re
+import subprocess
+import time
+import tempfile
+
+os.environ["PATH"] = "@bindirectory@" + ":" + os.environ["PATH"]
+
+if os.name == "nt":
+    tmp = os.getenv("TEMP")
+else:
+    tmp = "/tmp"
+
+if os.name == 'nt':
+    get = './gnunet-dht-get.exe'
+    put = './gnunet-dht-put.exe'
+    arm = 'gnunet-arm.exe'
+else:
+    get = './gnunet-dht-get'
+    put = './gnunet-dht-put'
+    arm = 'gnunet-arm'
+
+cfgfile = 'test_dht_api_peer1.conf'
+run_get = [get, '-c', cfgfile]
+run_put = [put, '-c', cfgfile]
+run_arm = [arm, '-c', cfgfile]
+debug = os.getenv('DEBUG')
+if debug:
+    run_arm += [debug.split(' ')]
+
+
+def cleanup(exitcode):
+    sys.exit(exitcode)
+
+
+def sub_run(args, want_stdo=True, want_stde=False, nofail=False):
+    if want_stdo:
+        stdo = subprocess.PIPE
+    else:
+        stdo = None
+    if want_stde:
+        stde = subprocess.PIPE
+    else:
+        stde = None
+    p = subprocess.Popen(args, stdout=stdo, stderr=stde)
+    stdo, stde = p.communicate()
+    if not nofail:
+        if p.returncode != 0:
+            sys.exit(p.returncode)
+    return (p.returncode, stdo, stde)
+
+
+def fail(result):
+    print(result)
+    r_arm(['-e'], want_stdo=False)
+    cleanup(1)
+
+
+def r_something(to_run, extra_args, failure=None, normal=True, **kw):
+    rc, stdo, stde = sub_run(to_run + extra_args, nofail=True, **kw)
+    if failure is not None:
+        failure(to_run + extra_args, rc, stdo, stde, normal)
+    return (rc, stdo, stde)
+
+
+def r_arm(extra_args, **kw):
+    return r_something(run_arm, extra_args, **kw)
+
+
+def r_get(extra_args, **kw):
+    return r_something(run_get, extra_args, **kw)
+
+
+def r_put(extra_args, **kw):
+    return r_something(run_put, extra_args, **kw)
+
+
+def end_arm_failure(command, rc, stdo, stde, normal):
+    if normal:
+        if rc != 0:
+            fail(
+                "FAIL: error running {}\nCommand output was:\n{}\n{}".format(
+                    command, stdo, stde
+                )
+            )
+    else:
+        if rc == 0:
+            fail(
+                "FAIL: expected error while running {}\nCommand output was:\n{}\n{}"
+                .format(command, stdo, stde)
+            )
+
+
+def print_only_failure(command, rc, stdo, stde, normal):
+    if normal:
+        if rc != 0:
+            print(
+                "FAIL: error running {}\nCommand output was:\n{}\n{}".format(
+                    command, stdo, stde
+                )
+            )
+            cleanup(1)
+    else:
+        if rc == 0:
+            print(
+                "FAIL: expected error while running {}\nCommand output was:\n{}\n{}"
+                .format(command, stdo, stde)
+            )
+            cleanup(1)
+
+
+print("TEST: Starting ARM...", end='')
+r_arm(['-s'], failure=end_arm_failure, want_stdo=False, want_stde=False)
+print("PASS")
+time.sleep(1)
+
+print("TEST: Testing put...", end='')
+r_put(['-k', 'testkey', '-d', 'testdata', '-t', '8'], failure=end_arm_failure)
+print("PASS")
+time.sleep(1)
+
+print("TEST: Testing get...", end='')
+rc, stdo, stde = r_get(['-k', 'testkey', '-T', '50 ms', '-t', '8'],
+                       want_stdo=True,
+                       failure=end_arm_failure)
+stdo = stdo.decode('utf-8').replace('\r', '').splitlines()
+expect = "Result 0, type 8:\ntestdata".splitlines()
+if len(stdo) != 2 or len(expect
+                         ) != 2 or stdo[0] != expect[0] or stdo[1] != expect[1]:
+    fail("output `{}' differs from expected `{}'".format(stdo, expect))
+print("PASS")
+
+r_arm(['-e', '-d'], failure=print_only_failure)
diff --git a/src/service/dht/test_dht_tools.sh b/src/service/dht/test_dht_tools.sh
new file mode 100755
index 000000000..462866f87
--- /dev/null
+++ b/src/service/dht/test_dht_tools.sh
@@ -0,0 +1,65 @@
+#!/bin/sh
+# This file is in the public domain.
+
+GNUNET_TMP="$(gnunet-config -f -s PATHS -o GNUNET_TMP)"
+out=`mktemp $GNUNET_TMP/test-gnunet-dht-logXXXXXXXX`
+tempcfg=`mktemp $GNUNET_TMP/test-dht-tools.XXXXXXXX`
+checkout="check.out"
+armexe="gnunet-arm -c $tempcfg "
+putexe="gnunet-dht-put -c $tempcfg "
+getexe="gnunet-dht-get -c $tempcfg "
+peerinfo="gnunet-peerinfo -c $tempcfg -sq"
+stop_arm()
+{
+  if ! $armexe $DEBUG -e -d > $out ; then
+    echo "FAIL: error running $armexe"
+    echo "Command output was:"
+    cat $out
+    rm -f $out $tempcfg
+    exit 1
+  fi
+  rm -f $out $tempcfg
+}
+
+cp test_dht_tools.conf $tempcfg
+
+echo -n "TEST: Starting ARM..."
+if ! $armexe $DEBUG -s > $out ; then
+  echo "FAIL: error running $armexe"
+  echo "Command output was:"
+  cat $out
+  stop_arm
+  exit 1
+fi
+echo "PASS"
+
+echo -n "TEST: Testing put..."
+if ! $putexe -k testkey -d testdata -t 8 > $out ; then
+  echo "FAIL: error running $putexe"
+  echo "Command output was:"
+  cat $out
+  stop_arm
+  exit 1
+fi
+echo "PASS"
+
+echo -n "TEST: Testing get..."
+echo "Result 0, type 8:" > $checkout
+echo "testdata" >> $checkout
+
+if ! $getexe -k testkey -T 100ms -t 8 > $out ; then
+  echo "FAIL: error running $putexe"
+  echo "Command output was:"
+  cat $out
+  stop_arm
+  exit 1
+fi
+
+if ! diff --strip-trailing-cr -q $out $checkout ; then
+  echo "FAIL: $out and $checkout differ:"
+  diff --strip-trailing-cr $out $checkout
+  stop_arm
+  exit 1
+fi
+echo "PASS"
+stop_arm
diff --git a/src/service/dht/test_dhtu_ip.c b/src/service/dht/test_dhtu_ip.c
new file mode 100644
index 000000000..030b17b5f
--- /dev/null
+++ b/src/service/dht/test_dhtu_ip.c
@@ -0,0 +1,45 @@
+/*
+      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/service/dht/testing_dhtu_cmd_send.c b/src/service/dht/testing_dhtu_cmd_send.c
new file mode 100644
index 000000000..88449659c
--- /dev/null
+++ b/src/service/dht/testing_dhtu_cmd_send.c
@@ -0,0 +1,115 @@
+/*
+      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;
+
+  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
+    };
+    
+    GNUNET_TESTING_set_label (&cmd.label,
+                              label);
+    return cmd;
+  }
+}