68 files changed, 25746 insertions, 0 deletions

diff --git a/src/contrib/Makefile.am b/src/contrib/Makefile.am
new file mode 100644
index 000000000..516fb872c
--- /dev/null
+++ b/src/contrib/Makefile.am
@@ -0,0 +1,4 @@
+SUBDIRS = \
+        #lib \
+        #plugin \
+        service
diff --git a/src/contrib/service/Makefile.am b/src/contrib/service/Makefile.am
new file mode 100644
index 000000000..25c3670d9
--- /dev/null
+++ b/src/contrib/service/Makefile.am
@@ -0,0 +1,9 @@
+if HAVE_EXPERIMENTAL
+ EXP_DIR = \
+  rps \
+  abd \
+  auction
+endif
+
+SUBDIRS = \
+        $(EXP_DIR)
diff --git a/src/contrib/service/abd/.gitignore b/src/contrib/service/abd/.gitignore
new file mode 100644
index 000000000..ee1eb7837
--- /dev/null
+++ b/src/contrib/service/abd/.gitignore
@@ -0,0 +1,2 @@
+gnunet-abd
+gnunet-service-abd
diff --git a/src/contrib/service/abd/Makefile.am b/src/contrib/service/abd/Makefile.am
new file mode 100644
index 000000000..6fa2dc848
--- /dev/null
+++ b/src/contrib/service/abd/Makefile.am
@@ -0,0 +1,106 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+EXTRA_DIST = \
+  test_abd_defaults.conf \
+  test_abd_lookup.conf \
+  $(check_SCRIPTS) \
+  $(pkgdata_DATA)
+
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+endif
+
+pkgcfgdir = $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+pkgcfg_DATA = \
+  abd.conf
+
+
+# /usr/lib - compiles a layer which can be used to be communicagte with the service
+lib_LTLIBRARIES = \
+  libgnunetabd.la
+
+# /usr/lib/gnunet/libexec - Business logic . Separate process
+libexec_PROGRAMS = \
+  gnunet-service-abd
+
+bin_PROGRAMS = \
+  gnunet-abd
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_gnsrecord_abd.la
+
+
+gnunet_abd_SOURCES = \
+ gnunet-abd.c
+gnunet_abd_LDADD = \
+  libgnunetabd.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+        $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  $(top_builddir)/src/namestore/libgnunetnamestore.la \
+  $(GN_LIBINTL)
+
+
+libgnunet_plugin_gnsrecord_abd_la_SOURCES = \
+  plugin_gnsrecord_abd.c
+libgnunet_plugin_gnsrecord_abd_la_LIBADD = \
+        libgnunetabd.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  $(LTLIBINTL)
+libgnunet_plugin_gnsrecord_abd_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+
+gnunet_service_abd_SOURCES = \
+ gnunet-service-abd.c
+gnunet_service_abd_LDADD = \
+        libgnunetabd.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+        $(top_builddir)/src/gns/libgnunetgns.la \
+        $(top_builddir)/src/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+  $(GN_LIBINTL)
+
+
+libgnunetabd_la_SOURCES = \
+ abd_api.c abd.h\
+ abd_serialization.c \
+ abd_serialization.h \
+ delegate_misc.c \
+ delegate_misc.h
+libgnunetabd_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/identity/libgnunetidentity.la \
+ $(XLIB)
+libgnunetabd_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)
+
+
+
+check_SCRIPTS = \
+  test_abd_issue.sh 
+  # test_abd_verify_simple.sh \
+  # test_abd_verify.sh \
+  # test_abd_verify_and.sh
+
+if ENABLE_TEST_RUN
+if HAVE_SQLITE
+ AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;
+ TESTS = $(check_SCRIPTS)
+endif
+endif
+
+
+
+
+
diff --git a/src/contrib/service/abd/abd.conf.in b/src/contrib/service/abd/abd.conf.in
new file mode 100644
index 000000000..7baf95fc8
--- /dev/null
+++ b/src/contrib/service/abd/abd.conf.in
@@ -0,0 +1,5 @@
+[abd]
+BINARY = gnunet-service-abd
+UNIXPATH = $GNUNET_USER_RUNTIME_DIR/gnunet-service-abd.sock
+RUN_PER_USER = YES
+OPTIONS = -L DEBUG
diff --git a/src/contrib/service/abd/abd.h b/src/contrib/service/abd/abd.h
new file mode 100644
index 000000000..26b8e222e
--- /dev/null
+++ b/src/contrib/service/abd/abd.h
@@ -0,0 +1,251 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012-2013 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file abd/abd.h
+ * @brief IPC messages between ABD API and ABD service
+ * @author Martin Schanzenbach
+ */
+#ifndef ABD_H
+#define ABD_H
+
+#include "gnunet_abd_service.h"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message from client to Credential service to collect credentials.
+ */
+struct CollectMessage
+{
+  /**
+   * Header of type #GNUNET_MESSAGE_TYPE_ABD_VERIFY
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Subject public key
+   */
+  struct GNUNET_CRYPTO_PrivateKey subject_key;
+
+  /**
+   * Trust anchor
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * Length of the issuer attribute
+   */
+  uint16_t issuer_attribute_len;
+
+  /**
+   * Direction of the resolution algo
+   */
+  uint16_t resolution_algo;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /* Followed by the zero-terminated attribute */
+};
+
+
+/**
+ * Message from client to Credential service to verify attributes.
+ */
+struct VerifyMessage
+{
+  /**
+   * Header of type #GNUNET_MESSAGE_TYPE_ABD_VERIFY
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Subject public key
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * Trust anchor
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * Number of delegates
+   */
+  uint32_t d_count;
+
+  /**
+   * Length of the issuer attribute
+   */
+  uint16_t issuer_attribute_len;
+
+  /**
+   * Direction of the resolution algo
+   */
+  uint16_t resolution_algo;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /* Followed by the zero-terminated attribute and credentials to look up */
+};
+
+
+/**
+ * Message from ABD service to client: new results.
+ */
+struct DelegationChainResultMessage
+{
+  /**
+    * Header of type #GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /**
+   * Indicates if credential has been found at all
+   */
+  uint32_t del_found GNUNET_PACKED;
+
+  /**
+   * The number of delegations in the response
+   */
+  uint32_t d_count GNUNET_PACKED;
+
+  /**
+   * The number of credentials in the response
+   */
+  uint32_t c_count GNUNET_PACKED;
+
+  /* followed by ad_count GNUNET_ABD_RecordData structs*/
+};
+
+/**
+ * Message from ABD service to client: new results.
+ */
+struct DelegationChainIntermediateMessage
+{
+  /**
+    * Header of type #GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique identifier for this request (for key collisions).
+   */
+  uint32_t id GNUNET_PACKED;
+
+  uint16_t is_bw GNUNET_PACKED;
+
+  uint32_t size GNUNET_PACKED;
+};
+
+struct DelegationRecordData
+{
+  /**
+   * Subject key
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * Subject attributes
+   */
+  uint32_t subject_attribute_len GNUNET_PACKED;
+};
+
+
+struct ChainEntry
+{
+  /**
+   * Issuer key
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * Subject key
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * Issuer attributes
+   */
+  uint32_t issuer_attribute_len GNUNET_PACKED;
+
+  /**
+   * Subject attributes
+   */
+  uint32_t subject_attribute_len GNUNET_PACKED;
+};
+
+
+struct DelegateEntry
+{
+  /**
+   * The signature for this credential by the issuer
+   */
+  struct GNUNET_CRYPTO_Signature signature;
+
+  /**
+   * Signature meta
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Public key of the issuer
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * Public key of the subject this credential was issued to
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * Expiration time of this credential
+   */
+  uint64_t expiration GNUNET_PACKED;
+
+  /**
+   * Issuer subject attribute length
+   */
+  uint32_t issuer_attribute_len;
+
+  /**
+   * Issuer attribute length
+   */
+  uint32_t subject_attribute_len;
+
+  /**
+   * Followed by the subject attribute string
+   */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/abd/abd_api.c b/src/contrib/service/abd/abd_api.c
new file mode 100644
index 000000000..3682f41ba
--- /dev/null
+++ b/src/contrib/service/abd/abd_api.c
@@ -0,0 +1,563 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2013, 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 abd/abd_api.c
+ * @brief library to access the ABD service
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_arm_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "abd.h"
+#include "abd_serialization.h"
+#include "gnunet_abd_service.h"
+#include "gnunet_identity_service.h"
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "abd-api", __VA_ARGS__)
+
+/**
+ * Handle to a verify request
+ */
+struct GNUNET_ABD_Request
+{
+
+  /**
+   * DLL
+   */
+  struct GNUNET_ABD_Request *next;
+
+  /**
+   * DLL
+   */
+  struct GNUNET_ABD_Request *prev;
+
+  /**
+   * handle to abd service
+   */
+  struct GNUNET_ABD_Handle *abd_handle;
+
+  /**
+   * processor to call on verify result
+   */
+  GNUNET_ABD_CredentialResultProcessor verify_proc;
+
+  /**
+   * @e verify_proc closure
+   */
+  void *proc_cls;
+
+  /**
+   * processor to call on intermediate result
+   */
+  GNUNET_ABD_IntermediateResultProcessor int_proc;
+
+  /**
+   * @e verify_proc2 closure
+   */
+  void *proc2_cls;
+
+  /**
+   * Envelope with the message for this queue entry.
+   */
+  struct GNUNET_MQ_Envelope *env;
+
+  /**
+   * request id
+   */
+  uint32_t r_id;
+};
+
+
+/**
+ * Connection to the ABD service.
+ */
+struct GNUNET_ABD_Handle
+{
+
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Connection to service (if available).
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Head of linked list of active verify requests.
+   */
+  struct GNUNET_ABD_Request *request_head;
+
+  /**
+   * Tail of linked list of active verify requests.
+   */
+  struct GNUNET_ABD_Request *request_tail;
+
+  /**
+   * Reconnect task
+   */
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  /**
+   * How long do we wait until we try to reconnect?
+   */
+  struct GNUNET_TIME_Relative reconnect_backoff;
+
+  /**
+   * Request Id generator.  Incremented by one for each request.
+   */
+  uint32_t r_id_gen;
+};
+
+
+/**
+ * Reconnect to ABD service.
+ *
+ * @param handle the handle to the ABD service
+ */
+static void
+reconnect (struct GNUNET_ABD_Handle *handle);
+
+
+/**
+ * Reconnect to ABD
+ *
+ * @param cls the handle
+ */
+static void
+reconnect_task (void *cls)
+{
+  struct GNUNET_ABD_Handle *handle = cls;
+
+  handle->reconnect_task = NULL;
+  reconnect (handle);
+}
+
+
+/**
+ * Disconnect from service and then reconnect.
+ *
+ * @param handle our handle
+ */
+static void
+force_reconnect (struct GNUNET_ABD_Handle *handle)
+{
+  GNUNET_MQ_destroy (handle->mq);
+  handle->mq = NULL;
+  handle->reconnect_backoff =
+    GNUNET_TIME_STD_BACKOFF (handle->reconnect_backoff);
+  handle->reconnect_task =
+    GNUNET_SCHEDULER_add_delayed (handle->reconnect_backoff,
+                                  &reconnect_task,
+                                  handle);
+}
+
+
+/**
+ * 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_ABD_Handle *`
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_ABD_Handle *handle = cls;
+
+  force_reconnect (handle);
+}
+
+
+/**
+ * Check validity of message received from the ABD service
+ *
+ * @param cls the `struct GNUNET_ABD_Handle *`
+ * @param vr_msg the incoming message
+ */
+static int
+check_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
+{
+  // TODO
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for messages received from the ABD service
+ *
+ * @param cls the `struct GNUNET_ABD_Handle *`
+ * @param vr_msg the incoming message
+ */
+static void
+handle_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
+{
+  struct GNUNET_ABD_Handle *handle = cls;
+  uint32_t r_id = ntohl (vr_msg->id);
+  struct GNUNET_ABD_Request *vr;
+  size_t mlen = ntohs (vr_msg->header.size) - sizeof (*vr_msg);
+  uint32_t d_count = ntohl (vr_msg->d_count);
+  uint32_t c_count = ntohl (vr_msg->c_count);
+  struct GNUNET_ABD_Delegation d_chain[d_count];
+  struct GNUNET_ABD_Delegate dels[c_count];
+  GNUNET_ABD_CredentialResultProcessor proc;
+  void *proc_cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received verify reply from ABD service\n");
+  for (vr = handle->request_head; NULL != vr; vr = vr->next)
+    if (vr->r_id == r_id)
+      break;
+  if (NULL == vr)
+    return;
+  proc = vr->verify_proc;
+  proc_cls = vr->proc_cls;
+  GNUNET_CONTAINER_DLL_remove (handle->request_head, handle->request_tail, vr);
+  GNUNET_MQ_discard (vr->env);
+  GNUNET_free (vr);
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_ABD_delegation_chain_deserialize (mlen,
+                                             (const char *) &vr_msg[1],
+                                             d_count,
+                                             d_chain,
+                                             c_count,
+                                             dels));
+  if (GNUNET_NO == ntohl (vr_msg->del_found))
+  {
+    proc (proc_cls, 0, NULL, 0,
+          NULL);
+  }
+  else
+  {
+    proc (proc_cls, d_count, d_chain, c_count, dels);
+  }
+}
+
+
+static int
+check_intermediate (void *cls, const struct
+                    DelegationChainIntermediateMessage *vr_msg)
+{
+  // TODO
+  return GNUNET_OK;
+}
+
+
+static void
+handle_intermediate (void *cls, const struct
+                     DelegationChainIntermediateMessage *vr_msg)
+{
+  struct GNUNET_ABD_Handle *handle = cls;
+  uint32_t r_id = ntohl (vr_msg->id);
+  uint32_t size = ntohl (vr_msg->size);
+  bool is_bw = ntohs (vr_msg->is_bw);
+  struct GNUNET_ABD_Request *vr;
+  GNUNET_ABD_IntermediateResultProcessor proc;
+  void *proc_cls;
+  struct GNUNET_ABD_Delegation *dd;
+
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received intermediate reply from ABD service\n");
+
+  for (vr = handle->request_head; NULL != vr; vr = vr->next)
+    if (vr->r_id == r_id)
+      break;
+  if (NULL == vr)
+    return;
+
+  proc = vr->int_proc;
+  proc_cls = vr->proc2_cls;
+
+  dd = GNUNET_new (struct GNUNET_ABD_Delegation);
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_ABD_delegation_chain_deserialize (size,
+                                             (const char *) &vr_msg[1],
+                                             1,
+                                             dd,
+                                             0,
+                                             NULL));
+  proc (proc_cls, dd, is_bw);
+}
+
+
+/**
+ * Reconnect to ABD service.
+ *
+ * @param handle the handle to the ABD service
+ */
+static void
+reconnect (struct GNUNET_ABD_Handle *handle)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] =
+  {GNUNET_MQ_hd_var_size (result,
+                          GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT,
+                          struct DelegationChainResultMessage,
+                          handle),
+   GNUNET_MQ_hd_var_size (result,
+                          GNUNET_MESSAGE_TYPE_ABD_COLLECT_RESULT,
+                          struct DelegationChainResultMessage,
+                          handle),
+   GNUNET_MQ_hd_var_size (intermediate,
+                          GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT,
+                          struct DelegationChainIntermediateMessage,
+                          handle),
+   GNUNET_MQ_handler_end ()};
+  struct GNUNET_ABD_Request *vr;
+
+  GNUNET_assert (NULL == handle->mq);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to ABD\n");
+  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
+                                      "abd",
+                                      handlers,
+                                      &mq_error_handler,
+                                      handle);
+  if (NULL == handle->mq)
+    return;
+  for (vr = handle->request_head; NULL != vr; vr = vr->next)
+    GNUNET_MQ_send_copy (handle->mq, vr->env);
+}
+
+
+/**
+ * Initialize the connection with the ABD service.
+ *
+ * @param cfg configuration to use
+ * @return handle to the ABD service, or NULL on error
+ */
+struct GNUNET_ABD_Handle *
+GNUNET_ABD_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_ABD_Handle *handle;
+
+  handle = GNUNET_new (struct GNUNET_ABD_Handle);
+  handle->cfg = cfg;
+  reconnect (handle);
+  if (NULL == handle->mq)
+  {
+    GNUNET_free (handle);
+    return NULL;
+  }
+  return handle;
+}
+
+
+/**
+ * Shutdown connection with the ABD service.
+ *
+ * @param handle handle of the ABD connection to stop
+ */
+void
+GNUNET_ABD_disconnect (struct GNUNET_ABD_Handle *handle)
+{
+  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_assert (NULL == handle->request_head);
+  GNUNET_free (handle);
+}
+
+
+/**
+ * Cancel pending verify request
+ *
+ * @param lr the verify request to cancel
+ */
+void
+GNUNET_ABD_request_cancel (struct GNUNET_ABD_Request *lr)
+{
+  struct GNUNET_ABD_Handle *handle = lr->abd_handle;
+
+  GNUNET_CONTAINER_DLL_remove (handle->request_head, handle->request_tail, lr);
+  GNUNET_MQ_discard (lr->env);
+  GNUNET_free (lr);
+}
+
+
+/**
+ * Performs attribute collection.
+ * Collects all abds of subject to fulfill the
+ * attribute, if possible
+ *
+ * @param handle handle to the Credential service
+ * @param issuer_key the issuer public key
+ * @param issuer_attribute the issuer attribute
+ * @param subject_key the subject public key
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the queued request
+ */
+struct GNUNET_ABD_Request *
+GNUNET_ABD_collect (
+  struct GNUNET_ABD_Handle *handle,
+  const struct GNUNET_CRYPTO_PublicKey *issuer_key,
+  const char *issuer_attribute,
+  const struct GNUNET_CRYPTO_PrivateKey *subject_key,
+  enum GNUNET_ABD_AlgoDirectionFlags direction,
+  GNUNET_ABD_CredentialResultProcessor proc,
+  void *proc_cls,
+  GNUNET_ABD_IntermediateResultProcessor proc2,
+  void *proc2_cls)
+{
+  /* IPC to shorten abd names, return shorten_handle */
+  struct CollectMessage *c_msg;
+  struct GNUNET_ABD_Request *vr;
+  size_t nlen;
+
+  if (NULL == issuer_attribute)
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+
+  // DEBUG LOG
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Trying to collect `%s' in ABD\n",
+       issuer_attribute);
+  nlen = strlen (issuer_attribute) + 1;
+  if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  vr = GNUNET_new (struct GNUNET_ABD_Request);
+  vr->abd_handle = handle;
+  vr->verify_proc = proc;
+  vr->proc_cls = proc_cls;
+  vr->int_proc =  proc2;
+  vr->proc2_cls = proc2_cls;
+  vr->r_id = handle->r_id_gen++;
+  vr->env =
+    GNUNET_MQ_msg_extra (c_msg, nlen, GNUNET_MESSAGE_TYPE_ABD_COLLECT);
+  c_msg->id = htonl (vr->r_id);
+  c_msg->subject_key = *subject_key;
+  c_msg->issuer_key = *issuer_key;
+  c_msg->issuer_attribute_len = htons (strlen (issuer_attribute));
+  c_msg->resolution_algo = htons (direction);
+
+  GNUNET_memcpy (&c_msg[1], issuer_attribute, strlen (issuer_attribute));
+  GNUNET_CONTAINER_DLL_insert (handle->request_head, handle->request_tail, vr);
+  if (NULL != handle->mq)
+    GNUNET_MQ_send_copy (handle->mq, vr->env);
+  return vr;
+}
+
+
+/**
+ * Performs attribute verification.
+ * Checks if there is a delegation chain from
+ * attribute ``issuer_attribute'' issued by the issuer
+ * with public key ``issuer_key'' maps to the attribute
+ * ``subject_attribute'' claimed by the subject with key
+ * ``subject_key''
+ *
+ * @param handle handle to the Credential service
+ * @param issuer_key the issuer public key
+ * @param issuer_attribute the issuer attribute
+ * @param subject_key the subject public key
+ * @param delegate_count number of delegates provided
+ * @param delegates subject delegates
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the queued request
+ */
+struct GNUNET_ABD_Request *
+GNUNET_ABD_verify (
+  struct GNUNET_ABD_Handle *handle,
+  const struct GNUNET_CRYPTO_PublicKey *issuer_key,
+  const char *issuer_attribute,
+  const struct GNUNET_CRYPTO_PublicKey *subject_key,
+  uint32_t delegate_count,
+  const struct GNUNET_ABD_Delegate *delegates,
+  enum GNUNET_ABD_AlgoDirectionFlags direction,
+  GNUNET_ABD_CredentialResultProcessor proc,
+  void *proc_cls,
+  GNUNET_ABD_IntermediateResultProcessor proc2,
+  void *proc2_cls)
+{
+  /* IPC to shorten abd names, return shorten_handle */
+  struct VerifyMessage *v_msg;
+  struct GNUNET_ABD_Request *vr;
+  size_t nlen;
+  size_t clen;
+
+  if ((NULL == issuer_attribute) || (NULL == delegates))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+
+  clen = GNUNET_ABD_delegates_get_size (delegate_count, delegates);
+
+  // DEBUG LOG
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Trying to verify `%s' in ABD\n",
+       issuer_attribute);
+  nlen = strlen (issuer_attribute) + 1 + clen;
+  if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  vr = GNUNET_new (struct GNUNET_ABD_Request);
+  vr->abd_handle = handle;
+  vr->verify_proc = proc;
+  vr->proc_cls = proc_cls;
+  vr->int_proc =  proc2;
+  vr->proc2_cls = proc2_cls;
+  vr->r_id = handle->r_id_gen++;
+  vr->env =
+    GNUNET_MQ_msg_extra (v_msg, nlen, GNUNET_MESSAGE_TYPE_ABD_VERIFY);
+  v_msg->id = htonl (vr->r_id);
+  v_msg->subject_key = *subject_key;
+  v_msg->d_count = htonl (delegate_count);
+  v_msg->issuer_key = *issuer_key;
+  v_msg->issuer_attribute_len = htons (strlen (issuer_attribute));
+  v_msg->resolution_algo = htons (direction);
+
+  GNUNET_memcpy (&v_msg[1], issuer_attribute, strlen (issuer_attribute));
+  GNUNET_ABD_delegates_serialize (delegate_count,
+                                  delegates,
+                                  clen,
+                                  ((char *) &v_msg[1])
+                                  + strlen (issuer_attribute) + 1);
+  GNUNET_CONTAINER_DLL_insert (handle->request_head, handle->request_tail, vr);
+  if (NULL != handle->mq)
+    GNUNET_MQ_send_copy (handle->mq, vr->env);
+  return vr;
+}
+
+
+/* end of abd_api.c */
diff --git a/src/contrib/service/abd/abd_serialization.c b/src/contrib/service/abd/abd_serialization.c
new file mode 100644
index 000000000..14960e804
--- /dev/null
+++ b/src/contrib/service/abd/abd_serialization.c
@@ -0,0 +1,516 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2013, 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 abd/abd_serialization.c
+ * @brief API to serialize and deserialize delegation chains
+ * and abds
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_abd_service.h"
+#include "gnunet_signatures.h"
+#include "abd.h"
+
+/**
+ * Calculate how many bytes we will need to serialize
+ * the given delegation chain
+ *
+ * @param ds_count number of delegation chain entries
+ * @param dsr array of #GNUNET_ABD_DelegationSet
+ * @return the required size to serialize
+ */
+size_t
+GNUNET_ABD_delegation_set_get_size (
+  unsigned int ds_count,
+  const struct GNUNET_ABD_DelegationSet *dsr)
+{
+  unsigned int i;
+  size_t ret;
+
+  ret = sizeof (struct DelegationRecordData) * (ds_count);
+
+  for (i = 0; i < ds_count; i++)
+  {
+    GNUNET_assert ((ret + dsr[i].subject_attribute_len) >= ret);
+    ret += dsr[i].subject_attribute_len;
+  }
+  return ret;
+}
+
+
+/**
+ * Serizalize the given delegation chain entries and abd
+ *
+ * @param d_count number of delegation chain entries
+ * @param dsr array of #GNUNET_ABD_DelegationSet
+ * @param dest_size size of the destination
+ * @param dest where to store the result
+ * @return the size of the data, -1 on failure
+ */
+ssize_t
+GNUNET_ABD_delegation_set_serialize (
+  unsigned int d_count,
+  const struct GNUNET_ABD_DelegationSet *dsr,
+  size_t dest_size,
+  char *dest)
+{
+  struct DelegationRecordData rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < d_count; i++)
+  {
+    rec.subject_attribute_len = htonl ((uint32_t) dsr[i].subject_attribute_len);
+    rec.subject_key = dsr[i].subject_key;
+    if (off + sizeof (rec) > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
+    off += sizeof (rec);
+    if (0 == dsr[i].subject_attribute_len)
+      continue;
+    if (off + dsr[i].subject_attribute_len > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off],
+                   dsr[i].subject_attribute,
+                   dsr[i].subject_attribute_len);
+    off += dsr[i].subject_attribute_len;
+  }
+  return off;
+}
+
+
+/**
+ * Deserialize the given destination
+ *
+ * @param len size of the serialized delegation chain and cred
+ * @param src the serialized data
+ * @param d_count the number of delegation chain entries
+ * @param dsr where to put the delegation chain entries
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+int
+GNUNET_ABD_delegation_set_deserialize (
+  size_t len,
+  const char *src,
+  unsigned int d_count,
+  struct GNUNET_ABD_DelegationSet *dsr)
+{
+  struct DelegationRecordData rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < d_count; i++)
+  {
+    if (off + sizeof (rec) > len)
+      return GNUNET_SYSERR;
+    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
+    dsr[i].subject_key = rec.subject_key;
+    off += sizeof (rec);
+    dsr[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
+    if (off + dsr[i].subject_attribute_len > len)
+      return GNUNET_SYSERR;
+    dsr[i].subject_attribute = (char *) &src[off];
+    off += dsr[i].subject_attribute_len;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Calculate how many bytes we will need to serialize
+ * the abds
+ *
+ * @param c_count number of abd entries
+ * @param cd a #GNUNET_ABD_Credential
+ * @return the required size to serialize
+ */
+size_t
+GNUNET_ABD_delegates_get_size (
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd)
+{
+  unsigned int i;
+  size_t ret;
+
+  ret = sizeof (struct DelegateEntry) * (c_count);
+
+  for (i = 0; i < c_count; i++)
+  {
+    GNUNET_assert ((ret + cd[i].issuer_attribute_len
+                    + cd[i].subject_attribute_len) >= ret);
+    // subject_attribute_len should be 0
+    ret += cd[i].issuer_attribute_len + cd[i].subject_attribute_len;
+  }
+  return ret;
+}
+
+
+/**
+ * Serizalize the given abds
+ *
+ * @param c_count number of abd entries
+ * @param cd a #GNUNET_ABD_Credential
+ * @param dest_size size of the destination
+ * @param dest where to store the result
+ * @return the size of the data, -1 on failure
+ */
+ssize_t
+GNUNET_ABD_delegates_serialize (
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd,
+  size_t dest_size,
+  char *dest)
+{
+  struct DelegateEntry c_rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < c_count; i++)
+  {
+    c_rec.subject_attribute_len = htonl (cd[i].subject_attribute_len);
+    c_rec.issuer_attribute_len = htonl (cd[i].issuer_attribute_len);
+    c_rec.issuer_key = cd[i].issuer_key;
+    c_rec.subject_key = cd[i].subject_key;
+    c_rec.signature = cd[i].signature;
+    c_rec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
+    c_rec.purpose.size =
+      htonl ((sizeof (struct DelegateEntry) + cd[i].issuer_attribute_len)
+             - sizeof (struct GNUNET_CRYPTO_Signature));
+    c_rec.expiration = GNUNET_htonll (cd[i].expiration.abs_value_us);
+    if (off + sizeof (c_rec) > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off], &c_rec, sizeof (c_rec));
+    off += sizeof (c_rec);
+    if (off + cd[i].issuer_attribute_len > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off],
+                   cd[i].issuer_attribute,
+                   cd[i].issuer_attribute_len);
+    off += cd[i].issuer_attribute_len;
+  }
+
+  return off;
+}
+
+
+/**
+ * Deserialize the given destination
+ *
+ * @param len size of the serialized creds
+ * @param src the serialized data
+ * @param c_count the number of abd entries
+ * @param cd where to put the abd data
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+int
+GNUNET_ABD_delegates_deserialize (size_t len,
+                                  const char *src,
+                                  unsigned int c_count,
+                                  struct GNUNET_ABD_Delegate *cd)
+{
+  struct DelegateEntry c_rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < c_count; i++)
+  {
+    if (off + sizeof (c_rec) > len)
+      return GNUNET_SYSERR;
+    GNUNET_memcpy (&c_rec, &src[off], sizeof (c_rec));
+    cd[i].issuer_attribute_len = ntohl ((uint32_t) c_rec.issuer_attribute_len);
+    cd[i].issuer_key = c_rec.issuer_key;
+    cd[i].subject_key = c_rec.subject_key;
+    cd[i].signature = c_rec.signature;
+    cd[i].expiration.abs_value_us = GNUNET_ntohll (c_rec.expiration);
+    off += sizeof (c_rec);
+    if (off + cd[i].issuer_attribute_len > len)
+      return GNUNET_SYSERR;
+    cd[i].issuer_attribute = &src[off];
+    off += cd[i].issuer_attribute_len;
+    cd[i].subject_attribute_len = 0;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Calculate how many bytes we will need to serialize
+ * the given delegation chain and abd
+ *
+ * @param d_count number of delegation chain entries
+ * @param dd array of #GNUNET_ABD_Delegation
+ * @param c_count number of abd entries
+ * @param cd a #GNUNET_ABD_Credential
+ * @return the required size to serialize
+ */
+size_t
+GNUNET_ABD_delegation_chain_get_size (
+  unsigned int d_count,
+  const struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd)
+{
+  unsigned int i;
+  size_t ret;
+
+  ret = sizeof (struct ChainEntry) * (d_count);
+
+  for (i = 0; i < d_count; i++)
+  {
+    GNUNET_assert (
+      (ret + dd[i].issuer_attribute_len + dd[i].subject_attribute_len) >= ret);
+    ret += dd[i].issuer_attribute_len + dd[i].subject_attribute_len;
+  }
+  return ret + GNUNET_ABD_delegates_get_size (c_count, cd);
+}
+
+
+/**
+ * Serizalize the given delegation chain entries and abd
+ *
+ * @param d_count number of delegation chain entries
+ * @param dd array of #GNUNET_ABD_Delegation
+ * @param c_count number of abd entries
+ * @param cd a #GNUNET_ABD_Credential
+ * @param dest_size size of the destination
+ * @param dest where to store the result
+ * @return the size of the data, -1 on failure
+ */
+ssize_t
+GNUNET_ABD_delegation_chain_serialize (
+  unsigned int d_count,
+  const struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd,
+  size_t dest_size,
+  char *dest)
+{
+  struct ChainEntry rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < d_count; i++)
+  {
+    rec.issuer_attribute_len = htonl ((uint32_t) dd[i].issuer_attribute_len);
+    rec.subject_attribute_len = htonl ((uint32_t) dd[i].subject_attribute_len);
+    rec.issuer_key = dd[i].issuer_key;
+    rec.subject_key = dd[i].subject_key;
+    if (off + sizeof (rec) > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
+    off += sizeof (rec);
+    if (off + dd[i].issuer_attribute_len > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off],
+                   dd[i].issuer_attribute,
+                   dd[i].issuer_attribute_len);
+    off += dd[i].issuer_attribute_len;
+    if (0 == dd[i].subject_attribute_len)
+      continue;
+    if (off + dd[i].subject_attribute_len > dest_size)
+      return -1;
+    GNUNET_memcpy (&dest[off],
+                   dd[i].subject_attribute,
+                   dd[i].subject_attribute_len);
+    off += dd[i].subject_attribute_len;
+  }
+  return off + GNUNET_ABD_delegates_serialize (c_count,
+                                               cd,
+                                               dest_size - off,
+                                               &dest[off]);
+}
+
+
+/**
+ * Deserialize the given destination
+ *
+ * @param len size of the serialized delegation chain and cred
+ * @param src the serialized data
+ * @param d_count the number of delegation chain entries
+ * @param dd where to put the delegation chain entries
+ * @param c_count the number of abd entries
+ * @param cd where to put the abd data
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+int
+GNUNET_ABD_delegation_chain_deserialize (
+  size_t len,
+  const char *src,
+  unsigned int d_count,
+  struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  struct GNUNET_ABD_Delegate *cd)
+{
+  struct ChainEntry rec;
+  unsigned int i;
+  size_t off;
+
+  off = 0;
+  for (i = 0; i < d_count; i++)
+  {
+    if (off + sizeof (rec) > len)
+      return GNUNET_SYSERR;
+    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
+    dd[i].issuer_attribute_len = ntohl ((uint32_t) rec.issuer_attribute_len);
+    dd[i].issuer_key = rec.issuer_key;
+    dd[i].subject_key = rec.subject_key;
+    off += sizeof (rec);
+    if (off + dd[i].issuer_attribute_len > len)
+      return GNUNET_SYSERR;
+    dd[i].issuer_attribute = &src[off];
+    off += dd[i].issuer_attribute_len;
+    dd[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
+    if (off + dd[i].subject_attribute_len > len)
+      return GNUNET_SYSERR;
+    dd[i].subject_attribute = &src[off];
+    off += dd[i].subject_attribute_len;
+  }
+  return GNUNET_ABD_delegates_deserialize (len - off,
+                                           &src[off],
+                                           c_count,
+                                           cd);
+}
+
+
+int
+GNUNET_ABD_delegate_serialize (struct GNUNET_ABD_Delegate *dele,
+                               char **data)
+{
+  size_t size;
+  struct DelegateEntry *cdata;
+  int attr_len;
+
+  // +1 for \0
+  if (0 == dele->subject_attribute_len)
+  {
+    attr_len = dele->issuer_attribute_len + 1;
+  }
+  else
+  {
+    attr_len = dele->issuer_attribute_len + dele->subject_attribute_len + 2;
+  }
+  size = sizeof (struct DelegateEntry) + attr_len;
+
+  char tmp_str[attr_len];
+  GNUNET_memcpy (tmp_str, dele->issuer_attribute, dele->issuer_attribute_len);
+  if (0 != dele->subject_attribute_len)
+  {
+    tmp_str[dele->issuer_attribute_len] = '\0';
+    GNUNET_memcpy (tmp_str + dele->issuer_attribute_len + 1,
+                   dele->subject_attribute,
+                   dele->subject_attribute_len);
+  }
+  tmp_str[attr_len - 1] = '\0';
+
+  *data = GNUNET_malloc (size);
+  cdata = (struct DelegateEntry *) *data;
+  cdata->subject_key = dele->subject_key;
+  cdata->issuer_key = dele->issuer_key;
+  cdata->expiration = GNUNET_htonll (dele->expiration.abs_value_us);
+  cdata->signature = dele->signature;
+  cdata->issuer_attribute_len = htonl (dele->issuer_attribute_len + 1);
+  if (0 == dele->subject_attribute_len)
+  {
+    cdata->subject_attribute_len = htonl (0);
+  }
+  else
+  {
+    cdata->subject_attribute_len = htonl (dele->subject_attribute_len + 1);
+  }
+  cdata->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
+  cdata->purpose.size =
+    htonl (size - sizeof (struct GNUNET_CRYPTO_Signature));
+
+  GNUNET_memcpy (&cdata[1], tmp_str, attr_len);
+
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_signature_verify_ (GNUNET_SIGNATURE_PURPOSE_DELEGATE,
+                                  &cdata->purpose,
+                                  &cdata->signature,
+                                  &cdata->issuer_key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Serialize: Invalid delegate\n");
+    return 0;
+  }
+  return size;
+}
+
+
+struct GNUNET_ABD_Delegate *
+GNUNET_ABD_delegate_deserialize (const char *data, size_t data_size)
+{
+  struct GNUNET_ABD_Delegate *dele;
+  struct DelegateEntry *cdata;
+  char *attr_combo_str;
+
+  if (data_size < sizeof (struct DelegateEntry))
+    return NULL;
+  cdata = (struct DelegateEntry *) data;
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_signature_verify_ (GNUNET_SIGNATURE_PURPOSE_DELEGATE,
+                                  &cdata->purpose,
+                                  &cdata->signature,
+                                  &cdata->issuer_key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deserialize: Invalid delegate\n");
+    return NULL;
+  }
+  attr_combo_str = (char *) &cdata[1];
+  int iss_len = ntohl (cdata->issuer_attribute_len);
+  int sub_len = ntohl (cdata->subject_attribute_len);
+  int attr_combo_len = iss_len + sub_len;
+
+  dele =
+    GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_combo_len);
+
+  dele->issuer_key = cdata->issuer_key;
+  dele->subject_key = cdata->subject_key;
+  GNUNET_memcpy (&dele[1], attr_combo_str, attr_combo_len);
+  dele->signature = cdata->signature;
+
+  // Set the pointers for the attributes
+  dele->issuer_attribute = (char *) &dele[1];
+  dele->issuer_attribute_len = iss_len;
+  dele->subject_attribute_len = sub_len;
+  if (0 == sub_len)
+  {
+    dele->subject_attribute = NULL;
+  }
+  else
+  {
+    dele->subject_attribute = (char *) &dele[1] + iss_len;
+  }
+
+  dele->expiration.abs_value_us = GNUNET_ntohll (cdata->expiration);
+
+  return dele;
+}
+
+
+/* end of abd_serialization.c */
diff --git a/src/contrib/service/abd/abd_serialization.h b/src/contrib/service/abd/abd_serialization.h
new file mode 100644
index 000000000..21dc45a7b
--- /dev/null
+++ b/src/contrib/service/abd/abd_serialization.h
@@ -0,0 +1,167 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2013, 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 abd/abd_serialization.h
+ * @brief API to serialize and deserialize delegation chains
+ * and abds
+ * @author Martin Schanzenbach
+ */
+#ifndef ABD_SERIALIZATION_H
+#define ABD_SERIALIZATION_H
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_abd_service.h"
+
+/**
+ * Calculate how many bytes we will need to serialize
+ * the given delegation record
+ *
+ * @param ds_count number of delegation chain entries
+ * @param dsr array of #GNUNET_ABD_Delegation
+ * @return the required size to serialize
+ */
+size_t
+GNUNET_ABD_delegation_set_get_size (
+  unsigned int ds_count,
+  const struct GNUNET_ABD_DelegationSet *dsr);
+
+/**
+ * Serizalize the given delegation record entries
+ *
+ * @param d_count number of delegation chain entries
+ * @param dsr array of #GNUNET_ABD_Delegation
+ * @param dest_size size of the destination
+ * @param dest where to store the result
+ * @return the size of the data, -1 on failure
+ */
+ssize_t
+GNUNET_ABD_delegation_set_serialize (
+  unsigned int d_count,
+  const struct GNUNET_ABD_DelegationSet *dsr,
+  size_t dest_size,
+  char *dest);
+
+
+/**
+ * Deserialize the given destination
+ *
+ * @param len size of the serialized delegation recird
+ * @param src the serialized data
+ * @param d_count the number of delegation chain entries
+ * @param dsr where to put the delegation chain entries
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+int
+GNUNET_ABD_delegation_set_deserialize (
+  size_t len,
+  const char *src,
+  unsigned int d_count,
+  struct GNUNET_ABD_DelegationSet *dsr);
+
+/**
+   * Calculate how many bytes we will need to serialize
+   * the given delegation chain and abd
+   *
+   * @param d_count number of delegation chain entries
+   * @param dd array of #GNUNET_ABD_Delegation
+   * @param c_count number of abd entries
+   * @param cd a #GNUNET_ABD_Delegate
+   * @return the required size to serialize
+   */
+size_t
+GNUNET_ABD_delegation_chain_get_size (
+  unsigned int d_count,
+  const struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd);
+
+/**
+   * Serizalize the given delegation chain entries and abd
+   *
+   * @param d_count number of delegation chain entries
+   * @param dd array of #GNUNET_ABD_Delegation
+   * @param c_count number of abd entries
+   * @param cd a #GNUNET_ABD_Delegate
+   * @param dest_size size of the destination
+   * @param dest where to store the result
+   * @return the size of the data, -1 on failure
+   */
+ssize_t
+GNUNET_ABD_delegation_chain_serialize (
+  unsigned int d_count,
+  const struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd,
+  size_t dest_size,
+  char *dest);
+
+
+/**
+   * Deserialize the given destination
+   *
+   * @param len size of the serialized delegation chain and cred
+   * @param src the serialized data
+   * @param d_count the number of delegation chain entries
+   * @param dd where to put the delegation chain entries
+   * @param c_count number of abd entries
+   * @param cd where to put the abd data
+   * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+   */
+int
+GNUNET_ABD_delegation_chain_deserialize (
+  size_t len,
+  const char *src,
+  unsigned int d_count,
+  struct GNUNET_ABD_Delegation *dd,
+  unsigned int c_count,
+  struct GNUNET_ABD_Delegate *cd);
+
+size_t
+GNUNET_ABD_delegates_get_size (
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd);
+
+ssize_t
+GNUNET_ABD_delegates_serialize (
+  unsigned int c_count,
+  const struct GNUNET_ABD_Delegate *cd,
+  size_t dest_size,
+  char *dest);
+
+
+int
+GNUNET_ABD_delegates_deserialize (size_t len,
+                                  const char *src,
+                                  unsigned int c_count,
+                                  struct GNUNET_ABD_Delegate *cd);
+
+int
+GNUNET_ABD_delegate_serialize (struct GNUNET_ABD_Delegate *cred,
+                               char **data);
+
+struct GNUNET_ABD_Delegate *
+GNUNET_ABD_delegate_deserialize (const char *data, size_t data_size);
+
+#endif
+/* end of abd_serialization.h */
diff --git a/src/contrib/service/abd/delegate_misc.c b/src/contrib/service/abd/delegate_misc.c
new file mode 100644
index 000000000..446c0b8d2
--- /dev/null
+++ b/src/contrib/service/abd/delegate_misc.c
@@ -0,0 +1,279 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2013, 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 abd/delegate_misc.c
+ * @brief Misc API for delegate
+ *
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_abd_service.h"
+#include "gnunet_signatures.h"
+#include "abd.h"
+#include <inttypes.h>
+
+char *
+GNUNET_ABD_delegate_to_string (
+  const struct GNUNET_ABD_Delegate *cred)
+{
+  char *cred_str;
+  char *subject_pkey;
+  char *issuer_pkey;
+  char *signature;
+
+  subject_pkey = GNUNET_CRYPTO_public_key_to_string (&cred->subject_key);
+  issuer_pkey = GNUNET_CRYPTO_public_key_to_string (&cred->issuer_key);
+  GNUNET_STRINGS_base64_encode ((char *) &cred->signature,
+                                sizeof (struct GNUNET_CRYPTO_Signature),
+                                &signature);
+  if (0 == cred->subject_attribute_len)
+  {
+    GNUNET_asprintf (&cred_str,
+                     "%s.%s -> %s | %s | %" SCNu64,
+                     issuer_pkey,
+                     cred->issuer_attribute,
+                     subject_pkey,
+                     signature,
+                     cred->expiration.abs_value_us);
+  }
+  else
+  {
+    GNUNET_asprintf (&cred_str,
+                     "%s.%s -> %s.%s | %s | %" SCNu64,
+                     issuer_pkey,
+                     cred->issuer_attribute,
+                     subject_pkey,
+                     cred->subject_attribute,
+                     signature,
+                     cred->expiration.abs_value_us);
+  }
+  GNUNET_free (subject_pkey);
+  GNUNET_free (issuer_pkey);
+  GNUNET_free (signature);
+
+  return cred_str;
+}
+
+
+struct GNUNET_ABD_Delegate *
+GNUNET_ABD_delegate_from_string (const char *s)
+{
+  struct GNUNET_ABD_Delegate *dele;
+  size_t enclen = (sizeof (struct GNUNET_CRYPTO_PublicKey)) * 8;
+  if (enclen % 5 > 0)
+    enclen += 5 - enclen % 5;
+  enclen /= 5; /* 260/5 = 52 */
+  char subject_pkey[enclen + 1];
+  char issuer_pkey[enclen + 1];
+  char iss_attr[253 + 1];
+  // Needs to be initialized, in case of Type 1 credential (A.a <- B)
+  char sub_attr[253 + 1] = "";
+  char signature[256]; // TODO max payload size
+
+  struct GNUNET_CRYPTO_Signature *sig;
+  struct GNUNET_TIME_Absolute etime_abs;
+
+  // If it's A.a <- B.b...
+  if (6 != sscanf (s,
+                   "%58s.%253s -> %58s.%253s | %s | %" SCNu64,
+                   issuer_pkey,
+                   iss_attr,
+                   subject_pkey,
+                   sub_attr,
+                   signature,
+                   &etime_abs.abs_value_us))
+  {
+    // Try if it's A.a <- B
+    if (5 != sscanf (s,
+                     "%58s.%253s -> %58s | %s | %" SCNu64,
+                     issuer_pkey,
+                     iss_attr,
+                     subject_pkey,
+                     signature,
+                     &etime_abs.abs_value_us))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Unable to parse DEL record string `%s'\n",
+                  s);
+      return NULL;
+    }
+  }
+
+  // +1 for \0
+  int attr_len;
+  if (strcmp (sub_attr, "") == 0)
+  {
+    attr_len = strlen (iss_attr) + 1;
+  }
+  else
+  {
+    attr_len = strlen (iss_attr) + strlen (sub_attr) + 2;
+  }
+  dele = GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_len);
+
+  char tmp_str[attr_len];
+  GNUNET_memcpy (tmp_str, iss_attr, strlen (iss_attr));
+  if (strcmp (sub_attr, "") != 0)
+  {
+    tmp_str[strlen (iss_attr)] = '\0';
+    GNUNET_memcpy (tmp_str + strlen (iss_attr) + 1,
+                   sub_attr,
+                   strlen (sub_attr));
+  }
+  tmp_str[attr_len - 1] = '\0';
+
+  if (GNUNET_SYSERR ==
+      GNUNET_CRYPTO_public_key_from_string (subject_pkey,
+                                              &dele->subject_key))
+  {
+    GNUNET_free (dele);
+    return NULL;
+  }
+  if (GNUNET_SYSERR ==
+      GNUNET_CRYPTO_public_key_from_string (issuer_pkey,
+                                              &dele->issuer_key))
+  {
+    GNUNET_free (dele);
+    return NULL;
+  }
+  GNUNET_assert (sizeof (struct GNUNET_CRYPTO_Signature) ==
+                 GNUNET_STRINGS_base64_decode (signature,
+                                               strlen (signature),
+                                               (void **) &sig));
+  dele->signature = *sig;
+  dele->expiration = etime_abs;
+  GNUNET_free (sig);
+
+  GNUNET_memcpy (&dele[1], tmp_str, attr_len);
+
+  dele->issuer_attribute = (char *) &dele[1];
+  dele->issuer_attribute_len = strlen (iss_attr);
+  if (strcmp (sub_attr, "") == 0)
+  {
+    dele->subject_attribute = NULL;
+    dele->subject_attribute_len = 0;
+  }
+  else
+  {
+    dele->subject_attribute = (char *) &dele[1] + strlen (iss_attr) + 1;
+    dele->subject_attribute_len = strlen (sub_attr);
+  }
+
+  return dele;
+}
+
+
+/**
+ * Issue an attribute to a subject
+ *
+ * @param issuer the ego that should be used to issue the attribute
+ * @param subject the subject of the attribute
+ * @param iss_attr the name of the attribute
+ * @param expiration the TTL of the credential
+ * @return handle to the queued request
+ */
+
+struct GNUNET_ABD_Delegate *
+GNUNET_ABD_delegate_issue (
+  const struct GNUNET_CRYPTO_PrivateKey *issuer,
+  struct GNUNET_CRYPTO_PublicKey *subject,
+  const char *iss_attr,
+  const char *sub_attr,
+  struct GNUNET_TIME_Absolute *expiration)
+{
+  struct DelegateEntry *del;
+  struct GNUNET_ABD_Delegate *dele;
+  size_t size;
+  int attr_len;
+
+  if (NULL == sub_attr)
+  {
+    // +1 for \0
+    attr_len = strlen (iss_attr) + 1;
+  }
+  else
+  {
+    // +2 for both strings need to be terminated with \0
+    attr_len = strlen (iss_attr) + strlen (sub_attr) + 2;
+  }
+  size = sizeof (struct DelegateEntry) + attr_len;
+
+  char tmp_str[attr_len];
+  GNUNET_memcpy (tmp_str, iss_attr, strlen (iss_attr));
+  if (NULL != sub_attr)
+  {
+    tmp_str[strlen (iss_attr)] = '\0';
+    GNUNET_memcpy (tmp_str + strlen (iss_attr) + 1,
+                   sub_attr,
+                   strlen (sub_attr));
+  }
+  tmp_str[attr_len - 1] = '\0';
+
+  del = GNUNET_malloc (size);
+  del->purpose.size =
+    htonl (size - sizeof (struct GNUNET_CRYPTO_Signature));
+  del->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
+  GNUNET_CRYPTO_key_get_public (issuer, &del->issuer_key);
+  del->subject_key = *subject;
+  del->expiration = GNUNET_htonll (expiration->abs_value_us);
+  del->issuer_attribute_len = htonl (strlen (iss_attr) + 1);
+  if (NULL == sub_attr)
+  {
+    del->subject_attribute_len = htonl (0);
+  }
+  else
+  {
+    del->subject_attribute_len = htonl (strlen (sub_attr) + 1);
+  }
+
+  GNUNET_memcpy (&del[1], tmp_str, attr_len);
+
+  GNUNET_CRYPTO_sign_ (issuer, &del->purpose, &del->signature);
+
+  dele = GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_len);
+  dele->signature = del->signature;
+  dele->expiration = *expiration;
+  GNUNET_CRYPTO_key_get_public (issuer, &dele->issuer_key);
+
+  dele->subject_key = *subject;
+
+  // Copy the combined string at the part in the memory where the struct ends
+  GNUNET_memcpy (&dele[1], tmp_str, attr_len);
+
+  dele->issuer_attribute = (char *) &dele[1];
+  dele->issuer_attribute_len = strlen (iss_attr);
+  if (NULL == sub_attr)
+  {
+    dele->subject_attribute = NULL;
+    dele->subject_attribute_len = 0;
+  }
+  else
+  {
+    dele->subject_attribute = (char *) &dele[1] + strlen (iss_attr) + 1;
+    dele->subject_attribute_len = strlen (sub_attr);
+  }
+
+  GNUNET_free (del);
+  return dele;
+}
diff --git a/src/contrib/service/abd/delegate_misc.h b/src/contrib/service/abd/delegate_misc.h
new file mode 100644
index 000000000..0a4ddd9eb
--- /dev/null
+++ b/src/contrib/service/abd/delegate_misc.h
@@ -0,0 +1,36 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012-2013 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file abd/delegate_misc.h
+ * @brief Delegate helper functions
+ */
+#ifndef DELEGATE_MISC_H
+#define DELEGATE_MISC_H
+
+#include "gnunet_abd_service.h"
+
+char *
+GNUNET_ABD_delegate_to_string (
+  const struct GNUNET_ABD_Delegate *cred);
+
+struct GNUNET_ABD_Delegate *
+GNUNET_ABD_delegate_from_string (const char *str);
+
+#endif
diff --git a/src/contrib/service/abd/gnunet-abd.c b/src/contrib/service/abd/gnunet-abd.c
new file mode 100644
index 000000000..1ed1adbe7
--- /dev/null
+++ b/src/contrib/service/abd/gnunet-abd.c
@@ -0,0 +1,1108 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012-2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+*/
+/**
+ * @file gnunet-abd.c
+ * @brief command line tool to access command line Credential service
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+#include <gnunet_util_lib.h>
+#include <gnunet_abd_service.h>
+#include <gnunet_gnsrecord_lib.h>
+#include <gnunet_namestore_service.h>
+#include "delegate_misc.h"
+#include "abd_serialization.h"
+
+/**
+ * Configuration we are using.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Handle to the namestore.
+ */
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+/**
+ * Private key for the our zone.
+ */
+static struct GNUNET_CRYPTO_PrivateKey zone_pkey;
+
+/**
+ * EgoLookup
+ */
+static struct GNUNET_IDENTITY_EgoLookup *el;
+
+/**
+ * Handle to Credential service.
+ */
+static struct GNUNET_ABD_Handle *abd;
+
+/**
+ * Desired timeout for the lookup (default is no timeout).
+ */
+static struct GNUNET_TIME_Relative timeout;
+
+/**
+ * Handle to verify request
+ */
+static struct GNUNET_ABD_Request *verify_request;
+
+/**
+ * Handle to collect request
+ */
+static struct GNUNET_ABD_Request *collect_request;
+
+/**
+ * Task scheduled to handle timeout.
+ */
+static struct GNUNET_SCHEDULER_Task *tt;
+
+/**
+ * Return value of the commandline.
+ */
+static int ret = 0;
+
+/**
+ * Subject pubkey string
+ */
+static char *subject;
+
+/**
+ * Subject delegate string
+ */
+static char *subject_delegate;
+
+/**
+ * Credential TTL
+ */
+static char *expiration;
+
+/**
+ * Subject key
+ */
+struct GNUNET_CRYPTO_PublicKey subject_pkey;
+
+/**
+ * Issuer key
+ */
+struct GNUNET_CRYPTO_PublicKey issuer_pkey;
+
+
+/**
+ * Issuer pubkey string
+ */
+static char *issuer_key;
+
+/**
+ * ego
+ */
+static char *ego_name;
+
+/**
+ * Issuer attribute
+ */
+static char *issuer_attr;
+
+/**
+ * Verify mode
+ */
+static int verify;
+
+/**
+ * Collect mode
+ */
+static int collect;
+
+/**
+ * Create mode
+ */
+static int create_is;
+
+/**
+ * Create mode
+ */
+static int create_ss;
+
+/**
+ * Create mode
+ */
+static int sign_ss;
+
+/**
+ * Signed issue credentials
+ */
+static char *import;
+
+/**
+ * Is record private
+ */
+static int is_private;
+
+/**
+ * Search direction: forward
+ */
+static int forward;
+
+/**
+ * Search direction: backward
+ */
+static int backward;
+
+/**
+ * API enum, filled and passed for collect/verify
+ */
+enum GNUNET_ABD_AlgoDirectionFlags direction = 0;
+
+/**
+ * Queue entry for the 'add' operation.
+ */
+static struct GNUNET_NAMESTORE_QueueEntry *add_qe;
+
+/**
+ * Value in binary format.
+ */
+static void *data;
+
+/**
+ * Number of bytes in #data.
+ */
+static size_t data_size;
+
+/**
+ * Type string converted to DNS type value.
+ */
+static uint32_t type;
+
+/**
+ * Type of the record to add/remove, NULL to remove all.
+ */
+static char *typestring;
+/**
+ * Expiration string converted to numeric value.
+ */
+static uint64_t etime;
+
+/**
+ * Is expiration time relative or absolute time?
+ */
+static int etime_is_rel = GNUNET_SYSERR;
+
+/**
+ * Record label for storing delegations
+ */
+static char *record_label;
+
+/**
+ * Task run on shutdown.  Cleans up everything.
+ *
+ * @param cls unused
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != verify_request)
+  {
+    GNUNET_ABD_request_cancel (verify_request);
+    verify_request = NULL;
+  }
+  if (NULL != abd)
+  {
+    GNUNET_ABD_disconnect (abd);
+    abd = NULL;
+  }
+  if (NULL != tt)
+  {
+    GNUNET_SCHEDULER_cancel (tt);
+    tt = NULL;
+  }
+  if (NULL != el)
+  {
+    GNUNET_IDENTITY_ego_lookup_cancel (el);
+    el = NULL;
+  }
+  if (NULL != add_qe)
+  {
+    GNUNET_NAMESTORE_cancel (add_qe);
+    add_qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+/**
+ * Task run on timeout. Triggers shutdown.
+ *
+ * @param cls unused
+ */
+static void
+do_timeout (void *cls)
+{
+  tt = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+handle_intermediate_result (void *cls,
+                            struct GNUNET_ABD_Delegation *dd,
+                            bool is_bw)
+{
+  char *prefix = "";
+  if (is_bw)
+    prefix = "Backward -";
+  else
+    prefix = "Forward -";
+
+  printf ("%s Intermediate result: %s.%s <- %s.%s\n",
+          prefix,
+          GNUNET_CRYPTO_public_key_to_string (&dd->issuer_key),
+          dd->issuer_attribute,
+          GNUNET_CRYPTO_public_key_to_string (&dd->subject_key),
+          dd->subject_attribute);
+}
+
+
+static void
+handle_collect_result (void *cls,
+                       unsigned int d_count,
+                       struct GNUNET_ABD_Delegation *dc,
+                       unsigned int c_count,
+                       struct GNUNET_ABD_Delegate *dele)
+{
+  int i;
+  char *line;
+
+  verify_request = NULL;
+  if (NULL != dele)
+  {
+    for (i = 0; i < c_count; i++)
+    {
+      line = GNUNET_ABD_delegate_to_string (&dele[i]);
+      printf ("%s\n", line);
+      GNUNET_free (line);
+    }
+  }
+  else
+  {
+    printf ("Received NULL\n");
+  }
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+handle_verify_result (void *cls,
+                      unsigned int d_count,
+                      struct GNUNET_ABD_Delegation *dc,
+                      unsigned int c_count,
+                      struct GNUNET_ABD_Delegate *dele)
+{
+  int i;
+  char *iss_key;
+  char *sub_key;
+
+  verify_request = NULL;
+  if (NULL == dele)
+    ret = 1;
+  else
+  {
+    printf ("Delegation Chain:\n");
+    for (i = 0; i < d_count; i++)
+    {
+      iss_key = GNUNET_CRYPTO_public_key_to_string (&dc[i].issuer_key);
+      sub_key = GNUNET_CRYPTO_public_key_to_string (&dc[i].subject_key);
+
+      if (0 != dc[i].subject_attribute_len)
+      {
+        printf ("(%d) %s.%s <- %s.%s\n",
+                i,
+                iss_key,
+                dc[i].issuer_attribute,
+                sub_key,
+                dc[i].subject_attribute);
+      }
+      else
+      {
+        printf ("(%d) %s.%s <- %s\n",
+                i,
+                iss_key,
+                dc[i].issuer_attribute,
+                sub_key);
+      }
+      GNUNET_free (iss_key);
+      GNUNET_free (sub_key);
+    }
+    printf ("\nDelegate(s):\n");
+    for (i = 0; i < c_count; i++)
+    {
+      iss_key = GNUNET_CRYPTO_public_key_to_string (&dele[i].issuer_key);
+      sub_key = GNUNET_CRYPTO_public_key_to_string (&dele[i].subject_key);
+      printf ("%s.%s <- %s\n", iss_key, dele[i].issuer_attribute, sub_key);
+      GNUNET_free (iss_key);
+      GNUNET_free (sub_key);
+    }
+    printf ("Successful.\n");
+  }
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Callback invoked from identity service with ego information.
+ * An @a ego of NULL means the ego was not found.
+ *
+ * @param cls closure with the configuration
+ * @param ego an ego known to identity service, or NULL
+ */
+static void
+identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
+{
+  const struct GNUNET_CRYPTO_PrivateKey *privkey;
+
+  el = NULL;
+  if (NULL == ego)
+  {
+    if (NULL != ego_name)
+    {
+      fprintf (stderr,
+               _ ("Ego `%s' not known to identity service\n"),
+               ego_name);
+    }
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  if (GNUNET_YES == collect)
+  {
+
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_public_key_from_string (issuer_key,
+                                                    &issuer_pkey))
+    {
+      fprintf (stderr,
+               _ ("Issuer public key `%s' is not well-formed\n"),
+               issuer_key);
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    privkey = GNUNET_IDENTITY_ego_get_private_key (ego);
+
+    collect_request = GNUNET_ABD_collect (abd,
+                                          &issuer_pkey,
+                                          issuer_attr,
+                                          privkey,
+                                          direction,
+                                          &handle_collect_result,
+                                          NULL,
+                                          &handle_intermediate_result,
+                                          NULL);
+    return;
+  }
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Parse expiration time.
+ *
+ * @param expirationstring text to parse
+ * @param[out] etime_is_rel set to #GNUNET_YES if time is relative
+ * @param[out] etime set to expiration time (abs or rel)
+ * @return #GNUNET_OK on success
+ */
+static int
+parse_expiration (const char *expirationstring,
+                  int *etime_is_rel,
+                  uint64_t *etime)
+{
+  // copied from namestore/gnunet-namestore.c
+  struct GNUNET_TIME_Relative etime_rel;
+  struct GNUNET_TIME_Absolute etime_abs;
+
+  if (0 == strcmp (expirationstring, "never"))
+  {
+    *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
+    *etime_is_rel = GNUNET_NO;
+    return GNUNET_OK;
+  }
+  if (GNUNET_OK ==
+      GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
+  {
+    *etime_is_rel = GNUNET_YES;
+    *etime = etime_rel.rel_value_us;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Storing record with relative expiration time of %s\n",
+                GNUNET_STRINGS_relative_time_to_string (etime_rel, GNUNET_NO));
+    return GNUNET_OK;
+  }
+  if (GNUNET_OK ==
+      GNUNET_STRINGS_fancy_time_to_absolute (expirationstring, &etime_abs))
+  {
+    *etime_is_rel = GNUNET_NO;
+    *etime = etime_abs.abs_value_us;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Storing record with absolute expiration time of %s\n",
+                GNUNET_STRINGS_absolute_time_to_string (etime_abs));
+    return GNUNET_OK;
+  }
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Function called if lookup fails.
+ */
+static void
+error_cb (void *cls)
+{
+  fprintf (stderr, "Error occurred during lookup, shutting down.\n");
+  GNUNET_SCHEDULER_shutdown ();
+  return;
+}
+
+
+static void
+add_continuation (void *cls, int32_t success, const char *emsg)
+{
+  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
+  *qe = NULL;
+
+  if (GNUNET_OK == success)
+    printf ("Adding successful.\n");
+  else
+    fprintf (stderr, "Error occurred during adding, shutting down.\n");
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+get_existing_record (void *cls,
+                     const struct GNUNET_CRYPTO_PrivateKey *zone_key,
+                     const char *rec_name,
+                     unsigned int rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct GNUNET_GNSRECORD_Data *rde;
+  struct GNUNET_GNSRECORD_Data*rdn =
+    GNUNET_malloc (sizeof(*rdn) * (rd_count + 1));
+
+  memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
+  GNUNET_memcpy (&rdn[1], rd,
+                 rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
+  rde = &rdn[0];
+  rde->data = data;
+  rde->data_size = data_size;
+  rde->record_type = type;
+
+  // Set flags
+  if (GNUNET_YES == is_private)
+    rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE;
+  rde->expiration_time = etime;
+  if (GNUNET_YES == etime_is_rel)
+    rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+  else if (GNUNET_NO != etime_is_rel)
+    rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
+
+  GNUNET_assert (NULL != rec_name);
+  add_qe = GNUNET_NAMESTORE_records_store (ns,
+                                           &zone_pkey,
+                                           rec_name,
+                                           rd_count + 1,
+                                           rde,
+                                           &add_continuation,
+                                           &add_qe);
+  GNUNET_free (rdn);
+  return;
+}
+
+
+static void
+store_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
+{
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_ABD_Delegate *cred;
+  struct GNUNET_CRYPTO_PublicKey zone_pubkey;
+  char *subject_pubkey_str;
+  char *zone_pubkey_str;
+
+  el = NULL;
+
+  ns = GNUNET_NAMESTORE_connect (cfg);
+  if (NULL == ns)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to connect to namestore\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  if (NULL == ego)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Ego does not exist!\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  // Key handling
+  zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
+
+  if (GNUNET_GNSRECORD_TYPE_DELEGATE == type)
+  {
+    // Parse import
+    cred = GNUNET_ABD_delegate_from_string (import);
+
+    if (NULL == cred)
+    {
+      fprintf (stderr,
+               "%s is not a valid credential\n", import);
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+
+    // Get import subject public key string
+    subject_pubkey_str =
+      GNUNET_CRYPTO_public_key_to_string (&cred->subject_key);
+
+    // Get zone public key string
+    GNUNET_IDENTITY_ego_get_public_key (ego, &zone_pubkey);
+    zone_pubkey_str =
+      GNUNET_CRYPTO_public_key_to_string (&zone_pubkey);
+
+    // Check if the subject key in the signed import matches the zone's key it is issued to
+    if (strcmp (zone_pubkey_str, subject_pubkey_str) != 0)
+    {
+      fprintf (stderr,
+               "Import signed delegate does not match this ego's public key.\n");
+      GNUNET_free (cred);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    // Expiration
+    etime = cred->expiration.abs_value_us;
+    etime_is_rel = GNUNET_NO;
+
+    // Prepare the data to be store in the record
+    data_size = GNUNET_ABD_delegate_serialize (cred, (char **) &data);
+    GNUNET_free (cred);
+  }
+  else
+  {
+    // For all other types e.g. GNUNET_GNSRECORD_TYPE_ATTRIBUTE
+    if (GNUNET_OK !=
+        GNUNET_GNSRECORD_string_to_value (type, subject, &data, &data_size))
+    {
+      if (typestring == NULL)
+      {
+        fputs ("Value for unknown record type not well-formed.\n", stderr);
+      }
+      else if (subject == NULL)
+      {
+        fprintf (stderr,
+                 "Value for record type `%s' not well-formed.\n",
+                 typestring);
+      }
+      else
+      {
+        fprintf (stderr,
+                 "Value `%s' invalid for record type `%s'\n",
+                 subject,
+                 typestring);
+      }
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    // Take care of expiration
+    if (NULL == expiration)
+    {
+      fprintf (stderr, "Missing option -e for operation 'create'\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (GNUNET_OK != parse_expiration (expiration, &etime_is_rel, &etime))
+    {
+      fprintf (stderr, "Invalid time format `%s'\n", expiration);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+  }
+
+  // Start lookup
+  add_qe = GNUNET_NAMESTORE_records_lookup (ns,
+                                            &zone_pkey,
+                                            record_label,
+                                            &error_cb,
+                                            NULL,
+                                            &get_existing_record,
+                                            NULL);
+  return;
+}
+
+
+static void
+sign_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
+{
+  const struct GNUNET_CRYPTO_PrivateKey *privkey;
+  struct GNUNET_ABD_Delegate *dele;
+  struct GNUNET_TIME_Absolute etime_abs;
+  char *res;
+
+  el = NULL;
+
+  // work on expiration time
+  if (NULL == expiration)
+  {
+    fprintf (stderr, "Please specify a TTL\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  else if (GNUNET_OK !=
+           GNUNET_STRINGS_fancy_time_to_absolute (expiration, &etime_abs))
+  {
+    fprintf (stderr,
+             "%s is not a valid ttl! Only absolute times are accepted!\n",
+             expiration);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  // If contains a space - split it by the first space only - assume first entry is subject followed by attribute(s)
+  char *subject_pubkey_str;
+  char *subject_attr = NULL;
+  char *token;
+
+  // Subject Public Key
+  token = strtok (subject, " ");
+  subject_pubkey_str = token;
+  // Subject Attribute(s)
+  token = strtok (NULL, " ");
+  if (NULL != token)
+  {
+    subject_attr = token;
+  }
+
+  // work on keys
+  privkey = GNUNET_IDENTITY_ego_get_private_key (ego);
+
+  if (NULL == subject_pubkey_str)
+  {
+    fprintf (stderr,
+             "Subject pubkey not given\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_public_key_from_string (subject_pubkey_str,
+                                                  &subject_pkey))
+  {
+    fprintf (stderr,
+             "Subject public key `%s' is not well-formed\n",
+             subject_pubkey_str);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  // Sign delegate
+  dele = GNUNET_ABD_delegate_issue (privkey,
+                                    &subject_pkey,
+                                    issuer_attr,
+                                    subject_attr,
+                                    &etime_abs);
+  res = GNUNET_ABD_delegate_to_string (dele);
+  GNUNET_free (dele);
+  printf ("%s\n", res);
+
+  GNUNET_free (ego_name);
+  ego_name = NULL;
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Main function that will be run.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param c configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  cfg = c;
+
+  tt = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+
+  // Check relevant cmdline parameters
+  if (GNUNET_YES == create_is)
+  {
+    if (NULL == ego_name)
+    {
+      fprintf (stderr, "Missing option '-ego'\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (NULL == issuer_attr)
+    {
+      fprintf (stderr, "Missing option '-attribute' for issuer attribute\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (NULL == subject)
+    {
+      fprintf (stderr, "Missing option -subject for operation 'create'.'\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    // Lookup ego, on success call store_cb and store as ATTRIBUTE type
+    type = GNUNET_GNSRECORD_TYPE_ATTRIBUTE;
+    record_label = issuer_attr;
+    el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &store_cb, (void *) cfg);
+    return;
+  }
+
+  if (GNUNET_YES == create_ss)
+  {
+
+    // check if signed parameter has been passed in cmd line call
+    if (NULL == import)
+    {
+      fprintf (stderr, "'import' required\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    type = GNUNET_GNSRECORD_TYPE_DELEGATE;
+    record_label = GNUNET_GNS_EMPTY_LABEL_AT;
+    // Store subject side
+    el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &store_cb, (void *) cfg);
+
+    return;
+  }
+
+  if (GNUNET_YES == sign_ss)
+  {
+    if (NULL == ego_name)
+    {
+      fprintf (stderr, "ego required\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (NULL == subject)
+    {
+      fprintf (stderr, "Subject public key needed\n");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    // lookup ego and call function sign_cb on success
+    el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &sign_cb, (void *) cfg);
+    return;
+  }
+
+  if ((GNUNET_NO == forward) && (GNUNET_NO == backward))
+  {
+    // set default: bidirectional
+    forward = GNUNET_YES;
+    backward = GNUNET_YES;
+  }
+  if (GNUNET_YES == forward)
+    direction |= GNUNET_ABD_FLAG_FORWARD;
+  if (GNUNET_YES == backward)
+    direction |= GNUNET_ABD_FLAG_BACKWARD;
+
+  if (GNUNET_YES == collect)
+  {
+    if (NULL == issuer_key)
+    {
+      fprintf (stderr, _ ("Issuer public key not well-formed\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    abd = GNUNET_ABD_connect (cfg);
+
+    if (NULL == abd)
+    {
+      fprintf (stderr, _ ("Failed to connect to ABD\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (NULL == issuer_attr)
+    {
+      fprintf (stderr, _ ("You must provide issuer the attribute\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    if (NULL == ego_name)
+    {
+      fprintf (stderr, _ ("ego required\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
+    return;
+  }
+
+  if (NULL == subject)
+  {
+    fprintf (stderr, _ ("Subject public key needed\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (GNUNET_OK != GNUNET_CRYPTO_public_key_from_string (subject,
+                                                               &subject_pkey))
+  {
+    fprintf (stderr,
+             _ ("Subject public key `%s' is not well-formed\n"),
+             subject);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  if (GNUNET_YES == verify)
+  {
+    if (NULL == issuer_key)
+    {
+      fprintf (stderr, _ ("Issuer public key not well-formed\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_public_key_from_string (issuer_key,
+                                                    &issuer_pkey))
+    {
+      fprintf (stderr,
+               _ ("Issuer public key `%s' is not well-formed\n"),
+               issuer_key);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    abd = GNUNET_ABD_connect (cfg);
+
+    if (NULL == abd)
+    {
+      fprintf (stderr, _ ("Failed to connect to ABD\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    if ((NULL == issuer_attr) || (NULL == subject_delegate))
+    {
+      fprintf (stderr, _ ("You must provide issuer and subject attributes\n"));
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+
+    // Subject credentials are comma separated
+    char *tmp = GNUNET_strdup (subject_delegate);
+    char *tok = strtok (tmp, ",");
+    if (NULL == tok)
+    {
+      fprintf (stderr, "Invalid subject credentials\n");
+      GNUNET_free (tmp);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    int count = 1;
+    int i;
+    while (NULL != (tok = strtok (NULL, ",")))
+      count++;
+    struct GNUNET_ABD_Delegate*delegates =
+      GNUNET_malloc (sizeof(*delegates) * count);
+    struct GNUNET_ABD_Delegate *dele;
+    GNUNET_free (tmp);
+    tmp = GNUNET_strdup (subject_delegate);
+    tok = strtok (tmp, ",");
+    for (i = 0; i < count; i++)
+    {
+      dele = GNUNET_ABD_delegate_from_string (tok);
+      GNUNET_memcpy (&delegates[i],
+                     dele,
+                     sizeof (struct GNUNET_ABD_Delegate));
+      delegates[i].issuer_attribute = GNUNET_strdup (dele->issuer_attribute);
+      tok = strtok (NULL, ",");
+      GNUNET_free (dele);
+    }
+
+    verify_request = GNUNET_ABD_verify (abd,
+                                        &issuer_pkey,
+                                        issuer_attr,
+                                        &subject_pkey,
+                                        count,
+                                        delegates,
+                                        direction,
+                                        &handle_verify_result,
+                                        NULL,
+                                        &handle_intermediate_result,
+                                        NULL);
+    for (i = 0; i < count; i++)
+    {
+      GNUNET_free_nz ((char *) delegates[i].issuer_attribute);
+      delegates[i].issuer_attribute = NULL;
+    }
+    GNUNET_free (tmp);
+    GNUNET_free (delegates);
+  }
+  else
+  {
+    fprintf (stderr,
+             _ (
+               "Please specify name to lookup, subject key and issuer key!\n"));
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  return;
+}
+
+
+/**
+ * The main function for gnunet-gns.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+  {GNUNET_GETOPT_option_flag ('V',
+                              "verify",
+                              gettext_noop (
+                                "verify credential against attribute"),
+                              &verify),
+   GNUNET_GETOPT_option_string (
+     's',
+     "subject",
+     "PKEY",
+     gettext_noop (
+       "The public key of the subject to lookup the"
+       "credential for, or for issuer side storage: subject and its attributes"),
+     &subject),
+   GNUNET_GETOPT_option_string (
+     'd',
+     "delegate",
+     "DELE",
+     gettext_noop ("The private, signed delegate presented by the subject"),
+     &subject_delegate),
+   GNUNET_GETOPT_option_string (
+     'i',
+     "issuer",
+     "PKEY",
+     gettext_noop (
+       "The public key of the authority to verify the credential against"),
+     &issuer_key),
+   GNUNET_GETOPT_option_string ('e',
+                                "ego",
+                                "EGO",
+                                gettext_noop ("The ego/zone name to use"),
+                                &ego_name),
+   GNUNET_GETOPT_option_string (
+     'a',
+     "attribute",
+     "ATTR",
+     gettext_noop ("The issuer attribute to verify against or to issue"),
+     &issuer_attr),
+   GNUNET_GETOPT_option_string ('T',
+                                "ttl",
+                                "EXP",
+                                gettext_noop (
+                                  "The time to live for the credential."
+                                  "e.g. 5m, 6h, \"1990-12-30 12:00:00\""),
+                                &expiration),
+   GNUNET_GETOPT_option_flag ('g',
+                              "collect",
+                              gettext_noop ("collect credentials"),
+                              &collect),
+   GNUNET_GETOPT_option_flag ('U',
+                              "createIssuerSide",
+                              gettext_noop (
+                                "Create and issue a credential issuer side."),
+                              &create_is),
+   GNUNET_GETOPT_option_flag ('C',
+                              "createSubjectSide",
+                              gettext_noop (
+                                "Issue a credential subject side."),
+                              &create_ss),
+   GNUNET_GETOPT_option_flag (
+     'S',
+     "signSubjectSide",
+     gettext_noop ("Create, sign and return a credential subject side."),
+     &sign_ss),
+   GNUNET_GETOPT_option_string (
+     'x',
+     "import",
+     "IMP",
+     gettext_noop (
+       "Import signed credentials that should be issued to a zone/ego"),
+     &import),
+   GNUNET_GETOPT_option_flag ('P',
+                              "private",
+                              gettext_noop ("Create private record entry."),
+                              &is_private),
+   GNUNET_GETOPT_option_flag (
+     'F',
+     "forward",
+     gettext_noop (
+       "Indicates that the collect/verify process is done via forward search."),
+     &forward),
+   GNUNET_GETOPT_option_flag (
+     'B',
+     "backward",
+     gettext_noop (
+       "Indicates that the collect/verify process is done via forward search."),
+     &backward),
+   GNUNET_GETOPT_OPTION_END};
+
+
+  timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  GNUNET_log_setup ("gnunet-abd", "WARNING", NULL);
+  if (GNUNET_OK != GNUNET_PROGRAM_run (argc,
+                                       argv,
+                                       "gnunet-abd",
+                                       _ ("GNUnet abd resolver tool"),
+                                       options,
+                                       &run,
+                                       NULL))
+    ret = 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-abd.c */
diff --git a/src/contrib/service/abd/gnunet-service-abd.c b/src/contrib/service/abd/gnunet-service-abd.c
new file mode 100644
index 000000000..5cbc105f6
--- /dev/null
+++ b/src/contrib/service/abd/gnunet-service-abd.c
@@ -0,0 +1,1778 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2011-2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+*/
+/**
+ * @file abd/gnunet-service-abd.c
+ * @brief GNUnet Credential Service (main service)
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+
+#include "gnunet_util_lib.h"
+
+#include "abd.h"
+#include "abd_serialization.h"
+#include "gnunet_abd_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "gnunet_statistics_service.h"
+#include <gnunet_gns_service.h>
+#include <gnunet_gnsrecord_lib.h>
+#include <gnunet_identity_service.h>
+#include <gnunet_namestore_service.h>
+
+
+#define GNUNET_ABD_MAX_LENGTH 255
+
+struct VerifyRequestHandle;
+
+struct DelegationSetQueueEntry;
+
+
+struct DelegationChainEntry
+{
+  /**
+   * DLL
+   */
+  struct DelegationChainEntry *next;
+
+  /**
+   * DLL
+   */
+  struct DelegationChainEntry *prev;
+
+  /**
+   * The issuer
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * The subject
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * The issued attribute
+   */
+  char *issuer_attribute;
+
+  /**
+   * The delegated attribute
+   */
+  char *subject_attribute;
+};
+
+/**
+ * DLL for record
+ */
+struct DelegateRecordEntry
+{
+  /**
+   * DLL
+   */
+  struct DelegateRecordEntry *next;
+
+  /**
+   * DLL
+   */
+  struct DelegateRecordEntry *prev;
+
+  /**
+   * Number of references in delegation chains
+   */
+  uint32_t refcount;
+
+  /**
+   * Payload
+   */
+  struct GNUNET_ABD_Delegate *delegate;
+};
+
+/**
+ * DLL used for delegations
+ * Used for OR delegations
+ */
+struct DelegationQueueEntry
+{
+  /**
+   * DLL
+   */
+  struct DelegationQueueEntry *next;
+
+  /**
+   * DLL
+   */
+  struct DelegationQueueEntry *prev;
+
+  /**
+   * Parent set
+   */
+  struct DelegationSetQueueEntry *parent_set;
+
+  /**
+   * Required solutions
+   */
+  uint32_t required_solutions;
+};
+
+/**
+ * DLL for delegation sets
+ * Used for AND delegation set
+ */
+struct DelegationSetQueueEntry
+{
+  /**
+   * DLL
+   */
+  struct DelegationSetQueueEntry *next;
+
+  /**
+   * DLL
+   */
+  struct DelegationSetQueueEntry *prev;
+
+  /**
+   * GNS handle
+   */
+  struct GNUNET_GNS_LookupRequest *lookup_request;
+
+  /**
+   * Verify handle
+   */
+  struct VerifyRequestHandle *handle;
+
+  /**
+   * Parent attribute delegation
+   */
+  struct DelegationQueueEntry *parent;
+
+  /**
+   * Issuer key
+   */
+  struct GNUNET_CRYPTO_PublicKey *issuer_key;
+
+  /**
+   * Queue entries of this set
+   */
+  struct DelegationQueueEntry *queue_entries_head;
+
+  /**
+   * Queue entries of this set
+   */
+  struct DelegationQueueEntry *queue_entries_tail;
+
+  /**
+   * Parent QueueEntry
+   */
+  struct DelegationQueueEntry *parent_queue_entry;
+
+  /**
+   * Issuer attribute delegated to
+   */
+  char *issuer_attribute;
+
+  /**
+   * The current attribute to look up
+   */
+  char *lookup_attribute;
+
+  /**
+   * Trailing attribute context
+   */
+  char *attr_trailer;
+
+  /**
+   * Still to resolve delegation as string
+   */
+  char *unresolved_attribute_delegation;
+
+  /**
+   * The delegation chain entry
+   */
+  struct DelegationChainEntry *delegation_chain_entry;
+
+  /**
+   * True if added by backward resolution
+   */
+  bool from_bw;
+};
+
+
+/**
+ * Handle to a lookup operation from api
+ */
+struct VerifyRequestHandle
+{
+  /**
+   * True if created by a collect request.
+   */
+  bool is_collect;
+  /**
+   * We keep these in a DLL.
+   */
+  struct VerifyRequestHandle *next;
+
+  /**
+   * We keep these in a DLL.
+   */
+  struct VerifyRequestHandle *prev;
+
+  /**
+   * Handle to the requesting client
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Size of delegation tree
+   */
+  uint32_t delegation_chain_size;
+
+  /**
+   * Children of this attribute
+   */
+  struct DelegationChainEntry *delegation_chain_head;
+
+  /**
+   * Children of this attribute
+   */
+  struct DelegationChainEntry *delegation_chain_tail;
+
+  /**
+   * List for bidirectional matching
+   */
+  struct DelegationSetQueueEntry *dsq_head;
+
+  /**
+   * List for bidirectional matching
+   */
+  struct DelegationSetQueueEntry *dsq_tail;
+
+  /**
+   * Issuer public key
+   */
+  struct GNUNET_CRYPTO_PublicKey issuer_key;
+
+  /**
+   * Issuer attribute
+   */
+  char *issuer_attribute;
+
+  /**
+   * Subject public key
+   */
+  struct GNUNET_CRYPTO_PublicKey subject_key;
+
+  /**
+   * Delegate DLL
+   */
+  struct DelegateRecordEntry *del_chain_head;
+
+  /**
+   * Delegate DLL
+   */
+  struct DelegateRecordEntry *del_chain_tail;
+
+  /**
+   * Delegate DLL size
+   */
+  uint32_t del_chain_size;
+
+  /**
+   * Current Delegation Pointer
+   */
+  struct DelegationQueueEntry *current_delegation;
+
+  /**
+   * request id
+   */
+  uint32_t request_id;
+
+  /**
+   * Pending lookups
+   */
+  uint64_t pending_lookups;
+
+  /**
+   * Direction of the resolution algo
+   */
+  enum GNUNET_ABD_AlgoDirectionFlags resolution_algo;
+
+  /**
+   * Delegate iterator for lookup
+   */
+  struct GNUNET_NAMESTORE_QueueEntry *dele_qe;
+};
+
+
+/**
+ * Head of the DLL.
+ */
+static struct VerifyRequestHandle *vrh_head = NULL;
+
+/**
+ * Tail of the DLL.
+ */
+static struct VerifyRequestHandle *vrh_tail = NULL;
+
+/**
+ * Handle to the statistics service
+ */
+static struct GNUNET_STATISTICS_Handle *statistics;
+
+/**
+ * Handle to GNS service.
+ */
+static struct GNUNET_GNS_Handle *gns;
+
+/**
+ * Handle to namestore service
+ */
+static struct GNUNET_NAMESTORE_Handle *namestore;
+
+static void
+print_deleset (struct DelegationSetQueueEntry *dsentry, char *text)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%s %s.%s <- %s.%s\n",
+              text,
+              GNUNET_CRYPTO_public_key_to_string (
+                &dsentry->delegation_chain_entry->issuer_key),
+              dsentry->delegation_chain_entry->issuer_attribute,
+              GNUNET_CRYPTO_public_key_to_string (
+                &dsentry->delegation_chain_entry->subject_key),
+              dsentry->delegation_chain_entry->subject_attribute);
+}
+
+
+static void
+cleanup_dsq_entry (struct DelegationSetQueueEntry *ds_entry)
+{
+  GNUNET_free (ds_entry->issuer_key);
+  GNUNET_free (ds_entry->issuer_attribute);
+  GNUNET_free (ds_entry->attr_trailer);
+  // those fields are only set/used in bw search
+  if (ds_entry->from_bw)
+  {
+    GNUNET_free (ds_entry->lookup_attribute);
+    GNUNET_free (ds_entry->unresolved_attribute_delegation);
+  }
+  if (NULL != ds_entry->lookup_request)
+  {
+    GNUNET_GNS_lookup_cancel (ds_entry->lookup_request);
+    ds_entry->lookup_request = NULL;
+  }
+  if (NULL != ds_entry->delegation_chain_entry)
+  {
+    GNUNET_free (
+      ds_entry->delegation_chain_entry->subject_attribute);
+    GNUNET_free (ds_entry->delegation_chain_entry->issuer_attribute);
+    GNUNET_free (ds_entry->delegation_chain_entry);
+  }
+  // Free DQ entries
+  for (struct DelegationQueueEntry *dq_entry = ds_entry->queue_entries_head;
+       NULL != ds_entry->queue_entries_head;
+       dq_entry = ds_entry->queue_entries_head)
+  {
+    GNUNET_CONTAINER_DLL_remove (ds_entry->queue_entries_head,
+                                 ds_entry->queue_entries_tail,
+                                 dq_entry);
+    GNUNET_free (dq_entry);
+  }
+  GNUNET_free (ds_entry);
+}
+
+
+static void
+cleanup_handle (struct VerifyRequestHandle *vrh)
+{
+  struct DelegateRecordEntry *del_entry;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up...\n");
+
+  if (NULL != vrh->dsq_head)
+  {
+    for (struct DelegationSetQueueEntry *ds_entry = vrh->dsq_head; NULL !=
+         vrh->dsq_head;
+         ds_entry = vrh->dsq_head)
+    {
+      GNUNET_CONTAINER_DLL_remove (vrh->dsq_head, vrh->dsq_tail, ds_entry);
+      cleanup_dsq_entry (ds_entry);
+    }
+  }
+  if (NULL != vrh->del_chain_head)
+  {
+    for (del_entry = vrh->del_chain_head; NULL != vrh->del_chain_head;
+         del_entry = vrh->del_chain_head)
+    {
+      GNUNET_CONTAINER_DLL_remove (vrh->del_chain_head,
+                                   vrh->del_chain_tail,
+                                   del_entry);
+      GNUNET_free (del_entry->delegate);
+      GNUNET_free (del_entry);
+    }
+  }
+  GNUNET_free (vrh->issuer_attribute);
+  GNUNET_free (vrh);
+}
+
+
+static void
+shutdown_task (void *cls)
+{
+  struct VerifyRequestHandle *vrh;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down!\n");
+
+  while (NULL != (vrh = vrh_head))
+  {
+    // ABD_resolver_lookup_cancel (clh->lookup);
+    GNUNET_CONTAINER_DLL_remove (vrh_head, vrh_tail, vrh);
+    cleanup_handle (vrh);
+  }
+
+  if (NULL != gns)
+  {
+    GNUNET_GNS_disconnect (gns);
+    gns = NULL;
+  }
+  if (NULL != namestore)
+  {
+    GNUNET_NAMESTORE_disconnect (namestore);
+    namestore = NULL;
+  }
+  if (NULL != statistics)
+  {
+    GNUNET_STATISTICS_destroy (statistics, GNUNET_NO);
+    statistics = NULL;
+  }
+}
+
+
+static void
+send_intermediate_response (struct VerifyRequestHandle *vrh, struct
+                            DelegationChainEntry *ch_entry, bool is_bw)
+{
+  struct DelegationChainIntermediateMessage *rmsg;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_ABD_Delegation *dd;
+  size_t size;
+
+  // Don't report immediate results during collect
+  if (vrh->is_collect)
+    return;
+
+  dd = GNUNET_new (struct GNUNET_ABD_Delegation);
+  dd->issuer_key = ch_entry->issuer_key;
+  dd->subject_key = ch_entry->subject_key;
+  dd->issuer_attribute = ch_entry->issuer_attribute;
+  dd->issuer_attribute_len = strlen (ch_entry->issuer_attribute) + 1;
+  dd->subject_attribute_len = 0;
+  dd->subject_attribute = NULL;
+  if (NULL != ch_entry->subject_attribute)
+  {
+    dd->subject_attribute = ch_entry->subject_attribute;
+    dd->subject_attribute_len = strlen (ch_entry->subject_attribute) + 1;
+  }
+
+
+  size = GNUNET_ABD_delegation_chain_get_size (1,
+                                               dd,
+                                               0,
+                                               NULL);
+
+  env = GNUNET_MQ_msg_extra (rmsg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT);
+  // Assign id so that client can find associated request
+  rmsg->id = vrh->request_id;
+  rmsg->is_bw = htons (is_bw);
+  rmsg->size = htonl (size);
+
+  GNUNET_assert (
+    -1 != GNUNET_ABD_delegation_chain_serialize (1,
+                                                 dd,
+                                                 0,
+                                                 NULL,
+                                                 size,
+                                                 (char *) &rmsg[1]));
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (vrh->client), env);
+
+  GNUNET_free (dd);
+}
+
+
+static void
+send_lookup_response (struct VerifyRequestHandle *vrh)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct DelegationChainResultMessage *rmsg;
+  struct DelegationChainEntry *dce;
+  struct GNUNET_ABD_Delegation dd[vrh->delegation_chain_size];
+  struct GNUNET_ABD_Delegate dele[vrh->del_chain_size];
+  struct DelegateRecordEntry *del;
+  struct DelegateRecordEntry *tmp;
+  size_t size;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending response\n");
+  dce = vrh->delegation_chain_head;
+  for (uint32_t i = 0; i < vrh->delegation_chain_size; i++)
+  {
+    dd[i].issuer_key = dce->issuer_key;
+    dd[i].subject_key = dce->subject_key;
+    dd[i].issuer_attribute = dce->issuer_attribute;
+    dd[i].issuer_attribute_len = strlen (dce->issuer_attribute) + 1;
+    dd[i].subject_attribute_len = 0;
+    dd[i].subject_attribute = NULL;
+    if (NULL != dce->subject_attribute)
+    {
+      dd[i].subject_attribute = dce->subject_attribute;
+      dd[i].subject_attribute_len = strlen (dce->subject_attribute) + 1;
+    }
+    dce = dce->next;
+  }
+
+  // Remove all not needed credentials
+  for (del = vrh->del_chain_head; NULL != del;)
+  {
+    if (del->refcount > 0)
+    {
+      del = del->next;
+      continue;
+    }
+    tmp = del;
+    del = del->next;
+    GNUNET_CONTAINER_DLL_remove (vrh->del_chain_head, vrh->del_chain_tail, tmp);
+    GNUNET_free (tmp->delegate);
+    GNUNET_free (tmp);
+    vrh->del_chain_size--;
+  }
+
+  // Get serialized record data
+  // Append at the end of rmsg
+  del = vrh->del_chain_head;
+  for (uint32_t i = 0; i < vrh->del_chain_size; i++)
+  {
+    dele[i].issuer_key = del->delegate->issuer_key;
+    dele[i].subject_key = del->delegate->subject_key;
+    dele[i].issuer_attribute_len = strlen (del->delegate->issuer_attribute) + 1;
+    dele[i].issuer_attribute = del->delegate->issuer_attribute;
+    dele[i].subject_attribute_len = del->delegate->subject_attribute_len;
+    dele[i].subject_attribute = del->delegate->subject_attribute;
+    dele[i].expiration = del->delegate->expiration;
+    dele[i].signature = del->delegate->signature;
+    del = del->next;
+  }
+  size =
+    GNUNET_ABD_delegation_chain_get_size (vrh->delegation_chain_size,
+                                          dd,
+                                          vrh->del_chain_size,
+                                          dele);
+  env = GNUNET_MQ_msg_extra (rmsg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT);
+  // Assign id so that client can find associated request
+  rmsg->id = vrh->request_id;
+  rmsg->d_count = htonl (vrh->delegation_chain_size);
+  rmsg->c_count = htonl (vrh->del_chain_size);
+
+  if (0 < vrh->del_chain_size)
+    rmsg->del_found = htonl (GNUNET_YES);
+  else
+    rmsg->del_found = htonl (GNUNET_NO);
+
+  GNUNET_assert (
+    -1 !=
+    GNUNET_ABD_delegation_chain_serialize (vrh->delegation_chain_size,
+                                           dd,
+                                           vrh->del_chain_size,
+                                           dele,
+                                           size,
+                                           (char *) &rmsg[1]));
+
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (vrh->client), env);
+  GNUNET_CONTAINER_DLL_remove (vrh_head, vrh_tail, vrh);
+  cleanup_handle (vrh);
+  GNUNET_STATISTICS_update (statistics,
+                            "Completed verifications",
+                            1,
+                            GNUNET_NO);
+}
+
+
+static char *
+partial_match (char *tmp_trail,
+               char *tmp_subattr,
+               char *parent_trail,
+               char *issuer_attribute)
+{
+  char *saveptr1, *saveptr2;
+  char *trail_token;
+  char *sub_token;
+  char *attr_trailer;
+
+  // tok both, parent->attr_trailer and del->sub_attr to see how far they match,
+  // take rest of parent trailer (only when del->sub_attr token is null), and
+  // create new/actual trailer with del->iss_attr
+  trail_token = strtok_r (tmp_trail, ".", &saveptr1);
+  sub_token = strtok_r (tmp_subattr, ".", &saveptr2);
+  while (NULL != trail_token && NULL != sub_token)
+  {
+    if (0 == strcmp (trail_token, sub_token))
+    {
+      // good, matches, remove
+    }
+    else
+    {
+      // not relevant for solving the chain, end for iteration here
+      return NULL;
+    }
+
+    trail_token = strtok_r (NULL, ".", &saveptr1);
+    sub_token = strtok_r (NULL, ".", &saveptr2);
+  }
+  // skip this entry and go to next for if:
+  // 1. at some point the attr of the trailer and the subject dont match
+  // 2. the trailer is NULL, but the subject has more attributes
+  // Reason: This will lead to "startzone.attribute" but we're looking for a solution
+  // for "<- startzone"
+  if (NULL == trail_token)
+  {
+    return NULL;
+  }
+
+  // do not have to check sub_token == NULL, if both would be NULL
+  // at the same time, the complete match part above should have triggered already
+
+  // otherwise, above while only ends when sub_token == NULL
+  GNUNET_asprintf (&attr_trailer, "%s", trail_token);
+  trail_token = strtok_r (NULL, ".", &saveptr1);
+  while (NULL != trail_token)
+  {
+    GNUNET_asprintf (&attr_trailer, "%s.%s", parent_trail, trail_token);
+    trail_token = strtok_r (NULL, ".", &saveptr1);
+  }
+  GNUNET_asprintf (&attr_trailer, "%s.%s", issuer_attribute, attr_trailer);
+  return attr_trailer;
+}
+
+
+static int
+handle_bidirectional_match (struct DelegationSetQueueEntry *actual_entry,
+                            struct DelegationSetQueueEntry *match_entry,
+                            struct VerifyRequestHandle *vrh)
+{
+  struct DelegationSetQueueEntry *old_fw_parent;
+  struct DelegationSetQueueEntry *fw_entry = actual_entry;
+  struct DelegationSetQueueEntry *last_entry = match_entry;
+  // parent fixing, combine backward and forward chain parts
+  while (NULL != fw_entry->parent_queue_entry)
+  {
+    old_fw_parent = fw_entry->parent_queue_entry->parent_set;
+    // set parent
+    fw_entry->parent_queue_entry->parent_set = last_entry;
+
+    last_entry = fw_entry;
+    fw_entry = old_fw_parent;
+  }
+  // set last entry of chain as actual_entry
+  // actual_entry = last_entry;
+  // set refcount, loop all delegations
+  for (struct DelegateRecordEntry *del_entry = vrh->del_chain_head;
+       del_entry != NULL;
+       del_entry = del_entry->next)
+  {
+    if (0 != memcmp (&last_entry->delegation_chain_entry->subject_key,
+                     &del_entry->delegate->issuer_key,
+                     sizeof (struct GNUNET_CRYPTO_PublicKey)))
+      continue;
+    if (0 != strcmp (last_entry->delegation_chain_entry->subject_attribute,
+                     del_entry->delegate->issuer_attribute))
+      continue;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found delegate.\n");
+    // increase refcount of the start delegation
+    del_entry->refcount++;
+  }
+  // backtrack
+  for (struct DelegationSetQueueEntry *tmp_set = last_entry;
+       NULL != tmp_set->parent_queue_entry;
+       tmp_set = tmp_set->parent_queue_entry->parent_set)
+  {
+    tmp_set->parent_queue_entry->required_solutions--;
+
+    // add new found entry to vrh
+    vrh->delegation_chain_size++;
+    GNUNET_CONTAINER_DLL_insert (vrh->delegation_chain_head,
+                                 vrh->delegation_chain_tail,
+                                 tmp_set->delegation_chain_entry);
+
+    // if one node on the path still needs solutions, this current
+    // patch cannot fulfill the conditions and therefore stops here
+    // however, it is in the vrh and can be used by the other paths
+    // related to this path/collection/verification
+    if (0 < tmp_set->parent_queue_entry->required_solutions)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Chain requires more solutions, waiting...\n");
+      return GNUNET_NO;
+    }
+  }
+  return GNUNET_YES;
+}
+
+
+static void
+forward_resolution (void *cls,
+                    uint32_t rd_count,
+                    const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct VerifyRequestHandle *vrh;
+  struct DelegationSetQueueEntry *current_set;
+  struct DelegationSetQueueEntry *ds_entry;
+  struct DelegationQueueEntry *dq_entry;
+  struct GNUNET_ABD_Delegate *del;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %d entries.\n", rd_count);
+
+  current_set = cls;
+  // set handle to NULL (as el = NULL)
+  current_set->lookup_request = NULL;
+  vrh = current_set->handle;
+  vrh->pending_lookups--;
+
+  // Loop record entries
+  for (uint32_t i = 0; i < rd_count; i++)
+  {
+    if (GNUNET_GNSRECORD_TYPE_DELEGATE != rd[i].record_type)
+      continue;
+
+    // Start deserialize into Delegate
+    del = GNUNET_ABD_delegate_deserialize (rd[i].data, rd[i].data_size);
+
+    if (NULL == del)
+      continue;
+
+    // Start: Create DQ Entry
+    dq_entry = GNUNET_new (struct DelegationQueueEntry);
+    // AND delegations are not possible, only 1 solution
+    dq_entry->required_solutions = 1;
+    dq_entry->parent_set = current_set;
+
+    // Insert it into the current set
+    GNUNET_CONTAINER_DLL_insert (current_set->queue_entries_head,
+                                 current_set->queue_entries_tail,
+                                 dq_entry);
+
+    // Start: Create DS Entry
+    ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
+    GNUNET_CONTAINER_DLL_insert (vrh->dsq_head, vrh->dsq_tail, ds_entry);
+    ds_entry->from_bw = false;
+
+    // (1) A.a <- A.b.c
+    // (2) A.b <- D.d
+    // (3) D.d <- E
+    // (4) E.c <- F.c
+    // (5) F.c <- G
+    // Possibilities:
+    // 1. complete match: trailer = 0, validate
+    // 2. partial match: replace
+    // 3. new solution: replace, add trailer
+
+    // At resolution chain start trailer of parent is NULL
+    if (NULL == current_set->attr_trailer)
+    {
+      // for (5) F.c <- G, remember .c when going upwards
+      ds_entry->attr_trailer = GNUNET_strdup (del->issuer_attribute);
+    }
+    else
+    {
+      if (0 == del->subject_attribute_len)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found: New solution\n");
+        // new solution
+        // create new trailer del->issuer_attribute, ds_entry->attr_trailer
+        GNUNET_asprintf (&ds_entry->attr_trailer,
+                         "%s.%s",
+                         del->issuer_attribute,
+                         current_set->attr_trailer);
+      }
+      else if (0 == strcmp (del->subject_attribute, current_set->attr_trailer))
+      {
+        // complete match
+        // new trailer == issuer attribute (e.g. (5) to (4))
+        ds_entry->attr_trailer = GNUNET_strdup (del->issuer_attribute);
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found: Partial match\n");
+        // partial match
+
+        char *trail = partial_match (GNUNET_strdup (current_set->attr_trailer),
+                                     GNUNET_strdup (del->subject_attribute),
+                                     current_set->attr_trailer,
+                                     GNUNET_strdup (del->issuer_attribute));
+
+        // if null: skip this record entry (reasons: mismatch or overmatch, both not relevant)
+        if (NULL == trail)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Entry not relevant, discarding: %s.%s <- %s.%s\n",
+                      GNUNET_CRYPTO_public_key_to_string (
+                        &del->issuer_key),
+                      del->issuer_attribute,
+                      GNUNET_CRYPTO_public_key_to_string (
+                        &del->subject_key),
+                      del->subject_attribute);
+          GNUNET_free (del);
+          continue;
+        }
+        else
+          ds_entry->attr_trailer = trail;
+      }
+    }
+
+
+    // Start: Credential Chain Entry
+    // issuer key is subject key, who needs to be contacted to resolve this (forward, therefore subject)
+    ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+    GNUNET_memcpy (ds_entry->issuer_key,
+                   &del->subject_key,
+                   sizeof (struct GNUNET_CRYPTO_PublicKey));
+
+    ds_entry->delegation_chain_entry = GNUNET_new (struct DelegationChainEntry);
+    ds_entry->delegation_chain_entry->subject_key = del->subject_key;
+    if (0 < del->subject_attribute_len)
+      ds_entry->delegation_chain_entry->subject_attribute =
+        GNUNET_strdup (del->subject_attribute);
+    ds_entry->delegation_chain_entry->issuer_key = del->issuer_key;
+    ds_entry->delegation_chain_entry->issuer_attribute =
+      GNUNET_strdup (del->issuer_attribute);
+
+    // Found new entry, repoting intermediate result
+    send_intermediate_response (vrh, ds_entry->delegation_chain_entry, false);
+
+    // current delegation as parent
+    ds_entry->parent_queue_entry = dq_entry;
+
+    // Check for solution
+    // if: issuer key we looking for
+    if (0 == memcmp (&del->issuer_key,
+                     &vrh->issuer_key,
+                     sizeof (struct GNUNET_CRYPTO_PublicKey)))
+    {
+      // if: issuer attr we looking for
+      if (0 == strcmp (del->issuer_attribute, vrh->issuer_attribute))
+      {
+        // if: complete match, meaning new trailer == issuer attr
+        if (0 == strcmp (vrh->issuer_attribute, ds_entry->attr_trailer))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found: Solution\n");
+
+          // Add found solution into delegation_chain
+          struct DelegationSetQueueEntry *tmp_set;
+          for (tmp_set = ds_entry; NULL != tmp_set->parent_queue_entry;
+               tmp_set = tmp_set->parent_queue_entry->parent_set)
+          {
+            if (NULL != tmp_set->delegation_chain_entry)
+            {
+              vrh->delegation_chain_size++;
+              GNUNET_CONTAINER_DLL_insert (vrh->delegation_chain_head,
+                                           vrh->delegation_chain_tail,
+                                           tmp_set->delegation_chain_entry);
+            }
+          }
+
+          // Increase refcount for this delegate
+          for (struct DelegateRecordEntry *del_entry = vrh->del_chain_head;
+               del_entry != NULL;
+               del_entry = del_entry->next)
+          {
+            if (0 == memcmp (&del_entry->delegate->issuer_key,
+                             &vrh->delegation_chain_head->subject_key,
+                             sizeof (struct GNUNET_CRYPTO_PublicKey)))
+            {
+              if (0 == strcmp (del_entry->delegate->issuer_attribute,
+                               vrh->delegation_chain_head->subject_attribute))
+              {
+                del_entry->refcount++;
+              }
+            }
+          }
+
+          send_lookup_response (vrh);
+          GNUNET_free (del);
+          return;
+        }
+      }
+    }
+
+    // Check for bidirectional crossmatch
+    for (struct DelegationSetQueueEntry *del_entry = vrh->dsq_head;
+         del_entry != NULL;
+         del_entry = del_entry->next)
+    {
+      // only check entries not by backward algorithm
+      if (del_entry->from_bw)
+      {
+        // key of list entry matches actual key
+        if (0 == memcmp (&del_entry->delegation_chain_entry->subject_key,
+                         &ds_entry->delegation_chain_entry->issuer_key,
+                         sizeof (struct GNUNET_CRYPTO_PublicKey)))
+        {
+          // compare entry subject attributes to this trailer (iss attr + old trailer)
+          if (0 == strcmp (del_entry->unresolved_attribute_delegation,
+                           ds_entry->attr_trailer))
+          {
+            print_deleset (del_entry, "Forward:");
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Forward: Found match with above!\n");
+
+            GNUNET_free (del);
+            // one node on the path still needs solutions: return
+            if (GNUNET_NO ==
+                handle_bidirectional_match (ds_entry, del_entry, vrh))
+              return;
+
+            send_lookup_response (vrh);
+            return;
+          }
+        }
+      }
+    }
+
+    // Starting a new GNS lookup
+    vrh->pending_lookups++;
+    ds_entry->handle = vrh;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting to look up trailer %s in zone %s\n",
+                ds_entry->attr_trailer,
+                GNUNET_CRYPTO_public_key_to_string (&del->issuer_key));
+
+    ds_entry->lookup_request =
+      GNUNET_GNS_lookup (gns,
+                         GNUNET_GNS_EMPTY_LABEL_AT,
+                         &del->issuer_key,
+                         GNUNET_GNSRECORD_TYPE_DELEGATE,
+                         GNUNET_GNS_LO_DEFAULT,
+                         &forward_resolution,
+                         ds_entry);
+    GNUNET_free (del);
+  }
+
+  if (0 == vrh->pending_lookups)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "We are all out of attributes...\n");
+    send_lookup_response (vrh);
+    return;
+  }
+}
+
+
+static void
+backward_resolution (void *cls,
+                     uint32_t rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct VerifyRequestHandle *vrh;
+  const struct GNUNET_ABD_DelegationRecord *sets;
+  struct DelegateRecordEntry *del_pointer;
+  struct DelegationSetQueueEntry *current_set;
+  struct DelegationSetQueueEntry *ds_entry;
+  struct DelegationSetQueueEntry *tmp_set;
+  struct DelegationQueueEntry *dq_entry;
+  char *expanded_attr;
+  char *lookup_attribute;
+
+  current_set = cls;
+  current_set->lookup_request = NULL;
+  vrh = current_set->handle;
+  vrh->pending_lookups--;
+
+  // Each OR
+  for (uint32_t i = 0; i < rd_count; i++)
+  {
+    if (GNUNET_GNSRECORD_TYPE_ATTRIBUTE != rd[i].record_type)
+      continue;
+
+    sets = rd[i].data;
+    struct GNUNET_ABD_DelegationSet set[ntohl (sets->set_count)];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found new attribute delegation with %d sets. Creating new Job...\n",
+                ntohl (sets->set_count));
+
+    if (GNUNET_OK !=
+        GNUNET_ABD_delegation_set_deserialize (GNUNET_ntohll (
+                                                 sets->data_size),
+                                               (const char *) &sets[1],
+                                               ntohl (sets->set_count),
+                                               set))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to deserialize!\n");
+      continue;
+    }
+    dq_entry = GNUNET_new (struct DelegationQueueEntry);
+    dq_entry->required_solutions = ntohl (sets->set_count);
+    dq_entry->parent_set = current_set;
+
+    GNUNET_CONTAINER_DLL_insert (current_set->queue_entries_head,
+                                 current_set->queue_entries_tail,
+                                 dq_entry);
+    // Each AND
+    for (uint32_t j = 0; j < ntohl (sets->set_count); j++)
+    {
+      ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
+      GNUNET_CONTAINER_DLL_insert (vrh->dsq_head, vrh->dsq_tail, ds_entry);
+      ds_entry->from_bw = true;
+
+      if (NULL != current_set->attr_trailer)
+      {
+        if (0 == set[j].subject_attribute_len)
+        {
+          GNUNET_asprintf (&expanded_attr, "%s", current_set->attr_trailer);
+        }
+        else
+        {
+          GNUNET_asprintf (&expanded_attr,
+                           "%s.%s",
+                           set[j].subject_attribute,
+                           current_set->attr_trailer);
+        }
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Expanded to %s\n", expanded_attr);
+        ds_entry->unresolved_attribute_delegation = expanded_attr;
+      }
+      else
+      {
+        if (0 != set[j].subject_attribute_len)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Not Expanding %s\n",
+                      set[j].subject_attribute);
+          ds_entry->unresolved_attribute_delegation =
+            GNUNET_strdup (set[j].subject_attribute);
+        }
+      }
+
+      // Add a credential chain entry
+      ds_entry->delegation_chain_entry =
+        GNUNET_new (struct DelegationChainEntry);
+      ds_entry->delegation_chain_entry->subject_key = set[j].subject_key;
+      ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+      GNUNET_memcpy (ds_entry->issuer_key,
+                     &set[j].subject_key,
+                     sizeof (struct GNUNET_CRYPTO_PublicKey));
+      if (0 < set[j].subject_attribute_len)
+        ds_entry->delegation_chain_entry->subject_attribute =
+          GNUNET_strdup (set[j].subject_attribute);
+      ds_entry->delegation_chain_entry->issuer_key = *current_set->issuer_key;
+      ds_entry->delegation_chain_entry->issuer_attribute =
+        GNUNET_strdup (current_set->lookup_attribute);
+
+      // Found new entry, repoting intermediate result
+      send_intermediate_response (vrh, ds_entry->delegation_chain_entry, true);
+
+      ds_entry->parent_queue_entry = dq_entry; // current_delegation;
+
+      /**
+       * Check if this delegation already matches one of our credentials
+       */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking for cred match\n");
+
+      for (del_pointer = vrh->del_chain_head; del_pointer != NULL;
+           del_pointer = del_pointer->next)
+      {
+        // If key and attribute match credential: continue and backtrack
+        if (0 != memcmp (&set[j].subject_key,
+                         &del_pointer->delegate->issuer_key,
+                         sizeof (struct GNUNET_CRYPTO_PublicKey)))
+          continue;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Checking if %s matches %s\n",
+                    ds_entry->unresolved_attribute_delegation,
+                    del_pointer->delegate->issuer_attribute);
+
+        if (0 != strcmp (ds_entry->unresolved_attribute_delegation,
+                         del_pointer->delegate->issuer_attribute))
+          continue;
+
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found issuer\n");
+        // increase refcount of the start delegation
+        del_pointer->refcount++;
+
+        // Backtrack
+        for (tmp_set = ds_entry; NULL != tmp_set->parent_queue_entry;
+             tmp_set = tmp_set->parent_queue_entry->parent_set)
+        {
+          tmp_set->parent_queue_entry->required_solutions--;
+          if (NULL != tmp_set->delegation_chain_entry)
+          {
+            vrh->delegation_chain_size++;
+            GNUNET_CONTAINER_DLL_insert (vrh->delegation_chain_head,
+                                         vrh->delegation_chain_tail,
+                                         tmp_set->delegation_chain_entry);
+          }
+          if (0 < tmp_set->parent_queue_entry->required_solutions)
+            break;
+        }
+
+        // if the break above is not called the condition of the for is met
+        if (NULL == tmp_set->parent_queue_entry)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All solutions found\n");
+          // Found match
+          send_lookup_response (vrh);
+          return;
+        }
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not all solutions found yet.\n");
+        continue;
+      }
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Building new lookup request from %s\n",
+                  ds_entry->unresolved_attribute_delegation);
+      // Continue with next/new backward resolution
+      char issuer_attribute_name[strlen (
+                                   ds_entry->unresolved_attribute_delegation)
+                                 + 1];
+      strcpy (issuer_attribute_name, ds_entry->unresolved_attribute_delegation);
+      char *next_attr = strtok (issuer_attribute_name, ".");
+      if (NULL == next_attr)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to parse next attribute\n");
+        continue;
+      }
+      GNUNET_asprintf (&lookup_attribute, "%s", next_attr);
+      GNUNET_asprintf (&ds_entry->lookup_attribute, "%s", next_attr);
+      if (strlen (next_attr) ==
+          strlen (ds_entry->unresolved_attribute_delegation))
+      {
+        ds_entry->attr_trailer = NULL;
+      }
+      else
+      {
+        next_attr += strlen (next_attr) + 1;
+        ds_entry->attr_trailer = GNUNET_strdup (next_attr);
+      }
+
+      // Check for bidirectional crossmatch
+      for (struct DelegationSetQueueEntry *del_entry = vrh->dsq_head;
+           del_entry != NULL;
+           del_entry = del_entry->next)
+      {
+        // only check entries added by forward algorithm
+        if (! del_entry->from_bw)
+        {
+          // key of list entry matches actual key
+          if (0 == memcmp (&del_entry->delegation_chain_entry->issuer_key,
+                           &ds_entry->delegation_chain_entry->subject_key,
+                           sizeof (struct GNUNET_CRYPTO_PublicKey)))
+          {
+            // compare entry subject attributes to this trailer (iss attr + old trailer)
+            if (0 == strcmp (del_entry->attr_trailer,
+                             ds_entry->unresolved_attribute_delegation))
+            {
+              print_deleset (del_entry, "Backward:");
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Backward: Found match with above!\n");
+
+              // if one node on the path still needs solutions: return
+              if (GNUNET_NO ==
+                  handle_bidirectional_match (del_entry, ds_entry, vrh))
+                break;
+
+              // Send lookup response
+              send_lookup_response (vrh);
+              return;
+            }
+          }
+        }
+      }
+
+      // Starting a new GNS lookup
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Looking up %s\n",
+                  ds_entry->lookup_attribute);
+      if (NULL != ds_entry->attr_trailer)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "%s still to go...\n",
+                    ds_entry->attr_trailer);
+
+      vrh->pending_lookups++;
+      ds_entry->handle = vrh;
+      ds_entry->lookup_request =
+        GNUNET_GNS_lookup (gns,
+                           lookup_attribute,
+                           ds_entry->issuer_key, // issuer_key,
+                           GNUNET_GNSRECORD_TYPE_ATTRIBUTE,
+                           GNUNET_GNS_LO_DEFAULT,
+                           &backward_resolution,
+                           ds_entry);
+
+      GNUNET_free (lookup_attribute);
+    }
+  }
+
+  if (0 == vrh->pending_lookups)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "We are all out of attributes...\n");
+    send_lookup_response (vrh);
+    return;
+  }
+}
+
+
+/**
+ * Result from GNS lookup.
+ *
+ * @param cls the closure (our client lookup handle)
+ */
+static int
+delegation_chain_bw_resolution_start (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Start Backward Resolution...\n");
+
+  struct VerifyRequestHandle *vrh = cls;
+  struct DelegationSetQueueEntry *ds_entry;
+  struct DelegateRecordEntry *del_entry;
+
+  if (0 == vrh->del_chain_size)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No delegates found\n");
+    send_lookup_response (vrh);
+    return 1;
+  }
+
+  // Pre-check with vrh->dele_chain_.. if match issuer_key
+  // Backward: check every cred entry if match issuer key
+  // otherwise: start at issuer and go down till match
+  // A.a <- ...
+  // X.x <- C
+  // Y.y <- C
+  // if not X.x or Y.y == A.a start at A
+  for (del_entry = vrh->del_chain_head; del_entry != NULL;
+       del_entry = del_entry->next)
+  {
+    if (0 != memcmp (&del_entry->delegate->issuer_key,
+                     &vrh->issuer_key,
+                     sizeof (struct GNUNET_CRYPTO_PublicKey)))
+      continue;
+    if (0 !=
+        strcmp (del_entry->delegate->issuer_attribute, vrh->issuer_attribute))
+      continue;
+    del_entry->refcount++;
+    // Found match prematurely
+    send_lookup_response (vrh);
+    return 1;
+  }
+
+
+  // Check for attributes from the issuer and follow the chain
+  // till you get the required subject's attributes
+  char issuer_attribute_name[strlen (vrh->issuer_attribute) + 1];
+  strcpy (issuer_attribute_name, vrh->issuer_attribute);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Looking up %s\n",
+              issuer_attribute_name);
+  ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
+  GNUNET_CONTAINER_DLL_insert (vrh->dsq_head, vrh->dsq_tail, ds_entry);
+  ds_entry->from_bw = true;
+  ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+  GNUNET_memcpy (ds_entry->issuer_key,
+                 &vrh->issuer_key,
+                 sizeof (struct GNUNET_CRYPTO_PublicKey));
+  ds_entry->issuer_attribute = GNUNET_strdup (vrh->issuer_attribute);
+
+  ds_entry->delegation_chain_entry = GNUNET_new (struct DelegationChainEntry);
+  ds_entry->delegation_chain_entry->issuer_key = vrh->issuer_key;
+  ds_entry->delegation_chain_entry->issuer_attribute =
+    GNUNET_strdup (vrh->issuer_attribute);
+
+  ds_entry->handle = vrh;
+  ds_entry->lookup_attribute = GNUNET_strdup (vrh->issuer_attribute);
+  ds_entry->unresolved_attribute_delegation = NULL;
+  vrh->pending_lookups = 1;
+
+  // Start with backward resolution
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start Backward Resolution\n");
+
+  ds_entry->lookup_request = GNUNET_GNS_lookup (gns,
+                                                issuer_attribute_name,
+                                                &vrh->issuer_key, // issuer_key,
+                                                GNUNET_GNSRECORD_TYPE_ATTRIBUTE,
+                                                GNUNET_GNS_LO_DEFAULT,
+                                                &backward_resolution,
+                                                ds_entry);
+  return 0;
+}
+
+
+static int
+delegation_chain_fw_resolution_start (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Start Forward Resolution...\n");
+
+  struct VerifyRequestHandle *vrh = cls;
+  struct DelegationSetQueueEntry *ds_entry;
+  struct DelegateRecordEntry *del_entry;
+
+  // set to 0 and increase on each lookup: for fw multiple lookups (may be) started
+  vrh->pending_lookups = 0;
+
+  if (0 == vrh->del_chain_size)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No delegations found\n");
+    send_lookup_response (vrh);
+    return 1;
+  }
+
+  // Pre-check with vrh->dele_chain_.. if match issuer_key
+  // otherwise FW: start multiple lookups for each vrh->dele_chain
+  // A.a <- ...
+  // X.x <- C
+  // Y.y <- C
+  // if not X.x or Y.y  == A.a start at X and at Y
+  for (del_entry = vrh->del_chain_head; del_entry != NULL;
+       del_entry = del_entry->next)
+  {
+    if (0 != memcmp (&del_entry->delegate->issuer_key,
+                     &vrh->issuer_key,
+                     sizeof (struct GNUNET_CRYPTO_PublicKey)))
+      continue;
+    if (0 !=
+        strcmp (del_entry->delegate->issuer_attribute, vrh->issuer_attribute))
+      continue;
+    del_entry->refcount++;
+    // Found match prematurely
+    send_lookup_response (vrh);
+    return 1;
+  }
+
+  // None match, therefore start for every delegation found a lookup chain
+  // Return and end collect process on first chain iss <-> sub found
+
+  // ds_entry created belongs to the first lookup, vrh still has the
+  // issuer+attr we look for
+  for (del_entry = vrh->del_chain_head; del_entry != NULL;
+       del_entry = del_entry->next)
+  {
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Looking for %s.%s\n",
+                GNUNET_CRYPTO_public_key_to_string (
+                  &del_entry->delegate->issuer_key),
+                del_entry->delegate->issuer_attribute);
+
+    ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
+    GNUNET_CONTAINER_DLL_insert (vrh->dsq_head, vrh->dsq_tail, ds_entry);
+    ds_entry->from_bw = false;
+    ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
+    GNUNET_memcpy (ds_entry->issuer_key,
+                   &del_entry->delegate->subject_key,
+                   sizeof (struct GNUNET_CRYPTO_PublicKey));
+
+    ds_entry->delegation_chain_entry = GNUNET_new (struct DelegationChainEntry);
+    ds_entry->delegation_chain_entry->subject_key =
+      del_entry->delegate->subject_key;
+    ds_entry->delegation_chain_entry->subject_attribute = NULL;
+    ds_entry->delegation_chain_entry->issuer_key =
+      del_entry->delegate->issuer_key;
+    ds_entry->delegation_chain_entry->issuer_attribute =
+      GNUNET_strdup (del_entry->delegate->issuer_attribute);
+
+    ds_entry->attr_trailer =
+      GNUNET_strdup (del_entry->delegate->issuer_attribute);
+    ds_entry->handle = vrh;
+
+    vrh->pending_lookups++;
+    // Start with forward resolution
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start Forward Resolution\n");
+
+    ds_entry->lookup_request =
+      GNUNET_GNS_lookup (gns,
+                         GNUNET_GNS_EMPTY_LABEL_AT,
+                         &del_entry->delegate->issuer_key, // issuer_key,
+                         GNUNET_GNSRECORD_TYPE_DELEGATE,
+                         GNUNET_GNS_LO_DEFAULT,
+                         &forward_resolution,
+                         ds_entry);
+  }
+  return 0;
+}
+
+
+static int
+check_verify (void *cls, const struct VerifyMessage *v_msg)
+{
+  size_t msg_size;
+  const char *attr;
+
+  msg_size = ntohs (v_msg->header.size);
+  if (msg_size < sizeof (struct VerifyMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (ntohs (v_msg->issuer_attribute_len) > GNUNET_ABD_MAX_LENGTH)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  attr = (const char *) &v_msg[1];
+
+  if (strlen (attr) > GNUNET_ABD_MAX_LENGTH)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+handle_verify (void *cls, const struct VerifyMessage *v_msg)
+{
+  struct VerifyRequestHandle *vrh;
+  struct GNUNET_SERVICE_Client *client = cls;
+  struct DelegateRecordEntry *del_entry;
+  uint32_t delegate_count;
+  uint32_t delegate_data_size;
+  char attr[GNUNET_ABD_MAX_LENGTH + 1];
+  char issuer_attribute[GNUNET_ABD_MAX_LENGTH + 1];
+  char *attrptr = attr;
+  char *delegate_data;
+  const char *utf_in;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received VERIFY message\n");
+  utf_in = (const char *) &v_msg[1];
+  GNUNET_STRINGS_utf8_tolower (utf_in, attrptr);
+  GNUNET_memcpy (issuer_attribute, attr, ntohs (v_msg->issuer_attribute_len));
+  issuer_attribute[ntohs (v_msg->issuer_attribute_len)] = '\0';
+  vrh = GNUNET_new (struct VerifyRequestHandle);
+  vrh->is_collect = false;
+  GNUNET_CONTAINER_DLL_insert (vrh_head, vrh_tail, vrh);
+  vrh->client = client;
+  vrh->request_id = v_msg->id;
+  vrh->issuer_key = v_msg->issuer_key;
+  vrh->subject_key = v_msg->subject_key;
+  vrh->issuer_attribute = GNUNET_strdup (issuer_attribute);
+  vrh->resolution_algo = ntohs (v_msg->resolution_algo);
+
+  vrh->del_chain_head = NULL;
+  vrh->del_chain_tail = NULL;
+  vrh->dsq_head = NULL;
+  vrh->dsq_tail = NULL;
+  vrh->del_chain_head = NULL;
+  vrh->del_chain_tail = NULL;
+
+  GNUNET_SERVICE_client_continue (vrh->client);
+  if (0 == strlen (issuer_attribute))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer attribute provided!\n");
+    send_lookup_response (vrh);
+    return;
+  }
+
+  // Parse delegates from verifaction message
+  delegate_count = ntohl (v_msg->d_count);
+  delegate_data_size = ntohs (v_msg->header.size)
+                       - sizeof (struct VerifyMessage)
+                       - ntohs (v_msg->issuer_attribute_len) - 1;
+  struct GNUNET_ABD_Delegate delegates[delegate_count];
+  memset (delegates,
+          0,
+          sizeof (struct GNUNET_ABD_Delegate) * delegate_count);
+  delegate_data = (char *) &v_msg[1] + ntohs (v_msg->issuer_attribute_len) + 1;
+  if (GNUNET_OK != GNUNET_ABD_delegates_deserialize (delegate_data_size,
+                                                     delegate_data,
+                                                     delegate_count,
+                                                     delegates))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot deserialize delegates!\n");
+    send_lookup_response (vrh);
+    return;
+  }
+
+  // Prepare vrh delegation chain for later validation
+  for (uint32_t i = 0; i < delegate_count; i++)
+  {
+    del_entry = GNUNET_new (struct DelegateRecordEntry);
+    del_entry->delegate =
+      GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate)
+                     + delegates[i].issuer_attribute_len + 1);
+    GNUNET_memcpy (del_entry->delegate,
+                   &delegates[i],
+                   sizeof (struct GNUNET_ABD_Delegate));
+    GNUNET_memcpy (&del_entry->delegate[1],
+                   delegates[i].issuer_attribute,
+                   delegates[i].issuer_attribute_len);
+    del_entry->delegate->issuer_attribute_len =
+      delegates[i].issuer_attribute_len;
+    del_entry->delegate->issuer_attribute = (char *) &del_entry->delegate[1];
+    GNUNET_CONTAINER_DLL_insert_tail (vrh->del_chain_head,
+                                      vrh->del_chain_tail,
+                                      del_entry);
+    vrh->del_chain_size++;
+  }
+
+  // Switch resolution algo
+  if (GNUNET_ABD_FLAG_BACKWARD & vrh->resolution_algo &&
+      GNUNET_ABD_FLAG_FORWARD & vrh->resolution_algo)
+  {
+    if (1 == delegation_chain_fw_resolution_start (vrh))
+      return;
+    delegation_chain_bw_resolution_start (vrh);
+  }
+  else if (GNUNET_ABD_FLAG_BACKWARD & vrh->resolution_algo)
+  {
+    delegation_chain_bw_resolution_start (vrh);
+  }
+  else if (GNUNET_ABD_FLAG_FORWARD & vrh->resolution_algo)
+  {
+    delegation_chain_fw_resolution_start (vrh);
+  }
+}
+
+
+static void
+handle_delegate_collection_error_cb (void *cls)
+{
+  struct VerifyRequestHandle *vrh = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got disconnected from namestore database.\n");
+  vrh->dele_qe = NULL;
+  send_lookup_response (vrh);
+}
+
+
+static void
+delegate_collection_finished (void *cls)
+{
+  struct VerifyRequestHandle *vrh = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done collecting delegates.\n");
+
+  // if both are set: bidirectional search, meaning start both chain resolutions
+  if (GNUNET_ABD_FLAG_BACKWARD & vrh->resolution_algo &&
+      GNUNET_ABD_FLAG_FORWARD & vrh->resolution_algo)
+  {
+    // if premature match found don't start bw resolution
+    if (1 == delegation_chain_fw_resolution_start (vrh))
+      return;
+    delegation_chain_bw_resolution_start (vrh);
+  }
+  else if (GNUNET_ABD_FLAG_BACKWARD & vrh->resolution_algo)
+  {
+    delegation_chain_bw_resolution_start (vrh);
+  }
+  else if (GNUNET_ABD_FLAG_FORWARD & vrh->resolution_algo)
+  {
+    delegation_chain_fw_resolution_start (vrh);
+  }
+}
+
+
+static void
+handle_delegate_collection_cb (void *cls,
+                               const struct GNUNET_CRYPTO_PrivateKey *key,
+                               const char *label,
+                               unsigned int rd_count,
+                               const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct VerifyRequestHandle *vrh = cls;
+  struct DelegateRecordEntry *del_entry;
+  vrh->dele_qe = NULL;
+
+  for (uint32_t i = 0; i < rd_count; i++)
+  {
+    if (GNUNET_GNSRECORD_TYPE_DELEGATE != rd[i].record_type)
+      continue;
+    // only add the entries that are explicitly marked as private
+    // and therefore symbolize the end of a chain
+    if (0 == (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE))
+      continue;
+    del_entry = GNUNET_new (struct DelegateRecordEntry);
+    del_entry->delegate = GNUNET_ABD_delegate_deserialize (rd[i].data, rd[i].data_size);
+    if (NULL == del_entry->delegate)
+    {
+      GNUNET_free (del_entry);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Invalid delegate found\n");
+      continue;
+    }
+    GNUNET_CONTAINER_DLL_insert_tail (vrh->del_chain_head,
+                                      vrh->del_chain_tail,
+                                      del_entry);
+    vrh->del_chain_size++;
+  }
+
+  delegate_collection_finished (vrh);
+}
+
+
+static void
+handle_collect (void *cls, const struct CollectMessage *c_msg)
+{
+  char attr[GNUNET_ABD_MAX_LENGTH + 1];
+  char issuer_attribute[GNUNET_ABD_MAX_LENGTH + 1];
+  struct VerifyRequestHandle *vrh;
+  struct GNUNET_SERVICE_Client *client = cls;
+  char *attrptr = attr;
+  const char *utf_in;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received COLLECT message\n");
+
+  utf_in = (const char *) &c_msg[1];
+  GNUNET_STRINGS_utf8_tolower (utf_in, attrptr);
+
+  GNUNET_memcpy (issuer_attribute, attr, ntohs (c_msg->issuer_attribute_len));
+  issuer_attribute[ntohs (c_msg->issuer_attribute_len)] = '\0';
+  vrh = GNUNET_new (struct VerifyRequestHandle);
+  vrh->is_collect = true;
+  GNUNET_CONTAINER_DLL_insert (vrh_head, vrh_tail, vrh);
+  vrh->client = client;
+  vrh->request_id = c_msg->id;
+  vrh->issuer_key = c_msg->issuer_key;
+  GNUNET_CRYPTO_key_get_public (&c_msg->subject_key, &vrh->subject_key);
+  vrh->issuer_attribute = GNUNET_strdup (issuer_attribute);
+  vrh->resolution_algo = ntohs (c_msg->resolution_algo);
+
+  vrh->del_chain_head = NULL;
+  vrh->del_chain_tail = NULL;
+  vrh->dsq_head = NULL;
+  vrh->dsq_tail = NULL;
+  vrh->del_chain_head = NULL;
+  vrh->del_chain_tail = NULL;
+
+  if (0 == strlen (issuer_attribute))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer attribute provided!\n");
+    send_lookup_response (vrh);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting delegates for subject\n");
+
+  // Get all delegates from subject
+  vrh->dele_qe =
+    GNUNET_NAMESTORE_records_lookup (namestore,
+                                     &c_msg->subject_key,
+                                     GNUNET_GNS_EMPTY_LABEL_AT,
+                                     &handle_delegate_collection_error_cb,
+                                     vrh,
+                                     &handle_delegate_collection_cb,
+                                     vrh);
+  GNUNET_SERVICE_client_continue (vrh->client);
+}
+
+
+static int
+check_collect (void *cls, const struct CollectMessage *c_msg)
+{
+  size_t msg_size;
+  const char *attr;
+
+  msg_size = ntohs (c_msg->header.size);
+  if (msg_size < sizeof (struct CollectMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (ntohs (c_msg->issuer_attribute_len) > GNUNET_ABD_MAX_LENGTH)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  attr = (const char *) &c_msg[1];
+
+  if (('\0' != attr[msg_size - sizeof (struct CollectMessage) - 1]) ||
+      (strlen (attr) > GNUNET_ABD_MAX_LENGTH))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
+}
+
+
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
+  return client;
+}
+
+
+/**
+ * Process Credential requests.
+ *
+ * @param cls closure
+ * @param c configuration to use
+ * @param handle service handle
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *handle)
+{
+
+  gns = GNUNET_GNS_connect (c);
+  if (NULL == gns)
+  {
+    fprintf (stderr, _ ("Failed to connect to GNS\n"));
+  }
+  namestore = GNUNET_NAMESTORE_connect (c);
+  if (NULL == namestore)
+  {
+    fprintf (stderr, _ ("Failed to connect to namestore\n"));
+  }
+
+  statistics = GNUNET_STATISTICS_create ("abd", c);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+}
+
+
+/**
+ * Define "main" method using service macro
+ */
+GNUNET_SERVICE_MAIN (
+  "abd",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (verify,
+                         GNUNET_MESSAGE_TYPE_ABD_VERIFY,
+                         struct VerifyMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (collect,
+                         GNUNET_MESSAGE_TYPE_ABD_COLLECT,
+                         struct CollectMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+/* end of gnunet-service-abd.c */
diff --git a/src/contrib/service/abd/plugin_gnsrecord_abd.c b/src/contrib/service/abd/plugin_gnsrecord_abd.c
new file mode 100644
index 000000000..43abe578f
--- /dev/null
+++ b/src/contrib/service/abd/plugin_gnsrecord_abd.c
@@ -0,0 +1,357 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+*/
+
+/**
+ * @file abd/plugin_gnsrecord_abd.c
+ * @brief gnsrecord plugin to provide the API for ABD records
+ * @author Martin Schanzenbach
+ */
+#include "platform.h"
+
+#include "gnunet_util_lib.h"
+
+#include "delegate_misc.h"
+#include "abd_serialization.h"
+#include "gnunet_abd_service.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_gnsrecord_plugin.h"
+#include "gnunet_signatures.h"
+/**
+ * Convert the 'value' of a record to a string.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param data value in binary encoding
+ * @param data_size number of bytes in @a data
+ * @return NULL on error, otherwise human-readable representation of the value
+ */
+static char *
+abd_value_to_string (void *cls,
+                     uint32_t type,
+                     const void *data,
+                     size_t data_size)
+{
+  const char *cdata;
+
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_ATTRIBUTE:
+    {
+      struct GNUNET_ABD_DelegationRecord sets;
+      char *attr_str;
+      char *subject_pkey;
+      char *tmp_str;
+      int i;
+      if (data_size < sizeof (struct GNUNET_ABD_DelegationRecord))
+        return NULL; /* malformed */
+
+      GNUNET_memcpy (&sets, data, sizeof (sets));
+      cdata = data;
+
+      struct GNUNET_ABD_DelegationSet set[ntohl (sets.set_count)];
+      if (GNUNET_OK !=
+          GNUNET_ABD_delegation_set_deserialize (GNUNET_ntohll (
+                                                   sets.data_size),
+                                                 &cdata[sizeof (sets)],
+                                                 ntohl (sets.set_count),
+                                                 set))
+        return NULL;
+
+      for (i = 0; i < ntohl (sets.set_count); i++)
+      {
+        subject_pkey =
+          GNUNET_CRYPTO_public_key_to_string (&set[i].subject_key);
+
+        if (0 == set[i].subject_attribute_len)
+        {
+          if (0 == i)
+          {
+            GNUNET_asprintf (&attr_str, "%s", subject_pkey);
+          }
+          else
+          {
+            GNUNET_asprintf (&tmp_str, "%s,%s", attr_str, subject_pkey);
+            GNUNET_free (attr_str);
+            attr_str = tmp_str;
+          }
+        }
+        else
+        {
+          if (0 == i)
+          {
+            GNUNET_asprintf (&attr_str,
+                             "%s %s",
+                             subject_pkey,
+                             set[i].subject_attribute);
+          }
+          else
+          {
+            GNUNET_asprintf (&tmp_str,
+                             "%s,%s %s",
+                             attr_str,
+                             subject_pkey,
+                             set[i].subject_attribute);
+            GNUNET_free (attr_str);
+            attr_str = tmp_str;
+          }
+        }
+        GNUNET_free (subject_pkey);
+      }
+      return attr_str;
+    }
+  case GNUNET_GNSRECORD_TYPE_DELEGATE:
+    {
+      struct GNUNET_ABD_Delegate *cred;
+      char *cred_str;
+
+      cred = GNUNET_ABD_delegate_deserialize (data, data_size);
+      cred_str = GNUNET_ABD_delegate_to_string (cred);
+      GNUNET_free (cred);
+      return cred_str;
+    }
+  default:
+    return NULL;
+  }
+}
+
+
+/**
+ * Convert human-readable version of a 'value' of a record to the binary
+ * representation.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param s human-readable string
+ * @param data set to value in binary encoding (will be allocated)
+ * @param data_size set to number of bytes in @a data
+ * @return #GNUNET_OK on success
+ */
+static int
+abd_string_to_value (void *cls,
+                     uint32_t type,
+                     const char *s,
+                     void **data,
+                     size_t *data_size)
+{
+  if (NULL == s)
+    return GNUNET_SYSERR;
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_ATTRIBUTE:
+    {
+      struct GNUNET_ABD_DelegationRecord *sets;
+      char attr_str[253 + 1];
+      char subject_pkey[58 + 1];
+      char *token;
+      char *tmp_str;
+      int matches = 0;
+      int entries;
+      size_t tmp_data_size;
+      int i;
+
+      tmp_str = GNUNET_strdup (s);
+      token = strtok (tmp_str, ",");
+      entries = 0;
+      tmp_data_size = 0;
+      *data_size = sizeof (struct GNUNET_ABD_DelegationRecord);
+      while (NULL != token)
+      {
+        // also fills the variables subject_pley and attr_str if "regex"-like match
+        matches = sscanf (token, "%s %s", subject_pkey, attr_str);
+
+        if (0 == matches)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _ ("Unable to parse ATTR record string `%s'\n"),
+                      s);
+          GNUNET_free (tmp_str);
+          return GNUNET_SYSERR;
+        }
+
+        entries++;
+        token = strtok (NULL, ",");
+      }
+      GNUNET_free (tmp_str);
+
+      tmp_str = GNUNET_strdup (s);
+      token = strtok (tmp_str, ",");
+      if (NULL == token)
+      {
+        GNUNET_free (tmp_str);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed string %s\n", s);
+        return GNUNET_SYSERR;
+      }
+
+      struct GNUNET_ABD_DelegationSet set[entries];
+      // sets memory to be 0, starting at *set for the size of struct * entries
+      memset (set, 0, sizeof (struct GNUNET_ABD_DelegationSet) * entries);
+      for (i = 0; i < entries; i++)
+      {
+        matches = sscanf (token, "%s %s", subject_pkey, attr_str);
+
+        // sets the public key for the set entry
+        if (GNUNET_SYSERR ==
+            GNUNET_CRYPTO_public_key_from_string (subject_pkey,
+                                                    &set[i].subject_key))
+        {
+          GNUNET_free (tmp_str);
+          return GNUNET_SYSERR;
+        }
+
+        // If not just key, also set subject attribute (Not A.a <- B but A.a <- B.b)
+        if (2 == matches)
+        {
+          set[i].subject_attribute_len = strlen (attr_str) + 1;
+          set[i].subject_attribute = GNUNET_strdup (attr_str);
+        }
+        // If more entries, then token string can take the next entry (separated by ',') by calling strtok again
+        token = strtok (NULL, ",");
+      }
+      tmp_data_size = GNUNET_ABD_delegation_set_get_size (entries, set);
+
+      if (-1 == tmp_data_size)
+      {
+        GNUNET_free (tmp_str);
+        return GNUNET_SYSERR;
+      }
+      *data_size += tmp_data_size;
+      *data = sets = GNUNET_malloc (*data_size);
+      GNUNET_ABD_delegation_set_serialize (entries,
+                                           set,
+                                           tmp_data_size,
+                                           (char *) &sets[1]);
+      for (i = 0; i < entries; i++)
+      {
+        if (0 != set[i].subject_attribute_len)
+        {
+          GNUNET_free_nz ((char *) set[i].subject_attribute);
+          set[i].subject_attribute = NULL;
+        }
+      }
+      sets->set_count = htonl (entries);
+      sets->data_size = GNUNET_htonll (tmp_data_size);
+
+      GNUNET_free (tmp_str);
+      return GNUNET_OK;
+    }
+  case GNUNET_GNSRECORD_TYPE_DELEGATE:
+    {
+      struct GNUNET_ABD_Delegate *cred;
+      cred = GNUNET_ABD_delegate_from_string (s);
+
+      *data_size = GNUNET_ABD_delegate_serialize (cred, (char **) data);
+      GNUNET_free (cred);
+      return GNUNET_OK;
+    }
+  default:
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Mapping of record type numbers to human-readable
+ * record type names.
+ */
+static struct
+{
+  const char *name;
+  uint32_t number;
+} name_map[] = {{"ATTR", GNUNET_GNSRECORD_TYPE_ATTRIBUTE},
+                {"DEL", GNUNET_GNSRECORD_TYPE_DELEGATE},
+                {NULL, UINT32_MAX}};
+
+
+/**
+ * Convert a type name (e.g. "AAAA") to the corresponding number.
+ *
+ * @param cls closure, unused
+ * @param gns_typename name to convert
+ * @return corresponding number, UINT32_MAX on error
+ */
+static uint32_t
+abd_typename_to_number (void *cls, const char *gns_typename)
+{
+  unsigned int i;
+
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (0 != strcasecmp (gns_typename, name_map[i].name)))
+    i++;
+  return name_map[i].number;
+}
+
+
+/**
+ * Convert a type number to the corresponding type string (e.g. 1 to "A")
+ *
+ * @param cls closure, unused
+ * @param type number of a type to convert
+ * @return corresponding typestring, NULL on error
+ */
+static const char *
+abd_number_to_typename (void *cls, uint32_t type)
+{
+  unsigned int i;
+
+  i = 0;
+  while ((name_map[i].name != NULL) && (type != name_map[i].number))
+    i++;
+  return name_map[i].name;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_plugin_gnsrecord_abd_init (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api->value_to_string = &abd_value_to_string;
+  api->string_to_value = &abd_string_to_value;
+  api->typename_to_number = &abd_typename_to_number;
+  api->number_to_typename = &abd_number_to_typename;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_plugin_gnsrecord_abd_done (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_gnsrecord_abd.c */
diff --git a/src/contrib/service/abd/test_abd_bi_and.sh b/src/contrib/service/abd/test_abd_bi_and.sh
new file mode 100755
index 000000000..99c89a344
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_and.sh
@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+gnunet-identity -C h -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+HKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep h | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c AND G.g
+#   (3) C.c <- (D.D)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F) priv
+#   (6) (G.g) <- H.h 
+#   (7) H.h <- (F) priv
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c, $GKEY g" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+gnunet-abd --createIssuerSide --ego=g --attribute="g" --subject="$HKEY h" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2049-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2049-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2049-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=h --attribute="h" --subject="$FKEY" --ttl="2049-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z h
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f --forward --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' --forward --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" --forward --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z g -d -n "g" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
+
diff --git a/src/contrib/service/abd/test_abd_bi_and2.sh b/src/contrib/service/abd/test_abd_bi_and2.sh
new file mode 100755
index 000000000..8d1601ef4
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_and2.sh
@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+gnunet-identity -C h -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+HKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep h | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c AND G.g
+#   (3) C.c <- (D.D)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F) priv
+#   (6) G.g <- (F) priv
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c, $GKEY g" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=g --attribute="g" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z h
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
+
diff --git a/src/contrib/service/abd/test_abd_bi_and3.sh b/src/contrib/service/abd/test_abd_bi_and3.sh
new file mode 100755
index 000000000..cde2a020b
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_and3.sh
@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+gnunet-identity -C h -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+HKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep h | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c AND G.g
+#   (3) C.c <- (D.d)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F) priv
+#   (6) G.g <- (H.h)
+#   (7) H.h <- (F) priv
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c, $GKEY g" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=g --attribute="g" --subject="$HKEY h" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=h --import="$SIGNED"
+gnunet-namestore -D -z h
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=h --attribute="h" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z h -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_bi_and4.sh b/src/contrib/service/abd/test_abd_bi_and4.sh
new file mode 100755
index 000000000..e8cd6efd6
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_and4.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+gnunet-identity -C h -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+HKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep h | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c AND G.g
+#   (3) C.c <- (F) priv
+#   (4) G.g <- (F) priv
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c, $GKEY g" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=g --attribute="g" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\'  --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS"  --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
+
diff --git a/src/contrib/service/abd/test_abd_bi_bw.sh b/src/contrib/service/abd/test_abd_bi_bw.sh
new file mode 100755
index 000000000..6b0e51722
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_bw.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c
+#   (3) C.c <- (D.D)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F)
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f --forward --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' --forward --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" --forward --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_bi_bw_link.sh b/src/contrib/service/abd/test_abd_bi_bw_link.sh
new file mode 100755
index 000000000..f60f78827
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_bw_link.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- G.g.c
+#   (3) (G.g) <- C
+#   (3) C.c <- (D.D)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F)
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$GKEY g.c" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+gnunet-abd --createIssuerSide --ego=g --attribute="g" --subject="$CKEY" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f --forward --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' --forward --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" --forward --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z g -d -n "g" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
+
diff --git a/src/contrib/service/abd/test_abd_bi_bw_link2.sh b/src/contrib/service/abd/test_abd_bi_bw_link2.sh
new file mode 100755
index 000000000..b0fb49b8e
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_bw_link2.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- G.g.c
+#   (3) G.g <- (C)
+#   (3) C.c <- (D.d)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F)
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$GKEY g.c" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=g --attribute="g" --subject="$CKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=c --import="$SIGNED"
+gnunet-namestore -D -z c
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" --private
+gnunet-namestore -D -z f
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=f --forward --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate=\'$DELS\' --forward --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$FKEY --delegate="$DELS" --forward --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z c -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
+
diff --git a/src/contrib/service/abd/test_abd_bi_fw.sh b/src/contrib/service/abd/test_abd_bi_fw.sh
new file mode 100755
index 000000000..75a940fbe
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_bi_fw.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C b -c test_abd_lookup.conf
+gnunet-identity -C c -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+BKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep b | awk '{print $3}')
+CKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep c | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+gnunet-identity -d
+
+#   (1) (A.a) <- B.b
+#   (2) (B.b) <- C.c
+#   (3) C.c <- (D.D)
+#   (4) D.d <- (E.e)
+#   (5) E.e <- (F.f)
+#   (6) F.f <- (G)
+
+# BIDIRECTIONAL
+gnunet-abd --createIssuerSide --ego=a --attribute="a" --subject="$BKEY b" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z a
+gnunet-abd --createIssuerSide --ego=b --attribute="b" --subject="$CKEY c" --ttl=5m -c test_abd_lookup.conf
+gnunet-namestore -D -z b
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=c --attribute="c" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY e" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="e" --subject="$FKEY f" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED" 
+gnunet-namestore -D -z f
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=f --attribute="f" --subject="$GKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=g --import="$SIGNED" --private
+gnunet-namestore -D -z g
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=g --forward --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$GKEY --delegate=\'$DELS\' --forward --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$GKEY --delegate="$DELS" --forward --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z a -d -n "a" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z b -d -n "b" -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z g -d -n "@" -t DEL -c test_abd_lookup.conf
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_defaults.conf b/src/contrib/service/abd/test_abd_defaults.conf
new file mode 100644
index 000000000..7b4cb576d
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_defaults.conf
@@ -0,0 +1,24 @@
+@INLINE@ ../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-abd-testing/
+
+[namestore-sqlite]
+FILENAME = $GNUNET_TEST_HOME/namestore/sqlite_test.db
+
+[namecache-sqlite]
+FILENAME=$GNUNET_TEST_HOME/namecache/namecache.db
+
+[identity]
+# Directory where we store information about our egos
+EGODIR = $GNUNET_TEST_HOME/identity/egos/
+
+[dhtcache]
+DATABASE = heap
+
+[transport]
+PLUGINS = tcp
+
+[transport-tcp]
+BINDTO = 127.0.0.1
+
diff --git a/src/contrib/service/abd/test_abd_issue.sh b/src/contrib/service/abd/test_abd_issue.sh
new file mode 100755
index 000000000..8076aa921
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_issue.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+#  (1) PKEY1.user -> PKEY2.resu.user
+#  (2) PKEY2.resu -> PKEY3
+#  (3) PKEY3.user -> PKEY4
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 30"
+
+TEST_ATTR="test"
+gnunet-arm -s -c test_abd_lookup.conf
+gnunet-identity -C testissuer -c test_abd_lookup.conf
+gnunet-identity -C testsubject -c test_abd_lookup.conf
+SUBJECT_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep testsubject | awk '{print $3}')
+ISSUER_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep testissuer | awk '{print $3}')
+
+# Get abd and store it with subject (3)
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=testissuer --attribute=$TEST_ATTR --subject=$SUBJECT_KEY --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf`
+
+STATUS=$?
+
+if test $? != 0
+then
+  echo "Error issuing..."
+  exit 1
+fi
+#Try import
+$DO_TIMEOUT gnunet-abd --createSubjectSide --ego=testsubject --import="$SIGNED" --private -c test_abd_lookup.conf
+RES=$?
+gnunet-arm -e -c test_abd_lookup.conf
+exit $RES
diff --git a/src/contrib/service/abd/test_abd_lookup.conf b/src/contrib/service/abd/test_abd_lookup.conf
new file mode 100644
index 000000000..4072ba23b
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_lookup.conf
@@ -0,0 +1,28 @@
+@INLINE@ test_abd_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-abd-peer-1/
+
+[dht]
+START_ON_DEMAND = YES
+
+[transport]
+PLUGINS =
+
+[abd]
+START_ON_DEMAND = YES
+#PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/credlog
+
+[rest]
+PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=$GNUNET_TMP/restlog
+
+[gns]
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+START_ON_DEMAND = YES
+AUTO_IMPORT_PKEY = YES
+MAX_PARALLEL_BACKGROUND_QUERIES = 10
+DEFAULT_LOOKUP_TIMEOUT = 15 s
+RECORD_PUT_INTERVAL = 1 h
+ZONE_PUBLISH_TIME_WINDOW = 1 h
+DNS_ROOT=PD67SGHF3E0447TU9HADIVU9OM7V4QHTOG0EBU69TFRI2LG63DR0
+
diff --git a/src/contrib/service/abd/test_abd_own.sh b/src/contrib/service/abd/test_abd_own.sh
new file mode 100755
index 000000000..3fc210284
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_own.sh
@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 10"
+gnunet-arm -s -c test_abd_lookup.conf
+
+gnunet-identity -C a -c test_abd_lookup.conf
+gnunet-identity -C d -c test_abd_lookup.conf
+gnunet-identity -C e -c test_abd_lookup.conf
+gnunet-identity -C f -c test_abd_lookup.conf
+gnunet-identity -C g -c test_abd_lookup.conf
+AKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep a | awk '{print $3}')
+DKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep d | awk '{print $3}')
+EKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep e | awk '{print $3}')
+FKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep f | awk '{print $3}')
+GKEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep g | awk '{print $3}')
+
+############################################################################################
+#   (1) EPub.discount <- EOrg.preferred
+#   (2) EOrg.preferred <- StateU.student
+#   (3) StateU.student <- RegistrarB.student
+#   (4) RegistrarB.student <- Alice
+
+gnunet-identity -C epub -c test_abd_lookup.conf
+gnunet-identity -C eorg -c test_abd_lookup.conf
+gnunet-identity -C stateu -c test_abd_lookup.conf
+gnunet-identity -C registrarb -c test_abd_lookup.conf
+gnunet-identity -C alice -c test_abd_lookup.conf
+
+EPUB_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep epub | awk '{print $3}')
+EORG_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep eorg | awk '{print $3}')
+STATEU_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep stateu | awk '{print $3}')
+REGISTRARB_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep registrarb | awk '{print $3}')
+ALICE_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep alice | awk '{print $3}')
+
+
+DISC_ATTR="discount"
+PREF_ATTR="preferred"
+STATE_STUD_ATTR="student"
+REG_STUD_ATTR="student"
+END_ATTR="end"
+
+gnunet-identity -d
+
+# FORWARD, subject side stored (different constellations)
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=a --attribute="a" --subject="$AKEY b.c" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=a --import="$SIGNED"
+gnunet-namestore -D -z a
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=a --attribute="b" --subject="$DKEY d" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=d --import="$SIGNED"
+gnunet-namestore -D -z d
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="d" --subject="$EKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=e --import="$SIGNED"
+gnunet-namestore -D -z e
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="c" --subject="$FKEY c" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED"
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=e --attribute="k" --subject="$FKEY c.k" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=f --import="$SIGNED"
+gnunet-namestore -D -z f
+
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=f --attribute="c" --subject="$GKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=g --import="$SIGNED" --private
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=a --attribute="c" --subject="$GKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=g --import="$SIGNED" --private
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=d --attribute="h.o" --subject="$GKEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=g --import="$SIGNED"
+gnunet-namestore -D -z g
+
+
+# BACKWARD, issuer side stored
+# (1) EPub assigns the attribute "discount" to all entities that have been assigned "preferred" by EOrg
+gnunet-abd --createIssuerSide --ego=epub --attribute=$DISC_ATTR --subject="$EORG_KEY $PREF_ATTR" --ttl=5m -c test_abd_lookup.conf
+
+# (2) EOrg assigns the attribute "preferred" to all entities that have been assigned "student" by StateU
+gnunet-abd --createIssuerSide --ego=eorg --attribute=$PREF_ATTR --subject="$STATEU_KEY $STATE_STUD_ATTR" --ttl=5m -c test_abd_lookup.conf
+
+# (3) StateU assigns the attribute "student" to all entities that have been asssigned "student" by RegistrarB
+gnunet-abd --createIssuerSide --ego=stateu --attribute=$STATE_STUD_ATTR --subject="$REGISTRARB_KEY $REG_STUD_ATTR" --ttl=5m -c test_abd_lookup.conf
+
+# (4) RegistrarB issues Alice the credential "student"
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=registrarb --attribute="$REG_STUD_ATTR" --subject="$ALICE_KEY" --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=alice --import="$SIGNED" --private
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+# FORWARD
+#DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$AKEY --attribute="a" --ego=g --forward -c test_abd_lookup.conf | paste -d, -s - -`
+#echo $DELS
+#echo gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$GKEY --delegate=\'$DELS\' --forward -c test_abd_lookup.conf
+#RES_DELS=`gnunet-abd --verify --issuer=$AKEY --attribute="a" --subject=$GKEY --delegate="$DELS" --forward -c test_abd_lookup.conf`
+
+# BACKWARD
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$EPUB_KEY --attribute=$DISC_ATTR --ego=alice --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$EPUB_KEY --attribute=$DISC_ATTR --subject=$ALICE_KEY --delegate=\'$DELS\' --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$EPUB_KEY --attribute=$DISC_ATTR --subject=$ALICE_KEY --delegate="$DELS" --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z epub -d -n $DISC_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z eorg -d -n $PREF_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z stateu -d -n $STATE_STUD_ATTR -t ATTR -c test_abd_lookup.conf
+#gnunet-namestore -z a -d -n "@" -t DEL -c test_abd_lookup.conf
+#gnunet-namestore -z d -d -n "@" -t DEL -c test_abd_lookup.conf
+#gnunet-namestore -z e -d -n "@" -t DEL -c test_abd_lookup.conf
+#gnunet-namestore -z f -d -n "@" -t DEL -c test_abd_lookup.conf
+#gnunet-namestore -z g -d -n "@" -t DEL -c test_abd_lookup.conf
+
+
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_verify.sh b/src/contrib/service/abd/test_abd_verify.sh
new file mode 100755
index 000000000..9ece91c62
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_verify.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+#  (1) Service.user -> GNU.project.member
+#  (2) GNU.project -> GNUnet
+#  (3) GNUnet.member -> GNUnet.developer
+#  (4) GNUnet.member -> GNUnet.user
+#  (5) GNUnet.developer -> Alice
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 30"
+gnunet-arm -s -c test_abd_lookup.conf
+gnunet-identity -C service -c test_abd_lookup.conf
+gnunet-identity -C alice -c test_abd_lookup.conf
+gnunet-identity -C gnu -c test_abd_lookup.conf
+gnunet-identity -C gnunet -c test_abd_lookup.conf
+
+GNU_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep gnu | grep -v gnunet | awk '{print $3}')
+ALICE_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep alice | awk '{print $3}')
+GNUNET_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep gnunet | awk '{print $3}')
+SERVICE_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep service | awk '{print $3}')
+
+USER_ATTR="user"
+GNU_PROJECT_ATTR="project"
+MEMBER_ATTR="member"
+DEVELOPER_ATTR="developer"
+DEV_ATTR="developer"
+TEST_CREDENTIAL="mygnunetcreds"
+
+gnunet-identity -d
+
+# (1) A service assigns the attribute "user" to all entities that have been assigned "member" by entities that werde assigned "project" from GNU
+gnunet-abd --createIssuerSide --ego=service --attribute="$USER_ATTR" --subject="$GNU_KEY $GNU_PROJECT_ATTR.$MEMBER_ATTR" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z service
+
+# (2) GNU recognized GNUnet as a GNU project and delegates the "project" attribute
+gnunet-abd --createIssuerSide --ego=gnu --attribute="$GNU_PROJECT_ATTR" --subject="$GNUNET_KEY" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z gnu
+
+# (3+4) GNUnet assigns the attribute "member" to all entities gnunet has also assigned "developer" or "user"
+gnunet-abd --createIssuerSide --ego=gnunet --attribute="$MEMBER_ATTR" --subject="$GNUNET_KEY $DEVELOPER_ATTR" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-abd --createIssuerSide --ego=gnunet --attribute="$MEMBER_ATTR" --subject="$GNUNET_KEY $USER_ATTR" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z gnunet
+
+# (5) GNUnet signes the delegate and Alice stores it
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=gnunet --attribute=$DEV_ATTR --subject=$ALICE_KEY --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=alice --import="$SIGNED" --private
+gnunet-namestore -D -z alice
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$SERVICE_KEY --attribute=$USER_ATTR --ego=alice --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$SERVICE_KEY --attribute=$USER_ATTR --subject=$ALICE_KEY --delegate=\'$DELS\' --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$SERVICE_KEY --attribute=$USER_ATTR --subject=$ALICE_KEY --delegate="$DELS" --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z alice -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z gnu -d -n $GNU_PROJECT_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z gnunet -d -n $MEMBER_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z service -d -n $USER_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_verify_and.sh b/src/contrib/service/abd/test_abd_verify_and.sh
new file mode 100755
index 000000000..c6287055e
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_verify_and.sh
@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+#  (1) Service.user -> GNU.project.member
+#  (2) GNU.project -> GNUnet
+#  (3) GNUnet.member -> GNUnet.developer AND GNUnet.user
+#  (4) GNUnet.developer -> Alice
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 30"
+gnunet-arm -s -c test_abd_lookup.conf
+gnunet-identity -C service -c test_abd_lookup.conf
+gnunet-identity -C alice -c test_abd_lookup.conf
+gnunet-identity -C gnu -c test_abd_lookup.conf
+gnunet-identity -C gnunet -c test_abd_lookup.conf
+
+GNU_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep gnu | grep -v gnunet | awk '{print $3}')
+ALICE_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep alice | awk '{print $3}')
+GNUNET_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep gnunet | awk '{print $3}')
+SERVICE_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep service | awk '{print $3}')
+
+USER_ATTR="user"
+GNU_PROJECT_ATTR="project"
+MEMBER_ATTR="member"
+DEVELOPER_ATTR="developer"
+DEV_ATTR="developer"
+
+gnunet-identity -d
+
+# (1) A service assigns the attribute "user" to all entities that have been assigned "member" by entities that werde assigned "project" from GNU
+gnunet-abd --createIssuerSide --ego=service --attribute="$USER_ATTR" --subject="$GNU_KEY $GNU_PROJECT_ATTR.$MEMBER_ATTR" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z service
+
+# (2) GNU recognized GNUnet as a GNU project and delegates the "project" attribute
+gnunet-abd --createIssuerSide --ego=gnu --attribute="$GNU_PROJECT_ATTR" --subject="$GNUNET_KEY" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z gnu
+
+# (3+4) GNUnet assigns the attribute "member" to all entities gnunet has also assigned "developer" or "user"
+gnunet-abd --createIssuerSide --ego=gnunet --attribute="$MEMBER_ATTR" --subject="$GNUNET_KEY $DEVELOPER_ATTR, $GNUNET_KEY $USER_ATTR" --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf
+gnunet-namestore -D -z gnunet
+
+# (5) GNUnet signes the delegates and Alice stores it
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=gnunet --attribute=$DEV_ATTR --subject=$ALICE_KEY --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=alice --import="$SIGNED" --private
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=gnunet --attribute=$USER_ATTR --subject=$ALICE_KEY --ttl="2019-12-12 10:00:00"`
+gnunet-abd --createSubjectSide --ego=alice --import="$SIGNED" --private
+gnunet-namestore -D -z alice
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$SERVICE_KEY --attribute=$USER_ATTR --ego=alice --backward -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+echo gnunet-abd --verify --issuer=$SERVICE_KEY --attribute=$USER_ATTR --subject=$ALICE_KEY --delegate=\'$DELS\' --backward -c test_abd_lookup.conf
+gnunet-abd --verify --issuer=$SERVICE_KEY --attribute=$USER_ATTR --subject=$ALICE_KEY --delegate="$DELS" --backward -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z alice -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-namestore -z gnu -d -n $GNU_PROJECT_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z gnunet -d -n $MEMBER_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-namestore -z service -d -n $USER_ATTR -t ATTR -c test_abd_lookup.conf
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credentials."
+  exit 1
+fi
diff --git a/src/contrib/service/abd/test_abd_verify_simple.sh b/src/contrib/service/abd/test_abd_verify_simple.sh
new file mode 100755
index 000000000..e917f8793
--- /dev/null
+++ b/src/contrib/service/abd/test_abd_verify_simple.sh
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+trap "gnunet-arm -e -c test_abd_lookup.conf" SIGINT
+
+LOCATION=$(which gnunet-config)
+if [ -z $LOCATION ]
+then
+  LOCATION="gnunet-config"
+fi
+$LOCATION --version 1> /dev/null
+if test $? != 0
+then
+        echo "GNUnet command line tools cannot be found, check environmental variables PATH and GNUNET_PREFIX"
+        exit 77
+fi
+
+rm -rf `gnunet-config -c test_abd_lookup.conf -s PATHS -o GNUNET_HOME -f`
+
+#  (1) Issuer.user -> Subject
+
+
+which timeout > /dev/null 2>&1 && DO_TIMEOUT="timeout 30"
+gnunet-arm -s -c test_abd_lookup.conf
+gnunet-identity -C testissuer -c test_abd_lookup.conf
+gnunet-identity -C testsubject -c test_abd_lookup.conf
+
+TEST_ATTR="user"
+SUBJECT_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep testsubject | awk '{print $3}')
+ISSUER_KEY=$(gnunet-identity -d -c test_abd_lookup.conf | grep testissuer | awk '{print $3}')
+
+gnunet-identity -d
+
+# Create delegate (1)
+SIGNED=`$DO_TIMEOUT gnunet-abd --signSubjectSide --ego=testissuer --attribute=$TEST_ATTR --subject=$SUBJECT_KEY --ttl="2019-12-12 10:00:00" -c test_abd_lookup.conf`
+gnunet-abd --createSubjectSide --ego=testsubject --import="$SIGNED" --private
+gnunet-namestore -D -z testsubject
+
+# Starting to resolve
+echo "+++ Starting to Resolve +++"
+
+DELS=`$DO_TIMEOUT gnunet-abd --collect --issuer=$ISSUER_KEY --attribute=$TEST_ATTR --ego=testsubject -c test_abd_lookup.conf | paste -d, -s - -`
+echo $DELS
+gnunet-abd --verify --issuer=$ISSUER_KEY --attribute=$TEST_ATTR --subject=$SUBJECT_KEY --delegate="$DELS" -c test_abd_lookup.conf
+
+RES=$?
+
+# Cleanup properly
+gnunet-namestore -z testsubject -d -n "@" -t DEL -c test_abd_lookup.conf
+gnunet-arm -e -c test_abd_lookup.conf
+
+if [ "$RES" == 0 ]
+then
+  exit 0
+else
+  echo "FAIL: Failed to verify credential."
+  exit 1
+fi
\ No newline at end of file
diff --git a/src/contrib/service/auction/.gitignore b/src/contrib/service/auction/.gitignore
new file mode 100644
index 000000000..5c3ec20cb
--- /dev/null
+++ b/src/contrib/service/auction/.gitignore
@@ -0,0 +1,5 @@
+gnunet-auction-create
+gnunet-auction-info
+gnunet-auction-join
+gnunet-service-auction
+test_auction_api
diff --git a/src/contrib/service/auction/Makefile.am b/src/contrib/service/auction/Makefile.am
new file mode 100644
index 000000000..ec0ffaf33
--- /dev/null
+++ b/src/contrib/service/auction/Makefile.am
@@ -0,0 +1,75 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir = $(pkgdatadir)/config.d/
+
+libexecdir = $(pkglibdir)/libexec/
+
+
+pkgcfg_DATA = \
+        auction.conf
+
+if USE_COVERAGE
+        AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+
+libexec_PROGRAMS = \
+        gnunet-service-auction
+
+gnunet_service_auction_SOURCES = \
+        gnunet-service-auction.c
+gnunet_service_auction_LDADD = \
+        $(top_builddir)/src/lib/util/libgnunetutil.la \
+        -ljansson \
+        $(GN_LIBINTL)
+
+
+bin_PROGRAMS = \
+        gnunet-auction-create \
+        gnunet-auction-info \
+        gnunet-auction-join
+
+gnunet_auction_create_SOURCES = \
+        gnunet-auction-create.c
+gnunet_auction_create_LDADD = \
+        $(top_builddir)/src/lib/util/libgnunetutil.la \
+        -ljansson \
+        $(GN_LIBINTL)
+
+gnunet_auction_info_SOURCES = \
+        gnunet-auction-info.c
+gnunet_auction_info_LDADD = \
+        $(top_builddir)/src/lib/util/libgnunetutil.la \
+        -ljansson \
+        $(GN_LIBINTL)
+
+gnunet_auction_join_SOURCES = \
+        gnunet-auction-join.c
+gnunet_auction_join_LDADD = \
+        $(top_builddir)/src/lib/util/libgnunetutil.la \
+        -ljansson \
+        $(GN_LIBINTL)
+
+
+check_PROGRAMS = \
+        test_auction_api
+
+test_auction_api_SOURCES = \
+        test_auction_api.c
+test_auction_api_LDADD = \
+        $(top_builddir)/src/lib/util/libgnunetutil.la
+
+
+check_SCRIPTS = \
+        test_auction_create.sh
+
+EXTRA_DIST = \
+  auction.h \
+  auction.conf \
+  $(check_SCRIPTS)
+
+if ENABLE_TEST_RUN
+        AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
+        TESTS = $(check_PROGRAMS) $(check_SCRIPTS)
+endif
diff --git a/src/contrib/service/auction/auction.conf b/src/contrib/service/auction/auction.conf
new file mode 100644
index 000000000..deb9ac1fc
--- /dev/null
+++ b/src/contrib/service/auction/auction.conf
@@ -0,0 +1,4 @@
+[auction]
+START_ON_DEMAND = NO
+BINARY = gnunet-service-auction
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-auction.sock
diff --git a/src/contrib/service/auction/auction.h b/src/contrib/service/auction/auction.h
new file mode 100644
index 000000000..dc8b933f6
--- /dev/null
+++ b/src/contrib/service/auction/auction.h
@@ -0,0 +1,77 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001-2011 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @author Markus Teich
+ * @file auction/auction.h
+ *
+ * @brief Common type definitions for the auction service and API.
+ */
+#ifndef AUCTION_H
+#define AUCTION_H
+
+#include "gnunet_common.h"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Auction creation request sent from the client to the service
+ */
+struct GNUNET_AUCTION_ClientCreateMessage
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_AUCTION_CLIENT_CREATE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * When should the auction start
+   */
+  struct GNUNET_TIME_AbsoluteNBO time_start;
+
+  /**
+   * How long is each round allowed to be maximally
+   */
+  struct GNUNET_TIME_RelativeNBO time_round;
+
+  /**
+   * Auction parameter m.
+   * 0 for first price auctions.
+   * >0 for M+1st price auctions.
+   */
+  uint16_t m GNUNET_PACKED;
+
+  /**
+   * Should the auction outcome be public?
+   * 0 for private outcome auctions.
+   * 1 for public outcome auctions.
+   */
+  uint16_t outcome_public GNUNET_PACKED;
+
+  /**
+   * TODO: Price mapping.
+   */
+
+  /* DESCRIPTION text copied to end of this message */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/auction/gnunet-auction-create.c b/src/contrib/service/auction/gnunet-auction-create.c
new file mode 100644
index 000000000..93947b89c
--- /dev/null
+++ b/src/contrib/service/auction/gnunet-auction-create.c
@@ -0,0 +1,219 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 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 auction/gnunet-auction-create.c
+ * @brief tool to create a new auction
+ * @author Markus Teich
+ */
+#include "platform.h"
+
+#include <float.h>
+
+#include "gnunet_util_lib.h"
+#include <jansson.h>
+/* #include "gnunet_auction_service.h" */
+
+#define FIRST_PRICE 0
+#define OUTCOME_PRIVATE 0
+#define OUTCOME_PUBLIC 1
+
+static int ret; /** Final status code. */
+static char *fndesc; /** filename of the item description */
+static char *fnprices; /** filename of the price map */
+static struct GNUNET_TIME_Relative dround; /** max round duration */
+static struct GNUNET_TIME_Relative dstart; /** time until auction starts */
+static unsigned int m = FIRST_PRICE; /** auction parameter m */
+static int outcome = OUTCOME_PRIVATE; /** outcome */
+static int interactive; /** keep running in foreground */
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  unsigned int i;
+  double cur, prev = DBL_MAX;
+  json_t *pmap;
+  json_t *parray;
+  json_t *pnode;
+  json_error_t jerr;
+
+  /* cmdline parsing */
+  if (GNUNET_TIME_UNIT_ZERO.rel_value_us == dstart.rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "required argument --regtime missing or invalid (zero)\n");
+    goto fail;
+  }
+  if (GNUNET_TIME_UNIT_ZERO.rel_value_us == dround.rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "required argument --roundtime missing or invalid (zero)\n");
+    goto fail;
+  }
+  if (! fndesc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "required argument --description missing\n");
+    goto fail;
+  }
+  if (! fnprices)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "required argument --pricemap missing\n");
+    goto fail;
+  }
+
+  /* parse and check pricemap validity */
+  if (! (pmap = json_load_file (fnprices, JSON_DECODE_INT_AS_REAL, &jerr)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "parsing pricemap json at %d:%d: %s\n",
+                jerr.line, jerr.column, jerr.text);
+    goto fail;
+  }
+  if (-1 == json_unpack_ex (pmap, &jerr, JSON_VALIDATE_ONLY,
+                            "{s:s, s:[]}", "currency", "prices"))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "validating pricemap: %s\n", jerr.text);
+    goto fail;
+  }
+  if (! (parray = json_object_get (pmap, "prices")) || ! json_is_array (parray))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "could not get `prices` array node from pricemap\n");
+    goto fail;
+  }
+  if (0 == json_array_size (parray))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "empty pricemap array\n");
+    goto fail;
+  }
+  json_array_foreach (parray, i, pnode)
+  {
+    if (-1 == json_unpack_ex (pnode, &jerr, 0, "F", &cur))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "validating pricearray index %d: %s\n", i, jerr.text);
+      goto fail;
+    }
+    if (prev <= cur)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "validating pricearray index %d: "
+                  "prices must be strictly monotonically decreasing\n",
+                  i);
+      goto fail;
+    }
+    prev = cur;
+  }
+
+  return;
+
+fail:
+  ret = 1;
+  return;
+}
+
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_filename ('d',
+                                   "description",
+                                   "FILE",
+                                   gettext_noop (
+                                     "description of the item to be sold"),
+                                   &fndesc),
+
+    GNUNET_GETOPT_option_filename ('p',
+                                   "pricemap",
+                                   "FILE",
+                                   gettext_noop ("mapping of possible prices"),
+                                   &fnprices),
+
+    GNUNET_GETOPT_option_relative_time ('r',
+                                        "roundtime",
+                                        "DURATION",
+                                        gettext_noop ("max duration per round"),
+                                        &dround),
+
+    GNUNET_GETOPT_option_relative_time ('s',
+                                        "regtime",
+                                        "DURATION",
+                                        gettext_noop (
+                                          "duration until auction starts"),
+                                        &dstart),
+    GNUNET_GETOPT_option_uint ('m',
+                               "m",
+                               "NUMBER",
+                               gettext_noop ("number of items to sell\n"
+                                             "0 for first price auction\n"
+                                             ">0 for vickrey/M+1st price auction"),
+                               &m),
+
+    GNUNET_GETOPT_option_flag ('u',
+                               "public",
+                               gettext_noop ("public auction outcome"),
+                               &outcome),
+
+    GNUNET_GETOPT_option_flag ('i',
+                               "interactive",
+                               gettext_noop (
+                                 "keep running in foreground until auction completes"),
+                               &interactive),
+
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc, argv,
+                             "gnunet-auction-create",
+                             gettext_noop ("create a new auction and "
+                                           "start listening for bidders"),
+                             options,
+                             &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
diff --git a/src/contrib/service/auction/gnunet-auction-info.c b/src/contrib/service/auction/gnunet-auction-info.c
new file mode 100644
index 000000000..dded45ce6
--- /dev/null
+++ b/src/contrib/service/auction/gnunet-auction-info.c
@@ -0,0 +1,86 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 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 auction/gnunet-auction.c
+ * @brief auction for writing a tool
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+/* #include "gnunet_auction_service.h" */
+
+/**
+ * Final status code.
+ */
+static int ret;
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  /* main code here */
+}
+
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    /* FIMXE: add options here */
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc, argv,
+                             "gnunet-auction",
+                             gettext_noop ("help text"),
+                             options,
+                             &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-auction.c */
diff --git a/src/contrib/service/auction/gnunet-auction-join.c b/src/contrib/service/auction/gnunet-auction-join.c
new file mode 100644
index 000000000..dded45ce6
--- /dev/null
+++ b/src/contrib/service/auction/gnunet-auction-join.c
@@ -0,0 +1,86 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 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 auction/gnunet-auction.c
+ * @brief auction for writing a tool
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+/* #include "gnunet_auction_service.h" */
+
+/**
+ * Final status code.
+ */
+static int ret;
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  /* main code here */
+}
+
+
+/**
+ * The main function.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    /* FIMXE: add options here */
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc, argv,
+                             "gnunet-auction",
+                             gettext_noop ("help text"),
+                             options,
+                             &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-auction.c */
diff --git a/src/contrib/service/auction/gnunet-service-auction.c b/src/contrib/service/auction/gnunet-service-auction.c
new file mode 100644
index 000000000..c20f0bdbe
--- /dev/null
+++ b/src/contrib/service/auction/gnunet-service-auction.c
@@ -0,0 +1,155 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2009 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 auction/gnunet-service-auction.c
+ * @brief service for executing auctions
+ * @author Markus Teich
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+#include "auction.h"
+
+/**
+ * Check AUCTION CREATE messages from the client.
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ * @return #GNUNET_OK (always)
+ */
+static int
+check_create (void *cls, const struct GNUNET_AUCTION_ClientCreateMessage *msg)
+{
+  /* always well-formed due to arbitrary length description */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for CREATE messages.
+ *
+ * @param cls the client we received this message from
+ * @param msg the actual message received
+ */
+static void
+handle_create (void *cls, const struct GNUNET_AUCTION_ClientCreateMessage *msg)
+{
+  struct GNUNET_SERVICE_Client *client = cls;
+//      struct GNUNET_MQ_Handle *mq;
+//      struct GNUNET_MQ_Envelope *env;
+//      struct GNUNET_AUCTION_blabla em;
+  //uint16_t size;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received CREATE message from client\n");
+
+  //size = ntohs (msg->header.size);
+
+  /**TODO: create auction and return auction object */
+//      mq = GNUNET_SERVICE_client_get_mq (client);
+//      setup_info_message (&em);
+//      env = GNUNET_MQ_msg_copy (&em.header);
+//      GNUNET_MQ_send (mq, env);
+
+  GNUNET_SERVICE_client_continue (client);
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+cleanup_task (void *cls)
+{
+  /* FIXME: do clean up here */
+}
+
+
+/**
+ * Callback called when a client connects to the service.
+ *
+ * @param cls closure for the service
+ * @param c the new client that connected to the service
+ * @param mq the message queue used to send messages to the client
+ * @return @a c
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *c,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  return c;
+}
+
+
+/**
+ * Callback called when a client disconnected from the service
+ *
+ * @param cls closure for the service
+ * @param c the client that disconnected
+ * @param internal_cls should be equal to @a c
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *c,
+                      void *internal_cls)
+{
+  GNUNET_assert (c == internal_cls);
+}
+
+
+/**
+ * Process auction requests.
+ *
+ * @param cls closure
+ * @param cfg configuration to use
+ * @param service the initialized service
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_SERVICE_Handle *service)
+{
+  /* FIXME: do setup here */
+  GNUNET_SCHEDULER_add_shutdown (&cleanup_task, NULL);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+  ("auction",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (create,
+                         GNUNET_MESSAGE_TYPE_AUCTION_CLIENT_CREATE,
+                         struct GNUNET_AUCTION_ClientCreateMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ())
+
+
+/* end of gnunet-service-auction.c */
diff --git a/src/contrib/service/auction/test_auction_api.c b/src/contrib/service/auction/test_auction_api.c
new file mode 100644
index 000000000..1eac9b5c4
--- /dev/null
+++ b/src/contrib/service/auction/test_auction_api.c
@@ -0,0 +1,44 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009 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 auction/test_auction_api.c
+ * @brief testcase for auction.c
+ */
+#include "platform.h"
+
+static int
+check ()
+{
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  ret = check ();
+
+  return ret;
+}
+
+
+/* end of test_auction_api.c */
diff --git a/src/contrib/service/auction/test_auction_create.sh b/src/contrib/service/auction/test_auction_create.sh
new file mode 100755
index 000000000..b0f4de738
--- /dev/null
+++ b/src/contrib/service/auction/test_auction_create.sh
@@ -0,0 +1,80 @@
+#! /bin/sh
+
+trap 'rm -f test.json' EXIT
+
+
+# missing required cmdline args
+gnunet-auction-create      -r 1 -d foo -p test.json && exit 1
+gnunet-auction-create -s 1      -d foo -p test.json && exit 1
+gnunet-auction-create -s 1 -r 1        -p test.json && exit 1
+gnunet-auction-create -s 1 -r 1 -d foo              && exit 1
+
+
+# no pricemap
+rm -f test.json
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+
+# json errors
+cat <<DOG >test.json
+[,]
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+bla
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+
+# unexpected structures
+cat <<DOG >test.json
+{"foo": "bar"}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"currency": "foo"}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"prices": []}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"currency": "foo", "prices": "bar"}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+
+# wrong array content
+cat <<DOG >test.json
+{"currency": "foo", "prices": []}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"currency": "foo", "prices": ["bar"]}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"currency": "foo", "prices": [null]}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+cat <<DOG >test.json
+{"currency": "foo", "prices": [1, 2]}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json && exit 1
+
+
+# correct example
+cat <<DOG >test.json
+{"currency": "foo", "prices": [2, 1]}
+DOG
+gnunet-auction-create -s 1 -r 1 -d foo -p test.json || exit 1
+
+rm -f test.json
diff --git a/src/contrib/service/rps/.gitignore b/src/contrib/service/rps/.gitignore
new file mode 100644
index 000000000..9e78e2ca0
--- /dev/null
+++ b/src/contrib/service/rps/.gitignore
@@ -0,0 +1,16 @@
+gnunet-service-rps
+gnunet-rps
+gnunet-rps-profiler
+test_rps_single_req
+test_rps_req_cancel
+test_rps_sub
+test_rps_seed_big
+test_rps_seed_request
+test_service_rps_custommap
+test_service_rps_sampler_elem
+test_service_rps_view
+test_rps_churn
+test_service_rps_peers
+test_rps_malicious_1
+test_rps_malicious_2
+test_rps_malicious_3
diff --git a/src/contrib/service/rps/Makefile.am b/src/contrib/service/rps/Makefile.am
new file mode 100644
index 000000000..2ee315d11
--- /dev/null
+++ b/src/contrib/service/rps/Makefile.am
@@ -0,0 +1,167 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+pkgcfg_DATA = \
+  rps.conf
+
+bin_PROGRAMS = gnunet-rps
+
+gnunet_rps_SOURCES = \
+  gnunet-rps.c
+
+gnunet_rps_LDADD = \
+  libgnunetrps.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(XLIB) $(GN_LIBINTL)
+
+lib_LTLIBRARIES = libgnunetrps.la
+
+libgnunetrps_la_SOURCES = \
+ gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
+  rps-test_util.h rps-test_util.c \
+  rps-sampler_common.h rps-sampler_common.c \
+  rps-sampler_client.h rps-sampler_client.c \
+  rps_api.c rps.h
+libgnunetrps_la_LIBADD = \
+  $(top_builddir)/src/nse/libgnunetnse.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL) $(XLIB)
+libgnunetrps_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+# Fix 'created both with libtool and without' error:
+libgnunetrps_la_CFLAGS = $(AM_CFLAGS)
+
+
+libexec_PROGRAMS = \
+ gnunet-service-rps
+
+#noinst_PROGRAMS = \
+# gnunet-rps-profiler
+
+
+gnunet_service_rps_SOURCES = \
+ gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
+ rps-sampler_common.h rps-sampler_common.c \
+ gnunet-service-rps_sampler.h gnunet-service-rps_sampler.c \
+ gnunet-service-rps_custommap.h gnunet-service-rps_custommap.c \
+ gnunet-service-rps_view.h gnunet-service-rps_view.c \
+ gnunet-service-rps.c
+
+
+gnunet_service_rps_LDADD = \
+  libgnunetrps.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/nse/libgnunetnse.la \
+  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(LIBGCRYPT_LIBS) \
+  -lm -lgcrypt \
+  $(GN_LIBINTL)
+
+
+check_PROGRAMS = \
+ test_service_rps_view \
+ test_service_rps_custommap \
+ test_service_rps_sampler_elem
+ # test_rps_single_req \
+ # test_rps_churn
+ # test_rps_sub \
+ # test_rps_seed_request 
+#if ENABLE_MALICIOUS
+#check_PROGRAMS += \
+# test_rps_malicious_1 \
+# test_rps_malicious_2 \
+# test_rps_malicious_3
+#endif
+
+rps_test_src = \
+        test_rps.c \
+        rps-test_util.h rps-test_util.c \
+ gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
+ rps-sampler_common.h rps-sampler_common.c \
+ gnunet-service-rps_sampler.h gnunet-service-rps_sampler.c
+
+#ld_rps_test_lib = \
+#       libgnunetrps.la \
+#  $(top_builddir)/src/lib/util/libgnunetutil.la \
+#  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+#  $(top_builddir)/src/testbed/libgnunettestbed.la \
+#  -lm
+
+if ENABLE_TEST_RUN
+AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
+TESTS = $(check_PROGRAMS)
+endif
+
+test_service_rps_view_SOURCES = \
+  gnunet-service-rps_view.h gnunet-service-rps_view.c \
+  test_service_rps_view.c
+test_service_rps_view_LDADD = $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_service_rps_custommap_SOURCES = \
+  gnunet-service-rps_custommap.h gnunet-service-rps_custommap.c \
+  test_service_rps_custommap.c
+test_service_rps_custommap_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+test_service_rps_sampler_elem_SOURCES = \
+  gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
+  rps-test_util.h rps-test_util.c \
+  test_service_rps_sampler_elem.c
+test_service_rps_sampler_elem_LDADD = $(top_builddir)/src/lib/util/libgnunetutil.la
+
+#test_rps_single_req_SOURCES = $(rps_test_src)
+#test_rps_single_req_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_seed_request_SOURCES = $(rps_test_src)
+#test_rps_seed_request_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_req_cancel_SOURCES = $(rps_test_src)
+#test_rps_req_cancel_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_sub_SOURCES = $(rps_test_src)
+#test_rps_sub_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_seed_big_SOURCES = $(rps_test_src)
+#test_rps_seed_big_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_churn_SOURCES = $(rps_test_src)
+#test_rps_churn_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_malicious_1_SOURCES = $(rps_test_src)
+#test_rps_malicious_1_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_malicious_2_SOURCES = $(rps_test_src)
+#test_rps_malicious_2_LDADD = $(ld_rps_test_lib)
+#
+#test_rps_malicious_3_SOURCES = $(rps_test_src)
+#test_rps_malicious_3_LDADD = $(ld_rps_test_lib)
+
+#gnunet_rps_profiler_SOURCES = \
+# gnunet-service-rps_sampler_elem.h gnunet-service-rps_sampler_elem.c \
+# rps-sampler_common.h rps-sampler_common.c \
+# gnunet-service-rps_sampler.h gnunet-service-rps_sampler.c \
+# rps-test_util.h rps-test_util.c \
+# gnunet-rps-profiler.c
+#gnunet_rps_profiler_LDADD = \
+#  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+#  libgnunetrps.la \
+#  $(top_builddir)/src/lib/util/libgnunetutil.la \
+#  $(top_builddir)/src/testbed/libgnunettestbed.la \
+#  -lm
+
+
+EXTRA_DIST = \
+  test_rps.conf
diff --git a/src/contrib/service/rps/gnunet-rps-profiler.c b/src/contrib/service/rps/gnunet-rps-profiler.c
new file mode 100644
index 000000000..df10ad5da
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-rps-profiler.c
@@ -0,0 +1,3199 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file rps/test_rps.c
+ * @brief Testcase for the random peer sampling service.  Starts
+ *        a peergroup with a given number of peers, then waits to
+ *        receive size pushes/pulls from each peer.  Expects to wait
+ *        for one message from each peer.
+ */
+#include "platform.h"
+// #include "rps_test_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testbed_service.h"
+
+#include "gnunet_rps_service.h"
+#include "rps-test_util.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <inttypes.h>
+
+
+#define BIT(n) (1 << (n))
+
+/**
+ * How many peers do we start?
+ */
+static uint32_t num_peers;
+
+/**
+ * @brief number of bits required to represent the largest peer id
+ */
+static unsigned bits_needed;
+
+/**
+ * How long do we run the test?
+ */
+static struct GNUNET_TIME_Relative duration;
+
+/**
+ * When do we do a hard shutdown?
+ */
+static struct GNUNET_TIME_Relative timeout;
+
+
+// /**
+//  * Portion of malicious peers
+//  */
+// static double portion = .1;
+
+/**
+ * Type of malicious peer to test
+ */
+static unsigned int mal_type = 0;
+
+/**
+ * Handles to all of the running peers
+ */
+static struct GNUNET_TESTBED_Peer **testbed_peers;
+
+enum STAT_TYPE
+{
+  STAT_TYPE_ROUNDS,                   /*   0 */
+  STAT_TYPE_BLOCKS,                   /*   1 */
+  STAT_TYPE_BLOCKS_MANY_PUSH,         /*   2 */
+  STAT_TYPE_BLOCKS_NO_PUSH,           /*   3 */
+  STAT_TYPE_BLOCKS_NO_PULL,           /*   4 */
+  STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL, /*   5 */
+  STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL,   /*   6 */
+  STAT_TYPE_ISSUED_PUSH_SEND,         /*   7 */
+  STAT_TYPE_ISSUED_PUSH_SEND_MH,      /*   8 */
+  STAT_TYPE_ISSUED_PULL_REQ,          /*   9 */
+  STAT_TYPE_ISSUED_PULL_REQ_MH,       /*  10 */
+  STAT_TYPE_ISSUED_PULL_REP,          /*  11 */
+  STAT_TYPE_SENT_PUSH_SEND,           /*  12 */
+  STAT_TYPE_SENT_PULL_REQ,            /*  13 */
+  STAT_TYPE_SENT_PULL_REQ_MH,         /*  14 */
+  STAT_TYPE_SENT_PULL_REP,            /*  15 */
+  STAT_TYPE_RECV_PUSH_SEND,           /*  16 */
+  STAT_TYPE_RECV_PUSH_SEND_MH,        /*  17 */
+  STAT_TYPE_RECV_PULL_REQ,            /*  18 */
+  STAT_TYPE_RECV_PULL_REQ_MH,         /*  19 */
+  STAT_TYPE_RECV_PULL_REP,            /*  20 */
+  STAT_TYPE_RECV_PULL_REP_MH,         /*  21 */
+  STAT_TYPE_VIEW_SIZE,                /*  22 */
+  STAT_TYPE_KNOWN_PEERS,              /*  23 */
+  STAT_TYPE_VALID_PEERS,              /*  24 */
+  STAT_TYPE_LEARND_PEERS,             /*  25 */
+  STAT_TYPE_PENDING_ONLINE_CHECKS,    /*  26 */
+  STAT_TYPE_UNREQUESTED_PULL_REPLIES, /*  27 */
+  STAT_TYPE_PEERS_IN_PUSH_MAP,        /*  28 */
+  STAT_TYPE_PEERS_IN_PULL_MAP,        /*  29 */
+  STAT_TYPE_PEERS_IN_VIEW,            /*  30 */
+  STAT_TYPE_VIEW_SIZE_AIM,            /*  31 */
+  STAT_TYPE_MAX,                      /*  32 */
+};
+
+static char*stat_type_strings[] = {
+  "# rounds",
+  "# rounds blocked",
+  "# rounds blocked - too many pushes",
+  "# rounds blocked - no pushes",
+  "# rounds blocked - no pull replies",
+  "# rounds blocked - too many pushes, no pull replies",
+  "# rounds blocked - no pushes, no pull replies",
+  "# push send issued",
+  "# push send issued (multi-hop peer)",
+  "# pull request send issued",
+  "# pull request send issued (multi-hop peer)",
+  "# pull reply send issued",
+  "# pushes sent",
+  "# pull requests sent",
+  "# pull requests sent (multi-hop peer)",
+  "# pull replies sent",
+  "# push message received",
+  "# push message received (multi-hop peer)",
+  "# pull request message received",
+  "# pull request message received (multi-hop peer)",
+  "# pull reply messages received",
+  "# pull reply messages received (multi-hop peer)",
+  "view size",
+  "# known peers",
+  "# valid peers",
+  "# learnd peers",
+  "# pending online checks",
+  "# unrequested pull replies",
+  "# peers in push map at end of round",
+  "# peers in pull map at end of round",
+  "# peers in view at end of round",
+  "view size aim",
+};
+
+struct STATcls
+{
+  struct RPSPeer *rps_peer;
+  enum STAT_TYPE stat_type;
+};
+
+
+/**
+ * @brief Converts string representation to the corresponding #STAT_TYPE enum.
+ *
+ * @param stat_str string representation of statistics specifier
+ *
+ * @return corresponding enum
+ */
+enum STAT_TYPE
+stat_str_2_type (const char *stat_str)
+{
+  if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL],
+                    stat_str,
+                    strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL])))
+  {
+    return STAT_TYPE_BLOCKS_NO_PULL;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL])))
+  {
+    return STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH])))
+  {
+    return STAT_TYPE_BLOCKS_MANY_PUSH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL])))
+  {
+    return STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH])))
+  {
+    return STAT_TYPE_BLOCKS_NO_PUSH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_BLOCKS])))
+  {
+    return STAT_TYPE_BLOCKS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ROUNDS],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_ROUNDS])))
+  {
+    return STAT_TYPE_ROUNDS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND])))
+  {
+    return STAT_TYPE_ISSUED_PUSH_SEND;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND_MH])))
+  {
+    return STAT_TYPE_ISSUED_PUSH_SEND_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ])))
+  {
+    return STAT_TYPE_ISSUED_PULL_REQ;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH])))
+  {
+    return STAT_TYPE_ISSUED_PULL_REQ_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP])))
+  {
+    return STAT_TYPE_ISSUED_PULL_REP;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND])))
+  {
+    return STAT_TYPE_SENT_PUSH_SEND;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REQ])))
+  {
+    return STAT_TYPE_SENT_PULL_REQ;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH])))
+  {
+    return STAT_TYPE_SENT_PULL_REQ_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REP],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REP])))
+  {
+    return STAT_TYPE_SENT_PULL_REP;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND])))
+  {
+    return STAT_TYPE_RECV_PUSH_SEND;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_RECV_PUSH_SEND_MH])))
+  {
+    return STAT_TYPE_RECV_PUSH_SEND_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REQ])))
+  {
+    return STAT_TYPE_RECV_PULL_REQ;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH])))
+  {
+    return STAT_TYPE_RECV_PULL_REQ_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REP])))
+  {
+    return STAT_TYPE_RECV_PULL_REP;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH])))
+  {
+    return STAT_TYPE_RECV_PULL_REP_MH;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE])))
+  {
+    return STAT_TYPE_VIEW_SIZE;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_KNOWN_PEERS],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_KNOWN_PEERS])))
+  {
+    return STAT_TYPE_KNOWN_PEERS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VALID_PEERS],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_VALID_PEERS])))
+  {
+    return STAT_TYPE_VALID_PEERS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_LEARND_PEERS],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_LEARND_PEERS])))
+  {
+    return STAT_TYPE_LEARND_PEERS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS])))
+  {
+    return STAT_TYPE_PENDING_ONLINE_CHECKS;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_UNREQUESTED_PULL_REPLIES],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_UNREQUESTED_PULL_REPLIES])))
+  {
+    return STAT_TYPE_UNREQUESTED_PULL_REPLIES;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP])))
+  {
+    return STAT_TYPE_PEERS_IN_PUSH_MAP;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP],
+                         stat_str,
+                         strlen (
+                           stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP])))
+  {
+    return STAT_TYPE_PEERS_IN_PULL_MAP;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW])))
+  {
+    return STAT_TYPE_PEERS_IN_VIEW;
+  }
+  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM],
+                         stat_str,
+                         strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM])))
+  {
+    return STAT_TYPE_VIEW_SIZE_AIM;
+  }
+  return STAT_TYPE_MAX;
+}
+
+
+/**
+ * @brief Indicates whether peer should go off- or online
+ */
+enum PEER_ONLINE_DELTA
+{
+  /**
+   * @brief Indicates peer going online
+   */
+  PEER_GO_ONLINE = 1,
+  /**
+   * @brief Indicates peer going offline
+   */
+  PEER_GO_OFFLINE = -1,
+};
+
+/**
+ * Operation map entry
+ */
+struct OpListEntry
+{
+  /**
+   * DLL next ptr
+   */
+  struct OpListEntry *next;
+
+  /**
+   * DLL prev ptr
+   */
+  struct OpListEntry *prev;
+
+  /**
+   * The testbed operation
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+  /**
+   * Depending on whether we start or stop RPS service at the peer, set this to
+   * #PEER_GO_ONLINE (1) or #PEER_GO_OFFLINE (-1)
+   */
+  enum PEER_ONLINE_DELTA delta;
+
+  /**
+   * Index of the regarding peer
+   */
+  unsigned int index;
+};
+
+/**
+ * OpList DLL head
+ */
+static struct OpListEntry *oplist_head;
+
+/**
+ * OpList DLL tail
+ */
+static struct OpListEntry *oplist_tail;
+
+
+/**
+ * A pending reply: A request was sent and the reply is pending.
+ */
+struct PendingReply
+{
+  /**
+   * DLL next,prev ptr
+   */
+  struct PendingReply *next;
+  struct PendingReply *prev;
+
+  /**
+   * Handle to the request we are waiting for
+   */
+  struct GNUNET_RPS_Request_Handle_Single_Info *req_handle;
+
+  /**
+   * The peer that requested
+   */
+  struct RPSPeer *rps_peer;
+};
+
+
+/**
+ * A pending request: A request was not made yet but is scheduled for later.
+ */
+struct PendingRequest
+{
+  /**
+   * DLL next,prev ptr
+   */
+  struct PendingRequest *next;
+  struct PendingRequest *prev;
+
+  /**
+   * Handle to the request we are waiting for
+   */
+  struct GNUNET_SCHEDULER_Task *request_task;
+
+  /**
+   * The peer that requested
+   */
+  struct RPSPeer *rps_peer;
+};
+
+
+/**
+ * Information we track for each peer.
+ */
+struct RPSPeer
+{
+  /**
+   * Index of the peer.
+   */
+  uint32_t index;
+
+  /**
+   * Handle for RPS connect operation.
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+  /**
+   * Handle to RPS service.
+   */
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  /**
+   * ID of the peer.
+   */
+  struct GNUNET_PeerIdentity *peer_id;
+
+  /**
+   * A request handle to check for an request
+   */
+  // struct GNUNET_RPS_Request_Handle *req_handle;
+
+  /**
+   * Peer on- or offline?
+   */
+  int online;
+
+  /**
+   * Number of Peer IDs to request during the whole test
+   */
+  unsigned int num_ids_to_request;
+
+  /**
+   * Pending requests DLL
+   */
+  struct PendingRequest *pending_req_head;
+  struct PendingRequest *pending_req_tail;
+
+  /**
+   * Number of pending requests
+   */
+  unsigned int num_pending_reqs;
+
+  /**
+   * Pending replies DLL
+   */
+  struct PendingReply *pending_rep_head;
+  struct PendingReply *pending_rep_tail;
+
+  /**
+   * Number of pending replies
+   */
+  unsigned int num_pending_reps;
+
+  /**
+   * Number of received PeerIDs
+   */
+  unsigned int num_recv_ids;
+
+  /**
+   * Pending operation on that peer
+   */
+  const struct OpListEntry *entry_op_manage;
+
+  /**
+   * Testbed operation to connect to statistics service
+   */
+  struct GNUNET_TESTBED_Operation *stat_op;
+
+  /**
+   * Handle to the statistics service
+   */
+  struct GNUNET_STATISTICS_Handle *stats_h;
+
+  /**
+   * @brief flags to indicate which statistics values have been already
+   * collected from the statistics service.
+   * Used to check whether we are able to shutdown.
+   */
+  uint32_t stat_collected_flags;
+
+  /**
+   * @brief File name of the file the stats are finally written to
+   */
+  const char *file_name_stats;
+
+  /**
+   * @brief File name of the file the stats are finally written to
+   */
+  const char *file_name_probs;
+
+  /**
+   * @brief File name of the file the stats are finally written to
+   */
+  const char *file_name_probs_hist;
+
+  /**
+   * @brief The current view
+   */
+  struct GNUNET_PeerIdentity *cur_view;
+
+  /**
+   * @brief Number of peers in the #cur_view.
+   */
+  uint32_t cur_view_count;
+
+  /**
+   * @brief Number of occurrences in other peer's view
+   */
+  uint32_t count_in_views;
+
+  /**
+   * @brief statistics values
+   */
+  uint64_t stats[STAT_TYPE_MAX];
+  /**
+   * @brief Handle for the statistics get request
+   */
+  struct GNUNET_STATISTICS_GetHandle *h_stat_get[STAT_TYPE_MAX];
+
+  /**
+   * @brief Keep the probabilities in cache for computing the probabilities
+   * with respect to history.
+   */
+  double *eval_probs_cache;
+};
+
+/**
+ * Information for all the peers.
+ */
+static struct RPSPeer *rps_peers;
+
+/**
+ * Peermap to get the index of a given peer ID quick.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+
+/**
+ * IDs of the peers.
+ */
+static struct GNUNET_PeerIdentity *rps_peer_ids;
+
+/**
+ * ID of the targeted peer.
+ */
+static struct GNUNET_PeerIdentity *target_peer;
+
+/**
+ * Number of online peers.
+ */
+static unsigned int num_peers_online;
+
+/**
+ * @brief The added sizes of the peer's views
+ */
+static unsigned int view_sizes;
+
+/**
+ * Return value from 'main'.
+ */
+static int ok;
+
+/**
+ * Identifier for the task that runs after the test to collect results
+ */
+static struct GNUNET_SCHEDULER_Task *post_test_task;
+
+/**
+ * Identifier for the shutdown task
+ */
+static struct GNUNET_SCHEDULER_Task *shutdown_task;
+
+
+/**
+ * Identifier for the churn task that runs periodically
+ */
+static struct GNUNET_SCHEDULER_Task *churn_task;
+
+/**
+ * Called to initialise the given RPSPeer
+ */
+typedef void (*InitPeer) (struct RPSPeer *rps_peer);
+
+/**
+ * @brief Called directly after connecting to the service
+ *
+ * @param rps_peer Specific peer the function is called on
+ * @param h the handle to the rps service
+ */
+typedef void (*PreTest) (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h);
+
+/**
+ * @brief Executes functions to test the api/service for a given peer
+ *
+ * Called from within #rps_connect_complete_cb ()
+ * Implemented by #churn_test_cb, #profiler_cb, #mal_cb, #single_req_cb,
+ * #delay_req_cb, #seed_big_cb, #single_peer_seed_cb, #seed_cb, #req_cancel_cb
+ *
+ * @param rps_peer the peer the task runs on
+ */
+typedef void (*MainTest) (struct RPSPeer *rps_peer);
+
+/**
+ * Callback called once the requested random peers are available
+ */
+typedef void (*ReplyHandle) (void *cls,
+                             uint64_t n,
+                             const struct GNUNET_PeerIdentity *recv_peers);
+
+/**
+ * Called directly before disconnecting from the service
+ */
+typedef void (*PostTest) (struct RPSPeer *peer);
+
+/**
+ * Function called after disconnect to evaluate test success
+ */
+typedef int (*EvaluationCallback) (void);
+
+/**
+ * @brief Do we have Churn?
+ */
+enum OPTION_CHURN
+{
+  /**
+   * @brief If we have churn this is set
+   */
+  HAVE_CHURN,
+  /**
+   * @brief If we have no churn this is set
+   */
+  HAVE_NO_CHURN,
+};
+
+/**
+ * @brief Is it ok to quit the test before the timeout?
+ */
+enum OPTION_QUICK_QUIT
+{
+  /**
+   * @brief It is ok for the test to quit before the timeout triggers
+   */
+  HAVE_QUICK_QUIT,
+
+  /**
+   * @brief It is NOT ok for the test to quit before the timeout triggers
+   */
+  HAVE_NO_QUICK_QUIT,
+};
+
+/**
+ * @brief Do we collect statistics at the end?
+ */
+enum OPTION_COLLECT_STATISTICS
+{
+  /**
+   * @brief We collect statistics at the end
+   */
+  COLLECT_STATISTICS,
+
+  /**
+   * @brief We do not collect statistics at the end
+   */
+  NO_COLLECT_STATISTICS,
+};
+
+/**
+ * @brief Do we collect views during run?
+ */
+enum OPTION_COLLECT_VIEW
+{
+  /**
+   * @brief We collect view during run
+   */
+  COLLECT_VIEW,
+
+  /**
+   * @brief We do not collect the view during run
+   */
+  NO_COLLECT_VIEW,
+};
+
+/**
+ * Structure to define a single test
+ */
+struct SingleTestRun
+{
+  /**
+   * Name of the test
+   */
+  char *name;
+
+  /**
+   * Called with a single peer in order to initialise that peer
+   */
+  InitPeer init_peer;
+
+  /**
+   * Called directly after connecting to the service
+   */
+  PreTest pre_test;
+
+  /**
+   * Main function for each peer
+   */
+  MainTest main_test;
+
+  /**
+   * Callback called once the requested peers are available
+   */
+  ReplyHandle reply_handle;
+
+  /**
+   * Called directly before disconnecting from the service
+   */
+  PostTest post_test;
+
+  /**
+   * Function to evaluate the test results
+   */
+  EvaluationCallback eval_cb;
+
+  /**
+   * Request interval
+   */
+  uint32_t request_interval;
+
+  /**
+   * Number of Requests to make.
+   */
+  uint32_t num_requests;
+
+  /**
+   * Run with (-out) churn
+   */
+  enum OPTION_CHURN have_churn;
+
+  /**
+   * Quit test before timeout?
+   */
+  enum OPTION_QUICK_QUIT have_quick_quit;
+
+  /**
+   * Collect statistics at the end?
+   */
+  enum OPTION_COLLECT_STATISTICS have_collect_statistics;
+
+  /**
+   * Collect view during run?
+   */
+  enum OPTION_COLLECT_VIEW have_collect_view;
+
+  /**
+   * @brief Mark which values from the statistics service to collect at the end
+   * of the run
+   */
+  uint32_t stat_collect_flags;
+} cur_test_run;
+
+/**
+ * Did we finish the test?
+ */
+static int post_test;
+
+/**
+ * Are we shutting down?
+ */
+static int in_shutdown;
+
+/**
+ * Append arguments to file
+ */
+static void
+tofile_ (const char *file_name, const char *line)
+{
+  struct GNUNET_DISK_FileHandle *f;
+  /* char output_buffer[512]; */
+  size_t size;
+  /* int size; */
+  size_t size2;
+
+  if (NULL == (f = GNUNET_DISK_file_open (file_name,
+                                          GNUNET_DISK_OPEN_APPEND
+                                          | GNUNET_DISK_OPEN_WRITE
+                                          | GNUNET_DISK_OPEN_CREATE,
+                                          GNUNET_DISK_PERM_USER_READ
+                                          | GNUNET_DISK_PERM_USER_WRITE
+                                          | GNUNET_DISK_PERM_GROUP_READ
+                                          | GNUNET_DISK_PERM_OTHER_READ)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Not able to open file %s\n",
+                file_name);
+    return;
+  }
+  /* size = GNUNET_snprintf (output_buffer,
+                          sizeof (output_buffer),
+                          "%llu %s\n",
+                          GNUNET_TIME_absolute_get ().abs_value_us,
+                          line);
+     if (0 > size)
+     {
+     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to write string to buffer (size: %i)\n",
+                size);
+     return;
+     } */size = strlen (line) * sizeof(char);
+
+  size2 = GNUNET_DISK_file_write (f, line, size);
+  if (size != size2)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unable to write to file! (Size: %lu, size2: %lu)\n",
+                size,
+                size2);
+    if (GNUNET_YES != GNUNET_DISK_file_close (f))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Unable to close file\n");
+    }
+    return;
+  }
+
+  if (GNUNET_YES != GNUNET_DISK_file_close (f))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unable to close file\n");
+  }
+}
+
+
+/**
+ * This function is used to facilitate writing important information to disk
+ */
+#define tofile(file_name, ...) do { \
+    char tmp_buf[512]; \
+    int size; \
+    size = GNUNET_snprintf (tmp_buf, sizeof(tmp_buf), __VA_ARGS__); \
+    if (0 > size) \
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \
+                "Failed to create tmp_buf\n"); \
+    else \
+    tofile_ (file_name, tmp_buf); \
+} while (0);
+
+
+/**
+ * Write the ids and their according index in the given array to a file
+ * Unused
+ */
+/* static void
+   ids_to_file (char *file_name,
+             struct GNUNET_PeerIdentity *peer_ids,
+             unsigned int num_peer_ids)
+   {
+   unsigned int i;
+
+   for (i=0 ; i < num_peer_ids ; i++)
+   {
+    to_file (file_name,
+             "%u\t%s",
+             i,
+             GNUNET_i2s_full (&peer_ids[i]));
+   }
+   } */
+
+/**
+ * Test the success of a single test
+ */
+static int
+evaluate (void)
+{
+  unsigned int i;
+  int tmp_ok;
+
+  tmp_ok = 1;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u. peer [%s] received %u of %u expected peer_ids: %i\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                rps_peers[i].num_recv_ids,
+                rps_peers[i].num_ids_to_request,
+                (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids));
+    tmp_ok &= (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids);
+  }
+  return tmp_ok ? 0 : 1;
+}
+
+
+/**
+ * Creates an oplist entry and adds it to the oplist DLL
+ */
+static struct OpListEntry *
+make_oplist_entry ()
+{
+  struct OpListEntry *entry;
+
+  entry = GNUNET_new (struct OpListEntry);
+  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
+  return entry;
+}
+
+
+/**
+ * @brief Checks if given peer already received its statistics value from the
+ * statistics service.
+ *
+ * @param rps_peer the peer to check for
+ *
+ * @return #GNUNET_YES if so
+ *         #GNUNET_NO otherwise
+ */
+static int
+check_statistics_collect_completed_single_peer (
+  const struct RPSPeer *rps_peer)
+{
+  if (cur_test_run.stat_collect_flags !=
+      (cur_test_run.stat_collect_flags
+       & rps_peer->stat_collected_flags))
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Checks if all peers already received their statistics value from the
+ * statistics service.
+ *
+ * @return #GNUNET_YES if so
+ *         #GNUNET_NO otherwise
+ */
+static int
+check_statistics_collect_completed ()
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    if (GNUNET_NO == check_statistics_collect_completed_single_peer (
+          &rps_peers[i]))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "At least Peer %" PRIu32
+                  " did not yet receive all statistics values\n",
+                  i);
+      return GNUNET_NO;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All peers received their statistics values\n");
+  return GNUNET_YES;
+}
+
+
+static void
+rps_disconnect_adapter (void *cls,
+                        void *op_result);
+
+static void
+cancel_pending_req (struct PendingRequest *pending_req)
+{
+  struct RPSPeer *rps_peer;
+
+  rps_peer = pending_req->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
+                               rps_peer->pending_req_tail,
+                               pending_req);
+  rps_peer->num_pending_reqs--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling pending rps get request\n");
+  GNUNET_SCHEDULER_cancel (pending_req->request_task);
+  GNUNET_free (pending_req);
+}
+
+
+static void
+cancel_request (struct PendingReply *pending_rep)
+{
+  struct RPSPeer *rps_peer;
+
+  rps_peer = pending_rep->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
+                               rps_peer->pending_rep_tail,
+                               pending_rep);
+  rps_peer->num_pending_reps--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling rps get reply\n");
+  GNUNET_assert (NULL != pending_rep->req_handle);
+  GNUNET_RPS_request_single_info_cancel (pending_rep->req_handle);
+  pending_rep->req_handle = NULL;
+  GNUNET_free (pending_rep);
+  pending_rep = NULL;
+}
+
+
+void
+clean_peer (unsigned peer_index)
+{
+  struct PendingRequest *pending_req;
+
+  while (NULL != (pending_req = rps_peers[peer_index].pending_req_head))
+  {
+    cancel_pending_req (pending_req);
+  }
+  pending_req = rps_peers[peer_index].pending_req_head;
+  rps_disconnect_adapter (&rps_peers[peer_index],
+                          &rps_peers[peer_index].rps_handle);
+  for (unsigned stat_type = STAT_TYPE_ROUNDS;
+       stat_type < STAT_TYPE_MAX;
+       stat_type++)
+  {
+    if (NULL != rps_peers[peer_index].h_stat_get[stat_type])
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "(%u) did not yet receive stat value for `%s'\n",
+                  rps_peers[peer_index].index,
+                  stat_type_strings[stat_type]);
+      GNUNET_STATISTICS_get_cancel (
+        rps_peers[peer_index].h_stat_get[stat_type]);
+    }
+  }
+  if (NULL != rps_peers[peer_index].op)
+  {
+    GNUNET_TESTBED_operation_done (rps_peers[peer_index].op);
+    rps_peers[peer_index].op = NULL;
+  }
+}
+
+
+/**
+ * Task run on timeout to shut everything down.
+ */
+static void
+shutdown_op (void *cls)
+{
+  unsigned int i;
+  struct OpListEntry *entry;
+
+  (void) cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Shutdown task scheduled, going down.\n");
+  in_shutdown = GNUNET_YES;
+
+  if (NULL != shutdown_task)
+  {
+    GNUNET_SCHEDULER_cancel (shutdown_task);
+    shutdown_task = NULL;
+  }
+  if (NULL != post_test_task)
+  {
+    GNUNET_SCHEDULER_cancel (post_test_task);
+    post_test_task = NULL;
+  }
+  if (NULL != churn_task)
+  {
+    GNUNET_SCHEDULER_cancel (churn_task);
+    churn_task = NULL;
+  }
+  entry = oplist_head;
+  while (NULL != (entry = oplist_head))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Operation still pending on shutdown (%u)\n",
+                entry->index);
+    GNUNET_TESTBED_operation_done (entry->op);
+    GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+    GNUNET_free (entry);
+  }
+  for (i = 0; i < num_peers; i++)
+  {
+    clean_peer (i);
+  }
+  close_all_files ();
+}
+
+
+static void
+trigger_shutdown (void *cls)
+{
+  (void) cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Shutdown was triggered by timeout, going down.\n");
+  shutdown_task = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Task run after #duration to collect statistics and potentially shut down.
+ */
+static void
+post_test_op (void *cls)
+{
+  unsigned int i;
+
+  (void) cls;
+
+  post_test_task = NULL;
+  post_test = GNUNET_YES;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Executing post test op.\n");
+  if (NULL != churn_task)
+  {
+    GNUNET_SCHEDULER_cancel (churn_task);
+    churn_task = NULL;
+  }
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Executing post test op. (peer %" PRIu32 ")\n",
+                rps_peers[i].index);
+    if (NULL != rps_peers[i].op)
+    {
+      GNUNET_TESTBED_operation_done (rps_peers[i].op);
+      rps_peers[i].op = NULL;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Cancelled testbed operation\n");
+    }
+    if (NULL != cur_test_run.post_test)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing post_test for peer %u\n",
+                  i);
+      cur_test_run.post_test (&rps_peers[i]);
+    }
+  }
+  /* If we do not collect statistics, shut down directly */
+  if ((NO_COLLECT_STATISTICS == cur_test_run.have_collect_statistics) ||
+      (GNUNET_YES == check_statistics_collect_completed ()) )
+  {
+    GNUNET_SCHEDULER_cancel (shutdown_task);
+    shutdown_task = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Get the id of peer i.
+ */
+void
+info_cb (void *cb_cls,
+         struct GNUNET_TESTBED_Operation *op,
+         const struct GNUNET_TESTBED_PeerInformation *pinfo,
+         const char *emsg)
+{
+  struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
+
+  (void) op;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  if ((NULL == pinfo) || (NULL != emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got Error: %s\n", emsg);
+    GNUNET_TESTBED_operation_done (entry->op);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u is %s\n",
+              entry->index,
+              GNUNET_i2s (pinfo->result.id));
+
+  rps_peer_ids[entry->index] = *(pinfo->result.id);
+  rps_peers[entry->index].peer_id = &rps_peer_ids[entry->index];
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (peer_map,
+                                                    &rps_peer_ids[entry->index],
+                                                    &rps_peers[entry->index],
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  tofile ("/tmp/rps/peer_ids",
+          "%u\t%s\n",
+          entry->index,
+          GNUNET_i2s_full (&rps_peer_ids[entry->index]));
+
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  GNUNET_TESTBED_operation_done (entry->op);
+  GNUNET_free (entry);
+}
+
+
+/**
+ * Callback to be called when RPS service connect operation is completed
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @param op the operation that has been finished
+ * @param ca_result the RPS service handle returned from rps_connect_adapter
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+rps_connect_complete_cb (void *cls,
+                         struct GNUNET_TESTBED_Operation *op,
+                         void *ca_result,
+                         const char *emsg)
+{
+  struct RPSPeer *rps_peer = cls;
+  struct GNUNET_RPS_Handle *rps = ca_result;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  rps_peer->rps_handle = rps;
+  rps_peer->online = GNUNET_YES;
+  num_peers_online++;
+
+  GNUNET_assert (op == rps_peer->op);
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to RPS service: %s\n",
+                emsg);
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Started client successfully (%u)\n",
+              rps_peer->index);
+
+  cur_test_run.main_test (rps_peer);
+}
+
+
+/**
+ * Adapter function called to establish a connection to
+ * the RPS service.
+ *
+ * @param cls closure
+ * @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 *
+rps_connect_adapter (void *cls,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_RPS_Handle *h;
+
+  h = GNUNET_RPS_connect (cfg);
+
+  if (NULL != cur_test_run.pre_test)
+    cur_test_run.pre_test (cls, h);
+
+  return h;
+}
+
+
+/**
+ * Called to open a connection to the peer's statistics
+ *
+ * @param cls peer 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 *
+stat_connect_adapter (void *cls,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct RPSPeer *peer = cls;
+
+  peer->stats_h = GNUNET_STATISTICS_create ("rps-profiler", cfg);
+  return peer->stats_h;
+}
+
+
+/**
+ * Called to disconnect from peer's statistics service
+ *
+ * @param cls peer context
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+stat_disconnect_adapter (void *cls, void *op_result)
+{
+  struct RPSPeer *peer = cls;
+
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "core", "# peers connected",
+  //               stat_iterator, peer));
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "nse", "# peers connected",
+  //               stat_iterator, peer));
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
+  peer->stats_h = NULL;
+}
+
+
+/**
+ * Called after successfully opening a connection to a peer's statistics
+ * service; we register statistics monitoring for CORE and NSE here.
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @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
+stat_complete_cb (void *cls,
+                  struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result,
+                  const char *emsg)
+{
+  // struct GNUNET_STATISTICS_Handle *sh = ca_result;
+  // struct RPSPeer *peer = (struct RPSPeer *) cls;
+  (void) cls;
+  (void) op;
+  (void) ca_result;
+
+  if (NULL != emsg)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "core", "# peers connected",
+  //               stat_iterator, peer));
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "nse", "# peers connected",
+  //               stat_iterator, peer));
+}
+
+
+/**
+ * Adapter function called to destroy connection to
+ * RPS service.
+ *
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+rps_disconnect_adapter (void *cls,
+                        void *op_result)
+{
+  struct RPSPeer *peer = cls;
+  struct GNUNET_RPS_Handle *h = op_result;
+  struct PendingReply *pending_rep;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "disconnect_adapter (%u)\n",
+              peer->index);
+  GNUNET_assert (NULL != peer);
+  if (NULL != peer->rps_handle)
+  {
+    while (NULL != (pending_rep = peer->pending_rep_head))
+    {
+      cancel_request (pending_rep);
+    }
+    GNUNET_assert (h == peer->rps_handle);
+    if (NULL != h)
+    {
+      GNUNET_RPS_disconnect (h);
+      h = NULL;
+    }
+    peer->rps_handle = NULL;
+  }
+}
+
+
+/***********************************************************************
+* Definition of tests
+***********************************************************************/
+
+/**
+ * Callback to call on receipt of a reply
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+default_reply_handle (void *cls,
+                      uint64_t n,
+                      const struct GNUNET_PeerIdentity *recv_peers)
+{
+  struct RPSPeer *rps_peer;
+  struct PendingReply *pending_rep = (struct PendingReply *) cls;
+  unsigned int i;
+
+  rps_peer = pending_rep->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
+                               rps_peer->pending_rep_tail,
+                               pending_rep);
+  rps_peer->num_pending_reps--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "[%s] got %" PRIu64 " peers:\n",
+              GNUNET_i2s (rps_peer->peer_id),
+              n);
+
+  for (i = 0; i < n; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u: %s\n",
+                i,
+                GNUNET_i2s (&recv_peers[i]));
+
+    rps_peer->num_recv_ids++;
+  }
+
+  if (GNUNET_YES != post_test)
+    return;
+  if (HAVE_QUICK_QUIT != cur_test_run.have_quick_quit)
+    return;
+  if (0 == evaluate ())
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Test succeeded before end of duration\n");
+    if (NULL != post_test_task)
+      GNUNET_SCHEDULER_cancel (post_test_task);
+    post_test_task = GNUNET_SCHEDULER_add_now (&post_test_op, NULL);
+    GNUNET_assert (NULL != post_test_task);
+  }
+}
+
+
+static void
+profiler_reply_handle_info (void *cls,
+                            const struct GNUNET_PeerIdentity *recv_peer,
+                            double probability,
+                            uint32_t num_observed);
+
+/**
+ * Request random peers.
+ */
+static void
+request_peers (void *cls)
+{
+  struct PendingRequest *pending_req = cls;
+  struct RPSPeer *rps_peer;
+  struct PendingReply *pending_rep;
+
+  rps_peer = pending_req->rps_peer;
+  GNUNET_assert (1 <= rps_peer->num_pending_reqs);
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
+                               rps_peer->pending_req_tail,
+                               pending_req);
+  rps_peer->num_pending_reqs--;
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Requesting one peer\n");
+  pending_rep = GNUNET_new (struct PendingReply);
+  pending_rep->rps_peer = rps_peer;
+  // pending_rep->req_handle = GNUNET_RPS_request_peers (rps_peer->rps_handle,
+  //    1,
+  //    cur_test_run.reply_handle,
+  //    pending_rep);
+  pending_rep->req_handle = GNUNET_RPS_request_peer_info (rps_peer->rps_handle,
+                                                          profiler_reply_handle_info,
+                                                          pending_rep);
+  GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_rep_head,
+                                    rps_peer->pending_rep_tail,
+                                    pending_rep);
+  rps_peer->num_pending_reps++;
+}
+
+
+/**
+ * Schedule requests for peer @a rps_peer that have neither been scheduled, nor
+ * issued, nor replied
+ */
+void
+schedule_missing_requests (struct RPSPeer *rps_peer)
+{
+  unsigned int i;
+  struct PendingRequest *pending_req;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling %u - %u missing requests\n",
+              rps_peer->num_ids_to_request,
+              rps_peer->num_pending_reqs + rps_peer->num_pending_reps);
+  GNUNET_assert (rps_peer->num_pending_reqs + rps_peer->num_pending_reps <=
+                 rps_peer->num_ids_to_request);
+  for (i = rps_peer->num_pending_reqs + rps_peer->num_pending_reps;
+       i < rps_peer->num_ids_to_request; i++)
+  {
+    pending_req = GNUNET_new (struct PendingRequest);
+    pending_req->rps_peer = rps_peer;
+    pending_req->request_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     cur_test_run.request_interval * i),
+      request_peers,
+      pending_req);
+    GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_req_head,
+                                      rps_peer->pending_req_tail,
+                                      pending_req);
+    rps_peer->num_pending_reqs++;
+  }
+}
+
+
+void
+cancel_pending_req_rep (struct RPSPeer *rps_peer)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling all (pending) requests.\n");
+  while (NULL != rps_peer->pending_req_head)
+    cancel_pending_req (rps_peer->pending_req_head);
+  GNUNET_assert (0 == rps_peer->num_pending_reqs);
+  while (NULL != rps_peer->pending_rep_head)
+    cancel_request (rps_peer->pending_rep_head);
+  GNUNET_assert (0 == rps_peer->num_pending_reps);
+}
+
+
+/***********************************
+* MALICIOUS
+***********************************/
+
+///**
+// * Initialise only non-mal RPSPeers
+// */
+//static void
+//mal_init_peer (struct RPSPeer *rps_peer)
+//{
+//  if (rps_peer->index >= round (portion * num_peers))
+//    rps_peer->num_ids_to_request = 1;
+//}
+
+
+///**
+// * @brief Set peers to (non-)malicious before execution
+// *
+// * Of signature #PreTest
+// *
+// * @param rps_peer the peer to set (non-) malicious
+// * @param h the handle to the service
+// */
+//static void
+//mal_pre (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
+//{
+//  #if ENABLE_MALICIOUS
+//  uint32_t num_mal_peers;
+//
+//  GNUNET_assert ((1 >= portion) &&
+//                 (0 < portion));
+//  num_mal_peers = round (portion * num_peers);
+//
+//  if (rps_peer->index < num_mal_peers)
+//  {
+//    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+//                "%u. peer [%s] of %" PRIu32
+//                " malicious peers turning malicious\n",
+//                rps_peer->index,
+//                GNUNET_i2s (rps_peer->peer_id),
+//                num_mal_peers);
+//
+//    GNUNET_RPS_act_malicious (h, mal_type, num_mal_peers,
+//                              rps_peer_ids, target_peer);
+//  }
+//  #endif /* ENABLE_MALICIOUS */
+//}
+
+
+// static void
+// mal_cb (struct RPSPeer *rps_peer)
+// {
+//   if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+//   {
+//     return;
+//   }
+// 
+//   #if ENABLE_MALICIOUS
+//   uint32_t num_mal_peers;
+// 
+//   GNUNET_assert ((1 >= portion) &&
+//                  (0 < portion));
+//   num_mal_peers = round (portion * num_peers);
+// 
+//   if (rps_peer->index >= num_mal_peers)
+//   {   /* It's useless to ask a malicious peer about a random sample -
+//          it's not sampling */
+//     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+//                                     GNUNET_TIME_UNIT_SECONDS, 2),
+//                                   seed_peers, rps_peer);
+//     schedule_missing_requests (rps_peer);
+//   }
+//   #endif /* ENABLE_MALICIOUS */
+// }
+
+
+/***********************************
+* CHURN
+***********************************/
+
+static void
+churn (void *cls);
+
+
+/***********************************
+* PROFILER
+***********************************/
+
+/**
+ * Callback to be called when RPS service is started or stopped at peers
+ *
+ * @param cls NULL
+ * @param op the operation handle
+ * @param emsg NULL on success; otherwise an error description
+ */
+static void
+churn_cb (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          const char *emsg)
+{
+  // FIXME
+  struct OpListEntry *entry = cls;
+
+  (void) op;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  GNUNET_TESTBED_operation_done (entry->op);
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to start/stop RPS at a peer\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_assert (0 != entry->delta);
+
+  num_peers_online += entry->delta;
+
+  if (PEER_GO_OFFLINE == entry->delta)
+  {   /* Peer hopefully just went offline */
+    if (GNUNET_YES != rps_peers[entry->index].online)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "peer %s was expected to go offline but is still marked as online\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      GNUNET_break (0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "peer %s probably went offline as expected\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+    }
+    rps_peers[entry->index].online = GNUNET_NO;
+  }
+
+  else if (PEER_GO_ONLINE < entry->delta)
+  {   /* Peer hopefully just went online */
+    if (GNUNET_NO != rps_peers[entry->index].online)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "peer %s was expected to go online but is still marked as offline\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      GNUNET_break (0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "peer %s probably went online as expected\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      if (NULL != cur_test_run.pre_test)
+      {
+        cur_test_run.pre_test (&rps_peers[entry->index],
+                               rps_peers[entry->index].rps_handle);
+        schedule_missing_requests (&rps_peers[entry->index]);
+      }
+    }
+    rps_peers[entry->index].online = GNUNET_YES;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Invalid value for delta: %i\n", entry->delta);
+    GNUNET_break (0);
+  }
+
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  rps_peers[entry->index].entry_op_manage = NULL;
+  GNUNET_free (entry);
+  // if (num_peers_in_round[current_round] == peers_running)
+  //  run_round ();
+}
+
+
+/**
+ * @brief Set the rps-service up or down for a specific peer
+ *
+ * @param i index of action
+ * @param j index of peer
+ * @param delta (#PEER_ONLINE_DELTA) down (-1) or up (1)
+ * @param prob_go_on_off the probability of the action
+ */
+static void
+manage_service_wrapper (unsigned int i, unsigned int j,
+                        enum PEER_ONLINE_DELTA delta,
+                        double prob_go_on_off)
+{
+  struct OpListEntry *entry = NULL;
+  uint32_t prob;
+
+  /* make sure that management operation is not already scheduled */
+  if (NULL != rps_peers[j].entry_op_manage)
+  {
+    return;
+  }
+
+  prob = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                   UINT32_MAX);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%u. selected peer (%u: %s) is %s.\n",
+              i,
+              j,
+              GNUNET_i2s (rps_peers[j].peer_id),
+              (PEER_GO_ONLINE == delta) ? "online" : "offline");
+  if (prob < prob_go_on_off * UINT32_MAX)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%s goes %s\n",
+                GNUNET_i2s (rps_peers[j].peer_id),
+                (PEER_GO_OFFLINE == delta) ? "offline" : "online");
+
+    if (PEER_GO_OFFLINE == delta)
+      cancel_pending_req_rep (&rps_peers[j]);
+    entry = make_oplist_entry ();
+    entry->delta = delta;
+    entry->index = j;
+    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
+                                                    testbed_peers[j],
+                                                    "rps",
+                                                    &churn_cb,
+                                                    entry,
+                                                    (PEER_GO_OFFLINE == delta) ?
+                                                    0 : 1);
+    rps_peers[j].entry_op_manage = entry;
+  }
+}
+
+
+static void
+churn (void *cls)
+{
+  unsigned int i;
+  unsigned int j;
+  double portion_online;
+  unsigned int *permut;
+  double prob_go_offline;
+  double portion_go_online;
+  double portion_go_offline;
+
+  (void) cls;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Churn function executing\n");
+
+  churn_task = NULL; /* Should be invalid by now */
+
+  /* Compute the probability for an online peer to go offline
+   * this round */
+  portion_online = num_peers_online * 1.0 / num_peers;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion online: %f\n",
+              portion_online);
+  portion_go_online = ((1 - portion_online) * .5 * .66);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion that should go online: %f\n",
+              portion_go_online);
+  portion_go_offline = (portion_online + portion_go_online) - .75;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion that probably goes offline: %f\n",
+              portion_go_offline);
+  prob_go_offline = portion_go_offline / (portion_online * .5);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Probability of a selected online peer to go offline: %f\n",
+              prob_go_offline);
+
+  permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         (unsigned int) num_peers);
+
+  /* Go over 50% randomly chosen peers */
+  for (i = 0; i < .5 * num_peers; i++)
+  {
+    j = permut[i];
+
+    /* If online, shut down with certain probability */
+    if (GNUNET_YES == rps_peers[j].online)
+    {
+      manage_service_wrapper (i, j, -1, prob_go_offline);
+    }
+
+    /* If offline, restart with certain probability */
+    else if (GNUNET_NO == rps_peers[j].online)
+    {
+      manage_service_wrapper (i, j, 1, 0.66);
+    }
+  }
+
+  GNUNET_free (permut);
+
+  churn_task = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
+    churn,
+    NULL);
+}
+
+
+/**
+ * Initialise given RPSPeer
+ */
+static void
+profiler_init_peer (struct RPSPeer *rps_peer)
+{
+  rps_peer->num_ids_to_request = cur_test_run.num_requests;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer shall request %i peers\n",
+              rps_peer->num_ids_to_request);
+}
+
+
+/**
+ * Callback to call on receipt of a reply
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+profiler_reply_handle (void *cls,
+                       uint64_t n,
+                       const struct GNUNET_PeerIdentity *recv_peers)
+{
+  struct RPSPeer *rps_peer;
+  struct RPSPeer *rcv_rps_peer;
+  char file_name_buf[128];
+  char file_name_dh_buf[128];
+  char file_name_dhr_buf[128];
+  char file_name_dhru_buf[128];
+  char *file_name = file_name_buf;
+  char *file_name_dh = file_name_dh_buf;
+  char *file_name_dhr = file_name_dhr_buf;
+  char *file_name_dhru = file_name_dhru_buf;
+  unsigned int i;
+  struct PendingReply *pending_rep = (struct PendingReply *) cls;
+
+  pending_rep->req_handle = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "profiler_reply_handle()\n");
+  rps_peer = pending_rep->rps_peer;
+  (void) GNUNET_asprintf (&file_name,
+                          "/tmp/rps/received_ids-%u",
+                          rps_peer->index);
+
+  (void) GNUNET_asprintf (&file_name_dh,
+                          "/tmp/rps/diehard_input-%u",
+                          rps_peer->index);
+  (void) GNUNET_asprintf (&file_name_dhr,
+                          "/tmp/rps/diehard_input_raw-%u",
+                          rps_peer->index);
+  (void) GNUNET_asprintf (&file_name_dhru,
+                          "/tmp/rps/diehard_input_raw_aligned-%u",
+                          rps_peer->index);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "[%s] got %" PRIu64 " peers:\n",
+              GNUNET_i2s (rps_peer->peer_id),
+              n);
+  for (i = 0; i < n; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u: %s\n",
+                i,
+                GNUNET_i2s (&recv_peers[i]));
+    tofile (file_name,
+            "%s\n",
+            GNUNET_i2s_full (&recv_peers[i]));
+    rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, &recv_peers[i]);
+    GNUNET_assert (NULL != rcv_rps_peer);
+    tofile (file_name_dh,
+            "%" PRIu32 "\n",
+            (uint32_t) rcv_rps_peer->index);
+#ifdef TO_FILE
+    to_file_raw (file_name_dhr,
+                 (char *) &rcv_rps_peer->index,
+                 sizeof(uint32_t));
+    to_file_raw_unaligned (file_name_dhru,
+                           (char *) &rcv_rps_peer->index,
+                           sizeof(uint32_t),
+                           bits_needed);
+#endif /* TO_FILE */
+  }
+  default_reply_handle (cls, n, recv_peers);
+}
+
+
+/**
+ * Callback to call on receipt of a reply
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+profiler_reply_handle_info (void *cls,
+                            const struct GNUNET_PeerIdentity *recv_peer,
+                            double probability,
+                            uint32_t num_observed)
+{
+  struct RPSPeer *rps_peer;
+  struct RPSPeer *rcv_rps_peer;
+  char file_name_buf[128];
+  char file_name_dh_buf[128];
+  char file_name_dhr_buf[128];
+  char file_name_dhru_buf[128];
+  char *file_name = file_name_buf;
+  char *file_name_dh = file_name_dh_buf;
+  char *file_name_dhr = file_name_dhr_buf;
+  char *file_name_dhru = file_name_dhru_buf;
+  struct PendingReply *pending_rep = (struct PendingReply *) cls;
+
+  pending_rep->req_handle = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "profiler_reply_handle()\n");
+  rps_peer = pending_rep->rps_peer;
+  (void) GNUNET_asprintf (&file_name,
+                          "/tmp/rps/received_ids-%u",
+                          rps_peer->index);
+
+  (void) GNUNET_asprintf (&file_name_dh,
+                          "/tmp/rps/diehard_input-%u",
+                          rps_peer->index);
+  (void) GNUNET_asprintf (&file_name_dhr,
+                          "/tmp/rps/diehard_input_raw-%u",
+                          rps_peer->index);
+  (void) GNUNET_asprintf (&file_name_dhru,
+                          "/tmp/rps/diehard_input_raw_aligned-%u",
+                          rps_peer->index);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "[%s] got peer with info:\n",
+              GNUNET_i2s (rps_peer->peer_id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "  %s\n",
+              GNUNET_i2s (recv_peer));
+  tofile (file_name,
+          "%s %f %" PRIu32 " \n",
+          GNUNET_i2s_full (recv_peer),
+          probability,
+          num_observed);
+  rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, recv_peer);
+  GNUNET_assert (NULL != rcv_rps_peer);
+  tofile (file_name_dh,
+          "%" PRIu32 "\n",
+          (uint32_t) rcv_rps_peer->index);
+#ifdef TO_FILE
+  to_file_raw (file_name_dhr,
+               (char *) &rcv_rps_peer->index,
+               sizeof(uint32_t));
+  to_file_raw_unaligned (file_name_dhru,
+                         (char *) &rcv_rps_peer->index,
+                         sizeof(uint32_t),
+                         bits_needed);
+#endif /* TO_FILE */
+  default_reply_handle (cls, 1, recv_peer);
+}
+
+
+static void
+profiler_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  /* Start churn */
+  if ((HAVE_CHURN == cur_test_run.have_churn) && (NULL == churn_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting churn task\n");
+    churn_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+      churn,
+      NULL);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not starting churn task\n");
+  }
+
+  /* Only request peer ids at one peer.
+   * (It's the before-last because last one is target of the focused attack.)
+   */
+  if (0 < rps_peer->num_ids_to_request)
+    schedule_missing_requests (rps_peer);
+}
+
+
+/**
+ * Function called from #profiler_eval with a filename.
+ *
+ * @param cls closure
+ * @param filename complete filename (absolute path)
+ * @return #GNUNET_OK to continue to iterate,
+ *  #GNUNET_NO to stop iteration with no error,
+ *  #GNUNET_SYSERR to abort iteration with error!
+ */
+static int
+file_name_cb (void *cls, const char *filename)
+{
+  if (NULL != strstr (filename, "sampler_el"))
+  {
+    struct RPS_SamplerElement *s_elem;
+    struct GNUNET_CRYPTO_AuthKey auth_key;
+    const char *key_char;
+    uint32_t i;
+    (void) cls;
+
+    key_char = filename + 20;   /* Length of "/tmp/rps/sampler_el-" */
+    tofile (filename, "--------------------------\n");
+
+    auth_key = string_to_auth_key (key_char);
+    s_elem = RPS_sampler_elem_create ();
+    RPS_sampler_elem_set (s_elem, auth_key);
+
+    for (i = 0; i < num_peers; i++)
+    {
+      RPS_sampler_elem_next (s_elem, &rps_peer_ids[i]);
+    }
+    RPS_sampler_elem_destroy (s_elem);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * This is run after the test finished.
+ *
+ * Compute all perfect samples.
+ */
+static int
+profiler_eval (void)
+{
+#ifdef TO_FILE
+  /* Compute perfect sample for each sampler element */
+  if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n");
+  }
+#endif /* TO_FILE */
+
+  return evaluate ();
+}
+
+
+/** @brief is b in view of a?
+ *
+ * @param a
+ * @param b
+ *
+ * @return
+ */
+static int
+is_in_view (uint32_t a, uint32_t b)
+{
+  uint32_t i;
+
+  for (i = 0; i < rps_peers[a].cur_view_count; i++)
+  {
+    if (0 == memcmp (rps_peers[b].peer_id,
+                     &rps_peers[a].cur_view[i],
+                     sizeof(struct GNUNET_PeerIdentity)))
+    {
+      return GNUNET_YES;
+    }
+  }
+  return GNUNET_NO;
+}
+
+
+static uint32_t
+get_idx_of_pid (const struct GNUNET_PeerIdentity *pid)
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    if (0 == memcmp (pid,
+                     rps_peers[i].peer_id,
+                     sizeof(struct GNUNET_PeerIdentity)))
+    {
+      return i;
+    }
+  }
+  // return 0; /* Should not happen - make compiler happy */
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "No known _PeerIdentity %s!\n",
+              GNUNET_i2s_full (pid));
+  GNUNET_assert (0);
+}
+
+
+/**
+ * @brief Counts number of peers in view of a that have b in their view
+ *
+ * @param a
+ * @param b
+ *
+ * @return
+ */
+static uint32_t
+count_containing_views (uint32_t a, uint32_t b)
+{
+  uint32_t i;
+  uint32_t peer_idx;
+  uint32_t count = 0;
+
+  for (i = 0; i < rps_peers[a].cur_view_count; i++)
+  {
+    peer_idx = get_idx_of_pid (&rps_peers[a].cur_view[i]);
+    if (GNUNET_YES == is_in_view (peer_idx, b))
+    {
+      count++;
+    }
+  }
+  return count;
+}
+
+
+/**
+ * @brief Computes the probability for each other peer to be selected by the
+ * sampling process based on the views of all peers
+ *
+ * @param peer_idx index of the peer that is about to sample
+ */
+static void
+compute_probabilities (uint32_t peer_idx)
+{
+  // double probs[num_peers] = { 0 };
+  double probs[num_peers];
+  double probs_hist[num_peers]; /* Probability respecting the history */
+  size_t probs_as_str_size = (num_peers * 10 + 2) * sizeof(char);
+  char *probs_as_str = GNUNET_malloc (probs_as_str_size);
+  char *probs_as_str_cpy;
+  uint32_t i;
+  double prob_push;
+  double prob_pull;
+  uint32_t view_size;
+  uint32_t cont_views;
+  uint32_t number_of_being_in_pull_events;
+  int tmp;
+  double sum_non_zero_prob = 0;
+  double sum_non_zero_prob_hist = 0;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Computing probabilities for peer %" PRIu32 "\n", peer_idx);
+  /* Firstly without knowledge of old views */
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\tfor peer %" PRIu32 ":\n", i);
+    view_size = rps_peers[i].cur_view_count;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tview_size: %" PRIu32 "\n", view_size);
+    /* For peer i the probability of being sampled is
+     * evenly distributed among all possibly observed peers. */
+    /* We could have observed a peer in three cases:
+     *   1. peer sent a push
+     *   2. peer was contained in a pull reply
+     *   3. peer was in history (sampler) - ignored for now */
+    /* 1. Probability of having received a push from peer i */
+    if ((GNUNET_YES == is_in_view (i, peer_idx)) &&
+        (1 <= (0.45 * view_size)))
+    {
+      if (0 == binom (view_size, 0.45 * view_size))
+        prob_push = 0;
+      else
+      {
+        prob_push = 1.0 * binom (0.45 * view_size, 1)
+                    /
+                    binom (view_size, 0.45 * view_size);
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\t%" PRIu32 " is in %" PRIu32 "'s view, prob: %f\n",
+                  peer_idx,
+                  i,
+                  prob_push);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\tposs choices from view: %" PRIu32 ", containing i: %"
+                  PRIu32 "\n",
+                  binom (view_size, 0.45 * view_size),
+                  binom (0.45 * view_size, 1));
+    }
+    else
+    {
+      prob_push = 0;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\t%" PRIu32 " is not in %" PRIu32 "'s view, prob: 0\n",
+                  peer_idx,
+                  i);
+    }
+    /* 2. Probability of peer i being contained in pulls */
+    view_size = rps_peers[peer_idx].cur_view_count;
+    cont_views = count_containing_views (peer_idx, i);
+    number_of_being_in_pull_events =
+      (binom (view_size, 0.45 * view_size)
+       - binom (view_size - cont_views, 0.45 * view_size));
+    if (0 != number_of_being_in_pull_events)
+    {
+      prob_pull = number_of_being_in_pull_events
+                  /
+                  (1.0 * binom (view_size, 0.45 * view_size));
+    }
+    else
+    {
+      prob_pull = 0;
+    }
+    probs[i] = prob_push + prob_pull - (prob_push * prob_pull);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\t%" PRIu32 " has %" PRIu32 " of %" PRIu32
+                " peers in its view who know %" PRIu32 " prob: %f\n",
+                peer_idx,
+                cont_views,
+                view_size,
+                i,
+                prob_pull);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations: %" PRIu32 "\n",
+                binom (view_size, 0.45 * view_size));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations without %" PRIu32
+                ": %" PRIu32 "\n",
+                i,
+                binom (view_size - cont_views, 0.45 * view_size));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations with %" PRIu32
+                ": %" PRIu32 "\n",
+                i,
+                number_of_being_in_pull_events);
+
+    probs_hist[i] = 0.9 * rps_peers[peer_idx].eval_probs_cache[i] + probs[i];
+    rps_peers[peer_idx].eval_probs_cache[i] = probs_hist[i];
+
+    sum_non_zero_prob += probs[i];
+    sum_non_zero_prob_hist += probs_hist[i];
+  }
+  /* normalize */
+  if (0 != sum_non_zero_prob)
+  {
+    for (i = 0; i < num_peers; i++)
+    {
+      probs[i] = probs[i] * (1.0 / sum_non_zero_prob);
+    }
+  }
+  if (0 != sum_non_zero_prob_hist)
+  {
+    for (i = 0; i < num_peers; i++)
+    {
+      probs_hist[i] = probs_hist[i] * (1.0 / sum_non_zero_prob_hist);
+    }
+  }
+
+  /* str repr */
+  for (i = 0; i < num_peers; i++)
+  {
+    probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
+    tmp = GNUNET_snprintf (probs_as_str,
+                           probs_as_str_size,
+                           "%s %7.6f", probs_as_str_cpy, probs[i]);
+    GNUNET_free (probs_as_str_cpy);
+    GNUNET_assert (0 <= tmp);
+  }
+
+  to_file_w_len (rps_peers[peer_idx].file_name_probs,
+                 probs_as_str_size,
+                 "%s",
+                 probs_as_str);
+
+  probs_as_str[0] = '\0';
+  for (i = 0; i < num_peers; i++)
+  {
+    probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
+    tmp = GNUNET_snprintf (probs_as_str,
+                           probs_as_str_size,
+                           "%s %7.6f", probs_as_str_cpy, probs_hist[i]);
+    GNUNET_free (probs_as_str_cpy);
+    GNUNET_assert (0 <= tmp);
+  }
+
+  to_file_w_len (rps_peers[peer_idx].file_name_probs_hist,
+                 probs_as_str_size,
+                 "%s",
+                 probs_as_str);
+  GNUNET_free (probs_as_str);
+}
+
+
+/**
+ * @brief This counts the number of peers in which views a given peer occurs.
+ *
+ * It also stores this value in the rps peer.
+ *
+ * @param peer_idx the index of the peer to count the representation
+ *
+ * @return the number of occurrences
+ */
+static uint32_t
+count_peer_in_views_2 (uint32_t peer_idx)
+{
+  uint32_t i, j;
+  uint32_t count = 0;
+
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    for (j = 0; j < rps_peers[i].cur_view_count; j++)   /* entry in view */
+    {
+      if (0 == memcmp (rps_peers[peer_idx].peer_id,
+                       &rps_peers[i].cur_view[j],
+                       sizeof(struct GNUNET_PeerIdentity)))
+      {
+        count++;
+        break;
+      }
+    }
+  }
+  rps_peers[peer_idx].count_in_views = count;
+  return count;
+}
+
+
+static uint32_t
+cumulated_view_sizes ()
+{
+  uint32_t i;
+
+  view_sizes = 0;
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    view_sizes += rps_peers[i].cur_view_count;
+  }
+  return view_sizes;
+}
+
+
+static void
+count_peer_in_views (uint32_t *count_peers)
+{
+  uint32_t i, j;
+
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    for (j = 0; j < rps_peers[i].cur_view_count; j++)   /* entry in view */
+    {
+      if (0 == memcmp (rps_peers[i].peer_id,
+                       &rps_peers[i].cur_view[j],
+                       sizeof(struct GNUNET_PeerIdentity)))
+      {
+        count_peers[i]++;
+      }
+    }
+  }
+}
+
+
+void
+compute_diversity ()
+{
+  uint32_t i;
+  /* ith entry represents the number of occurrences in other peer's views */
+  uint32_t *count_peers = GNUNET_new_array (num_peers, uint32_t);
+  uint32_t views_total_size;
+  double expected;
+  /* deviation from expected number of peers */
+  double *deviation = GNUNET_new_array (num_peers, double);
+
+  views_total_size = 0;
+  expected = 0;
+
+  /* For each peer count its representation in other peer's views*/
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    views_total_size += rps_peers[i].cur_view_count;
+    count_peer_in_views (count_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Counted representation of %" PRIu32 "th peer [%s]: %" PRIu32
+                "\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                count_peers[i]);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "size of all views combined: %" PRIu32 "\n",
+              views_total_size);
+  expected = ((double) 1 / num_peers) * views_total_size;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Expected number of occurrences of each peer in all views: %f\n",
+              expected);
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    deviation[i] = expected - count_peers[i];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Deviation from expectation: %f\n", deviation[i]);
+  }
+  GNUNET_free (count_peers);
+  GNUNET_free (deviation);
+}
+
+
+void
+print_view_sizes ()
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "View size of %" PRIu32 ". [%s] is %" PRIu32 "\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                rps_peers[i].cur_view_count);
+  }
+}
+
+
+void
+all_views_updated_cb ()
+{
+  compute_diversity ();
+  print_view_sizes ();
+}
+
+
+void
+view_update_cb (void *cls,
+                uint64_t view_size,
+                const struct GNUNET_PeerIdentity *peers)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "View was updated (%" PRIu64 ")\n", view_size);
+  struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
+  to_file ("/tmp/rps/view_sizes.txt",
+           "%" PRIu32 " %" PRIu64 "",
+           rps_peer->index,
+           view_size);
+  for (uint64_t i = 0; i < view_size; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t%s\n", GNUNET_i2s (&peers[i]));
+  }
+  GNUNET_array_grow (rps_peer->cur_view,
+                     rps_peer->cur_view_count,
+                     view_size);
+  // *rps_peer->cur_view = *peers;
+  GNUNET_memcpy (rps_peer->cur_view,
+                 peers,
+                 view_size * sizeof(struct GNUNET_PeerIdentity));
+  to_file ("/tmp/rps/count_in_views.txt",
+           "%" PRIu32 " %" PRIu32 "",
+           rps_peer->index,
+           count_peer_in_views_2 (rps_peer->index));
+  cumulated_view_sizes ();
+  if (0 != view_size)
+  {
+    to_file ("/tmp/rps/repr.txt",
+             "%" PRIu32  /* index */
+             " %" PRIu32  /* occurrence in views */
+             " %" PRIu32  /* view sizes */
+             " %f"  /* fraction of repr in views */
+             " %f"  /* average view size */
+             " %f"  /* prob of occurrence in view slot */
+             " %f" "",  /* exp frac of repr in views */
+             rps_peer->index,
+             count_peer_in_views_2 (rps_peer->index),
+             view_sizes,
+             count_peer_in_views_2 (rps_peer->index) / (view_size * 1.0), /* fraction of representation in views */
+             view_sizes / (view_size * 1.0),  /* average view size */
+             1.0 / view_size,  /* prob of occurrence in view slot */
+             (1.0 / view_size) * (view_sizes / view_size)  /* expected fraction of repr in views */
+             );
+  }
+  compute_probabilities (rps_peer->index);
+  all_views_updated_cb ();
+}
+
+
+static void
+pre_profiler (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
+{
+  rps_peer->file_name_probs =
+    store_prefix_file_name (rps_peer->index, "probs");
+  rps_peer->file_name_probs_hist =
+    store_prefix_file_name (rps_peer->index, "probs_hist");
+  rps_peer->eval_probs_cache = GNUNET_new_array (num_peers, double);
+  memset (rps_peer->eval_probs_cache, 0, num_peers * sizeof (double));
+  GNUNET_RPS_view_request (h, 0, view_update_cb, rps_peer);
+}
+
+void
+write_final_stats (void)
+{
+  uint64_t sums[STAT_TYPE_MAX] = { 0 };
+
+  for (uint32_t i = 0; i < num_peers; i++)
+  {
+    to_file ("/tmp/rps/final_stats.csv",
+             "%" PRIu32 ", "  /* index */
+             "%s, %"  /* id */
+             PRIu64 ", %"  /* rounds */
+             PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
+             PRIu64 ", %"                                                                   /* blocking */
+             PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"  /* issued */
+             PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"  /* sent */
+             PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
+             PRIu64 ", %"                                                                   /* recv */
+             PRIu64 ", %"  /* view size */
+             PRIu64 ", %"  /* known peers */
+             PRIu64 ", %"  /* valid peers */
+             PRIu64 ", %"  /* learned peers */
+             PRIu64 ", %"  /* pending online checks */
+             PRIu64 ", %"  /* unrequested pull replies */
+             PRIu64 ", %"  /* peers in push map */
+             PRIu64 ", %"  /* peers in pull map */
+             PRIu64 ", %"  /* peers in view */
+             PRIu64 "\n" /* view size aim */,
+             i,
+             GNUNET_i2s (rps_peers[i].peer_id),
+             rps_peers[i].stats[STAT_TYPE_ROUNDS],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS_MANY_PUSH],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS_NO_PUSH],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS_NO_PULL],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL],
+             rps_peers[i].stats[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL],
+             rps_peers[i].stats[STAT_TYPE_ISSUED_PUSH_SEND],
+             rps_peers[i].stats[STAT_TYPE_ISSUED_PUSH_SEND_MH],
+             rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REQ],
+             rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REQ_MH],
+             rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REP],
+             rps_peers[i].stats[STAT_TYPE_SENT_PUSH_SEND],
+             rps_peers[i].stats[STAT_TYPE_SENT_PULL_REQ],
+             rps_peers[i].stats[STAT_TYPE_SENT_PULL_REQ_MH],
+             rps_peers[i].stats[STAT_TYPE_SENT_PULL_REP],
+             rps_peers[i].stats[STAT_TYPE_RECV_PUSH_SEND],
+             rps_peers[i].stats[STAT_TYPE_RECV_PUSH_SEND_MH],
+             rps_peers[i].stats[STAT_TYPE_RECV_PULL_REQ],
+             rps_peers[i].stats[STAT_TYPE_RECV_PULL_REQ_MH],
+             rps_peers[i].stats[STAT_TYPE_RECV_PULL_REP_MH],
+             rps_peers[i].stats[STAT_TYPE_RECV_PULL_REP],
+             rps_peers[i].stats[STAT_TYPE_VIEW_SIZE],
+             rps_peers[i].stats[STAT_TYPE_KNOWN_PEERS],
+             rps_peers[i].stats[STAT_TYPE_VALID_PEERS],
+             rps_peers[i].stats[STAT_TYPE_LEARND_PEERS],
+             rps_peers[i].stats[STAT_TYPE_PENDING_ONLINE_CHECKS],
+             rps_peers[i].stats[STAT_TYPE_UNREQUESTED_PULL_REPLIES],
+             rps_peers[i].stats[STAT_TYPE_PEERS_IN_PUSH_MAP],
+             rps_peers[i].stats[STAT_TYPE_PEERS_IN_PULL_MAP],
+             rps_peers[i].stats[STAT_TYPE_PEERS_IN_VIEW],
+             rps_peers[i].stats[STAT_TYPE_VIEW_SIZE_AIM]);
+    for (enum STAT_TYPE stat_type = STAT_TYPE_ROUNDS;
+         stat_type < STAT_TYPE_MAX;
+         stat_type++)
+    {
+      sums[stat_type] += rps_peers[i].stats[stat_type];
+    }
+  }
+  to_file ("/tmp/rps/final_stats.dat",
+           "SUM %"
+           PRIu64 " %" /* rounds */
+           PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
+           " %"                                                                    /* blocking */
+           PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* issued */
+           PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* sent */
+           PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
+           PRIu64 ", %"                                                                  /* recv */
+           PRIu64 ", %" /* view size */
+           PRIu64 ", %" /* known peers */
+           PRIu64 ", %" /* valid peers */
+           PRIu64 ", %" /* learned peers */
+           PRIu64 ", %" /* pending online checks */
+           PRIu64 ", %" /* unrequested pull replies */
+           PRIu64 ", %" /* peers in push map */
+           PRIu64 ", %" /* peers in pull map */
+           PRIu64 ", %" /* peers in view */
+           PRIu64 "\n" /* view size aim */,
+           sums[STAT_TYPE_ROUNDS],
+           sums[STAT_TYPE_BLOCKS],
+           sums[STAT_TYPE_BLOCKS_MANY_PUSH],
+           sums[STAT_TYPE_BLOCKS_NO_PUSH],
+           sums[STAT_TYPE_BLOCKS_NO_PULL],
+           sums[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL],
+           sums[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL],
+           sums[STAT_TYPE_ISSUED_PUSH_SEND],
+           sums[STAT_TYPE_ISSUED_PUSH_SEND_MH],
+           sums[STAT_TYPE_ISSUED_PULL_REQ],
+           sums[STAT_TYPE_ISSUED_PULL_REQ_MH],
+           sums[STAT_TYPE_ISSUED_PULL_REP],
+           sums[STAT_TYPE_SENT_PUSH_SEND],
+           sums[STAT_TYPE_SENT_PULL_REQ],
+           sums[STAT_TYPE_SENT_PULL_REQ_MH],
+           sums[STAT_TYPE_SENT_PULL_REP],
+           sums[STAT_TYPE_RECV_PUSH_SEND],
+           sums[STAT_TYPE_RECV_PUSH_SEND_MH],
+           sums[STAT_TYPE_RECV_PULL_REQ],
+           sums[STAT_TYPE_RECV_PULL_REQ_MH],
+           sums[STAT_TYPE_RECV_PULL_REP],
+           sums[STAT_TYPE_RECV_PULL_REP_MH],
+           sums[STAT_TYPE_VIEW_SIZE],
+           sums[STAT_TYPE_KNOWN_PEERS],
+           sums[STAT_TYPE_VALID_PEERS],
+           sums[STAT_TYPE_LEARND_PEERS],
+           sums[STAT_TYPE_PENDING_ONLINE_CHECKS],
+           sums[STAT_TYPE_UNREQUESTED_PULL_REPLIES],
+           sums[STAT_TYPE_PEERS_IN_PUSH_MAP],
+           sums[STAT_TYPE_PEERS_IN_PULL_MAP],
+           sums[STAT_TYPE_PEERS_IN_VIEW],
+           sums[STAT_TYPE_VIEW_SIZE_AIM]);
+}
+
+
+/**
+ * Continuation called by #GNUNET_STATISTICS_get() functions.
+ *
+ * Remembers that this specific statistics value was received for this peer.
+ * Checks whether all peers received their statistics yet.
+ * Issues the shutdown.
+ *
+ * @param cls closure
+ * @param success #GNUNET_OK if statistics were
+ *        successfully obtained, #GNUNET_SYSERR if not.
+ */
+void
+post_test_shutdown_ready_cb (void *cls,
+                             int success)
+{
+  struct STATcls *stat_cls = (struct STATcls *) cls;
+  struct RPSPeer *rps_peer = stat_cls->rps_peer;
+
+  rps_peer->h_stat_get[stat_cls->stat_type] = NULL;
+  if (GNUNET_OK == success)
+  {
+    /* set flag that we we got the value */
+    rps_peer->stat_collected_flags |= BIT (stat_cls->stat_type);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Peer %u did not receive statistics value\n",
+                rps_peer->index);
+    GNUNET_free (stat_cls);
+    GNUNET_break (0);
+    return;
+  }
+
+  if ((NULL != rps_peer->stat_op) &&
+      (GNUNET_YES == check_statistics_collect_completed_single_peer (
+         rps_peer)) )
+  {
+    GNUNET_TESTBED_operation_done (rps_peer->stat_op);
+  }
+
+  write_final_stats ();
+  if (GNUNET_YES == check_statistics_collect_completed ())
+  {
+    // write_final_stats ();
+    GNUNET_free (stat_cls);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Shutting down\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  else
+  {
+    GNUNET_free (stat_cls);
+  }
+}
+
+
+/**
+ * Callback function to process statistic values.
+ *
+ * @param cls closure
+ * @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
+ */
+int
+stat_iterator (void *cls,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
+{
+  const struct STATcls *stat_cls = (const struct STATcls *) cls;
+  struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer;
+  enum STAT_TYPE stat_type;
+
+  (void) subsystem;
+  (void) is_persistent;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got stat value: %s - %" PRIu64 " (%u)\n",
+              name,
+              value,
+              rps_peer->index);
+  to_file (rps_peer->file_name_stats,
+           "%s: %" PRIu64 "\n",
+           name,
+           value);
+  stat_type = stat_str_2_type (name);
+  GNUNET_assert (STAT_TYPE_ROUNDS <= stat_type &&
+                 STAT_TYPE_MAX > stat_type);
+  rps_peer->stats[stat_type] = value;
+  return GNUNET_OK;
+}
+
+
+void
+post_profiler (struct RPSPeer *rps_peer)
+{
+  if (COLLECT_STATISTICS != cur_test_run.have_collect_statistics)
+  {
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Going to request statistic values with mask 0x%" PRIx32 "\n",
+              cur_test_run.stat_collect_flags);
+
+  struct STATcls *stat_cls;
+  uint32_t stat_type;
+  for (stat_type = STAT_TYPE_ROUNDS;
+       stat_type < STAT_TYPE_MAX;
+       stat_type++)
+  {
+    if (BIT (stat_type) & cur_test_run.stat_collect_flags)
+    {
+      stat_cls = GNUNET_malloc (sizeof(struct STATcls));
+      stat_cls->rps_peer = rps_peer;
+      stat_cls->stat_type = stat_type;
+      rps_peer->file_name_stats =
+        store_prefix_file_name (rps_peer->index, "stats");
+      rps_peer->h_stat_get[stat_type] =
+        GNUNET_STATISTICS_get (rps_peer->stats_h,
+                               "rps",
+                               stat_type_strings [stat_type],
+                               post_test_shutdown_ready_cb,
+                               stat_iterator,
+                               (struct STATcls *) stat_cls);
+      GNUNET_assert (NULL != rps_peer->h_stat_get);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Requested statistics for %s (peer %" PRIu32 ")\n",
+                  stat_type_strings [stat_type],
+                  rps_peer->index);
+    }
+  }
+  GNUNET_free (rps_peer->eval_probs_cache);
+}
+
+
+/***********************************************************************
+* /Definition of tests
+***********************************************************************/
+
+
+/**
+ * Actual "main" function for the testcase.
+ *
+ * @param cls closure
+ * @param h the run handle
+ * @param n_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 connection attempts that
+ *          failed
+ */
+static void
+test_run (void *cls,
+          struct GNUNET_TESTBED_RunHandle *h,
+          unsigned int n_peers,
+          struct GNUNET_TESTBED_Peer **peers,
+          unsigned int links_succeeded,
+          unsigned int links_failed)
+{
+  unsigned int i;
+  struct OpListEntry *entry;
+
+  (void) cls;
+  (void) h;
+  (void) links_failed;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
+
+  /* Check whether we timed out */
+  if ((n_peers != num_peers) ||
+      (NULL == peers) ||
+      (0 == links_succeeded) )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Going down due to args (eg. timeout)\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n",
+                num_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n",
+                links_succeeded);
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+
+  /* Initialize peers */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "going to initialise peers\n");
+  testbed_peers = peers;
+  num_peers_online = 0;
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "initialising %u\n", i);
+    entry = make_oplist_entry ();
+    entry->index = i;
+    rps_peers[i].index = i;
+    if (NULL != cur_test_run.init_peer)
+      cur_test_run.init_peer (&rps_peers[i]);
+    if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
+    {
+      rps_peers->cur_view_count = 0;
+      rps_peers->cur_view = NULL;
+    }
+    entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
+                                                     GNUNET_TESTBED_PIT_IDENTITY,
+                                                     &info_cb,
+                                                     entry);
+  }
+
+  /* Bring peers up */
+  GNUNET_assert (num_peers == n_peers);
+  for (i = 0; i < n_peers; i++)
+  {
+    rps_peers[i].index = i;
+    rps_peers[i].op =
+      GNUNET_TESTBED_service_connect (&rps_peers[i],
+                                      peers[i],
+                                      "rps",
+                                      &rps_connect_complete_cb,
+                                      &rps_peers[i],
+                                      &rps_connect_adapter,
+                                      &rps_disconnect_adapter,
+                                      &rps_peers[i]);
+    /* Connect all peers to statistics service */
+    if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Connecting to statistics service\n");
+      rps_peers[i].stat_op =
+        GNUNET_TESTBED_service_connect (NULL,
+                                        peers[i],
+                                        "statistics",
+                                        stat_complete_cb,
+                                        &rps_peers[i],
+                                        &stat_connect_adapter,
+                                        &stat_disconnect_adapter,
+                                        &rps_peers[i]);
+    }
+  }
+
+  if (NULL != churn_task)
+    GNUNET_SCHEDULER_cancel (churn_task);
+  post_test_task = GNUNET_SCHEDULER_add_delayed (duration, &post_test_op, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "timeout for shutdown is %lu\n",
+              timeout.rel_value_us / 1000000);
+  shutdown_task = GNUNET_SCHEDULER_add_delayed (timeout,
+                                                &trigger_shutdown,
+                                                NULL);
+  GNUNET_SCHEDULER_add_shutdown (shutdown_op, NULL);
+}
+
+
+/**
+ * Entry point for the testcase, sets up the testbed.
+ *
+ * @param argc unused
+ * @param argv unused
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  // int ret_value;
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+
+  /* Defaults for tests */
+  churn_task = NULL;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
+  cur_test_run.name = "test-rps-profiler";
+  if (0 == num_peers)
+    num_peers = 10;
+  mal_type = 3;
+  cur_test_run.init_peer = profiler_init_peer;
+  // cur_test_run.pre_test = mal_pre;
+  cur_test_run.pre_test = pre_profiler;
+  cur_test_run.main_test = profiler_cb;
+  cur_test_run.reply_handle = profiler_reply_handle;
+  cur_test_run.eval_cb = profiler_eval;
+  cur_test_run.post_test = post_profiler;
+  cur_test_run.request_interval = 2;
+  if (0 == cur_test_run.num_requests)
+    cur_test_run.num_requests = 5;
+  // cur_test_run.have_churn = HAVE_CHURN;
+  cur_test_run.have_churn = HAVE_NO_CHURN;
+  cur_test_run.have_quick_quit = HAVE_QUICK_QUIT;
+  cur_test_run.have_collect_statistics = COLLECT_STATISTICS;
+  cur_test_run.stat_collect_flags = BIT (STAT_TYPE_ROUNDS)
+                                    | BIT (STAT_TYPE_BLOCKS)
+                                    | BIT (STAT_TYPE_BLOCKS_MANY_PUSH)
+                                    | BIT (STAT_TYPE_BLOCKS_NO_PUSH)
+                                    | BIT (STAT_TYPE_BLOCKS_NO_PULL)
+                                    | BIT (STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL)
+                                    | BIT (STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL)
+                                    | BIT (STAT_TYPE_ISSUED_PUSH_SEND)
+                                    | BIT (STAT_TYPE_ISSUED_PUSH_SEND_MH)
+                                    | BIT (STAT_TYPE_ISSUED_PULL_REQ)
+                                    | BIT (STAT_TYPE_ISSUED_PULL_REQ_MH)
+                                    | BIT (STAT_TYPE_ISSUED_PULL_REP)
+                                    | BIT (STAT_TYPE_SENT_PUSH_SEND)
+                                    | BIT (STAT_TYPE_SENT_PULL_REQ)
+                                    | BIT (STAT_TYPE_SENT_PULL_REQ_MH)
+                                    | BIT (STAT_TYPE_SENT_PULL_REP)
+                                    | BIT (STAT_TYPE_RECV_PUSH_SEND)
+                                    | BIT (STAT_TYPE_RECV_PUSH_SEND_MH)
+                                    | BIT (STAT_TYPE_RECV_PULL_REQ)
+                                    | BIT (STAT_TYPE_RECV_PULL_REQ_MH)
+                                    | BIT (STAT_TYPE_RECV_PULL_REP)
+                                    | BIT (STAT_TYPE_RECV_PULL_REP_MH)
+                                    | BIT (STAT_TYPE_VIEW_SIZE)
+                                    | BIT (STAT_TYPE_KNOWN_PEERS)
+                                    | BIT (STAT_TYPE_VALID_PEERS)
+                                    | BIT (STAT_TYPE_LEARND_PEERS)
+                                    | BIT (STAT_TYPE_PENDING_ONLINE_CHECKS)
+                                    | BIT (STAT_TYPE_UNREQUESTED_PULL_REPLIES)
+                                    | BIT (STAT_TYPE_PEERS_IN_PUSH_MAP)
+                                    | BIT (STAT_TYPE_PEERS_IN_PULL_MAP)
+                                    | BIT (STAT_TYPE_PEERS_IN_VIEW)
+                                    | BIT (STAT_TYPE_VIEW_SIZE_AIM);
+  cur_test_run.have_collect_view = COLLECT_VIEW;
+
+  /* 'Clean' directory */
+  (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
+  GNUNET_DISK_directory_create ("/tmp/rps/");
+  if (0 == duration.rel_value_us)
+  {
+    if (0 == timeout.rel_value_us)
+    {
+      duration = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90);
+      timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                               (90 * 1.2)
+                                               + (0.01 * num_peers));
+    }
+    else
+    {
+      duration = GNUNET_TIME_relative_multiply (
+          GNUNET_TIME_UNIT_SECONDS,
+          ( (double) timeout.rel_value_us /  (double) 1000000)
+          * 0.75);
+    }
+  }
+  else
+  {
+    if (0 == timeout.rel_value_us)
+    {
+      timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                               ((duration.rel_value_us
+                                                 / 1000000)
+                                                * 1.2) + (0.01 * num_peers));
+    }
+  }
+  GNUNET_assert (duration.rel_value_us < timeout.rel_value_us);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "duration is %lus\n",
+              duration.rel_value_us / 1000000);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "timeout is %lus\n",
+              timeout.rel_value_us / 1000000);
+
+  /* Compute number of bits for representing largest peer id */
+  for (bits_needed = 1; (uint32_t) (1 << bits_needed) < num_peers; bits_needed++)
+    ;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Need %u bits to represent %" PRIu32 " peers\n",
+              bits_needed,
+              num_peers);
+
+  rps_peers = GNUNET_new_array (num_peers, struct RPSPeer);
+  peer_map = GNUNET_CONTAINER_multipeermap_create (num_peers, GNUNET_NO);
+  rps_peer_ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
+  if ((2 == mal_type) ||
+      (3 == mal_type))
+    target_peer = &rps_peer_ids[num_peers - 2];
+
+  ok = 1;
+  GNUNET_TESTBED_run (NULL,
+                      cfg,
+                      num_peers,
+                      0, /* event mask */
+                      NULL,
+                      NULL,
+                      &test_run,
+                      NULL);
+}
+
+
+/**
+ * Entry point for the testcase, sets up the testbed.
+ *
+ * @param argc unused
+ * @param argv unused
+ * @return 0 on success
+ */
+int
+main (int argc, char *argv[])
+{
+  int ret_value;
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_uint ('n',
+                               "num-peers",
+                               "COUNT",
+                               gettext_noop ("number of peers to start"),
+                               &num_peers),
+    GNUNET_GETOPT_option_relative_time ('d',
+                                        "duration",
+                                        "DURATION",
+                                        gettext_noop (
+                                          "duration of the profiling"),
+                                        &duration),
+    GNUNET_GETOPT_option_relative_time ('t',
+                                        "timeout",
+                                        "TIMEOUT",
+                                        gettext_noop (
+                                          "timeout for the profiling"),
+                                        &timeout),
+    GNUNET_GETOPT_option_uint ('r',
+                               "num-requests",
+                               "COUNT",
+                               gettext_noop ("number of PeerIDs to request"),
+                               &cur_test_run.num_requests),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  unsetenv ("XDG_DATA_HOME");
+  unsetenv ("XDG_CONFIG_HOME");
+  // if (GNUNET_OK !=
+  //    GNUNET_STRINGS_get_utf8_args (argc, argv,
+  //                                  &argc, &argv))
+  //  return 2;
+  ret_value = 0;
+  if (GNUNET_OK !=
+      GNUNET_PROGRAM_run (argc,
+                          argv,
+                          "gnunet-rps-profiler",
+                          gettext_noop (
+                            "Measure quality and performance of the RPS service."),
+                          options,
+                          &run,
+                          NULL))
+  {
+    ret_value = 1;
+  }
+  if (0 != ret_value)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Test did not run successfully!\n");
+  }
+  else
+  {
+    ret_value = cur_test_run.eval_cb ();
+    if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
+    {
+      GNUNET_array_grow (rps_peers->cur_view,
+                         rps_peers->cur_view_count,
+                         0);
+    }
+    GNUNET_free (rps_peers);
+    GNUNET_free (rps_peer_ids);
+    GNUNET_CONTAINER_multipeermap_destroy (peer_map);
+  }
+  return ret_value;
+}
+
+
+/* end of test_rps.c */
diff --git a/src/contrib/service/rps/gnunet-rps.c b/src/contrib/service/rps/gnunet-rps.c
new file mode 100644
index 000000000..f90fc0d88
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-rps.c
@@ -0,0 +1,294 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-rps.c
+ * @brief random peer sampling
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_rps_service.h"
+#include <inttypes.h>
+
+static int ret;
+
+/**
+ * RPS handle
+ */
+static struct GNUNET_RPS_Handle *rps_handle;
+
+/**
+ * Request handle
+ */
+static struct GNUNET_RPS_Request_Handle *req_handle;
+
+/**
+ * PeerID (Option --seed)
+ */
+static struct GNUNET_PeerIdentity peer_id;
+
+/**
+ * @brief Do we want to receive updates of the view? (Option --view)
+ */
+static int view_update;
+
+/**
+ * @brief Do we want to receive updates of the view? (Option --view)
+ */
+static int stream_input;
+
+/**
+ * @brief Number of updates we want to receive
+ */
+static uint64_t num_view_updates;
+
+
+/**
+ * Task run when user presses CTRL-C to abort.
+ * Cancels pending request and disconnects.
+ *
+ * @param cls NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+
+  if (NULL != req_handle)
+    GNUNET_RPS_request_cancel (req_handle);
+  GNUNET_RPS_disconnect (rps_handle);
+}
+
+
+/**
+ * Callback called on receipt of reply.
+ * Prints replied PeerIDs.
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+reply_handle (void *cls,
+              uint64_t n,
+              const struct GNUNET_PeerIdentity *recv_peers)
+{
+  uint64_t i;
+
+  (void) cls;
+
+  req_handle = NULL;
+  for (i = 0; i < n; i++)
+  {
+    fprintf (stdout, "%s\n",
+             GNUNET_i2s_full (&recv_peers[i]));
+  }
+  ret = 0;
+
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Callback called on receipt view update.
+ * Prints view.
+ *
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+view_update_handle (void *cls,
+                    uint64_t n,
+                    const struct GNUNET_PeerIdentity *recv_peers)
+{
+  uint64_t i;
+
+  (void) cls;
+
+  if (0 == n)
+  {
+    fprintf (stdout, "Empty view\n");
+  }
+  req_handle = NULL;
+  for (i = 0; i < n; i++)
+  {
+    fprintf (stdout, "%s\n",
+             GNUNET_i2s_full (&recv_peers[i]));
+  }
+
+  if (1 == num_view_updates)
+  {
+    ret = 0;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  else if (1 < num_view_updates)
+  {
+    num_view_updates--;
+  }
+}
+
+
+/**
+ * Callback called on receipt of peer from biased stream
+ *
+ * @param num_peers number of peers
+ * @param recv_peers the received peers
+ */
+static void
+stream_input_handle (void *cls,
+                     uint64_t num_peers,
+                     const struct GNUNET_PeerIdentity *recv_peers)
+{
+  uint64_t i;
+
+  (void) cls;
+
+  if (0 == num_peers)
+  {
+    fprintf (stdout, "No peer was returned\n");
+  }
+  req_handle = NULL;
+  for (i = 0; i < num_peers; i++)
+  {
+    fprintf (stdout, "%s\n",
+             GNUNET_i2s_full (&recv_peers[i]));
+  }
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  static uint64_t num_peers;
+  static struct GNUNET_PeerIdentity zero_pid;
+
+  (void) cls;
+  (void) cfgfile;
+
+  rps_handle = GNUNET_RPS_connect (cfg);
+  if (NULL == rps_handle)
+  {
+    fprintf (stderr, "Failed to connect to the rps service\n");
+    return;
+  }
+
+  if ((0 == memcmp (&zero_pid, &peer_id, sizeof(peer_id))) &&
+      (! view_update) &&
+      (! stream_input))
+  {   /* Request n PeerIDs */
+      /* If number was specified use it, else request single peer. */
+    if ((NULL == args[0]) ||
+        (0 == sscanf (args[0], "%lu", &num_peers)) )
+    {
+      num_peers = 1;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Requesting %" PRIu64 " PeerIDs\n", num_peers);
+    req_handle = GNUNET_RPS_request_peers (rps_handle, num_peers, reply_handle,
+                                           NULL);
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  }
+  else if (view_update)
+  {
+    /* Get updates of view */
+    if ((NULL == args[0]) ||
+        (0 == sscanf (args[0], "%lu", &num_view_updates)) )
+    {
+      num_view_updates = 0;
+    }
+    GNUNET_RPS_view_request (rps_handle, num_view_updates, view_update_handle,
+                             NULL);
+    if (0 != num_view_updates)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Requesting %" PRIu64 " view updates\n", num_view_updates);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Requesting continuous view updates\n");
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  }
+  else if (stream_input)
+  {
+    /* Get updates of view */
+    GNUNET_RPS_stream_request (rps_handle, stream_input_handle, NULL);
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  }
+  else
+  {   /* Seed PeerID */
+    GNUNET_RPS_seed_ids (rps_handle, 1, &peer_id);
+    fprintf (stdout, "Seeded PeerID %s\n", GNUNET_i2s_full (&peer_id));
+    ret = 0;
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+  }
+}
+
+
+/**
+ * The main function to rps.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  const char helpstr[] =
+    "Get random GNUnet peers. If none is specified a single is requested.";
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_base32_auto ('s',
+                                      "seed",
+                                      "PEER_ID",
+                                      gettext_noop ("Seed a PeerID"),
+                                      &peer_id),
+    GNUNET_GETOPT_option_flag ('V',
+                               "view",
+                               gettext_noop (
+                                 "Get updates of view (0 for infinite updates)"),
+                               &view_update),
+    GNUNET_GETOPT_option_flag ('S',
+                               "stream",
+                               gettext_noop ("Get peers from biased stream"),
+                               &stream_input),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "gnunet-rps [NUMBER_OF_PEERS]",
+                              gettext_noop
+                                (helpstr),
+                              options, &run, NULL)) ? ret : 1;
+}
+
+
+/* end of gnunet-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps.c b/src/contrib/service/rps/gnunet-service-rps.c
new file mode 100644
index 000000000..76e33c87b
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps.c
@@ -0,0 +1,5009 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013-2015 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file rps/gnunet-service-rps.c
+ * @brief rps service implementation
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_applications.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_core_service.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_nse_service.h"
+#include "gnunet_statistics_service.h"
+#include "rps.h"
+#include "rps-test_util.h"
+#include "gnunet-service-rps_sampler.h"
+#include "gnunet-service-rps_custommap.h"
+#include "gnunet-service-rps_view.h"
+#include "gnunet_constants.h"
+
+#include <math.h>
+#include <inttypes.h>
+#include <string.h>
+
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+// TODO check for overflows
+
+// TODO align message structs
+
+// TODO connect to friends
+
+// TODO blacklist? (-> mal peer detection on top of brahms)
+
+// hist_size_init, hist_size_max
+
+/***********************************************************************
+* Old gnunet-service-rps_peers.c
+***********************************************************************/
+
+/**
+ * Set a peer flag of given peer context.
+ */
+#define SET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
+
+/**
+ * Get peer flag of given peer context.
+ */
+#define check_peer_flag_set(peer_ctx, mask) \
+  ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
+
+/**
+ * Unset flag of given peer context.
+ */
+#define UNSET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
+
+/**
+ * Get channel flag of given channel context.
+ */
+#define check_channel_flag_set(channel_flags, mask) \
+  ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
+
+/**
+ * Unset flag of given channel context.
+ */
+#define unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask))
+
+
+/**
+ * Pending operation on peer consisting of callback and closure
+ *
+ * When an operation cannot be executed right now this struct is used to store
+ * the callback and closure for later execution.
+ */
+struct PeerPendingOp
+{
+  /**
+   * Callback
+   */
+  PeerOp op;
+
+  /**
+   * Closure
+   */
+  void *op_cls;
+};
+
+/**
+ * List containing all messages that are yet to be send
+ *
+ * This is used to keep track of all messages that have not been sent yet. When
+ * a peer is to be removed the pending messages can be removed properly.
+ */
+struct PendingMessage
+{
+  /**
+   * DLL next, prev
+   */
+  struct PendingMessage *next;
+  struct PendingMessage *prev;
+
+  /**
+   * The envelope to the corresponding message
+   */
+  struct GNUNET_MQ_Envelope *ev;
+
+  /**
+   * The corresponding context
+   */
+  struct PeerContext *peer_ctx;
+
+  /**
+   * The message type
+   */
+  const char *type;
+};
+
+/**
+ * @brief Context for a channel
+ */
+struct ChannelCtx;
+
+/**
+ * Struct used to keep track of other peer's status
+ *
+ * This is stored in a multipeermap.
+ * It contains information such as cadet channels, a message queue for sending,
+ * status about the channels, the pending operations on this peer and some flags
+ * about the status of the peer itself. (online, valid, ...)
+ */
+struct PeerContext
+{
+  /**
+   * The Sub this context belongs to.
+   */
+  struct Sub *sub;
+
+  /**
+   * Message queue open to client
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Channel open to client.
+   */
+  struct ChannelCtx *send_channel_ctx;
+
+  /**
+   * Channel open from client.
+   */
+  struct ChannelCtx *recv_channel_ctx;
+
+  /**
+   * Array of pending operations on this peer.
+   */
+  struct PeerPendingOp *pending_ops;
+
+  /**
+   * Handle to the callback given to cadet_ntfy_tmt_rdy()
+   *
+   * To be canceled on shutdown.
+   */
+  struct PendingMessage *online_check_pending;
+
+  /**
+   * Number of pending operations.
+   */
+  unsigned int num_pending_ops;
+
+  /**
+   * Identity of the peer
+   */
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * Flags indicating status of peer
+   */
+  uint32_t peer_flags;
+
+  /**
+   * Last time we received something from that peer.
+   */
+  struct GNUNET_TIME_Absolute last_message_recv;
+
+  /**
+   * Last time we received a keepalive message.
+   */
+  struct GNUNET_TIME_Absolute last_keepalive;
+
+  /**
+   * DLL with all messages that are yet to be sent
+   */
+  struct PendingMessage *pending_messages_head;
+  struct PendingMessage *pending_messages_tail;
+
+  /**
+   * This is pobably followed by 'statistical' data (when we first saw
+   * it, how did we get its ID, how many pushes (in a timeinterval),
+   * ...)
+   */
+  uint32_t round_pull_req;
+};
+
+/**
+ * @brief Closure to #valid_peer_iterator
+ */
+struct PeersIteratorCls
+{
+  /**
+   * Iterator function
+   */
+  PeersIterator iterator;
+
+  /**
+   * Closure to iterator
+   */
+  void *cls;
+};
+
+/**
+ * @brief Context for a channel
+ */
+struct ChannelCtx
+{
+  /**
+   * @brief The channel itself
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * @brief The peer context associated with the channel
+   */
+  struct PeerContext *peer_ctx;
+
+  /**
+   * @brief When channel destruction needs to be delayed (because it is called
+   * from within the cadet routine of another channel destruction) this task
+   * refers to the respective _SCHEDULER_Task.
+   */
+  struct GNUNET_SCHEDULER_Task *destruction_task;
+};
+
+
+#if ENABLE_MALICIOUS
+
+/**
+ * If type is 2 This struct is used to store the attacked peers in a DLL
+ */
+struct AttackedPeer
+{
+  /**
+   * DLL
+   */
+  struct AttackedPeer *next;
+  struct AttackedPeer *prev;
+
+  /**
+   * PeerID
+   */
+  struct GNUNET_PeerIdentity peer_id;
+};
+
+#endif /* ENABLE_MALICIOUS */
+
+/**
+ * @brief This number determines the number of slots for files that represent
+ * histograms
+ */
+#define HISTOGRAM_FILE_SLOTS 32
+
+/**
+ * @brief The size (in bytes) a file needs to store the histogram
+ *
+ * Per slot: 1 newline, up to 4 chars,
+ * Additionally: 1 null termination
+ */
+#define SIZE_DUMP_FILE (HISTOGRAM_FILE_SLOTS * 5) + 1
+
+/**
+ * @brief One Sub.
+ *
+ * Essentially one instance of brahms that only connects to other instances
+ * with the same (secret) value.
+ */
+struct Sub
+{
+  /**
+   * @brief Hash of the shared value that defines Subs.
+   */
+  struct GNUNET_HashCode hash;
+
+  /**
+   * @brief Port to communicate to other peers.
+   */
+  struct GNUNET_CADET_Port *cadet_port;
+
+  /**
+   * @brief Hashmap of valid peers.
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
+
+  /**
+   * @brief Filename of the file that stores the valid peers persistently.
+   */
+  char *filename_valid_peers;
+
+  /**
+   * Set of all peers to keep track of them.
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+
+  /**
+   * @brief This is the minimum estimate used as sampler size.
+   *
+   * It is configured by the user.
+   */
+  unsigned int sampler_size_est_min;
+
+  /**
+   * The size of sampler we need to be able to satisfy the Brahms protocol's
+   * need of random peers.
+   *
+   * This is one minimum size the sampler grows to.
+   */
+  unsigned int sampler_size_est_need;
+
+  /**
+   * Time interval the do_round task runs in.
+   */
+  struct GNUNET_TIME_Relative round_interval;
+
+  /**
+   * Sampler used for the Brahms protocol itself.
+   */
+  struct RPS_Sampler *sampler;
+
+#ifdef TO_FILE_FULL
+  /**
+   * Name to log view to
+   */
+  char *file_name_view_log;
+#endif /* TO_FILE_FULL */
+
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+  /**
+   * Name to log number of observed peers to
+   */
+  char *file_name_observed_log;
+#endif /* TO_FILE_FULL */
+
+  /**
+   * @brief Count the observed peers
+   */
+  uint32_t num_observed_peers;
+
+  /**
+   * @brief Multipeermap (ab-) used to count unique peer_ids
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *observed_unique_peers;
+#endif /* TO_FILE */
+
+  /**
+   * List to store peers received through pushes temporary.
+   */
+  struct CustomPeerMap *push_map;
+
+  /**
+   * List to store peers received through pulls temporary.
+   */
+  struct CustomPeerMap *pull_map;
+
+  /**
+   * @brief This is the estimate used as view size.
+   *
+   * It is initialised with the minimum
+   */
+  unsigned int view_size_est_need;
+
+  /**
+   * @brief This is the minimum estimate used as view size.
+   *
+   * It is configured by the user.
+   */
+  unsigned int view_size_est_min;
+
+  /**
+   * @brief The view.
+   */
+  struct View *view;
+
+  /**
+   * Identifier for the main task that runs periodically.
+   */
+  struct GNUNET_SCHEDULER_Task *do_round_task;
+
+  /* === stats === */
+
+  /**
+   * @brief Counts the executed rounds.
+   */
+  uint32_t num_rounds;
+
+  /**
+   * @brief This array accumulates the number of received pushes per round.
+   *
+   * Number at index i represents the number of rounds with i observed pushes.
+   */
+  uint32_t push_recv[HISTOGRAM_FILE_SLOTS];
+
+  /**
+   * @brief Histogram of deltas between the expected and actual number of
+   * received pushes.
+   *
+   * As half of the entries are expected to be negative, this is shifted by
+   * #HISTOGRAM_FILE_SLOTS/2.
+   */
+  uint32_t push_delta[HISTOGRAM_FILE_SLOTS];
+
+  /**
+   * @brief Number of pull replies with this delay measured in rounds.
+   *
+   * Number at index i represents the number of pull replies with a delay of i
+   * rounds.
+   */
+  uint32_t pull_delays[HISTOGRAM_FILE_SLOTS];
+};
+
+
+/***********************************************************************
+* Globals
+***********************************************************************/
+
+/**
+ * Our configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Handle to the statistics service.
+ */
+struct GNUNET_STATISTICS_Handle *stats;
+
+/**
+ * Handler to CADET.
+ */
+struct GNUNET_CADET_Handle *cadet_handle;
+
+/**
+ * Handle to CORE
+ */
+struct GNUNET_CORE_Handle *core_handle;
+
+/**
+ * @brief PeerMap to keep track of connected peers.
+ */
+struct GNUNET_CONTAINER_MultiPeerMap *map_single_hop;
+
+/**
+ * Our own identity.
+ */
+static struct GNUNET_PeerIdentity own_identity;
+
+/**
+ * Percentage of total peer number in the view
+ * to send random PUSHes to
+ */
+static float alpha;
+
+/**
+ * Percentage of total peer number in the view
+ * to send random PULLs to
+ */
+static float beta;
+
+/**
+ * Handler to NSE.
+ */
+static struct GNUNET_NSE_Handle *nse;
+
+/**
+ * Handle to the PEERSTORE service.
+ */
+static struct GNUNET_PEERSTORE_Handle *peerstore;
+
+/**
+ * Our peerstore notification context.  We use notification
+ * to instantly learn about new peers as they are discovered.
+ */
+static struct GNUNET_PEERSTORE_NotifyContext *peerstore_notify;
+
+
+#if ENABLE_MALICIOUS
+/**
+ * Type of malicious peer
+ *
+ * 0 Don't act malicious at all - Default
+ * 1 Try to maximise representation
+ * 2 Try to partition the network
+ * 3 Combined attack
+ */
+static uint32_t mal_type;
+
+/**
+ * Other malicious peers
+ */
+static struct GNUNET_PeerIdentity *mal_peers;
+
+/**
+ * Hashmap of malicious peers used as set.
+ * Used to more efficiently check whether we know that peer.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *mal_peer_set;
+
+/**
+ * Number of other malicious peers
+ */
+static uint32_t num_mal_peers;
+
+
+/**
+ * If type is 2 this is the DLL of attacked peers
+ */
+static struct AttackedPeer *att_peers_head;
+static struct AttackedPeer *att_peers_tail;
+
+/**
+ * This index is used to point to an attacked peer to
+ * implement the round-robin-ish way to select attacked peers.
+ */
+static struct AttackedPeer *att_peer_index;
+
+/**
+ * Hashmap of attacked peers used as set.
+ * Used to more efficiently check whether we know that peer.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *att_peer_set;
+
+/**
+ * Number of attacked peers
+ */
+static uint32_t num_attacked_peers;
+
+/**
+ * If type is 1 this is the attacked peer
+ */
+static struct GNUNET_PeerIdentity attacked_peer;
+
+/**
+ * The limit of PUSHes we can send in one round.
+ * This is an assumption of the Brahms protocol and either implemented
+ * via proof of work
+ * or
+ * assumed to be the bandwidth limitation.
+ */
+static uint32_t push_limit = 10000;
+#endif /* ENABLE_MALICIOUS */
+
+/**
+ * @brief Main Sub.
+ *
+ * This is run in any case by all peers and connects to all peers without
+ * specifying a shared value.
+ */
+static struct Sub *msub;
+
+/**
+ * @brief Maximum number of valid peers to keep.
+ * TODO read from config
+ */
+static const uint32_t num_valid_peers_max = UINT32_MAX;
+
+/***********************************************************************
+* /Globals
+***********************************************************************/
+
+
+static void
+do_round (void *cls);
+
+#if ENABLE_MALICIOUS
+static void
+do_mal_round (void *cls);
+
+#endif /* ENABLE_MALICIOUS */
+
+
+/**
+ * @brief Get the #PeerContext associated with a peer
+ *
+ * @param peer_map The peer map containing the context
+ * @param peer the peer id
+ *
+ * @return the #PeerContext
+ */
+static struct PeerContext *
+get_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+              const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *ctx;
+  int ret;
+
+  ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+  GNUNET_assert (GNUNET_YES == ret);
+  ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
+  GNUNET_assert (NULL != ctx);
+  return ctx;
+}
+
+
+/**
+ * @brief Check whether we have information about the given peer.
+ *
+ * FIXME probably deprecated. Make this the new _online.
+ *
+ * @param peer_map The peer map to check for the existence of @a peer
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is known
+ *         #GNUNET_NO  if peer is not known
+ */
+static int
+check_peer_known (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+                  const struct GNUNET_PeerIdentity *peer)
+{
+  if (NULL != peer_map)
+  {
+    return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+  }
+  else
+  {
+    return GNUNET_NO;
+  }
+}
+
+
+/**
+ * @brief Create a new #PeerContext and insert it into the peer map
+ *
+ * @param sub The Sub this context belongs to.
+ * @param peer the peer to create the #PeerContext for
+ *
+ * @return the #PeerContext
+ */
+static struct PeerContext *
+create_peer_ctx (struct Sub *sub,
+                 const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *ctx;
+  int ret;
+
+  GNUNET_assert (GNUNET_NO == check_peer_known (sub->peer_map, peer));
+
+  ctx = GNUNET_new (struct PeerContext);
+  ctx->peer_id = *peer;
+  ctx->sub = sub;
+  ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  GNUNET_assert (GNUNET_OK == ret);
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "# known peers",
+                           GNUNET_CONTAINER_multipeermap_size (sub->peer_map),
+                           GNUNET_NO);
+  }
+  return ctx;
+}
+
+
+/**
+ * @brief Create or get a #PeerContext
+ *
+ * @param sub The Sub to which the created context belongs to
+ * @param peer the peer to get the associated context to
+ *
+ * @return the context
+ */
+static struct PeerContext *
+create_or_get_peer_ctx (struct Sub *sub,
+                        const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
+  {
+    return create_peer_ctx (sub, peer);
+  }
+  return get_peer_ctx (sub->peer_map, peer);
+}
+
+
+/**
+ * @brief Check whether we have a connection to this @a peer
+ *
+ * Also sets the #Peers_ONLINE flag accordingly
+ *
+ * @param peer_ctx Context of the peer of which connectivity is to be checked
+ *
+ * @return #GNUNET_YES if we are connected
+ *         #GNUNET_NO  otherwise
+ */
+static int
+check_connected (struct PeerContext *peer_ctx)
+{
+  /* If we don't know about this peer we don't know whether it's online */
+  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+                                     &peer_ctx->peer_id))
+  {
+    return GNUNET_NO;
+  }
+  /* Get the context */
+  peer_ctx = get_peer_ctx (peer_ctx->sub->peer_map, &peer_ctx->peer_id);
+  /* If we have no channel to this peer we don't know whether it's online */
+  if ((NULL == peer_ctx->send_channel_ctx) &&
+      (NULL == peer_ctx->recv_channel_ctx))
+  {
+    UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+    return GNUNET_NO;
+  }
+  /* Otherwise (if we have a channel, we know that it's online */
+  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief The closure to #get_rand_peer_iterator.
+ */
+struct GetRandPeerIteratorCls
+{
+  /**
+   * @brief The index of the peer to return.
+   * Will be decreased until 0.
+   * Then current peer is returned.
+   */
+  uint32_t index;
+
+  /**
+   * @brief Pointer to peer to return.
+   */
+  const struct GNUNET_PeerIdentity *peer;
+};
+
+
+/**
+ * @brief Iterator function for #get_random_peer_from_peermap.
+ *
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Decreases the index until the index is null.
+ * Then returns the current peer.
+ *
+ * @param cls the #GetRandPeerIteratorCls containing index and peer
+ * @param peer current peer
+ * @param value unused
+ *
+ * @return  #GNUNET_YES if we should continue to
+ *          iterate,
+ *          #GNUNET_NO if not.
+ */
+static int
+get_rand_peer_iterator (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        void *value)
+{
+  struct GetRandPeerIteratorCls *iterator_cls = cls;
+
+  (void) value;
+
+  if (0 >= iterator_cls->index)
+  {
+    iterator_cls->peer = peer;
+    return GNUNET_NO;
+  }
+  iterator_cls->index--;
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Get a random peer from @a peer_map
+ *
+ * @param valid_peers Peer map containing valid peers from which to select a
+ * random one
+ *
+ * @return a random peer
+ */
+static const struct GNUNET_PeerIdentity *
+get_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
+{
+  struct GetRandPeerIteratorCls *iterator_cls;
+  const struct GNUNET_PeerIdentity *ret;
+
+  iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
+  iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                  GNUNET_CONTAINER_multipeermap_size (
+                                                    valid_peers));
+  (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+                                                get_rand_peer_iterator,
+                                                iterator_cls);
+  ret = iterator_cls->peer;
+  GNUNET_free (iterator_cls);
+  return ret;
+}
+
+
+/**
+ * @brief Add a given @a peer to valid peers.
+ *
+ * If valid peers are already #num_valid_peers_max, delete a peer previously.
+ *
+ * @param peer The peer that is added to the valid peers.
+ * @param valid_peers Peer map of valid peers to which to add the @a peer
+ *
+ * @return #GNUNET_YES if no other peer had to be removed
+ *         #GNUNET_NO  otherwise
+ */
+static int
+add_valid_peer (const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
+{
+  const struct GNUNET_PeerIdentity *rand_peer;
+  int ret;
+
+  ret = GNUNET_YES;
+  /* Remove random peers until there is space for a new one */
+  while (num_valid_peers_max <=
+         GNUNET_CONTAINER_multipeermap_size (valid_peers))
+  {
+    rand_peer = get_random_peer_from_peermap (valid_peers);
+    GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
+    ret = GNUNET_NO;
+  }
+  (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  if (valid_peers == msub->valid_peers)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "# valid peers",
+                           GNUNET_CONTAINER_multipeermap_size (valid_peers),
+                           GNUNET_NO);
+  }
+  return ret;
+}
+
+
+static void
+remove_pending_message (struct PendingMessage *pending_msg, int cancel);
+
+/**
+ * @brief Set the peer flag to living and
+ *        call the pending operations on this peer.
+ *
+ * Also adds peer to #valid_peers.
+ *
+ * @param peer_ctx the #PeerContext of the peer to set online
+ */
+static void
+set_peer_online (struct PeerContext *peer_ctx)
+{
+  struct GNUNET_PeerIdentity *peer;
+  unsigned int i;
+
+  peer = &peer_ctx->peer_id;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %s is online and valid, calling %i pending operations on it\n",
+       GNUNET_i2s (peer),
+       peer_ctx->num_pending_ops);
+
+  if (NULL != peer_ctx->online_check_pending)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Removing pending online check for peer %s\n",
+         GNUNET_i2s (&peer_ctx->peer_id));
+    // TODO wait until cadet sets mq->cancel_impl
+    // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
+    remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
+    peer_ctx->online_check_pending = NULL;
+  }
+
+  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+
+  /* Call pending operations */
+  for (i = 0; i < peer_ctx->num_pending_ops; i++)
+  {
+    peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
+  }
+  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
+}
+
+
+static void
+cleanup_destroyed_channel (void *cls,
+                           const struct GNUNET_CADET_Channel *channel);
+
+/* Declaration of handlers */
+static void
+handle_peer_check (void *cls,
+                   const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_push (void *cls,
+                  const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_pull_request (void *cls,
+                          const struct GNUNET_MessageHeader *msg);
+
+static int
+check_peer_pull_reply (void *cls,
+                       const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+static void
+handle_peer_pull_reply (void *cls,
+                        const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+/* End declaration of handlers */
+
+/**
+ * @brief Allocate memory for a new channel context and insert it into DLL
+ *
+ * @param peer_ctx context of the according peer
+ *
+ * @return The channel context
+ */
+static struct ChannelCtx *
+add_channel_ctx (struct PeerContext *peer_ctx)
+{
+  struct ChannelCtx *channel_ctx;
+
+  channel_ctx = GNUNET_new (struct ChannelCtx);
+  channel_ctx->peer_ctx = peer_ctx;
+  return channel_ctx;
+}
+
+
+/**
+ * @brief Free memory and NULL pointers.
+ *
+ * @param channel_ctx The channel context.
+ */
+static void
+remove_channel_ctx (struct ChannelCtx *channel_ctx)
+{
+  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+
+  if (NULL != channel_ctx->destruction_task)
+  {
+    GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+    channel_ctx->destruction_task = NULL;
+  }
+
+  if (NULL == peer_ctx)
+    return;
+  if (channel_ctx == peer_ctx->send_channel_ctx)
+  {
+    peer_ctx->send_channel_ctx = NULL;
+    peer_ctx->mq = NULL;
+  }
+  else if (channel_ctx == peer_ctx->recv_channel_ctx)
+  {
+    peer_ctx->recv_channel_ctx = NULL;
+  }
+  GNUNET_free (channel_ctx);
+}
+
+
+/**
+ * @brief Get the channel of a peer. If not existing, create.
+ *
+ * @param peer_ctx Context of the peer of which to get the channel
+ * @return the #GNUNET_CADET_Channel used to send data to @a peer_ctx
+ */
+struct GNUNET_CADET_Channel *
+get_channel (struct PeerContext *peer_ctx)
+{
+  /* There exists a copy-paste-clone in run() */
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (peer_check,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_push,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_pull_request,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_var_size (peer_pull_reply,
+                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+                           struct GNUNET_RPS_P2P_PullReplyMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+
+
+  if (NULL == peer_ctx->send_channel_ctx)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Trying to establish channel to peer %s\n",
+         GNUNET_i2s (&peer_ctx->peer_id));
+    peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
+    peer_ctx->send_channel_ctx->channel =
+      GNUNET_CADET_channel_create (cadet_handle,
+                                   peer_ctx->send_channel_ctx,  /* context */
+                                   &peer_ctx->peer_id,
+                                   &peer_ctx->sub->hash,
+                                   NULL,  /* WindowSize handler */
+                                   &cleanup_destroyed_channel,  /* Disconnect handler */
+                                   cadet_handlers);
+  }
+  GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
+  GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
+  return peer_ctx->send_channel_ctx->channel;
+}
+
+
+/**
+ * Get the message queue (#GNUNET_MQ_Handle) of a specific peer.
+ *
+ * If we already have a message queue open to this client,
+ * simply return it, otherwise create one.
+ *
+ * @param peer_ctx Context of the peer of which to get the mq
+ * @return the #GNUNET_MQ_Handle
+ */
+static struct GNUNET_MQ_Handle *
+get_mq (struct PeerContext *peer_ctx)
+{
+  if (NULL == peer_ctx->mq)
+  {
+    peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
+  }
+  return peer_ctx->mq;
+}
+
+
+/**
+ * @brief Add an envelope to a message passed to mq to list of pending messages
+ *
+ * @param peer_ctx Context of the peer for which to insert the envelope
+ * @param ev envelope to the message
+ * @param type type of the message to be sent
+ * @return pointer to pending message
+ */
+static struct PendingMessage *
+insert_pending_message (struct PeerContext *peer_ctx,
+                        struct GNUNET_MQ_Envelope *ev,
+                        const char *type)
+{
+  struct PendingMessage *pending_msg;
+
+  pending_msg = GNUNET_new (struct PendingMessage);
+  pending_msg->ev = ev;
+  pending_msg->peer_ctx = peer_ctx;
+  pending_msg->type = type;
+  GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
+                               peer_ctx->pending_messages_tail,
+                               pending_msg);
+  return pending_msg;
+}
+
+
+/**
+ * @brief Remove a pending message from the respective DLL
+ *
+ * @param pending_msg the pending message to remove
+ * @param cancel whether to cancel the pending message, too
+ */
+static void
+remove_pending_message (struct PendingMessage *pending_msg, int cancel)
+{
+  struct PeerContext *peer_ctx;
+
+  (void) cancel;
+
+  peer_ctx = pending_msg->peer_ctx;
+  GNUNET_assert (NULL != peer_ctx);
+  GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
+                               peer_ctx->pending_messages_tail,
+                               pending_msg);
+  // TODO wait for the cadet implementation of message cancellation
+  // if (GNUNET_YES == cancel)
+  // {
+  //  GNUNET_MQ_send_cancel (pending_msg->ev);
+  // }
+  GNUNET_free (pending_msg);
+}
+
+
+/**
+ * @brief This is called in response to the first message we sent as a
+ * online check.
+ *
+ * @param cls #PeerContext of peer with pending online check
+ */
+static void
+mq_online_check_successful (void *cls)
+{
+  struct PeerContext *peer_ctx = cls;
+
+  if (NULL != peer_ctx->online_check_pending)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Online check for peer %s was successful\n",
+         GNUNET_i2s (&peer_ctx->peer_id));
+    remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
+    peer_ctx->online_check_pending = NULL;
+    set_peer_online (peer_ctx);
+    (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
+  }
+}
+
+
+/**
+ * Issue a check whether peer is online
+ *
+ * @param peer_ctx the context of the peer
+ */
+static void
+check_peer_online (struct PeerContext *peer_ctx)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Get informed about peer %s getting online\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+
+  struct GNUNET_MQ_Handle *mq;
+  struct GNUNET_MQ_Envelope *ev;
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
+  peer_ctx->online_check_pending =
+    insert_pending_message (peer_ctx, ev, "Check online");
+  mq = get_mq (peer_ctx);
+  GNUNET_MQ_notify_sent (ev,
+                         mq_online_check_successful,
+                         peer_ctx);
+  GNUNET_MQ_send (mq, ev);
+  if (peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# pending online checks",
+                              1,
+                              GNUNET_NO);
+  }
+}
+
+
+/**
+ * @brief Check whether function of type #PeerOp was already scheduled
+ *
+ * The array with pending operations will probably never grow really big, so
+ * iterating over it should be ok.
+ *
+ * @param peer_ctx Context of the peer to check for the operation
+ * @param peer_op the operation (#PeerOp) on the peer
+ *
+ * @return #GNUNET_YES if this operation is scheduled on that peer
+ *         #GNUNET_NO  otherwise
+ */
+static int
+check_operation_scheduled (const struct PeerContext *peer_ctx,
+                           const PeerOp peer_op)
+{
+  unsigned int i;
+
+  for (i = 0; i < peer_ctx->num_pending_ops; i++)
+    if (peer_op == peer_ctx->pending_ops[i].op)
+      return GNUNET_YES;
+  return GNUNET_NO;
+}
+
+
+/**
+ * @brief Callback for scheduler to destroy a channel
+ *
+ * @param channel_ctx Context of the channel
+ */
+static void
+destroy_channel (struct ChannelCtx *channel_ctx)
+{
+  struct GNUNET_CADET_Channel *channel;
+
+  if (NULL != channel_ctx->destruction_task)
+  {
+    GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+    channel_ctx->destruction_task = NULL;
+  }
+  GNUNET_assert (channel_ctx->channel != NULL);
+  channel = channel_ctx->channel;
+  channel_ctx->channel = NULL;
+  GNUNET_CADET_channel_destroy (channel);
+  remove_channel_ctx (channel_ctx);
+}
+
+
+/**
+ * @brief Destroy a cadet channel.
+ *
+ * This satisfies the function signature of #GNUNET_SCHEDULER_TaskCallback.
+ *
+ * @param cls
+ */
+static void
+destroy_channel_cb (void *cls)
+{
+  struct ChannelCtx *channel_ctx = cls;
+
+  channel_ctx->destruction_task = NULL;
+  destroy_channel (channel_ctx);
+}
+
+
+/**
+ * @brief Schedule the destruction of a channel for immediately afterwards.
+ *
+ * In case a channel is to be destroyed from within the callback to the
+ * destruction of another channel (send channel), we cannot call
+ * GNUNET_CADET_channel_destroy directly, but need to use this scheduling
+ * construction.
+ *
+ * @param channel_ctx channel to be destroyed.
+ */
+static void
+schedule_channel_destruction (struct ChannelCtx *channel_ctx)
+{
+  GNUNET_assert (NULL ==
+                 channel_ctx->destruction_task);
+  GNUNET_assert (NULL !=
+                 channel_ctx->channel);
+  channel_ctx->destruction_task =
+    GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
+                              channel_ctx);
+}
+
+
+/**
+ * @brief Remove peer
+ *
+ * - Empties the list with pending operations
+ * - Empties the list with pending messages
+ * - Cancels potentially existing online check
+ * - Schedules closing of send and recv channels
+ * - Removes peer from peer map
+ *
+ * @param peer_ctx Context of the peer to be destroyed
+ * @return #GNUNET_YES if peer was removed
+ *         #GNUNET_NO  otherwise
+ */
+static int
+destroy_peer (struct PeerContext *peer_ctx)
+{
+  GNUNET_assert (NULL != peer_ctx);
+  GNUNET_assert (NULL != peer_ctx->sub->peer_map);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
+                                              &peer_ctx->peer_id))
+  {
+    return GNUNET_NO;
+  }
+  SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to remove peer %s\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+  UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+
+  /* Clear list of pending operations */
+  // TODO this probably leaks memory
+  //      ('only' the cls to the function. Not sure what to do with it)
+  GNUNET_array_grow (peer_ctx->pending_ops,
+                     peer_ctx->num_pending_ops,
+                     0);
+  /* Remove all pending messages */
+  while (NULL != peer_ctx->pending_messages_head)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Removing unsent %s\n",
+         peer_ctx->pending_messages_head->type);
+    /* Cancel pending message, too */
+    if ((NULL != peer_ctx->online_check_pending) &&
+        (0 == memcmp (peer_ctx->pending_messages_head,
+                      peer_ctx->online_check_pending,
+                      sizeof(struct PendingMessage))))
+    {
+      peer_ctx->online_check_pending = NULL;
+      if (peer_ctx->sub == msub)
+      {
+        GNUNET_STATISTICS_update (stats,
+                                  "# pending online checks",
+                                  -1,
+                                  GNUNET_NO);
+      }
+    }
+    remove_pending_message (peer_ctx->pending_messages_head,
+                            GNUNET_YES);
+  }
+
+  /* If we are still waiting for notification whether this peer is online
+   * cancel the according task */
+  if (NULL != peer_ctx->online_check_pending)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing pending online check for peer %s\n",
+                GNUNET_i2s (&peer_ctx->peer_id));
+    // TODO wait until cadet sets mq->cancel_impl
+    // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
+    remove_pending_message (peer_ctx->online_check_pending,
+                            GNUNET_YES);
+    peer_ctx->online_check_pending = NULL;
+  }
+
+  if (NULL != peer_ctx->send_channel_ctx)
+  {
+    /* This is possibly called from within channel destruction */
+    peer_ctx->send_channel_ctx->peer_ctx = NULL;
+    schedule_channel_destruction (peer_ctx->send_channel_ctx);
+    peer_ctx->send_channel_ctx = NULL;
+    peer_ctx->mq = NULL;
+  }
+  if (NULL != peer_ctx->recv_channel_ctx)
+  {
+    /* This is possibly called from within channel destruction */
+    peer_ctx->recv_channel_ctx->peer_ctx = NULL;
+    schedule_channel_destruction (peer_ctx->recv_channel_ctx);
+    peer_ctx->recv_channel_ctx = NULL;
+  }
+
+  if (GNUNET_YES !=
+      GNUNET_CONTAINER_multipeermap_remove_all (peer_ctx->sub->peer_map,
+                                                &peer_ctx->peer_id))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "removing peer from peer_ctx->sub->peer_map failed\n");
+  }
+  if (peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "# known peers",
+                           GNUNET_CONTAINER_multipeermap_size (
+                             peer_ctx->sub->peer_map),
+                           GNUNET_NO);
+  }
+  GNUNET_free (peer_ctx);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Iterator over hash map entries. Deletes all contexts of peers.
+ *
+ * @param cls closure
+ * @param key current public key
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+peermap_clear_iterator (void *cls,
+                        const struct GNUNET_PeerIdentity *key,
+                        void *value)
+{
+  struct Sub *sub = cls;
+
+  (void) value;
+
+  destroy_peer (get_peer_ctx (sub->peer_map, key));
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief This is called once a message is sent.
+ *
+ * Removes the pending message
+ *
+ * @param cls type of the message that was sent
+ */
+static void
+mq_notify_sent_cb (void *cls)
+{
+  struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "%s was sent.\n",
+       pending_msg->type);
+  if (pending_msg->peer_ctx->sub == msub)
+  {
+    if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
+      GNUNET_STATISTICS_update (stats, "# pull replies sent", 1, GNUNET_NO);
+    if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
+      GNUNET_STATISTICS_update (stats, "# pull requests sent", 1, GNUNET_NO);
+    if (0 == strncmp ("PUSH", pending_msg->type, 4))
+      GNUNET_STATISTICS_update (stats, "# pushes sent", 1, GNUNET_NO);
+    if ((0 == strncmp ("PULL REQUEST", pending_msg->type, 12)) &&
+        (NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              &pending_msg->
+                                                              peer_ctx->peer_id)) )
+      GNUNET_STATISTICS_update (stats,
+                                "# pull requests sent (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+  }
+  /* Do not cancel message */
+  remove_pending_message (pending_msg, GNUNET_NO);
+}
+
+
+/**
+ * @brief Iterator function for #store_valid_peers.
+ *
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Writes single peer to disk.
+ *
+ * @param cls the file handle to write to.
+ * @param peer current peer
+ * @param value unused
+ *
+ * @return  #GNUNET_YES if we should continue to
+ *          iterate,
+ *          #GNUNET_NO if not.
+ */
+static int
+store_peer_presistently_iterator (void *cls,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  void *value)
+{
+  const struct GNUNET_DISK_FileHandle *fh = cls;
+  char peer_string[128];
+  int size;
+  ssize_t ret;
+
+  (void) value;
+
+  if (NULL == peer)
+  {
+    return GNUNET_YES;
+  }
+  size = GNUNET_snprintf (peer_string,
+                          sizeof(peer_string),
+                          "%s\n",
+                          GNUNET_i2s_full (peer));
+  GNUNET_assert (53 == size);
+  ret = GNUNET_DISK_file_write (fh,
+                                peer_string,
+                                size);
+  GNUNET_assert (size == ret);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Store the peers currently in #valid_peers to disk.
+ *
+ * @param sub Sub for which to store the valid peers
+ */
+static void
+store_valid_peers (const struct Sub *sub)
+{
+  struct GNUNET_DISK_FileHandle *fh;
+  uint32_t number_written_peers;
+  int ret;
+
+  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
+  {
+    return;
+  }
+
+  ret = GNUNET_DISK_directory_create_for_file (sub->filename_valid_peers);
+  if (GNUNET_SYSERR == ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not able to create directory for file `%s'\n",
+         sub->filename_valid_peers);
+    GNUNET_break (0);
+  }
+  else if (GNUNET_NO == ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Directory for file `%s' exists but is not writable for us\n",
+         sub->filename_valid_peers);
+    GNUNET_break (0);
+  }
+  fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
+                              GNUNET_DISK_OPEN_WRITE
+                              | GNUNET_DISK_OPEN_CREATE,
+                              GNUNET_DISK_PERM_USER_READ
+                              | GNUNET_DISK_PERM_USER_WRITE);
+  if (NULL == fh)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not able to write valid peers to file `%s'\n",
+         sub->filename_valid_peers);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Writing %u valid peers to disk\n",
+       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+  number_written_peers =
+    GNUNET_CONTAINER_multipeermap_iterate (sub->valid_peers,
+                                           store_peer_presistently_iterator,
+                                           fh);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  GNUNET_assert (number_written_peers ==
+                 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+}
+
+
+/**
+ * @brief Convert string representation of peer id to peer id.
+ *
+ * Counterpart to #GNUNET_i2s_full.
+ *
+ * @param string_repr The string representation of the peer id
+ *
+ * @return The peer id
+ */
+static const struct GNUNET_PeerIdentity *
+s2i_full (const char *string_repr)
+{
+  struct GNUNET_PeerIdentity *peer;
+  size_t len;
+  int ret;
+
+  peer = GNUNET_new (struct GNUNET_PeerIdentity);
+  len = strlen (string_repr);
+  if (52 > len)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not able to convert string representation of PeerID to PeerID\n"
+         "String representation: %s (len %lu) - too short\n",
+         string_repr,
+         len);
+    GNUNET_break (0);
+  }
+  else if (52 < len)
+  {
+    len = 52;
+  }
+  ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
+                                                    len,
+                                                    &peer->public_key);
+  if (GNUNET_OK != ret)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not able to convert string representation of PeerID to PeerID\n"
+         "String representation: %s\n",
+         string_repr);
+    GNUNET_break (0);
+  }
+  return peer;
+}
+
+
+/**
+ * @brief Restore the peers on disk to #valid_peers.
+ *
+ * @param sub Sub for which to restore the valid peers
+ */
+static void
+restore_valid_peers (const struct Sub *sub)
+{
+  off_t file_size;
+  uint32_t num_peers;
+  struct GNUNET_DISK_FileHandle *fh;
+  char *buf;
+  ssize_t size_read;
+  char *iter_buf;
+  char *str_repr;
+  const struct GNUNET_PeerIdentity *peer;
+
+  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
+  {
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_DISK_file_test (sub->filename_valid_peers))
+  {
+    return;
+  }
+  fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
+                              GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_NONE);
+  GNUNET_assert (NULL != fh);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
+  num_peers = file_size / 53;
+  buf = GNUNET_malloc (file_size);
+  size_read = GNUNET_DISK_file_read (fh, buf, file_size);
+  GNUNET_assert (size_read == file_size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Restoring %" PRIu32 " peers from file `%s'\n",
+       num_peers,
+       sub->filename_valid_peers);
+  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
+  {
+    str_repr = GNUNET_strndup (iter_buf, 53);
+    peer = s2i_full (str_repr);
+    GNUNET_free (str_repr);
+    add_valid_peer (peer, sub->valid_peers);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Restored valid peer %s from disk\n",
+         GNUNET_i2s_full (peer));
+  }
+  iter_buf = NULL;
+  GNUNET_free (buf);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
+       num_peers,
+       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+  if (num_peers != GNUNET_CONTAINER_multipeermap_size (sub->valid_peers))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Number of restored peers does not match file size. Have probably duplicates.\n");
+  }
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Restored %u valid peers from disk\n",
+       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+}
+
+
+/**
+ * @brief Delete storage of peers that was created with #initialise_peers ()
+ *
+ * @param sub Sub for which the storage is deleted
+ */
+static void
+peers_terminate (struct Sub *sub)
+{
+  if (GNUNET_SYSERR ==
+      GNUNET_CONTAINER_multipeermap_iterate (sub->peer_map,
+                                             &peermap_clear_iterator,
+                                             sub))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Iteration destroying peers was aborted.\n");
+  }
+  GNUNET_CONTAINER_multipeermap_destroy (sub->peer_map);
+  sub->peer_map = NULL;
+  store_valid_peers (sub);
+  GNUNET_free (sub->filename_valid_peers);
+  sub->filename_valid_peers = NULL;
+  GNUNET_CONTAINER_multipeermap_destroy (sub->valid_peers);
+  sub->valid_peers = NULL;
+}
+
+
+/**
+ * Iterator over #valid_peers hash map entries.
+ *
+ * @param cls Closure that contains iterator function and closure
+ * @param peer current peer id
+ * @param value value in the hash map - unused
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+valid_peer_iterator (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
+{
+  struct PeersIteratorCls *it_cls = cls;
+
+  (void) value;
+
+  return it_cls->iterator (it_cls->cls, peer);
+}
+
+
+/**
+ * @brief Get all currently known, valid peer ids.
+ *
+ * @param valid_peers Peer map containing the valid peers in question
+ * @param iterator function to call on each peer id
+ * @param it_cls extra argument to @a iterator
+ * @return the number of key value pairs processed,
+ *         #GNUNET_SYSERR if it aborted iteration
+ */
+static int
+get_valid_peers (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
+                 PeersIterator iterator,
+                 void *it_cls)
+{
+  struct PeersIteratorCls *cls;
+  int ret;
+
+  cls = GNUNET_new (struct PeersIteratorCls);
+  cls->iterator = iterator;
+  cls->cls = it_cls;
+  ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+                                               valid_peer_iterator,
+                                               cls);
+  GNUNET_free (cls);
+  return ret;
+}
+
+
+/**
+ * @brief Add peer to known peers.
+ *
+ * This function is called on new peer_ids from 'external' sources
+ * (client seed, cadet get_peers(), ...)
+ *
+ * @param sub Sub with the peer map that the @a peer will be added to
+ * @param peer the new #GNUNET_PeerIdentity
+ *
+ * @return #GNUNET_YES if peer was inserted
+ *         #GNUNET_NO  otherwise
+ */
+static int
+insert_peer (struct Sub *sub,
+             const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_YES == check_peer_known (sub->peer_map, peer))
+  {
+    return GNUNET_NO;   /* We already know this peer - nothing to do */
+  }
+  (void) create_peer_ctx (sub, peer);
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Check whether flags on a peer are set.
+ *
+ * @param peer_map Peer map that is expected to contain the @a peer
+ * @param peer the peer to check the flag of
+ * @param flags the flags to check
+ *
+ * @return #GNUNET_SYSERR if peer is not known
+ *         #GNUNET_YES    if all given flags are set
+ *         #GNUNET_NO     otherwise
+ */
+static int
+check_peer_flag (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+                 const struct GNUNET_PeerIdentity *peer,
+                 enum Peers_PeerFlags flags)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == check_peer_known (peer_map, peer))
+  {
+    return GNUNET_SYSERR;
+  }
+  peer_ctx = get_peer_ctx (peer_map, peer);
+  return check_peer_flag_set (peer_ctx, flags);
+}
+
+
+/**
+ * @brief Try connecting to a peer to see whether it is online
+ *
+ * If not known yet, insert into known peers
+ *
+ * @param sub Sub which would contain the @a peer
+ * @param peer the peer whose online is to be checked
+ * @return #GNUNET_YES if the check was issued
+ *         #GNUNET_NO  otherwise
+ */
+static int
+issue_peer_online_check (struct Sub *sub,
+                         const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+
+  (void) insert_peer (sub, peer);   // TODO even needed?
+  peer_ctx = get_peer_ctx (sub->peer_map, peer);
+  if ((GNUNET_NO == check_peer_flag (sub->peer_map, peer, Peers_ONLINE)) &&
+      (NULL == peer_ctx->online_check_pending))
+  {
+    check_peer_online (peer_ctx);
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * @brief Check if peer is removable.
+ *
+ * Check if
+ *  - a recv channel exists
+ *  - there are pending messages
+ *  - there is no pending pull reply
+ *
+ * @param peer_ctx Context of the peer in question
+ * @return #GNUNET_YES    if peer is removable
+ *         #GNUNET_NO     if peer is NOT removable
+ *         #GNUNET_SYSERR if peer is not known
+ */
+static int
+check_removable (const struct PeerContext *peer_ctx)
+{
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (
+        peer_ctx->sub->peer_map,
+        &peer_ctx->peer_id))
+  {
+    return GNUNET_SYSERR;
+  }
+
+  if ((NULL != peer_ctx->recv_channel_ctx) ||
+      (NULL != peer_ctx->pending_messages_head) ||
+      (GNUNET_YES == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)))
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Check whether @a peer is actually a peer.
+ *
+ * A valid peer is a peer that we know exists eg. we were connected to once.
+ *
+ * @param valid_peers Peer map that would contain the @a peer
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is valid
+ *         #GNUNET_NO  if peer is not valid
+ */
+static int
+check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
+                  const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
+}
+
+
+/**
+ * @brief Indicate that we want to send to the other peer
+ *
+ * This establishes a sending channel
+ *
+ * @param peer_ctx Context of the target peer
+ */
+static void
+indicate_sending_intention (struct PeerContext *peer_ctx)
+{
+  GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+                                                 &peer_ctx->peer_id));
+  (void) get_channel (peer_ctx);
+}
+
+
+/**
+ * @brief Check whether other peer has the intention to send/opened channel
+ *        towars us
+ *
+ * @param peer_ctx Context of the peer in question
+ *
+ * @return #GNUNET_YES if peer has the intention to send
+ *         #GNUNET_NO  otherwise
+ */
+static int
+check_peer_send_intention (const struct PeerContext *peer_ctx)
+{
+  if (NULL != peer_ctx->recv_channel_ctx)
+  {
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Handle the channel a peer opens to us.
+ *
+ * @param cls The closure - Sub
+ * @param channel The channel the peer wants to establish
+ * @param initiator The peer's peer ID
+ *
+ * @return initial channel context for the channel
+ *         (can be NULL -- that's not an error)
+ */
+static void *
+handle_inbound_channel (void *cls,
+                        struct GNUNET_CADET_Channel *channel,
+                        const struct GNUNET_PeerIdentity *initiator)
+{
+  struct PeerContext *peer_ctx;
+  struct ChannelCtx *channel_ctx;
+  struct Sub *sub = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "New channel was established to us (Peer %s).\n",
+       GNUNET_i2s (initiator));
+  GNUNET_assert (NULL != channel);  /* according to cadet API */
+  /* Make sure we 'know' about this peer */
+  peer_ctx = create_or_get_peer_ctx (sub, initiator);
+  set_peer_online (peer_ctx);
+  (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
+  channel_ctx = add_channel_ctx (peer_ctx);
+  channel_ctx->channel = channel;
+  /* We only accept one incoming channel per peer */
+  if (GNUNET_YES == check_peer_send_intention (get_peer_ctx (sub->peer_map,
+                                                             initiator)))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Already got one receive channel. Destroying old one.\n");
+    GNUNET_break_op (0);
+    destroy_channel (peer_ctx->recv_channel_ctx);
+    peer_ctx->recv_channel_ctx = channel_ctx;
+    /* return the channel context */
+    return channel_ctx;
+  }
+  peer_ctx->recv_channel_ctx = channel_ctx;
+  return channel_ctx;
+}
+
+
+/**
+ * @brief Check whether a sending channel towards the given peer exists
+ *
+ * @param peer_ctx Context of the peer in question
+ *
+ * @return #GNUNET_YES if a sending channel towards that peer exists
+ *         #GNUNET_NO  otherwise
+ */
+static int
+check_sending_channel_exists (const struct PeerContext *peer_ctx)
+{
+  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+                                     &peer_ctx->peer_id))
+  {   /* If no such peer exists, there is no channel */
+    return GNUNET_NO;
+  }
+  if (NULL == peer_ctx->send_channel_ctx)
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Destroy the send channel of a peer e.g. stop indicating a sending
+ *        intention to another peer
+ *
+ * @param peer_ctx Context to the peer
+ * @return #GNUNET_YES if channel was destroyed
+ *         #GNUNET_NO  otherwise
+ */
+static int
+destroy_sending_channel (struct PeerContext *peer_ctx)
+{
+  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+                                     &peer_ctx->peer_id))
+  {
+    return GNUNET_NO;
+  }
+  if (NULL != peer_ctx->send_channel_ctx)
+  {
+    destroy_channel (peer_ctx->send_channel_ctx);
+    (void) check_connected (peer_ctx);
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * @brief Send a message to another peer.
+ *
+ * Keeps track about pending messages so they can be properly removed when the
+ * peer is destroyed.
+ *
+ * @param peer_ctx Context of the peer to which the message is to be sent
+ * @param ev envelope of the message
+ * @param type type of the message
+ */
+static void
+send_message (struct PeerContext *peer_ctx,
+              struct GNUNET_MQ_Envelope *ev,
+              const char *type)
+{
+  struct PendingMessage *pending_msg;
+  struct GNUNET_MQ_Handle *mq;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending message to %s of type %s\n",
+              GNUNET_i2s (&peer_ctx->peer_id),
+              type);
+  pending_msg = insert_pending_message (peer_ctx, ev, type);
+  mq = get_mq (peer_ctx);
+  GNUNET_MQ_notify_sent (ev,
+                         mq_notify_sent_cb,
+                         pending_msg);
+  GNUNET_MQ_send (mq, ev);
+}
+
+
+/**
+ * @brief Schedule a operation on given peer
+ *
+ * Avoids scheduling an operation twice.
+ *
+ * @param peer_ctx Context of the peer for which to schedule the operation
+ * @param peer_op the operation to schedule
+ * @param cls Closure to @a peer_op
+ *
+ * @return #GNUNET_YES if the operation was scheduled
+ *         #GNUNET_NO  otherwise
+ */
+static int
+schedule_operation (struct PeerContext *peer_ctx,
+                    const PeerOp peer_op,
+                    void *cls)
+{
+  struct PeerPendingOp pending_op;
+
+  GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+                                                 &peer_ctx->peer_id));
+
+  // TODO if ONLINE execute immediately
+
+  if (GNUNET_NO == check_operation_scheduled (peer_ctx, peer_op))
+  {
+    pending_op.op = peer_op;
+    pending_op.op_cls = cls;
+    GNUNET_array_append (peer_ctx->pending_ops,
+                         peer_ctx->num_pending_ops,
+                         pending_op);
+    return GNUNET_YES;
+  }
+  return GNUNET_NO;
+}
+
+
+/***********************************************************************
+* /Old gnunet-service-rps_peers.c
+***********************************************************************/
+
+
+/***********************************************************************
+* Housekeeping with clients
+***********************************************************************/
+
+/**
+ * Closure used to pass the client and the id to the callback
+ * that replies to a client's request
+ */
+struct ReplyCls
+{
+  /**
+   * DLL
+   */
+  struct ReplyCls *next;
+  struct ReplyCls *prev;
+
+  /**
+   * The identifier of the request
+   */
+  uint32_t id;
+
+  /**
+   * The handle to the request
+   */
+  struct RPS_SamplerRequestHandle *req_handle;
+
+  /**
+   * The client handle to send the reply to
+   */
+  struct ClientContext *cli_ctx;
+};
+
+
+/**
+ * Struct used to store the context of a connected client.
+ */
+struct ClientContext
+{
+  /**
+   * DLL
+   */
+  struct ClientContext *next;
+  struct ClientContext *prev;
+
+  /**
+   * The message queue to communicate with the client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * @brief How many updates this client expects to receive.
+   */
+  int64_t view_updates_left;
+
+  /**
+   * @brief Whether this client wants to receive stream updates.
+   * Either #GNUNET_YES or #GNUNET_NO
+   */
+  int8_t stream_update;
+
+  /**
+   * The client handle to send the reply to
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * The #Sub this context belongs to
+   */
+  struct Sub *sub;
+};
+
+/**
+ * DLL with all clients currently connected to us
+ */
+struct ClientContext *cli_ctx_head;
+struct ClientContext *cli_ctx_tail;
+
+/***********************************************************************
+* /Housekeeping with clients
+***********************************************************************/
+
+
+/***********************************************************************
+* Util functions
+***********************************************************************/
+
+
+/**
+ * Print peerlist to log.
+ */
+static void
+print_peer_list (struct GNUNET_PeerIdentity *list,
+                 unsigned int len)
+{
+  unsigned int i;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Printing peer list of length %u at %p:\n",
+       len,
+       list);
+  for (i = 0; i < len; i++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "%u. peer: %s\n",
+         i, GNUNET_i2s (&list[i]));
+  }
+}
+
+
+/**
+ * Remove peer from list.
+ */
+static void
+rem_from_list (struct GNUNET_PeerIdentity **peer_list,
+               unsigned int *list_size,
+               const struct GNUNET_PeerIdentity *peer)
+{
+  unsigned int i;
+  struct GNUNET_PeerIdentity *tmp;
+
+  tmp = *peer_list;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Removing peer %s from list at %p\n",
+       GNUNET_i2s (peer),
+       tmp);
+
+  for (i = 0; i < *list_size; i++)
+  {
+    if (0 == GNUNET_memcmp (&tmp[i], peer))
+    {
+      if (i < *list_size - 1)
+      {       /* Not at the last entry -- shift peers left */
+        memmove (&tmp[i], &tmp[i + 1],
+                 ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
+      }
+      /* Remove last entry (should be now useless PeerID) */
+      GNUNET_array_grow (tmp, *list_size, (*list_size) - 1);
+    }
+  }
+  *peer_list = tmp;
+}
+
+
+/**
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is online.
+ * Implements #PeerOp
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ *         GNUNET_NO if peer was not inserted
+ */
+static void
+insert_in_view_op (void *cls,
+                   const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is online.
+ *
+ * @param sub Sub in with the view to insert in
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ *         GNUNET_NO if peer was not inserted
+ */
+static int
+insert_in_view (struct Sub *sub,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  struct PeerContext *peer_ctx;
+  int online;
+  int ret;
+
+  online = check_peer_flag (sub->peer_map, peer, Peers_ONLINE);
+  peer_ctx = get_peer_ctx (sub->peer_map, peer);  // TODO indirection needed?
+  if ((GNUNET_NO == online) ||
+      (GNUNET_SYSERR == online))   /* peer is not even known */
+  {
+    (void) issue_peer_online_check (sub, peer);
+    (void) schedule_operation (peer_ctx, insert_in_view_op, sub);
+    return GNUNET_NO;
+  }
+  /* Open channel towards peer to keep connection open */
+  indicate_sending_intention (peer_ctx);
+  ret = View_put (sub->view, peer);
+  if (peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "view size",
+                           View_size (peer_ctx->sub->view),
+                           GNUNET_NO);
+  }
+  return ret;
+}
+
+
+/**
+ * @brief Send view to client
+ *
+ * @param cli_ctx the context of the client
+ * @param view_array the peerids of the view as array (can be empty)
+ * @param view_size the size of the view array (can be 0)
+ */
+static void
+send_view (const struct ClientContext *cli_ctx,
+           const struct GNUNET_PeerIdentity *view_array,
+           uint64_t view_size)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
+  struct Sub *sub;
+
+  if (NULL == view_array)
+  {
+    if (NULL == cli_ctx->sub)
+      sub = msub;
+    else
+      sub = cli_ctx->sub;
+    view_size = View_size (sub->view);
+    view_array = View_get_as_array (sub->view);
+  }
+
+  ev = GNUNET_MQ_msg_extra (out_msg,
+                            view_size * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY);
+  out_msg->num_peers = htonl (view_size);
+
+  GNUNET_memcpy (&out_msg[1],
+                 view_array,
+                 view_size * sizeof(struct GNUNET_PeerIdentity));
+  GNUNET_MQ_send (cli_ctx->mq, ev);
+}
+
+
+/**
+ * @brief Send peer from biased stream to client.
+ *
+ * TODO merge with send_view, parameterise
+ *
+ * @param cli_ctx the context of the client
+ * @param view_array the peerids of the view as array (can be empty)
+ * @param view_size the size of the view array (can be 0)
+ */
+static void
+send_stream_peers (const struct ClientContext *cli_ctx,
+                   uint64_t num_peers,
+                   const struct GNUNET_PeerIdentity *peers)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
+
+  GNUNET_assert (NULL != peers);
+
+  ev = GNUNET_MQ_msg_extra (out_msg,
+                            num_peers * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY);
+  out_msg->num_peers = htonl (num_peers);
+
+  GNUNET_memcpy (&out_msg[1],
+                 peers,
+                 num_peers * sizeof(struct GNUNET_PeerIdentity));
+  GNUNET_MQ_send (cli_ctx->mq, ev);
+}
+
+
+/**
+ * @brief sends updates to clients that are interested
+ *
+ * @param sub Sub for which to notify clients
+ */
+static void
+clients_notify_view_update (const struct Sub *sub)
+{
+  struct ClientContext *cli_ctx_iter;
+  uint64_t num_peers;
+  const struct GNUNET_PeerIdentity *view_array;
+
+  num_peers = View_size (sub->view);
+  view_array = View_get_as_array (sub->view);
+  /* check size of view is small enough */
+  if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "View is too big to send\n");
+    return;
+  }
+
+  for (cli_ctx_iter = cli_ctx_head;
+       NULL != cli_ctx_iter;
+       cli_ctx_iter = cli_ctx_iter->next)
+  {
+    if (1 < cli_ctx_iter->view_updates_left)
+    {
+      /* Client wants to receive limited amount of updates */
+      cli_ctx_iter->view_updates_left -= 1;
+    }
+    else if (1 == cli_ctx_iter->view_updates_left)
+    {
+      /* Last update of view for client */
+      cli_ctx_iter->view_updates_left = -1;
+    }
+    else if (0 > cli_ctx_iter->view_updates_left)
+    {
+      /* Client is not interested in updates */
+      continue;
+    }
+    /* else _updates_left == 0 - infinite amount of updates */
+
+    /* send view */
+    send_view (cli_ctx_iter, view_array, num_peers);
+  }
+}
+
+
+/**
+ * @brief sends updates to clients that are interested
+ *
+ * @param num_peers Number of peers to send
+ * @param peers the array of peers to send
+ */
+static void
+clients_notify_stream_peer (const struct Sub *sub,
+                            uint64_t num_peers,
+                            const struct GNUNET_PeerIdentity *peers)
+// TODO enum StreamPeerSource)
+{
+  struct ClientContext *cli_ctx_iter;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got peer (%s) from biased stream - update all clients\n",
+       GNUNET_i2s (peers));
+
+  for (cli_ctx_iter = cli_ctx_head;
+       NULL != cli_ctx_iter;
+       cli_ctx_iter = cli_ctx_iter->next)
+  {
+    if ((GNUNET_YES == cli_ctx_iter->stream_update) &&
+        ((sub == cli_ctx_iter->sub) || (sub == msub) ))
+    {
+      send_stream_peers (cli_ctx_iter, num_peers, peers);
+    }
+  }
+}
+
+
+/**
+ * Put random peer from sampler into the view as history update.
+ *
+ * @param ids Array of Peers to insert into view
+ * @param num_peers Number of peers to insert
+ * @param cls Closure - The Sub for which this is to be done
+ */
+static void
+hist_update (const struct GNUNET_PeerIdentity *ids,
+             uint32_t num_peers,
+             void *cls)
+{
+  unsigned int i;
+  struct Sub *sub = cls;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    int inserted;
+    if (GNUNET_YES != check_peer_known (sub->peer_map, &ids[i]))
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Peer in history update not known!\n");
+      continue;
+    }
+    inserted = insert_in_view (sub, &ids[i]);
+    if (GNUNET_OK == inserted)
+    {
+      clients_notify_stream_peer (sub, 1, &ids[i]);
+    }
+#ifdef TO_FILE_FULL
+    to_file (sub->file_name_view_log,
+             "+%s\t(history)",
+             GNUNET_i2s_full (ids));
+#endif /* TO_FILE_FULL */
+  }
+  clients_notify_view_update (sub);
+}
+
+
+/**
+ * Wrapper around #RPS_sampler_resize()
+ *
+ * If we do not have enough sampler elements, double current sampler size
+ * If we have more than enough sampler elements, halv current sampler size
+ *
+ * @param sampler The sampler to resize
+ * @param new_size New size to which to resize
+ */
+static void
+resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
+{
+  unsigned int sampler_size;
+
+  // TODO statistics
+  // TODO respect the min, max
+  sampler_size = RPS_sampler_get_size (sampler);
+  if (sampler_size > new_size * 4)
+  {   /* Shrinking */
+    RPS_sampler_resize (sampler, sampler_size / 2);
+  }
+  else if (sampler_size < new_size)
+  {   /* Growing */
+    RPS_sampler_resize (sampler, sampler_size * 2);
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "sampler_size is now %u\n", sampler_size);
+}
+
+
+#if ENABLE_MALICIOUS
+/**
+ * Add all peers in @a peer_array to @a peer_map used as set.
+ *
+ * @param peer_array array containing the peers
+ * @param num_peers number of peers in @peer_array
+ * @param peer_map the peermap to use as set
+ */
+static void
+add_peer_array_to_set (const struct GNUNET_PeerIdentity *peer_array,
+                       unsigned int num_peers,
+                       struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
+{
+  unsigned int i;
+
+  if (NULL == peer_map)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Trying to add peers to non-existing peermap.\n");
+    return;
+  }
+
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_CONTAINER_multipeermap_put (peer_map,
+                                       &peer_array[i],
+                                       NULL,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    if (msub->peer_map == peer_map)
+    {
+      GNUNET_STATISTICS_set (stats,
+                             "# known peers",
+                             GNUNET_CONTAINER_multipeermap_size (peer_map),
+                             GNUNET_NO);
+    }
+  }
+}
+
+
+#endif /* ENABLE_MALICIOUS */
+
+
+/**
+ * Send a PULL REPLY to @a peer_id
+ *
+ * @param peer_ctx Context of the peer to send the reply to
+ * @param peer_ids the peers to send to @a peer_id
+ * @param num_peer_ids the number of peers to send to @a peer_id
+ */
+static void
+send_pull_reply (struct PeerContext *peer_ctx,
+                 const struct GNUNET_PeerIdentity *peer_ids,
+                 unsigned int num_peer_ids)
+{
+  uint32_t send_size;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_P2P_PullReplyMessage *out_msg;
+
+  /* Compute actual size */
+  send_size = sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)
+              + num_peer_ids * sizeof(struct GNUNET_PeerIdentity);
+
+  if (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < send_size)
+    /* Compute number of peers to send
+     * If too long, simply truncate */
+    // TODO select random ones via permutation
+    //      or even better: do good protocol design
+    send_size =
+      (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
+       - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage))
+      / sizeof(struct GNUNET_PeerIdentity);
+  else
+    send_size = num_peer_ids;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to send PULL REPLY with %u peers to %s\n",
+       send_size, GNUNET_i2s (&peer_ctx->peer_id));
+
+  ev = GNUNET_MQ_msg_extra (out_msg,
+                            send_size * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
+  out_msg->num_peers = htonl (send_size);
+  GNUNET_memcpy (&out_msg[1], peer_ids,
+                 send_size * sizeof(struct GNUNET_PeerIdentity));
+
+  send_message (peer_ctx, ev, "PULL REPLY");
+  if (peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats, "# pull reply send issued", 1, GNUNET_NO);
+  }
+  // TODO check with send intention: as send_channel is used/opened we indicate
+  // a sending intention without intending it.
+  // -> clean peer afterwards?
+  // -> use recv_channel?
+}
+
+
+/**
+ * Insert PeerID in #pull_map
+ *
+ * Called once we know a peer is online.
+ *
+ * @param cls Closure - Sub with the pull map to insert into
+ * @param peer Peer to insert
+ */
+static void
+insert_in_pull_map (void *cls,
+                    const struct GNUNET_PeerIdentity *peer)
+{
+  struct Sub *sub = cls;
+
+  CustomPeerMap_put (sub->pull_map, peer);
+}
+
+
+/**
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is online.
+ * Implements #PeerOp
+ *
+ * @param cls Closure - Sub with view to insert peer into
+ * @param peer the peer to insert
+ */
+static void
+insert_in_view_op (void *cls,
+                   const struct GNUNET_PeerIdentity *peer)
+{
+  struct Sub *sub = cls;
+  int inserted;
+
+  inserted = insert_in_view (sub, peer);
+  if (GNUNET_OK == inserted)
+  {
+    clients_notify_stream_peer (sub, 1, peer);
+  }
+}
+
+
+/**
+ * Update sampler with given PeerID.
+ * Implements #PeerOp
+ *
+ * @param cls Closure - Sub containing the sampler to insert into
+ * @param peer Peer to insert
+ */
+static void
+insert_in_sampler (void *cls,
+                   const struct GNUNET_PeerIdentity *peer)
+{
+  struct Sub *sub = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating samplers with peer %s from insert_in_sampler()\n",
+       GNUNET_i2s (peer));
+  RPS_sampler_update (sub->sampler, peer);
+  if (0 < RPS_sampler_count_id (sub->sampler, peer))
+  {
+    /* Make sure we 'know' about this peer */
+    (void) issue_peer_online_check (sub, peer);
+    /* Establish a channel towards that peer to indicate we are going to send
+     * messages to it */
+    // indicate_sending_intention (peer);
+  }
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# observed peers in gossip",
+                              1,
+                              GNUNET_NO);
+  }
+#ifdef TO_FILE
+  sub->num_observed_peers++;
+  (void) GNUNET_CONTAINER_multipeermap_put
+    (sub->observed_unique_peers,
+    peer,
+    NULL,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  uint32_t num_observed_unique_peers =
+    GNUNET_CONTAINER_multipeermap_size (sub->observed_unique_peers);
+  GNUNET_STATISTICS_set (stats,
+                         "# unique peers in gossip",
+                         num_observed_unique_peers,
+                         GNUNET_NO);
+#ifdef TO_FILE_FULL
+  to_file (sub->file_name_observed_log,
+           "%" PRIu32 " %" PRIu32 " %f\n",
+           sub->num_observed_peers,
+           num_observed_unique_peers,
+           1.0 * num_observed_unique_peers / sub->num_observed_peers)
+#endif /* TO_FILE_FULL */
+#endif /* TO_FILE */
+}
+
+
+/**
+ * @brief This is called on peers from external sources (cadet, peerinfo, ...)
+ *        If the peer is not known, online check is issued and it is
+ *        scheduled to be inserted in sampler and view.
+ *
+ * "External sources" refer to every source except the gossip.
+ *
+ * @param sub Sub for which @a peer was received
+ * @param peer peer to insert/peer received
+ */
+static void
+got_peer (struct Sub *sub,
+          const struct GNUNET_PeerIdentity *peer)
+{
+  /* If we did not know this peer already, insert it into sampler and view */
+  if (GNUNET_YES == issue_peer_online_check (sub, peer))
+  {
+    schedule_operation (get_peer_ctx (sub->peer_map, peer),
+                        &insert_in_sampler, sub);
+    schedule_operation (get_peer_ctx (sub->peer_map, peer),
+                        &insert_in_view_op, sub);
+  }
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# learnd peers",
+                              1,
+                              GNUNET_NO);
+  }
+}
+
+
+/**
+ * @brief Checks if there is a sending channel and if it is needed
+ *
+ * @param peer_ctx Context of the peer to check
+ * @return GNUNET_YES if sending channel exists and is still needed
+ *         GNUNET_NO  otherwise
+ */
+static int
+check_sending_channel_needed (const struct PeerContext *peer_ctx)
+{
+  /* struct GNUNET_CADET_Channel *channel; */
+  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+                                     &peer_ctx->peer_id))
+  {
+    return GNUNET_NO;
+  }
+  if (GNUNET_YES == check_sending_channel_exists (peer_ctx))
+  {
+    if ((0 < RPS_sampler_count_id (peer_ctx->sub->sampler,
+                                   &peer_ctx->peer_id)) ||
+        (GNUNET_YES == View_contains_peer (peer_ctx->sub->view,
+                                           &peer_ctx->peer_id)) ||
+        (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->push_map,
+                                                    &peer_ctx->peer_id)) ||
+        (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->pull_map,
+                                                    &peer_ctx->peer_id)) ||
+        (GNUNET_YES == check_peer_flag (peer_ctx->sub->peer_map,
+                                        &peer_ctx->peer_id,
+                                        Peers_PULL_REPLY_PENDING)))
+    {     /* If we want to keep the connection to peer open */
+      return GNUNET_YES;
+    }
+    return GNUNET_NO;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * @brief remove peer from our knowledge, the view, push and pull maps and
+ * samplers.
+ *
+ * @param sub Sub with the data structures the peer is to be removed from
+ * @param peer the peer to remove
+ */
+static void
+remove_peer (struct Sub *sub,
+             const struct GNUNET_PeerIdentity *peer)
+{
+  (void) View_remove_peer (sub->view,
+                           peer);
+  CustomPeerMap_remove_peer (sub->pull_map,
+                             peer);
+  CustomPeerMap_remove_peer (sub->push_map,
+                             peer);
+  RPS_sampler_reinitialise_by_value (sub->sampler,
+                                     peer);
+  /* We want to destroy the peer now.
+   * Sometimes, it just seems that it's already been removed from the peer_map,
+   * so check the peer_map first. */
+  if (GNUNET_YES == check_peer_known (sub->peer_map,
+                                      peer))
+  {
+    destroy_peer (get_peer_ctx (sub->peer_map,
+                                peer));
+  }
+}
+
+
+/**
+ * @brief Remove data that is not needed anymore.
+ *
+ * If the sending channel is no longer needed it is destroyed.
+ *
+ * @param sub Sub in which the current peer is to be cleaned
+ * @param peer the peer whose data is about to be cleaned
+ */
+static void
+clean_peer (struct Sub *sub,
+            const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_NO == check_sending_channel_needed (get_peer_ctx (sub->peer_map,
+                                                               peer)))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to remove send channel to peer %s\n",
+         GNUNET_i2s (peer));
+    #if ENABLE_MALICIOUS
+    if (0 != GNUNET_memcmp (&attacked_peer,
+                            peer))
+      (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
+                                                    peer));
+    #else /* ENABLE_MALICIOUS */
+    (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
+                                                  peer));
+    #endif /* ENABLE_MALICIOUS */
+  }
+
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (sub->peer_map,
+                                                           peer))
+  {
+    /* Peer was already removed by callback on destroyed channel */
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Peer was removed from our knowledge during cleanup\n");
+    return;
+  }
+
+  if ((GNUNET_NO == check_peer_send_intention (get_peer_ctx (sub->peer_map,
+                                                             peer))) &&
+      (GNUNET_NO == View_contains_peer (sub->view, peer)) &&
+      (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
+      (GNUNET_NO == CustomPeerMap_contains_peer (sub->pull_map, peer)) &&
+      (0 == RPS_sampler_count_id (sub->sampler, peer)) &&
+      (GNUNET_YES == check_removable (get_peer_ctx (sub->peer_map, peer))))
+  {   /* We can safely remove this peer */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to remove peer %s\n",
+         GNUNET_i2s (peer));
+    remove_peer (sub, peer);
+    return;
+  }
+}
+
+
+/**
+ * @brief This is called when a channel is destroyed.
+ *
+ * Removes peer completely from our knowledge if the send_channel was destroyed
+ * Otherwise simply delete the recv_channel
+ * Also check if the knowledge about this peer is still needed.
+ * If not, remove this peer from our knowledge.
+ *
+ * @param cls The closure - Context to the channel
+ * @param channel The channel being closed
+ */
+static void
+cleanup_destroyed_channel (void *cls,
+                           const struct GNUNET_CADET_Channel *channel)
+{
+  struct ChannelCtx *channel_ctx = cls;
+  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+
+  (void) channel;
+
+  channel_ctx->channel = NULL;
+  if ((NULL != peer_ctx) &&
+      (peer_ctx->send_channel_ctx == channel_ctx) &&
+      (GNUNET_YES == check_sending_channel_needed (peer_ctx)) )
+  {
+    remove_channel_ctx (channel_ctx);
+    remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
+  }
+  else
+  {
+    /* We need this if-else construct because we need to make sure the channel
+     * (context) is cleaned up before removing the peer, but still need to
+     * compare it while checking the condition */
+    remove_channel_ctx (channel_ctx);
+  }
+}
+
+
+/***********************************************************************
+* /Util functions
+***********************************************************************/
+
+
+/***********************************************************************
+* Sub
+***********************************************************************/
+
+/**
+ * @brief Create a new Sub
+ *
+ * @param hash Hash of value shared among rps instances on other hosts that
+ *        defines a subgroup to sample from.
+ * @param sampler_size Size of the sampler
+ * @param round_interval Interval (in average) between two rounds
+ *
+ * @return Sub
+ */
+struct Sub *
+new_sub (const struct GNUNET_HashCode *hash,
+         uint32_t sampler_size,
+         struct GNUNET_TIME_Relative round_interval)
+{
+  struct Sub *sub;
+
+  sub = GNUNET_new (struct Sub);
+
+  /* With the hash generated from the secret value this service only connects
+   * to rps instances that share the value */
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (peer_check,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_push,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (peer_pull_request,
+                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_var_size (peer_pull_reply,
+                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+                           struct GNUNET_RPS_P2P_PullReplyMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+  sub->hash = *hash;
+  sub->cadet_port =
+    GNUNET_CADET_open_port (cadet_handle,
+                            &sub->hash,
+                            &handle_inbound_channel, /* Connect handler */
+                            sub, /* cls */
+                            NULL, /* WindowSize handler */
+                            &cleanup_destroyed_channel, /* Disconnect handler */
+                            cadet_handlers);
+  if (NULL == sub->cadet_port)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Cadet port `%s' is already in use.\n",
+         GNUNET_APPLICATION_PORT_RPS);
+    GNUNET_assert (0);
+  }
+
+  /* Set up general data structure to keep track about peers */
+  sub->valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                               "rps",
+                                               "FILENAME_VALID_PEERS",
+                                               &sub->filename_valid_peers))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "rps",
+                               "FILENAME_VALID_PEERS");
+  }
+  if (0 != strncmp ("DISABLE", sub->filename_valid_peers, 7))
+  {
+    char *tmp_filename_valid_peers;
+    char str_hash[105];
+
+    GNUNET_snprintf (str_hash,
+                     sizeof(str_hash), "%s",
+                     GNUNET_h2s_full (hash));
+    tmp_filename_valid_peers = sub->filename_valid_peers;
+    GNUNET_asprintf (&sub->filename_valid_peers,
+                     "%s%s",
+                     tmp_filename_valid_peers,
+                     str_hash);
+    GNUNET_free (tmp_filename_valid_peers);
+  }
+  sub->peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+
+  /* Set up the sampler */
+  sub->sampler_size_est_min = sampler_size;
+  sub->sampler_size_est_need = sampler_size;;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sub->sampler_size_est_min);
+  GNUNET_assert (0 != round_interval.rel_value_us);
+  sub->round_interval = round_interval;
+  sub->sampler = RPS_sampler_init (sampler_size,
+                                   round_interval);
+
+  /* Logging of internals */
+#ifdef TO_FILE_FULL
+  // FIXME: The service cannot know the index, which is required by this
+  // function:
+  // sub->file_name_view_log = store_prefix_file_name (&own_identity, "view");
+#endif /* TO_FILE_FULL */
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+  // FIXME: The service cannot know the index, which is required by this
+  // function:
+  // sub->file_name_observed_log = store_prefix_file_name (&own_identity,
+  //                                                       "observed");
+#endif /* TO_FILE_FULL */
+  sub->num_observed_peers = 0;
+  sub->observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1,
+                                                                     GNUNET_NO);
+#endif /* TO_FILE */
+
+  /* Set up data structures for gossip */
+  sub->push_map = CustomPeerMap_create (4);
+  sub->pull_map = CustomPeerMap_create (4);
+  sub->view_size_est_min = sampler_size;;
+  sub->view = View_create (sub->view_size_est_min);
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "view size aim",
+                           sub->view_size_est_min,
+                           GNUNET_NO);
+  }
+
+  /* Start executing rounds */
+  sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
+
+  return sub;
+}
+
+
+#ifdef TO_FILE
+// /**
+//  * @brief Write all numbers in the given array into the given file
+//  *
+//  * Single numbers divided by a newline
+//  *
+//  * FIXME: The call to store_prefix_file_name expects the index of the peer,
+//  * which cannot be known to the service.
+//  * Write a dedicated function that uses the peer id.
+//  *
+//  * @param hist_array[] the array to dump
+//  * @param file_name file to dump into
+//  */
+// static void
+// write_histogram_to_file (const uint32_t hist_array[],
+//                          const char *file_name)
+// {
+//   char collect_str[SIZE_DUMP_FILE + 1] = "";
+//   char *recv_str_iter;
+//   char *file_name_full;
+//
+//   recv_str_iter = collect_str;
+//   file_name_full = store_prefix_file_name (&own_identity,
+//                                            file_name);
+//   for (uint32_t i = 0; i < HISTOGRAM_FILE_SLOTS; i++)
+//   {
+//     char collect_str_tmp[8];
+//
+//     GNUNET_snprintf (collect_str_tmp,
+//                      sizeof(collect_str_tmp),
+//                      "%" PRIu32 "\n",
+//                      hist_array[i]);
+//     recv_str_iter = stpncpy (recv_str_iter,
+//                              collect_str_tmp,
+//                              6);
+//   }
+//   (void) stpcpy (recv_str_iter,
+//                  "\n");
+//   LOG (GNUNET_ERROR_TYPE_DEBUG,
+//        "Writing push stats to disk\n");
+//   to_file_w_len (file_name_full,
+//                  SIZE_DUMP_FILE, "%s",
+//                  collect_str);
+//   GNUNET_free (file_name_full);
+// }
+
+
+#endif /* TO_FILE */
+
+
+/**
+ * @brief Destroy Sub.
+ *
+ * @param sub Sub to destroy
+ */
+static void
+destroy_sub (struct Sub *sub)
+{
+  GNUNET_assert (NULL != sub);
+  GNUNET_assert (NULL != sub->do_round_task);
+  GNUNET_SCHEDULER_cancel (sub->do_round_task);
+  sub->do_round_task = NULL;
+
+  /* Disconnect from cadet */
+  GNUNET_CADET_close_port (sub->cadet_port);
+  sub->cadet_port = NULL;
+
+  /* Clean up data structures for peers */
+  RPS_sampler_destroy (sub->sampler);
+  sub->sampler = NULL;
+  View_destroy (sub->view);
+  sub->view = NULL;
+  CustomPeerMap_destroy (sub->push_map);
+  sub->push_map = NULL;
+  CustomPeerMap_destroy (sub->pull_map);
+  sub->pull_map = NULL;
+  peers_terminate (sub);
+
+  /* Free leftover data structures */
+#ifdef TO_FILE_FULL
+  GNUNET_free (sub->file_name_view_log);
+  sub->file_name_view_log = NULL;
+#endif /* TO_FILE_FULL */
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+  GNUNET_free (sub->file_name_observed_log);
+  sub->file_name_observed_log = NULL;
+#endif /* TO_FILE_FULL */
+
+  // FIXME: Currently this calls malfunctionning code
+  // /* Write push frequencies to disk */
+  // write_histogram_to_file (sub->push_recv,
+  //                          "push_recv");
+
+  // /* Write push deltas to disk */
+  // write_histogram_to_file (sub->push_delta,
+  //                          "push_delta");
+
+  // /* Write pull delays to disk */
+  // write_histogram_to_file (sub->pull_delays,
+  //                          "pull_delays");
+
+  GNUNET_CONTAINER_multipeermap_destroy (sub->observed_unique_peers);
+  sub->observed_unique_peers = NULL;
+#endif /* TO_FILE */
+
+  GNUNET_free (sub);
+}
+
+
+/***********************************************************************
+* /Sub
+***********************************************************************/
+
+
+/***********************************************************************
+* Core handlers
+***********************************************************************/
+
+/**
+ * @brief Callback on initialisation of Core.
+ *
+ * @param cls - unused
+ * @param my_identity - unused
+ */
+void
+core_init (void *cls,
+           const struct GNUNET_PeerIdentity *my_identity)
+{
+  (void) cls;
+  (void) my_identity;
+
+  map_single_hop = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+}
+
+
+/**
+ * @brief Callback for core.
+ * Method called whenever a given peer connects.
+ *
+ * @param cls closure - unused
+ * @param peer peer identity this notification is about
+ * @return closure given to #core_disconnects as peer_cls
+ */
+void *
+core_connects (void *cls,
+               const struct GNUNET_PeerIdentity *peer,
+               struct GNUNET_MQ_Handle *mq)
+{
+  (void) cls;
+  (void) mq;
+
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_put (map_single_hop,
+                                                    peer,
+                                                    NULL,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  return NULL;
+}
+
+
+/**
+ * @brief Callback for core.
+ * Method called whenever a peer disconnects.
+ *
+ * @param cls closure - unused
+ * @param peer peer identity this notification is about
+ * @param peer_cls closure given in #core_connects - unused
+ */
+void
+core_disconnects (void *cls,
+                  const struct GNUNET_PeerIdentity *peer,
+                  void *peer_cls)
+{
+  (void) cls;
+  (void) peer_cls;
+
+  GNUNET_CONTAINER_multipeermap_remove_all (map_single_hop, peer);
+}
+
+
+/***********************************************************************
+* /Core handlers
+***********************************************************************/
+
+
+/**
+ * @brief Destroy the context for a (connected) client
+ *
+ * @param cli_ctx Context to destroy
+ */
+static void
+destroy_cli_ctx (struct ClientContext *cli_ctx)
+{
+  GNUNET_assert (NULL != cli_ctx);
+  GNUNET_CONTAINER_DLL_remove (cli_ctx_head,
+                               cli_ctx_tail,
+                               cli_ctx);
+  if (NULL != cli_ctx->sub)
+  {
+    destroy_sub (cli_ctx->sub);
+    cli_ctx->sub = NULL;
+  }
+  GNUNET_free (cli_ctx);
+}
+
+
+/**
+ * @brief Update sizes in sampler and view on estimate update from nse service
+ *
+ * @param sub Sub
+ * @param logestimate the log(Base 2) value of the current network size estimate
+ * @param std_dev standard deviation for the estimate
+ */
+static void
+adapt_sizes (struct Sub *sub, double logestimate, double std_dev)
+{
+  double estimate;
+
+  // double scale; // TODO this might go global/config
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received a ns estimate - logest: %f, std_dev: %f (old_size: %u)\n",
+       logestimate, std_dev, RPS_sampler_get_size (sub->sampler));
+  // scale = .01;
+  estimate = GNUNET_NSE_log_estimate_to_n (logestimate);
+  // GNUNET_NSE_log_estimate_to_n (logestimate);
+  estimate = pow (estimate, 1.0 / 3);
+  // TODO add if std_dev is a number
+  // estimate += (std_dev * scale);
+  if (sub->view_size_est_min < ceil (estimate))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate);
+    sub->sampler_size_est_need = estimate;
+    sub->view_size_est_need = estimate;
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate);
+    // sub->sampler_size_est_need = sub->view_size_est_min;
+    sub->view_size_est_need = sub->view_size_est_min;
+  }
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "view size aim",
+                           sub->view_size_est_need,
+                           GNUNET_NO);
+  }
+
+  /* If the NSE has changed adapt the lists accordingly */
+  resize_wrapper (sub->sampler, sub->sampler_size_est_need);
+  View_change_len (sub->view, sub->view_size_est_need);
+}
+
+
+/**
+ * Function called by NSE.
+ *
+ * Updates sizes of sampler list and view and adapt those lists
+ * accordingly.
+ *
+ * implements #GNUNET_NSE_Callback
+ *
+ * @param cls Closure - unused
+ * @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_callback (void *cls,
+              struct GNUNET_TIME_Absolute timestamp,
+              double logestimate, double std_dev)
+{
+  (void) cls;
+  (void) timestamp;
+  struct ClientContext *cli_ctx_iter;
+
+  adapt_sizes (msub, logestimate, std_dev);
+  for (cli_ctx_iter = cli_ctx_head;
+       NULL != cli_ctx_iter;
+       cli_ctx_iter = cli_ctx_iter->next)
+  {
+    if (NULL != cli_ctx_iter->sub)
+    {
+      adapt_sizes (cli_ctx_iter->sub, logestimate, std_dev);
+    }
+  }
+}
+
+
+/**
+ * @brief This function is called, when the client seeds peers.
+ * It verifies that @a msg is well-formed.
+ *
+ * @param cls the closure (#ClientContext)
+ * @param msg the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ *         #GNUNET_SYSERR otherwise
+ */
+static int
+check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+  uint16_t msize = ntohs (msg->header.size);
+  uint32_t num_peers = ntohl (msg->num_peers);
+
+  msize -= sizeof(struct GNUNET_RPS_CS_SeedMessage);
+  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
+      (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+         ntohl (msg->num_peers),
+         (msize / sizeof(struct GNUNET_PeerIdentity)));
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cli_ctx->client);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle seed from the client.
+ *
+ * @param cls closure
+ * @param msg the actual message
+ */
+static void
+handle_client_seed (void *cls,
+                    const struct GNUNET_RPS_CS_SeedMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+  struct GNUNET_PeerIdentity *peers;
+  uint32_t num_peers;
+  uint32_t i;
+
+  num_peers = ntohl (msg->num_peers);
+  peers = (struct GNUNET_PeerIdentity *) &msg[1];
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client seeded peers:\n");
+  print_peer_list (peers, num_peers);
+
+  for (i = 0; i < num_peers; i++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Updating samplers with seed %" PRIu32 ": %s\n",
+         i,
+         GNUNET_i2s (&peers[i]));
+
+    if (NULL != msub)
+      got_peer (msub, &peers[i]);                 /* Condition needed? */
+    if (NULL != cli_ctx->sub)
+      got_peer (cli_ctx->sub, &peers[i]);
+  }
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * Handle RPS request from the client.
+ *
+ * @param cls Client context
+ * @param msg Message containing the number of updates the client wants to
+ * receive
+ */
+static void
+handle_client_view_request (void *cls,
+                            const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+  uint64_t num_updates;
+
+  num_updates = ntohl (msg->num_updates);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client requested %" PRIu64 " updates of view.\n",
+       num_updates);
+
+  GNUNET_assert (NULL != cli_ctx);
+  cli_ctx->view_updates_left = num_updates;
+  send_view (cli_ctx, NULL, 0);
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * @brief Handle the cancellation of the view updates.
+ *
+ * @param cls The client context
+ * @param msg Unused
+ */
+static void
+handle_client_view_cancel (void *cls,
+                           const struct GNUNET_MessageHeader *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+
+  (void) msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client does not want to receive updates of view any more.\n");
+
+  GNUNET_assert (NULL != cli_ctx);
+  cli_ctx->view_updates_left = 0;
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+  if (GNUNET_YES == cli_ctx->stream_update)
+  {
+    destroy_cli_ctx (cli_ctx);
+  }
+}
+
+
+/**
+ * Handle RPS request for biased stream from the client.
+ *
+ * @param cls Client context
+ * @param msg unused
+ */
+static void
+handle_client_stream_request (void *cls,
+                              const struct
+                              GNUNET_RPS_CS_DEBUG_StreamRequest *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+
+  (void) msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client requested peers from biased stream.\n");
+  cli_ctx->stream_update = GNUNET_YES;
+
+  GNUNET_assert (NULL != cli_ctx);
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * @brief Handles the cancellation of the stream of biased peer ids
+ *
+ * @param cls The client context
+ * @param msg unused
+ */
+static void
+handle_client_stream_cancel (void *cls,
+                             const struct GNUNET_MessageHeader *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+
+  (void) msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client canceled receiving peers from biased stream.\n");
+  cli_ctx->stream_update = GNUNET_NO;
+
+  GNUNET_assert (NULL != cli_ctx);
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * @brief Create and start a Sub.
+ *
+ * @param cls Closure - unused
+ * @param msg Message containing the necessary information
+ */
+static void
+handle_client_start_sub (void *cls,
+                         const struct GNUNET_RPS_CS_SubStartMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requested start of a new sub.\n");
+  if ((NULL != cli_ctx->sub) &&
+      (0 != memcmp (&cli_ctx->sub->hash,
+                    &msg->hash,
+                    sizeof(struct GNUNET_HashCode))) )
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Already have a Sub with different share for this client. Remove old one, add new.\n");
+    destroy_sub (cli_ctx->sub);
+    cli_ctx->sub = NULL;
+  }
+  cli_ctx->sub = new_sub (&msg->hash,
+                          msub->sampler_size_est_min, // TODO make api input?
+                          GNUNET_TIME_relative_ntoh (msg->round_interval));
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * @brief Destroy the Sub
+ *
+ * @param cls Closure - unused
+ * @param msg Message containing the hash that identifies the Sub
+ */
+static void
+handle_client_stop_sub (void *cls,
+                        const struct GNUNET_RPS_CS_SubStopMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+
+  GNUNET_assert (NULL != cli_ctx->sub);
+  if (0 != memcmp (&cli_ctx->sub->hash, &msg->hash, sizeof(struct
+                                                           GNUNET_HashCode)))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Share of current sub and request differ!\n");
+  }
+  destroy_sub (cli_ctx->sub);
+  cli_ctx->sub = NULL;
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * Handle a CHECK_LIVE message from another peer.
+ *
+ * This does nothing. But without calling #GNUNET_CADET_receive_done()
+ * the channel is blocked for all other communication.
+ *
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
+ */
+static void
+handle_peer_check (void *cls,
+                   const struct GNUNET_MessageHeader *msg)
+{
+  const struct ChannelCtx *channel_ctx = cls;
+  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
+
+  (void) msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer));
+  if (channel_ctx->peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# pending online checks",
+                              -1,
+                              GNUNET_NO);
+  }
+
+  GNUNET_CADET_receive_done (channel_ctx->channel);
+}
+
+
+/**
+ * Handle a PUSH message from another peer.
+ *
+ * Check the proof of work and store the PeerID
+ * in the temporary list for pushed PeerIDs.
+ *
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
+ */
+static void
+handle_peer_push (void *cls,
+                  const struct GNUNET_MessageHeader *msg)
+{
+  const struct ChannelCtx *channel_ctx = cls;
+  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
+
+  (void) msg;
+
+  // (check the proof of work (?))
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received PUSH (%s)\n",
+       GNUNET_i2s (peer));
+  if (channel_ctx->peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats, "# push message received", 1, GNUNET_NO);
+    if ((NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              peer)))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# push message received (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+
+  #if ENABLE_MALICIOUS
+  struct AttackedPeer *tmp_att_peer;
+
+  if ((1 == mal_type) ||
+      (3 == mal_type))
+  {   /* Try to maximise representation */
+    tmp_att_peer = GNUNET_new (struct AttackedPeer);
+    tmp_att_peer->peer_id = *peer;
+    if (NULL == att_peer_set)
+      att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
+    if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
+                                                             peer))
+    {
+      GNUNET_CONTAINER_DLL_insert (att_peers_head,
+                                   att_peers_tail,
+                                   tmp_att_peer);
+      add_peer_array_to_set (peer, 1, att_peer_set);
+    }
+    else
+    {
+      GNUNET_free (tmp_att_peer);
+    }
+  }
+
+
+  else if (2 == mal_type)
+  {
+    /* We attack one single well-known peer - simply ignore */
+  }
+  #endif /* ENABLE_MALICIOUS */
+
+  /* Add the sending peer to the push_map */
+  CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, peer);
+
+  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+                                     &channel_ctx->peer_ctx->peer_id));
+  GNUNET_CADET_receive_done (channel_ctx->channel);
+}
+
+
+/**
+ * Handle PULL REQUEST request message from another peer.
+ *
+ * Reply with the view of PeerIDs.
+ *
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
+ */
+static void
+handle_peer_pull_request (void *cls,
+                          const struct GNUNET_MessageHeader *msg)
+{
+  const struct ChannelCtx *channel_ctx = cls;
+  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+  const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
+  const struct GNUNET_PeerIdentity *view_array;
+
+  (void) msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (
+         peer));
+  if (peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# pull request message received",
+                              1,
+                              GNUNET_NO);
+    if ((NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              &peer_ctx->peer_id)))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# pull request message received (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+
+  #if ENABLE_MALICIOUS
+  if ((1 == mal_type)
+      || (3 == mal_type))
+  {   /* Try to maximise representation */
+    send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
+  }
+
+  else if (2 == mal_type)
+  {   /* Try to partition network */
+    if (0 == GNUNET_memcmp (&attacked_peer, peer))
+    {
+      send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
+    }
+  }
+  #endif /* ENABLE_MALICIOUS */
+
+  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+                                     &channel_ctx->peer_ctx->peer_id));
+  GNUNET_CADET_receive_done (channel_ctx->channel);
+  view_array = View_get_as_array (channel_ctx->peer_ctx->sub->view);
+  send_pull_reply (peer_ctx,
+                   view_array,
+                   View_size (channel_ctx->peer_ctx->sub->view));
+}
+
+
+/**
+ * Check whether we sent a corresponding request and
+ * whether this reply is the first one.
+ *
+ * @param cls Closure - Context of channel
+ * @param msg Message containing the replied peers
+ */
+static int
+check_peer_pull_reply (void *cls,
+                       const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
+{
+  struct ChannelCtx *channel_ctx = cls;
+  struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
+
+  if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+
+  if ((ntohs (msg->header.size) - sizeof(struct
+                                         GNUNET_RPS_P2P_PullReplyMessage))
+      / sizeof(struct GNUNET_PeerIdentity) != ntohl (msg->num_peers))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+         ntohl (msg->num_peers),
+         (ntohs (msg->header.size) - sizeof(struct
+                                            GNUNET_RPS_P2P_PullReplyMessage))
+         / sizeof(struct GNUNET_PeerIdentity));
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_YES != check_peer_flag (sender_ctx->sub->peer_map,
+                                     &sender_ctx->peer_id,
+                                     Peers_PULL_REPLY_PENDING))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Received a pull reply from a peer (%s) we didn't request one from!\n",
+         GNUNET_i2s (&sender_ctx->peer_id));
+    if (sender_ctx->sub == msub)
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# unrequested pull replies",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle PULL REPLY message from another peer.
+ *
+ * @param cls Closure
+ * @param msg The message header
+ */
+static void
+handle_peer_pull_reply (void *cls,
+                        const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
+{
+  const struct ChannelCtx *channel_ctx = cls;
+  const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
+  const struct GNUNET_PeerIdentity *peers;
+  struct Sub *sub = channel_ctx->peer_ctx->sub;
+  uint32_t i;
+
+#if ENABLE_MALICIOUS
+  struct AttackedPeer *tmp_att_peer;
+#endif /* ENABLE_MALICIOUS */
+
+  sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (
+         sender));
+  if (channel_ctx->peer_ctx->sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# pull reply messages received",
+                              1,
+                              GNUNET_NO);
+    if ((NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              &channel_ctx->
+                                                              peer_ctx->peer_id)) )
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# pull reply messages received (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+
+  #if ENABLE_MALICIOUS
+  // We shouldn't even receive pull replies as we're not sending
+  if (2 == mal_type)
+  {
+  }
+  #endif /* ENABLE_MALICIOUS */
+
+  /* Do actual logic */
+  peers = (const struct GNUNET_PeerIdentity *) &msg[1];
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "PULL REPLY received, got following %u peers:\n",
+       ntohl (msg->num_peers));
+
+  for (i = 0; i < ntohl (msg->num_peers); i++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "%u. %s\n",
+         i,
+         GNUNET_i2s (&peers[i]));
+
+    #if ENABLE_MALICIOUS
+    if ((NULL != att_peer_set) &&
+        ((1 == mal_type) || (3 == mal_type) ))
+    {     /* Add attacked peer to local list */
+          // TODO check if we sent a request and this was the first reply
+      if ((GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
+                                                                &peers[i]))
+          && (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mal_peer_set,
+                                                                   &peers[i])) )
+      {
+        tmp_att_peer = GNUNET_new (struct AttackedPeer);
+        tmp_att_peer->peer_id = peers[i];
+        GNUNET_CONTAINER_DLL_insert (att_peers_head,
+                                     att_peers_tail,
+                                     tmp_att_peer);
+        add_peer_array_to_set (&peers[i], 1, att_peer_set);
+      }
+      continue;
+    }
+    #endif /* ENABLE_MALICIOUS */
+    /* Make sure we 'know' about this peer */
+    (void) insert_peer (channel_ctx->peer_ctx->sub,
+                        &peers[i]);
+
+    if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
+                                        &peers[i]))
+    {
+      CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
+                         &peers[i]);
+    }
+    else
+    {
+      schedule_operation (channel_ctx->peer_ctx,
+                          insert_in_pull_map,
+                          channel_ctx->peer_ctx->sub);    /* cls */
+      (void) issue_peer_online_check (channel_ctx->peer_ctx->sub,
+                                      &peers[i]);
+    }
+  }
+
+  UNSET_PEER_FLAG (get_peer_ctx (channel_ctx->peer_ctx->sub->peer_map,
+                                 sender),
+                   Peers_PULL_REPLY_PENDING);
+  clean_peer (channel_ctx->peer_ctx->sub,
+              sender);
+
+  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+                                     sender));
+  GNUNET_CADET_receive_done (channel_ctx->channel);
+}
+
+
+/**
+ * Compute a random delay.
+ * A uniformly distributed value between mean + spread and mean - spread.
+ *
+ * For example for mean 4 min and spread 2 the minimum is (4 min - (1/2 * 4 min))
+ * It would return a random value between 2 and 6 min.
+ *
+ * @param mean the mean time until the next round
+ * @param spread the inverse amount of deviation from the mean
+ */
+static struct GNUNET_TIME_Relative
+compute_rand_delay (struct GNUNET_TIME_Relative mean,
+                    unsigned int spread)
+{
+  struct GNUNET_TIME_Relative half_interval;
+  struct GNUNET_TIME_Relative ret;
+  unsigned int rand_delay;
+  unsigned int max_rand_delay;
+
+  if (0 == spread)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not accepting spread of 0\n");
+    GNUNET_break (0);
+    GNUNET_assert (0);
+  }
+  GNUNET_assert (0 != mean.rel_value_us);
+
+  /* Compute random time value between spread * mean and spread * mean */
+  half_interval = GNUNET_TIME_relative_divide (mean, spread);
+
+  max_rand_delay = GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us
+                   / mean.rel_value_us * (2 / spread);
+  /**
+   * Compute random value between (0 and 1) * round_interval
+   * via multiplying round_interval with a 'fraction' (0 to value)/value
+   */
+  rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         max_rand_delay);
+  ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay);
+  ret = GNUNET_TIME_relative_divide (ret, max_rand_delay);
+  ret = GNUNET_TIME_relative_add (ret, half_interval);
+
+  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == ret.rel_value_us)
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Returning FOREVER_REL\n");
+
+  return ret;
+}
+
+
+/**
+ * Send single pull request
+ *
+ * @param peer_ctx Context to the peer to send request to
+ */
+static void
+send_pull_request (struct PeerContext *peer_ctx)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  GNUNET_assert (GNUNET_NO == check_peer_flag (peer_ctx->sub->peer_map,
+                                               &peer_ctx->peer_id,
+                                               Peers_PULL_REPLY_PENDING));
+  SET_PEER_FLAG (peer_ctx,
+                 Peers_PULL_REPLY_PENDING);
+  peer_ctx->round_pull_req = peer_ctx->sub->num_rounds;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to send PULL REQUEST to peer %s.\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
+  send_message (peer_ctx,
+                ev,
+                "PULL REQUEST");
+  if (peer_ctx->sub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# pull request send issued",
+                              1,
+                              GNUNET_NO);
+    if ((NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              &peer_ctx->peer_id)))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# pull request send issued (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+}
+
+
+/**
+ * Send single push
+ *
+ * @param peer_ctx Context of peer to send push to
+ */
+static void
+send_push (struct PeerContext *peer_ctx)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to send PUSH to peer %s.\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
+  send_message (peer_ctx, ev, "PUSH");
+  if (peer_ctx->sub)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# push send issued",
+                              1,
+                              GNUNET_NO);
+    if ((NULL != map_single_hop) &&
+        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+                                                              &peer_ctx->peer_id)))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# push send issued (multi-hop peer)",
+                                1,
+                                GNUNET_NO);
+    }
+  }
+}
+
+
+#if ENABLE_MALICIOUS
+
+
+/**
+ * @brief This function is called, when the client tells us to act malicious.
+ * It verifies that @a msg is well-formed.
+ *
+ * @param cls the closure (#ClientContext)
+ * @param msg the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_client_act_malicious (void *cls,
+                            const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+  uint16_t msize = ntohs (msg->header.size);
+  uint32_t num_peers = ntohl (msg->num_peers);
+
+  msize -= sizeof(struct GNUNET_RPS_CS_ActMaliciousMessage);
+  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
+      (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+         ntohl (msg->num_peers),
+         (msize / sizeof(struct GNUNET_PeerIdentity)));
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cli_ctx->client);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Turn RPS service to act malicious.
+ *
+ * @param cls Closure
+ * @param client The client that sent the message
+ * @param msg The message header
+ */
+static void
+handle_client_act_malicious (void *cls,
+                             const struct
+                             GNUNET_RPS_CS_ActMaliciousMessage *msg)
+{
+  struct ClientContext *cli_ctx = cls;
+  struct GNUNET_PeerIdentity *peers;
+  uint32_t num_mal_peers_sent;
+  uint32_t num_mal_peers_old;
+  struct Sub *sub = cli_ctx->sub;
+
+  if (NULL == sub)
+    sub = msub;
+  /* Do actual logic */
+  peers = (struct GNUNET_PeerIdentity *) &msg[1];
+  mal_type = ntohl (msg->type);
+  if (NULL == mal_peer_set)
+    mal_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n",
+       mal_type,
+       ntohl (msg->num_peers));
+
+  if (1 == mal_type)
+  {   /* Try to maximise representation */
+      /* Add other malicious peers to those we already know */
+
+    num_mal_peers_sent = ntohl (msg->num_peers);
+    num_mal_peers_old = num_mal_peers;
+    GNUNET_array_grow (mal_peers,
+                       num_mal_peers,
+                       num_mal_peers + num_mal_peers_sent);
+    GNUNET_memcpy (&mal_peers[num_mal_peers_old],
+                   peers,
+                   num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
+
+    /* Add all mal peers to mal_peer_set */
+    add_peer_array_to_set (&mal_peers[num_mal_peers_old],
+                           num_mal_peers_sent,
+                           mal_peer_set);
+
+    /* Substitute do_round () with do_mal_round () */
+    GNUNET_assert (NULL != sub->do_round_task);
+    GNUNET_SCHEDULER_cancel (sub->do_round_task);
+    sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
+  }
+
+  else if ((2 == mal_type) ||
+           (3 == mal_type))
+  {   /* Try to partition the network */
+      /* Add other malicious peers to those we already know */
+
+    num_mal_peers_sent = ntohl (msg->num_peers) - 1;
+    num_mal_peers_old = num_mal_peers;
+    GNUNET_assert (GNUNET_MAX_MALLOC_CHECKED > num_mal_peers_sent);
+    GNUNET_array_grow (mal_peers,
+                       num_mal_peers,
+                       num_mal_peers + num_mal_peers_sent);
+    if ((NULL != mal_peers) &&
+        (0 != num_mal_peers) )
+    {
+      GNUNET_memcpy (&mal_peers[num_mal_peers_old],
+                     peers,
+                     num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
+
+      /* Add all mal peers to mal_peer_set */
+      add_peer_array_to_set (&mal_peers[num_mal_peers_old],
+                             num_mal_peers_sent,
+                             mal_peer_set);
+    }
+
+    /* Store the one attacked peer */
+    GNUNET_memcpy (&attacked_peer,
+                   &msg->attacked_peer,
+                   sizeof(struct GNUNET_PeerIdentity));
+    /* Set the flag of the attacked peer to valid to avoid problems */
+    if (GNUNET_NO == check_peer_known (sub->peer_map, &attacked_peer))
+    {
+      (void) issue_peer_online_check (sub, &attacked_peer);
+    }
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Attacked peer is %s\n",
+         GNUNET_i2s (&attacked_peer));
+
+    /* Substitute do_round () with do_mal_round () */
+    if (NULL != sub->do_round_task)
+    {
+      /* Probably in shutdown */
+      GNUNET_SCHEDULER_cancel (sub->do_round_task);
+      sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
+    }
+  }
+  else if (0 == mal_type)
+  {   /* Stop acting malicious */
+    GNUNET_array_grow (mal_peers, num_mal_peers, 0);
+
+    /* Substitute do_mal_round () with do_round () */
+    GNUNET_SCHEDULER_cancel (sub->do_round_task);
+    sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
+  }
+  else
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_continue (cli_ctx->client);
+  }
+  GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * Send out PUSHes and PULLs maliciously.
+ *
+ * This is executed regylary.
+ *
+ * @param cls Closure - Sub
+ */
+static void
+do_mal_round (void *cls)
+{
+  uint32_t num_pushes;
+  uint32_t i;
+  struct GNUNET_TIME_Relative time_next_round;
+  struct AttackedPeer *tmp_att_peer;
+  struct Sub *sub = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to execute next round maliciously type %" PRIu32 ".\n",
+       mal_type);
+  sub->do_round_task = NULL;
+  GNUNET_assert (mal_type <= 3);
+  /* Do malicious actions */
+  if (1 == mal_type)
+  {   /* Try to maximise representation */
+      /* The maximum of pushes we're going to send this round */
+    num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit,
+                                         num_attacked_peers),
+                             GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to send %" PRIu32 " pushes\n",
+         num_pushes);
+
+    /* Send PUSHes to attacked peers */
+    for (i = 0; i < num_pushes; i++)
+    {
+      if (att_peers_tail == att_peer_index)
+        att_peer_index = att_peers_head;
+      else
+        att_peer_index = att_peer_index->next;
+
+      send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
+    }
+
+    /* Send PULLs to some peers to learn about additional peers to attack */
+    tmp_att_peer = att_peer_index;
+    for (i = 0; i < num_pushes * alpha; i++)
+    {
+      if (att_peers_tail == tmp_att_peer)
+        tmp_att_peer = att_peers_head;
+      else
+        att_peer_index = tmp_att_peer->next;
+
+      send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
+    }
+  }
+
+
+  else if (2 == mal_type)
+  {   /**
+       * Try to partition the network
+       * Send as many pushes to the attacked peer as possible
+       * That is one push per round as it will ignore more.
+       */
+    (void) issue_peer_online_check (sub, &attacked_peer);
+    if (GNUNET_YES == check_peer_flag (sub->peer_map,
+                                       &attacked_peer,
+                                       Peers_ONLINE))
+      send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
+  }
+
+
+  if (3 == mal_type)
+  {   /* Combined attack */
+      /* Send PUSH to attacked peers */
+    if (GNUNET_YES == check_peer_known (sub->peer_map, &attacked_peer))
+    {
+      (void) issue_peer_online_check (sub, &attacked_peer);
+      if (GNUNET_YES == check_peer_flag (sub->peer_map,
+                                         &attacked_peer,
+                                         Peers_ONLINE))
+      {
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "Goding to send push to attacked peer (%s)\n",
+             GNUNET_i2s (&attacked_peer));
+        send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
+      }
+    }
+    (void) issue_peer_online_check (sub, &attacked_peer);
+
+    /* The maximum of pushes we're going to send this round */
+    num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit - 1,
+                                         num_attacked_peers),
+                             GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to send %" PRIu32 " pushes\n",
+         num_pushes);
+
+    for (i = 0; i < num_pushes; i++)
+    {
+      if (att_peers_tail == att_peer_index)
+        att_peer_index = att_peers_head;
+      else
+        att_peer_index = att_peer_index->next;
+
+      send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
+    }
+
+    /* Send PULLs to some peers to learn about additional peers to attack */
+    tmp_att_peer = att_peer_index;
+    for (i = 0; i < num_pushes * alpha; i++)
+    {
+      if (att_peers_tail == tmp_att_peer)
+        tmp_att_peer = att_peers_head;
+      else
+        att_peer_index = tmp_att_peer->next;
+
+      send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
+    }
+  }
+
+  /* Schedule next round */
+  time_next_round = compute_rand_delay (sub->round_interval, 2);
+
+  GNUNET_assert (NULL == sub->do_round_task);
+  sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+                                                     &do_mal_round, sub);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
+}
+
+
+#endif /* ENABLE_MALICIOUS */
+
+
+/**
+ * Send out PUSHes and PULLs, possibly update #view, samplers.
+ *
+ * This is executed regylary.
+ *
+ * @param cls Closure - Sub
+ */
+static void
+do_round (void *cls)
+{
+  unsigned int i;
+  const struct GNUNET_PeerIdentity *view_array;
+  unsigned int *permut;
+  unsigned int a_peers; /* Number of peers we send pushes to */
+  unsigned int b_peers; /* Number of peers we send pull requests to */
+  uint32_t first_border;
+  uint32_t second_border;
+  struct GNUNET_PeerIdentity peer;
+  struct GNUNET_PeerIdentity *update_peer;
+  struct Sub *sub = cls;
+
+  sub->num_rounds++;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to execute next round.\n");
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_update (stats, "# rounds", 1, GNUNET_NO);
+  }
+  sub->do_round_task = NULL;
+#ifdef TO_FILE_FULL
+  to_file (sub->file_name_view_log,
+           "___ new round ___");
+#endif /* TO_FILE_FULL */
+  view_array = View_get_as_array (sub->view);
+  for (i = 0; i < View_size (sub->view); i++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "\t%s\n", GNUNET_i2s (&view_array[i]));
+#ifdef TO_FILE_FULL
+    to_file (sub->file_name_view_log,
+             "=%s\t(do round)",
+             GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
+  }
+
+
+  /* Send pushes and pull requests */
+  if (0 < View_size (sub->view))
+  {
+    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+                                           View_size (sub->view));
+
+    /* Send PUSHes */
+    a_peers = ceil (alpha * View_size (sub->view));
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
+         a_peers, alpha, View_size (sub->view));
+    for (i = 0; i < a_peers; i++)
+    {
+      peer = view_array[permut[i]];
+      // FIXME if this fails schedule/loop this for later
+      send_push (get_peer_ctx (sub->peer_map, &peer));
+    }
+
+    /* Send PULL requests */
+    b_peers = ceil (beta * View_size (sub->view));
+    first_border = a_peers;
+    second_border = a_peers + b_peers;
+    if (second_border > View_size (sub->view))
+    {
+      first_border = View_size (sub->view) - b_peers;
+      second_border = View_size (sub->view);
+    }
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
+         b_peers, beta, View_size (sub->view));
+    for (i = first_border; i < second_border; i++)
+    {
+      peer = view_array[permut[i]];
+      if (GNUNET_NO == check_peer_flag (sub->peer_map,
+                                        &peer,
+                                        Peers_PULL_REPLY_PENDING))
+      {       // FIXME if this fails schedule/loop this for later
+        send_pull_request (get_peer_ctx (sub->peer_map, &peer));
+      }
+    }
+
+    GNUNET_free (permut);
+    permut = NULL;
+  }
+
+
+  /* Update view */
+  /* TODO see how many peers are in push-/pull- list! */
+
+  if ((CustomPeerMap_size (sub->push_map) <= alpha * sub->view_size_est_need) &&
+      (0 < CustomPeerMap_size (sub->push_map)) &&
+      (0 < CustomPeerMap_size (sub->pull_map)))
+  {   /* If conditions for update are fulfilled, update */
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
+
+    uint32_t final_size;
+    uint32_t peers_to_clean_size;
+    struct GNUNET_PeerIdentity *peers_to_clean;
+
+    peers_to_clean = NULL;
+    peers_to_clean_size = 0;
+    GNUNET_array_grow (peers_to_clean,
+                       peers_to_clean_size,
+                       View_size (sub->view));
+    GNUNET_memcpy (peers_to_clean,
+                   view_array,
+                   View_size (sub->view) * sizeof(struct GNUNET_PeerIdentity));
+
+    /* Seems like recreating is the easiest way of emptying the peermap */
+    View_clear (sub->view);
+#ifdef TO_FILE_FULL
+    to_file (sub->file_name_view_log,
+             "--- emptied ---");
+#endif /* TO_FILE_FULL */
+
+    first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
+                               CustomPeerMap_size (sub->push_map));
+    second_border = first_border
+                    + GNUNET_MIN (floor (beta * sub->view_size_est_need),
+                                  CustomPeerMap_size (sub->pull_map));
+    final_size = second_border
+                 + ceil ((1 - (alpha + beta)) * sub->view_size_est_need);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"
+         PRIu32 "\n",
+         first_border,
+         second_border,
+         final_size);
+
+    /* Update view with peers received through PUSHes */
+    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+                                           CustomPeerMap_size (sub->push_map));
+    for (i = 0; i < first_border; i++)
+    {
+      int inserted;
+      inserted = insert_in_view (sub,
+                                 CustomPeerMap_get_peer_by_index (sub->push_map,
+                                                                  permut[i]));
+      if (GNUNET_OK == inserted)
+      {
+        clients_notify_stream_peer (sub,
+                                    1,
+                                    CustomPeerMap_get_peer_by_index (
+                                      sub->push_map, permut[i]));
+      }
+#ifdef TO_FILE_FULL
+      to_file (sub->file_name_view_log,
+               "+%s\t(push list)",
+               GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
+       // TODO change the peer_flags accordingly
+    }
+    GNUNET_free (permut);
+    permut = NULL;
+
+    /* Update view with peers received through PULLs */
+    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+                                           CustomPeerMap_size (sub->pull_map));
+    for (i = first_border; i < second_border; i++)
+    {
+      int inserted;
+      inserted = insert_in_view (sub,
+                                 CustomPeerMap_get_peer_by_index (sub->pull_map,
+                                                                  permut[i
+                                                                         -
+                                                                         first_border
+                                                                  ]));
+      if (GNUNET_OK == inserted)
+      {
+        clients_notify_stream_peer (sub,
+                                    1,
+                                    CustomPeerMap_get_peer_by_index (
+                                      sub->pull_map,
+                                      permut[i
+                                             - first_border]));
+      }
+#ifdef TO_FILE_FULL
+      to_file (sub->file_name_view_log,
+               "+%s\t(pull list)",
+               GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
+       // TODO change the peer_flags accordingly
+    }
+    GNUNET_free (permut);
+    permut = NULL;
+
+    /* Update view with peers from history */
+    RPS_sampler_get_n_rand_peers (sub->sampler,
+                                  final_size - second_border,
+                                  hist_update,
+                                  sub);
+    // TODO change the peer_flags accordingly
+
+    for (i = 0; i < View_size (sub->view); i++)
+      rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
+
+    /* Clean peers that were removed from the view */
+    for (i = 0; i < peers_to_clean_size; i++)
+    {
+#ifdef TO_FILE_FULL
+      to_file (sub->file_name_view_log,
+               "-%s",
+               GNUNET_i2s_full (&peers_to_clean[i]));
+#endif /* TO_FILE_FULL */
+      clean_peer (sub, &peers_to_clean[i]);
+    }
+
+    GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
+    clients_notify_view_update (sub);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
+    if (sub == msub)
+    {
+      GNUNET_STATISTICS_update (stats, "# rounds blocked", 1, GNUNET_NO);
+      if ((CustomPeerMap_size (sub->push_map) > alpha
+           * sub->view_size_est_need) &&
+          ! (0 >= CustomPeerMap_size (sub->pull_map)))
+        GNUNET_STATISTICS_update (stats, "# rounds blocked - too many pushes",
+                                  1, GNUNET_NO);
+      if ((CustomPeerMap_size (sub->push_map) > alpha
+           * sub->view_size_est_need) &&
+          (0 >= CustomPeerMap_size (sub->pull_map)))
+        GNUNET_STATISTICS_update (stats,
+                                  "# rounds blocked - too many pushes, no pull replies",
+                                  1, GNUNET_NO);
+      if ((0 >= CustomPeerMap_size (sub->push_map)) &&
+          ! (0 >= CustomPeerMap_size (sub->pull_map)))
+        GNUNET_STATISTICS_update (stats, "# rounds blocked - no pushes", 1,
+                                  GNUNET_NO);
+      if ((0 >= CustomPeerMap_size (sub->push_map)) &&
+          (0 >= CustomPeerMap_size (sub->pull_map)))
+        GNUNET_STATISTICS_update (stats,
+                                  "# rounds blocked - no pushes, no pull replies",
+                                  1, GNUNET_NO);
+      if ((0 >= CustomPeerMap_size (sub->pull_map)) &&
+          (CustomPeerMap_size (sub->push_map) > alpha
+           * sub->view_size_est_need) &&
+          (0 >= CustomPeerMap_size (sub->push_map)) )
+        GNUNET_STATISTICS_update (stats, "# rounds blocked - no pull replies",
+                                  1, GNUNET_NO);
+    }
+  }
+  // TODO independent of that also get some peers from CADET_get_peers()?
+  if (CustomPeerMap_size (sub->push_map) < HISTOGRAM_FILE_SLOTS)
+  {
+    sub->push_recv[CustomPeerMap_size (sub->push_map)]++;
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Push map size too big for histogram (%u, %u)\n",
+         CustomPeerMap_size (sub->push_map),
+         HISTOGRAM_FILE_SLOTS);
+  }
+  // FIXME check bounds of histogram
+  sub->push_delta[(int32_t) (CustomPeerMap_size (sub->push_map)
+                             - (alpha * sub->view_size_est_need))
+                  + (HISTOGRAM_FILE_SLOTS / 2)]++;
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "# peers in push map at end of round",
+                           CustomPeerMap_size (sub->push_map),
+                           GNUNET_NO);
+    GNUNET_STATISTICS_set (stats,
+                           "# peers in pull map at end of round",
+                           CustomPeerMap_size (sub->pull_map),
+                           GNUNET_NO);
+    GNUNET_STATISTICS_set (stats,
+                           "# peers in view at end of round",
+                           View_size (sub->view),
+                           GNUNET_NO);
+    GNUNET_STATISTICS_set (stats,
+                           "# expected pushes",
+                           alpha * sub->view_size_est_need,
+                           GNUNET_NO);
+    GNUNET_STATISTICS_set (stats,
+                           "delta expected - received pushes",
+                           CustomPeerMap_size (sub->push_map) - (alpha
+                                                                 * sub->
+                                                                 view_size_est_need),
+                           GNUNET_NO);
+  }
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
+       CustomPeerMap_size (sub->push_map),
+       CustomPeerMap_size (sub->pull_map),
+       alpha,
+       View_size (sub->view),
+       alpha * View_size (sub->view));
+
+  /* Update samplers */
+  for (i = 0; i < CustomPeerMap_size (sub->push_map); i++)
+  {
+    update_peer = CustomPeerMap_get_peer_by_index (sub->push_map, i);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Updating with peer %s from push list\n",
+         GNUNET_i2s (update_peer));
+    insert_in_sampler (sub, update_peer);
+    clean_peer (sub, update_peer);  /* This cleans only if it is not in the view */
+  }
+
+  for (i = 0; i < CustomPeerMap_size (sub->pull_map); i++)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Updating with peer %s from pull list\n",
+         GNUNET_i2s (CustomPeerMap_get_peer_by_index (sub->pull_map, i)));
+    insert_in_sampler (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
+    /* This cleans only if it is not in the view */
+    clean_peer (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
+  }
+
+
+  /* Empty push/pull lists */
+  CustomPeerMap_clear (sub->push_map);
+  CustomPeerMap_clear (sub->pull_map);
+
+  if (sub == msub)
+  {
+    GNUNET_STATISTICS_set (stats,
+                           "view size",
+                           View_size (sub->view),
+                           GNUNET_NO);
+  }
+
+  struct GNUNET_TIME_Relative time_next_round;
+
+  time_next_round = compute_rand_delay (sub->round_interval, 2);
+
+  /* Schedule next round */
+  sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+                                                     &do_round, sub);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
+}
+
+
+/**
+ * This is called from GNUNET_CADET_get_peers().
+ *
+ * It is called on every peer(ID) that cadet somehow has contact with.
+ * We use those to initialise the sampler.
+ *
+ * implements #GNUNET_CADET_PeersCB
+ *
+ * @param cls Closure - Sub
+ * @param peer Peer, or NULL on "EOF".
+ * @param tunnel Do we have a tunnel towards this peer?
+ * @param n_paths Number of known paths towards this peer.
+ * @param best_path How long is the best path?
+ *                  (0 = unknown, 1 = ourselves, 2 = neighbor)
+ */
+void
+init_peer_cb (void *cls,
+              const struct GNUNET_PeerIdentity *peer,
+              int tunnel, /* "Do we have a tunnel towards this peer?" */
+              unsigned int n_paths, /* "Number of known paths towards this peer" */
+              unsigned int best_path) /* "How long is the best path?
+                                       * (0 = unknown, 1 = ourselves, 2 = neighbor)" */
+{
+  struct Sub *sub = cls;
+
+  (void) tunnel;
+  (void) n_paths;
+  (void) best_path;
+
+  if (NULL != peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got peer_id %s from cadet\n",
+         GNUNET_i2s (peer));
+    got_peer (sub, peer);
+  }
+}
+
+
+/**
+ * @brief Iterator function over stored, valid peers.
+ *
+ * We initialise the sampler with those.
+ *
+ * @param cls Closure - Sub
+ * @param peer the peer id
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+valid_peers_iterator (void *cls,
+                      const struct GNUNET_PeerIdentity *peer)
+{
+  struct Sub *sub = cls;
+
+  if (NULL != peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got stored, valid peer %s\n",
+         GNUNET_i2s (peer));
+    got_peer (sub, peer);
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Iterator over peers from peerinfo.
+ *
+ * @param cls Closure - Sub
+ * @param peer id of the peer, NULL for last call
+ * @param hello hello message for the peer (can be NULL)
+ * @param err_msg error message
+ */
+void
+process_peerinfo_peers (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        const struct GNUNET_MessageHeader *hello,
+                        const char *emsg)
+{
+  struct Sub *sub = cls;
+
+  (void) hello;
+  (void) emsg;
+
+  if (NULL != peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got peer_id %s from peerinfo\n",
+         GNUNET_i2s (peer));
+    got_peer (sub, peer);
+  }
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls Closure - unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  (void) cls;
+  struct ClientContext *client_ctx;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "RPS service is going down\n");
+
+  /* Clean all clients */
+  for (client_ctx = cli_ctx_head;
+       NULL != cli_ctx_head;
+       client_ctx = cli_ctx_head)
+  {
+    destroy_cli_ctx (client_ctx);
+  }
+  if (NULL != msub)
+  {
+    destroy_sub (msub);
+    msub = NULL;
+  }
+
+  /* Disconnect from other services */
+  GNUNET_PEERSTORE_hello_changed_notify_cancel (peerstore_notify);
+  GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_YES);
+  peerstore = NULL;
+  GNUNET_NSE_disconnect (nse);
+  if (NULL != map_single_hop)
+  {
+    /* core_init was called - core was initialised */
+    /* disconnect first, so no callback tries to access missing peermap */
+    GNUNET_CORE_disconnect (core_handle);
+    core_handle = NULL;
+    GNUNET_CONTAINER_multipeermap_destroy (map_single_hop);
+    map_single_hop = NULL;
+  }
+
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats,
+                               GNUNET_NO);
+    stats = NULL;
+  }
+  GNUNET_CADET_disconnect (cadet_handle);
+  cadet_handle = NULL;
+#if ENABLE_MALICIOUS
+  struct AttackedPeer *tmp_att_peer;
+  GNUNET_array_grow (mal_peers,
+                     num_mal_peers,
+                     0);
+  if (NULL != mal_peer_set)
+    GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
+  if (NULL != att_peer_set)
+    GNUNET_CONTAINER_multipeermap_destroy (att_peer_set);
+  while (NULL != att_peers_head)
+  {
+    tmp_att_peer = att_peers_head;
+    GNUNET_CONTAINER_DLL_remove (att_peers_head,
+                                 att_peers_tail,
+                                 tmp_att_peer);
+    GNUNET_free (tmp_att_peer);
+  }
+#endif /* ENABLE_MALICIOUS */
+  close_all_files ();
+}
+
+
+/**
+ * Handle client connecting to the service.
+ *
+ * @param cls unused
+ * @param client the new client
+ * @param mq the message queue of @a client
+ * @return @a client
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct ClientContext *cli_ctx;
+
+  (void) cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client connected\n");
+  if (NULL == client)
+    return client; /* Server was destroyed before a client connected. Shutting down */
+  cli_ctx = GNUNET_new (struct ClientContext);
+  cli_ctx->mq = mq;
+  cli_ctx->view_updates_left = -1;
+  cli_ctx->stream_update = GNUNET_NO;
+  cli_ctx->client = client;
+  GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
+                               cli_ctx_tail,
+                               cli_ctx);
+  return cli_ctx;
+}
+
+
+/**
+ * Callback called when a client disconnected from the service
+ *
+ * @param cls closure for the service
+ * @param client the client that disconnected
+ * @param internal_cls should be equal to @a c
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *internal_cls)
+{
+  struct ClientContext *cli_ctx = internal_cls;
+
+  (void) cls;
+  GNUNET_assert (client == cli_ctx->client);
+  if (NULL == client)
+  {  /* shutdown task - destroy all clients */
+    while (NULL != cli_ctx_head)
+      destroy_cli_ctx (cli_ctx_head);
+  }
+  else
+  {   /* destroy this client */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Client disconnected. Destroy its context.\n");
+    destroy_cli_ctx (cli_ctx);
+  }
+}
+
+
+/**
+ * Handle random peer sampling clients.
+ *
+ * @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)
+{
+  struct GNUNET_TIME_Relative round_interval;
+  long long unsigned int sampler_size;
+  char hash_port_string[] = GNUNET_APPLICATION_PORT_RPS;
+  struct GNUNET_HashCode hash;
+
+  (void) cls;
+  (void) service;
+
+  GNUNET_log_setup ("rps",
+                    GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
+                    NULL);
+  cfg = c;
+  /* Get own ID */
+  GNUNET_CRYPTO_get_peer_identity (cfg,
+                                   &own_identity); // TODO check return value
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "STARTING SERVICE (rps) for peer [%s]\n",
+              GNUNET_i2s (&own_identity));
+#if ENABLE_MALICIOUS
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Malicious execution compiled in.\n");
+#endif /* ENABLE_MALICIOUS */
+
+  /* Get time interval from the configuration */
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_time (cfg,
+                                           "RPS",
+                                           "ROUNDINTERVAL",
+                                           &round_interval))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "RPS", "ROUNDINTERVAL");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  /* Get initial size of sampler/view from the configuration */
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "RPS",
+                                             "MINSIZE",
+                                             &sampler_size))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "RPS", "MINSIZE");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  cadet_handle = GNUNET_CADET_connect (cfg);
+  GNUNET_assert (NULL != cadet_handle);
+  core_handle = GNUNET_CORE_connect (cfg,
+                                     NULL, /* cls */
+                                     core_init, /* init */
+                                     core_connects, /* connects */
+                                     core_disconnects, /* disconnects */
+                                     NULL); /* handlers */
+  GNUNET_assert (NULL != core_handle);
+
+
+  alpha = 0.45;
+  beta = 0.45;
+
+
+  /* Set up main Sub */
+  GNUNET_CRYPTO_hash (hash_port_string,
+                      strlen (hash_port_string),
+                      &hash);
+  msub = new_sub (&hash,
+                  sampler_size, /* Will be overwritten by config */
+                  round_interval);
+
+
+  peerstore = GNUNET_PEERSTORE_connect (cfg);
+
+  /* connect to NSE */
+  nse = GNUNET_NSE_connect (cfg, nse_callback, NULL);
+
+  // LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
+  // GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, msub);
+  // TODO send push/pull to each of those peers?
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
+  restore_valid_peers (msub);
+  get_valid_peers (msub->valid_peers, valid_peers_iterator, msub);
+
+  peerstore_notify = GNUNET_PEERSTORE_hello_changed_notify (peerstore,
+                                                            GNUNET_NO,
+                                                            process_peerinfo_peers,
+                                                            msub);
+
+  LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
+
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  stats = GNUNET_STATISTICS_create ("rps", cfg);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+  ("rps",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (client_seed,
+                         GNUNET_MESSAGE_TYPE_RPS_CS_SEED,
+                         struct GNUNET_RPS_CS_SeedMessage,
+                         NULL),
+#if ENABLE_MALICIOUS
+  GNUNET_MQ_hd_var_size (client_act_malicious,
+                         GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
+                         struct GNUNET_RPS_CS_ActMaliciousMessage,
+                         NULL),
+#endif /* ENABLE_MALICIOUS */
+  GNUNET_MQ_hd_fixed_size (client_view_request,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST,
+                           struct GNUNET_RPS_CS_DEBUG_ViewRequest,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_view_cancel,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_stream_request,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST,
+                           struct GNUNET_RPS_CS_DEBUG_StreamRequest,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_stream_cancel,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_start_sub,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START,
+                           struct GNUNET_RPS_CS_SubStartMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_stop_sub,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP,
+                           struct GNUNET_RPS_CS_SubStopMessage,
+                           NULL),
+  GNUNET_MQ_handler_end ());
+
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_custommap.c b/src/contrib/service/rps/gnunet-service-rps_custommap.c
new file mode 100644
index 000000000..b1e73be17
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_custommap.c
@@ -0,0 +1,356 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_custommap.c
+ * @brief utilities for managing (information about) peers
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet-service-rps_custommap.h"
+#include <inttypes.h>
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-peers", __VA_ARGS__)
+
+
+/**
+ * Peer map to store peers with specialised use-cases (push_list, pull_list,
+ * view, ...)
+ *
+ * It is aimed for use as unordered list-like structures that can be indexed.
+ * Main use-case:
+ *
+ *  permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+ *                                         CustomPeerMap_size (peer_map));
+ *  for (i = 0; i < some_border; i++)
+ *    some_array[i] = *CustomPeerMap_get_peer_by_index (peer_map, permut[i]);
+ *  for (i = some_border; i < CustomPeerMap_size (peer_map); i++)
+ *    other_array[i-some_border] =
+ *      *CustomPeerMap_get_peer_by_index (peer_map, permut[i]);
+ *
+ * This list is expected to
+ * - be altered in small steps frequently
+ * - be cleared regularly
+ * - often being queried whether a peer is contained
+ * - alter indices of peers
+ * - contain continuous indices 0 <= i < len
+ * - not contain duplicate peers
+ */
+struct CustomPeerMap
+{
+  /**
+   * Multihashmap to be able to access a random index
+   */
+  struct GNUNET_CONTAINER_MultiHashMap32 *hash_map;
+
+  /**
+   * Peermap to quickly check whether a peer is contained
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+};
+
+
+/**
+ * Create an empty peermap.
+ *
+ * @param len the initial length for the internal maps
+ *
+ * @return the newly created custom peer map
+ */
+struct CustomPeerMap *
+CustomPeerMap_create (unsigned int len)
+{
+  struct CustomPeerMap *c_peer_map;
+
+  c_peer_map = GNUNET_new (struct CustomPeerMap);
+  c_peer_map->hash_map = GNUNET_CONTAINER_multihashmap32_create (len);
+  c_peer_map->peer_map = GNUNET_CONTAINER_multipeermap_create (len,
+                                                               GNUNET_NO);
+  return c_peer_map;
+}
+
+
+/**
+ * Get the size of the custom peer map
+ *
+ * @param c_peer_map the custom peer map to look in
+ *
+ * @return size of the map
+ */
+unsigned int
+CustomPeerMap_size (const struct CustomPeerMap *c_peer_map)
+{
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (c_peer_map->hash_map) ==
+                 GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+  return GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map);
+}
+
+
+/**
+ * Insert peer into the custom peer map
+ *
+ * @param c_peer_map the custom peer map to insert peer
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if map did not contain peer previously
+ *         GNUNET_NO if map did contain peer previously
+ */
+int
+CustomPeerMap_put (const struct CustomPeerMap *c_peer_map,
+                   const struct GNUNET_PeerIdentity *peer)
+{
+  uint32_t *index;
+  struct GNUNET_PeerIdentity *p;
+
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (c_peer_map->hash_map) ==
+                 GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (c_peer_map->peer_map,
+                                                           peer))
+  {
+    /* Need to store the index of the peer in the peermap to be able to remove
+     * it properly */
+    index = GNUNET_new (uint32_t);
+    *index = CustomPeerMap_size (c_peer_map);
+    p = GNUNET_new (struct GNUNET_PeerIdentity);
+    *p = *peer;
+    GNUNET_assert (p != peer);
+    GNUNET_assert (0 == memcmp (p,
+                                peer,
+                                sizeof(struct GNUNET_PeerIdentity)));
+    GNUNET_CONTAINER_multipeermap_put (c_peer_map->peer_map,
+                                       p,
+                                       index,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    GNUNET_CONTAINER_multihashmap32_put (c_peer_map->hash_map,
+                                         *index,
+                                         p,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (
+                     c_peer_map->hash_map) ==
+                   GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+    return GNUNET_OK;
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Check whether custom peer map contains a peer
+ *
+ * @param c_peer_map the custom peer map to look in
+ * @param peer the peer to check for
+ *
+ * @return GNUNET_OK if map contains peer
+ *         GNUNET_NO  otherwise
+ */
+int
+CustomPeerMap_contains_peer (const struct CustomPeerMap *c_peer_map,
+                             const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_contains (c_peer_map->peer_map, peer);
+}
+
+
+/**
+ * Get index of peer in custom peer map
+ *
+ * @param c_peer_map the custom peer map to look in
+ * @param peer the peer to get the index from
+ *
+ * @return the index
+ */
+static uint32_t *
+CustomPeerMap_get_index_pointer (const struct CustomPeerMap *c_peer_map,
+                                 const struct GNUNET_PeerIdentity *peer)
+{
+  uint32_t *index;
+
+  GNUNET_assert (GNUNET_YES == CustomPeerMap_contains_peer (c_peer_map, peer));
+  index = GNUNET_CONTAINER_multipeermap_get (c_peer_map->peer_map, peer);
+  return index;
+}
+
+
+/**
+ * Remove peer from custom peer map
+ *
+ * @param c_peer_map the custom peer map to remove the peer from
+ * @param peer the peer to remove
+ *
+ * @return GNUNET_OK if map contained peer and removed it successfully
+ *         GNUNET_NO if map does not contain peer
+ */
+int
+CustomPeerMap_remove_peer (const struct CustomPeerMap *c_peer_map,
+                           const struct GNUNET_PeerIdentity *peer)
+{
+  uint32_t *index;
+  struct GNUNET_PeerIdentity *p;
+  uint32_t *last_index;
+  struct GNUNET_PeerIdentity *last_p;
+  int ret;
+
+  if (GNUNET_NO == CustomPeerMap_contains_peer (c_peer_map,
+                                                peer))
+  {
+    return GNUNET_NO;
+  }
+  index = CustomPeerMap_get_index_pointer (c_peer_map,
+                                           peer);
+  GNUNET_assert (*index < CustomPeerMap_size (c_peer_map));
+  /* Need to get the pointer stored in the hashmap to free it */
+  p = GNUNET_CONTAINER_multihashmap32_get (c_peer_map->hash_map,
+                                           *index);
+  GNUNET_assert (NULL != p);
+  GNUNET_CONTAINER_multihashmap32_remove_all (c_peer_map->hash_map,
+                                              *index);
+  // TODO wrong peerid?
+  GNUNET_CONTAINER_multipeermap_remove_all (c_peer_map->peer_map,
+                                            peer);
+  if (*index != CustomPeerMap_size (c_peer_map))
+  {   /* fill 'gap' with peer at last index */
+    last_p =
+      GNUNET_CONTAINER_multihashmap32_get (c_peer_map->hash_map,
+                                           CustomPeerMap_size (c_peer_map));
+    GNUNET_assert (NULL != last_p);
+    last_index = GNUNET_CONTAINER_multipeermap_get (c_peer_map->peer_map,
+                                                    last_p);
+    GNUNET_assert (NULL != last_index);
+    GNUNET_assert (CustomPeerMap_size (c_peer_map) == *last_index);
+    ret = GNUNET_CONTAINER_multihashmap32_put (c_peer_map->hash_map,
+                                               *index,
+                                               last_p,
+                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    GNUNET_assert (GNUNET_OK == ret);
+    GNUNET_CONTAINER_multihashmap32_remove_all (c_peer_map->hash_map,
+                                                *last_index);
+    *last_index = *index;
+  }
+  GNUNET_free (index);
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (c_peer_map->hash_map) ==
+                 GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+  GNUNET_free (p);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get a peer by index
+ *
+ * @param c_peer_map the custom peer map to look in
+ * @param index the index of the peer to get
+ *
+ * @return peer to the corresponding index.
+ *         if this index is not known, return NULL
+ */
+struct GNUNET_PeerIdentity *
+CustomPeerMap_get_peer_by_index (const struct CustomPeerMap *c_peer_map,
+                                 uint32_t index)
+{
+  if (GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap32_contains (c_peer_map->hash_map, index))
+  {
+    return GNUNET_CONTAINER_multihashmap32_get (c_peer_map->hash_map, index);
+  }
+  return NULL;
+}
+
+
+/**
+ * Remove peer from custom peer map by index
+ *
+ * @param c_peer_map the custom peer map to remove the peer from
+ * @param index the index of the peer to remove
+ *
+ * @return GNUNET_OK if map contained peer and removed it successfully
+ *         GNUNET_NO if map does not contain (index of) peer
+ */
+int
+CustomPeerMap_remove_peer_by_index (const struct CustomPeerMap *c_peer_map,
+                                    uint32_t index)
+{
+  uint32_t *index_p;
+  struct GNUNET_PeerIdentity *peer;
+
+  if (index >= CustomPeerMap_size (c_peer_map))
+  {
+    return GNUNET_NO;
+  }
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (c_peer_map->hash_map) ==
+                 GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multihashmap32_contains (c_peer_map->hash_map, index))
+  {
+    return GNUNET_NO;
+  }
+  peer = CustomPeerMap_get_peer_by_index (c_peer_map, index);
+  GNUNET_assert (NULL != peer);
+  index_p = CustomPeerMap_get_index_pointer (c_peer_map, peer);
+  GNUNET_assert (index == *index_p);
+  CustomPeerMap_remove_peer (c_peer_map, peer);
+  GNUNET_assert (GNUNET_CONTAINER_multihashmap32_size (c_peer_map->hash_map) ==
+                 GNUNET_CONTAINER_multipeermap_size (c_peer_map->peer_map));
+  return GNUNET_OK;
+}
+
+
+/**
+ * Clear the custom peer map
+ *
+ * @param c_peer_map the custom peer map to look in
+ *
+ * @return size of the map
+ */
+void
+CustomPeerMap_clear (const struct CustomPeerMap *c_peer_map)
+{
+  while (0 < CustomPeerMap_size (c_peer_map))
+  {
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap32_contains (
+                     c_peer_map->hash_map,
+                     CustomPeerMap_size (
+                       c_peer_map) - 1));
+    GNUNET_assert (GNUNET_OK ==
+                   CustomPeerMap_remove_peer_by_index (c_peer_map,
+                                                       CustomPeerMap_size (
+                                                         c_peer_map) - 1));
+  }
+  GNUNET_assert (0 == CustomPeerMap_size (c_peer_map));
+}
+
+
+/**
+ * Destroy peermap.
+ *
+ * @param c_peer_map the map to destroy
+ */
+void
+CustomPeerMap_destroy (struct CustomPeerMap *c_peer_map)
+{
+  CustomPeerMap_clear (c_peer_map);
+  GNUNET_CONTAINER_multihashmap32_destroy (c_peer_map->hash_map);
+  GNUNET_CONTAINER_multipeermap_destroy (c_peer_map->peer_map);
+  GNUNET_free (c_peer_map);
+}
+
+
+/* end of gnunet-service-rps_custommap.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_custommap.h b/src/contrib/service/rps/gnunet-service-rps_custommap.h
new file mode 100644
index 000000000..e7f669c63
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_custommap.h
@@ -0,0 +1,159 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_custommap.h
+ * @brief utilities for managing (information about) peers
+ * @author Julius Bünger
+ */
+#include "gnunet_util_lib.h"
+#include <inttypes.h>
+
+
+/**
+ * Peer map to store peers with specialised use-cases (push_list, pull_list,
+ * view, ...)
+ *
+ * It is aimed for use as unordered list-like structures that can be indexed.
+ * Main use-case:
+ *
+ *  permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+ *                                         CustomPeerMap_size (peer_map));
+ *  for (i = 0; i < some_border; i++)
+ *    some_array[i] = *CustomPeerMap_get_peer_by_index (peer_map, permut[i]);
+ *  for (i = some_border; i < CustomPeerMap_size (peer_map); i++)
+ *    other_array[i-some_border] =
+ *      *CustomPeerMap_get_peer_by_index (peer_map, permut[i]);
+ *
+ * This list is expected to
+ * - be altered in small steps frequently
+ * - be cleared regularly
+ * - often being queried whether a peer is contained
+ * - alter indices of peers
+ * - contain continuous indices 0 <= i < len
+ * - not contain duplicate peers
+ */
+struct CustomPeerMap;
+
+
+/**
+ * Create an empty peermap.
+ *
+ * @param len the initial length for the internal maps
+ *
+ * @return the newly created custom peer map
+ */
+struct CustomPeerMap *
+CustomPeerMap_create (unsigned int len);
+
+/**
+ * Get the size of the custom peer map
+ *
+ * @param c_peer_map the custom peer map to look in
+ *
+ * @return size of the map
+ */
+unsigned int
+CustomPeerMap_size (const struct CustomPeerMap *c_peer_map);
+
+/**
+ * Insert peer into the custom peer map
+ *
+ * @param c_peer_map the custom peer map to insert peer
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if map did not contain peer previously
+ *         GNUNET_NO if map did contain peer previously
+ */
+int
+CustomPeerMap_put (const struct CustomPeerMap *c_peer_map,
+                   const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Check whether custom peer map contains a peer
+ *
+ * @param c_peer_map the custom peer map to look in
+ * @param peer the peer to check for
+ *
+ * @return GNUNET_OK if map contains peer
+ *         GNUNET_NO  otherwise
+ */
+int
+CustomPeerMap_contains_peer (const struct CustomPeerMap *c_peer_map,
+                             const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Remove peer from custom peer map
+ *
+ * @param c_peer_map the custom peer map to remove the peer from
+ * @param peer the peer to remove
+ *
+ * @return GNUNET_OK if map contained peer and removed it successfully
+ *         GNUNET_NO if map does not contain peer
+ */
+int
+CustomPeerMap_remove_peer (const struct CustomPeerMap *c_peer_map,
+                           const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Get a peer by index
+ *
+ * @param c_peer_map the custom peer map to look in
+ * @param index the index of the peer to get
+ *
+ * @return peer to the corresponding index.
+ *         if this index is not known, return NULL
+ */
+struct GNUNET_PeerIdentity *
+CustomPeerMap_get_peer_by_index (const struct CustomPeerMap *c_peer_map,
+                                 uint32_t index);
+
+/**
+ * Remove peer from custom peer map by index
+ *
+ * @param c_peer_map the custom peer map to remove the peer from
+ * @param index the index of the peer to remove
+ *
+ * @return GNUNET_OK if map contained peer and removed it successfully
+ *         GNUNET_NO if map does not contain (index of) peer
+ */
+int
+CustomPeerMap_remove_peer_by_index (const struct CustomPeerMap *c_peer_map,
+                                    uint32_t index);
+
+/**
+ * Clear the custom peer map
+ *
+ * @param c_peer_map the custom peer map to look in
+ *
+ * @return size of the map
+ */
+void
+CustomPeerMap_clear (const struct CustomPeerMap *c_peer_map);
+
+/**
+ * Destroy peermap.
+ *
+ * @param c_peer_map the map to destroy
+ */
+void
+CustomPeerMap_destroy (struct CustomPeerMap *c_peer_map);
+
+/* end of gnunet-service-rps_custommap.h */
diff --git a/src/contrib/service/rps/gnunet-service-rps_sampler.c b/src/contrib/service/rps/gnunet-service-rps_sampler.c
new file mode 100644
index 000000000..598cc887e
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_sampler.c
@@ -0,0 +1,268 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_sampler.c
+ * @brief sampler implementation
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "rps.h"
+
+#include "rps-sampler_common.h"
+#include "gnunet-service-rps_sampler.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <math.h>
+#include <inttypes.h>
+
+#include "rps-test_util.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-sampler", __VA_ARGS__)
+
+
+// multiple 'clients'?
+
+// TODO check for overflows
+
+// TODO align message structs
+
+// hist_size_init, hist_size_max
+
+/***********************************************************************
+* WARNING: This section needs to be reviewed regarding the use of
+* functions providing (pseudo)randomness!
+***********************************************************************/
+
+// TODO care about invalid input of the caller (size 0 or less...)
+
+/**
+ * @brief Callback called each time a new peer was put into the sampler
+ *
+ * @param cls A possibly given closure
+ */
+typedef void
+(*SamplerNotifyUpdateCB) (void *cls);
+
+/**
+ * @brief Context for a callback. Contains callback and closure.
+ *
+ * Meant to be an entry in an DLL.
+ */
+struct SamplerNotifyUpdateCTX
+{
+  /**
+   * @brief The Callback to call on updates
+   */
+  SamplerNotifyUpdateCB notify_cb;
+
+  /**
+   * @brief The according closure.
+   */
+  void *cls;
+
+  /**
+   * @brief Next element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *next;
+
+  /**
+   * @brief Previous element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *prev;
+};
+
+
+/**
+ * Type of function used to differentiate between modified and not modified
+ * Sampler.
+ */
+typedef void
+(*RPS_get_peers_type) (void *cls);
+
+/**
+ * Get one random peer out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ * Only used internally
+ */
+static void
+sampler_get_rand_peer (void *cls);
+
+
+/**
+ * Closure to _get_n_rand_peers_ready_cb()
+ */
+struct RPS_SamplerRequestHandle
+{
+  /**
+   * DLL
+   */
+  struct RPS_SamplerRequestHandle *next;
+  struct RPS_SamplerRequestHandle *prev;
+
+  /**
+   * Number of peers we are waiting for.
+   */
+  uint32_t num_peers;
+
+  /**
+   * Number of peers we currently have.
+   */
+  uint32_t cur_num_peers;
+
+  /**
+   * Pointer to the array holding the ids.
+   */
+  struct GNUNET_PeerIdentity *ids;
+
+  /**
+   * Head and tail for the DLL to store the tasks for single requests
+   */
+  struct GetPeerCls *gpc_head;
+  struct GetPeerCls *gpc_tail;
+
+  /**
+   * Sampler.
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * Callback to be called when all ids are available.
+   */
+  RPS_sampler_n_rand_peers_ready_cb callback;
+
+  /**
+   * Closure given to the callback
+   */
+  void *cls;
+};
+
+///**
+// * Global sampler variable.
+// */
+// struct RPS_Sampler *sampler;
+
+
+/**
+ * The minimal size for the extended sampler elements.
+ */
+static size_t min_size;
+
+/**
+ * The maximal size the extended sampler elements should grow to.
+ */
+static size_t max_size;
+
+/**
+ * The size the extended sampler elements currently have.
+ */
+// static size_t extra_size;
+
+/**
+ * Inedex to the sampler element that is the next to be returned
+ */
+static uint32_t client_get_index;
+
+
+/**
+ * Initialise a tuple of sampler elements.
+ *
+ * @param init_size the size the sampler is initialised with
+ * @param max_round_interval maximum time a round takes
+ * @return a handle to a sampler that consists of sampler elements.
+ */
+struct RPS_Sampler *
+RPS_sampler_init (size_t init_size,
+                  struct GNUNET_TIME_Relative max_round_interval)
+{
+  struct RPS_Sampler *sampler;
+
+  /* Initialise context around extended sampler */
+  min_size = 10; // TODO make input to _samplers_init()
+  max_size = 1000; // TODO make input to _samplers_init()
+
+  sampler = GNUNET_new (struct RPS_Sampler);
+
+  sampler->max_round_interval = max_round_interval;
+  sampler->get_peers = sampler_get_rand_peer;
+  // sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
+  // GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
+  RPS_sampler_resize (sampler, init_size);
+
+  client_get_index = 0;
+
+  // GNUNET_assert (init_size == sampler->sampler_size);
+  return sampler;
+}
+
+
+/**
+ * Get one random peer out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ * Only used internally
+ */
+static void
+sampler_get_rand_peer (void *cls)
+{
+  struct GetPeerCls *gpc = cls;
+  uint32_t r_index;
+  struct RPS_Sampler *sampler;
+
+  gpc->get_peer_task = NULL;
+  gpc->notify_ctx = NULL;
+  sampler = gpc->req_handle->sampler;
+
+  /**;
+   * Choose the r_index of the peer we want to return
+   * at random from the interval of the gossip list
+   */
+  r_index = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG,
+                                      sampler->sampler_size);
+
+  if (EMPTY == sampler->sampler_elements[r_index]->is_empty)
+  {
+    // LOG (GNUNET_ERROR_TYPE_DEBUG,
+    //     "Not returning randomly selected, empty PeerID. - Rescheduling.\n");
+
+    gpc->notify_ctx =
+      sampler_notify_on_update (sampler,
+                                &sampler_get_rand_peer,
+                                gpc);
+    return;
+  }
+
+  GNUNET_CONTAINER_DLL_remove (gpc->req_handle->gpc_head,
+                               gpc->req_handle->gpc_tail,
+                               gpc);
+  *gpc->id = sampler->sampler_elements[r_index]->peer_id;
+  gpc->cont (gpc->cont_cls, gpc->id, 0,
+             sampler->sampler_elements[r_index]->num_peers);
+
+  GNUNET_free (gpc);
+}
+
+
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_sampler.h b/src/contrib/service/rps/gnunet-service-rps_sampler.h
new file mode 100644
index 000000000..410823bea
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_sampler.h
@@ -0,0 +1,157 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_sampler.h
+ * @brief sampler implementation
+ * @author Julius Bünger
+ */
+
+#ifndef RPS_SAMPLER_H
+#define RPS_SAMPLER_H
+#include <inttypes.h>
+#include "rps-sampler_common.h"
+
+
+/**
+ * A sampler sampling a stream of PeerIDs.
+ */
+struct RPS_Sampler;
+
+/**
+ * A handle to cancel a request.
+ */
+struct RPS_SamplerRequestHandle;
+
+
+/**
+ * Get the size of the sampler.
+ *
+ * @param sampler the sampler to return the size of.
+ * @return the size of the sampler
+ */
+unsigned int
+RPS_sampler_get_size (struct RPS_Sampler *sampler);
+
+
+/**
+ * Grow or shrink the size of the sampler.
+ *
+ * @param sampler the sampler to resize.
+ * @param new_size the new size of the sampler (not 0)
+ */
+void
+RPS_sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size);
+
+
+/**
+ * Initialise a tuple of samplers.
+ *
+ * @param init_size the size the sampler is initialised with
+ * @param max_round_interval maximum time a round takes
+ * @return a handle to a sampler that consists of sampler elements.
+ */
+struct RPS_Sampler *
+RPS_sampler_init (size_t init_size,
+                  struct GNUNET_TIME_Relative max_round_interval);
+
+
+/**
+ * Update every sampler element of this sampler with given peer
+ *
+ * @param sampler the sampler to update.
+ * @param id the PeerID that is put in the sampler
+ */
+void
+RPS_sampler_update (struct RPS_Sampler *sampler,
+                    const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Reinitialise all previously initialised sampler elements with the given
+ * value.
+ *
+ * Used to get rid of a PeerID.
+ *
+ * FIXME: This should also consider currently pending requests
+ *        (Pending requests already collect peerids. As long as not all
+ *        requested IDs have been collected, they are kept.
+ *        Ideally, the @p id should be removed from all pending requests. This
+ *        seems quite complicated.)
+ *
+ * @param sampler the sampler to reinitialise a sampler in.
+ * @param id the id of the samplers to update.
+ */
+void
+RPS_sampler_reinitialise_by_value (struct RPS_Sampler *sampler,
+                                   const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Get n random peers out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ * Random with or without consumption?
+ *
+ * @param sampler the sampler to get peers from.
+ * @param cb callback that will be called once the ids are ready.
+ * @param cls closure given to @a cb
+ * @param for_client #GNUNET_YES if result is used for client,
+ *                   #GNUNET_NO if used internally
+ * @param num_peers the number of peers requested
+ */
+struct RPS_SamplerRequestHandle *
+RPS_sampler_get_n_rand_peers (struct RPS_Sampler *sampler,
+                              uint32_t num_peers,
+                              RPS_sampler_n_rand_peers_ready_cb cb,
+                              void *cls);
+
+/**
+ * Cancel a request issued through #RPS_sampler_n_rand_peers_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle);
+
+
+/**
+ * Counts how many Samplers currently hold a given PeerID.
+ *
+ * @param sampler the sampler to count ids in.
+ * @param id the PeerID to count.
+ * @return the number of occurrences of id.
+ */
+uint32_t
+RPS_sampler_count_id (struct RPS_Sampler *sampler,
+                      const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Cleans the samplers.
+ *
+ * @param sampler the sampler to destroy.
+ */
+void
+RPS_sampler_destroy (struct RPS_Sampler *sampler);
+
+#endif
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_sampler_elem.c b/src/contrib/service/rps/gnunet-service-rps_sampler_elem.c
new file mode 100644
index 000000000..a6dc755a3
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_sampler_elem.c
@@ -0,0 +1,170 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_sampler.c
+ * @brief sampler implementation
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <inttypes.h>
+
+#include "rps-test_util.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-sampler_elem", __VA_ARGS__)
+
+
+/***********************************************************************
+* WARNING: This section needs to be reviewed regarding the use of
+* functions providing (pseudo)randomness!
+***********************************************************************/
+
+
+/**
+ * Reinitialise a previously initialised sampler element.
+ *
+ * @param sampler_elem The sampler element to (re-) initialise
+ */
+void
+RPS_sampler_elem_reinit (struct RPS_SamplerElement *sampler_elem)
+{
+  sampler_elem->is_empty = EMPTY;
+
+  // I guess I don't need to call GNUNET_CRYPTO_hmac_derive_key()...
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG,
+                              &(sampler_elem->auth_key.key),
+                              GNUNET_CRYPTO_HASH_LENGTH);
+
+  sampler_elem->last_client_request = GNUNET_TIME_UNIT_FOREVER_ABS;
+
+  sampler_elem->birth = GNUNET_TIME_absolute_get ();
+  sampler_elem->num_peers = 0;
+  sampler_elem->num_change = 0;
+}
+
+
+/**
+ * Create a sampler element and initialise it.
+ *
+ * In this implementation this means choosing an auth_key for later use in
+ * a hmac at random.
+ *
+ * @return a newly created RPS_SamplerElement which currently holds no id.
+ */
+struct RPS_SamplerElement *
+RPS_sampler_elem_create (void)
+{
+  struct RPS_SamplerElement *s;
+
+  s = GNUNET_new (struct RPS_SamplerElement);
+
+  RPS_sampler_elem_reinit (s);
+
+  return s;
+}
+
+
+/**
+ * Destroy a sampler element.
+ *
+ * @param sampler_elem the element to destroy
+ */
+void
+RPS_sampler_elem_destroy (struct RPS_SamplerElement *sampler_elem)
+{
+  GNUNET_free (sampler_elem);
+}
+
+
+/**
+ * Update a sampler element with a PeerID
+ *
+ * @param sampler_elem The sampler element to update
+ * @param new_ID The PeerID to update with
+ */
+void
+RPS_sampler_elem_next (struct RPS_SamplerElement *sampler_elem,
+                       const struct GNUNET_PeerIdentity *new_ID)
+{
+  struct GNUNET_HashCode other_hash;
+
+  sampler_elem->num_peers++;
+
+  if (0 == GNUNET_memcmp (new_ID, &(sampler_elem->peer_id)))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Have already PeerID %s\n",
+         GNUNET_i2s (&(sampler_elem->peer_id)));
+  }
+  else
+  {
+    GNUNET_CRYPTO_hmac (&sampler_elem->auth_key,
+                        new_ID,
+                        sizeof(struct GNUNET_PeerIdentity),
+                        &other_hash);
+
+    if (EMPTY == sampler_elem->is_empty)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Got PeerID %s; Simply accepting (was empty previously).\n",
+           GNUNET_i2s (new_ID));
+      sampler_elem->peer_id = *new_ID;
+      sampler_elem->peer_id_hash = other_hash;
+
+      sampler_elem->num_change++;
+    }
+    else if (0 > GNUNET_CRYPTO_hash_cmp (&other_hash,
+                                         &sampler_elem->peer_id_hash))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Discarding old PeerID %s\n",
+           GNUNET_i2s (&sampler_elem->peer_id));
+      sampler_elem->peer_id = *new_ID;
+      sampler_elem->peer_id_hash = other_hash;
+
+      sampler_elem->num_change++;
+    }
+    else
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Keeping old PeerID %s\n",
+           GNUNET_i2s (&sampler_elem->peer_id));
+    }
+  }
+  sampler_elem->is_empty = NOT_EMPTY;
+}
+
+
+/**
+ * Set the min-wise independent function of the given sampler element.
+ *
+ * @param sampler_elem the sampler element
+ * @param auth_key the key to use
+ */
+void
+RPS_sampler_elem_set (struct RPS_SamplerElement *sampler_elem,
+                      struct GNUNET_CRYPTO_AuthKey auth_key)
+{
+  sampler_elem->auth_key = auth_key;
+}
+
+
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_sampler_elem.h b/src/contrib/service/rps/gnunet-service-rps_sampler_elem.h
new file mode 100644
index 000000000..98959a88f
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_sampler_elem.h
@@ -0,0 +1,153 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_sampler_elem.h
+ * @brief sampler element implementation
+ * @author Julius Bünger
+ */
+
+#ifndef RPS_SAMPLER_ELEM_H
+#define RPS_SAMPLER_ELEM_H
+#include <inttypes.h>
+
+
+/***********************************************************************
+* WARNING: This section needs to be reviewed regarding the use of
+* functions providing (pseudo)randomness!
+***********************************************************************/
+
+/**
+ * Used to indicate whether a sampler element is empty.
+ */
+enum RPS_SamplerEmpty
+{
+  NOT_EMPTY = 0x0,
+  EMPTY = 0x1
+};
+
+/**
+ * A sampler element sampling one PeerID at a time.
+ */
+struct RPS_SamplerElement
+{
+  /**
+   * Min-wise linear permutation used by this sampler.
+   *
+   * This is an key later used by a hmac.
+   */
+  struct GNUNET_CRYPTO_AuthKey auth_key;
+
+  /**
+   * The PeerID this sampler currently samples.
+   */
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * The according hash value of this PeerID.
+   */
+  struct GNUNET_HashCode peer_id_hash;
+
+
+  /**
+   * Time of last request.
+   */
+  struct GNUNET_TIME_Absolute last_client_request;
+
+  /**
+   * Flag that indicates that we are not holding a valid PeerID right now.
+   */
+  enum RPS_SamplerEmpty is_empty;
+
+  /**
+   * 'Birth'
+   */
+  struct GNUNET_TIME_Absolute birth;
+
+  /**
+   * How many times a PeerID was put in this sampler.
+   */
+  uint32_t num_peers;
+
+  /**
+   * How many times this sampler changed the peer_id.
+   */
+  uint32_t num_change;
+
+  /**
+   * The file name this sampler element should log to
+   */
+  char *file_name;
+};
+
+
+/**
+ * Reinitialise a previously initialised sampler element.
+ *
+ * @param sampler_el The sampler element to (re-) initialise
+ */
+void
+RPS_sampler_elem_reinit (struct RPS_SamplerElement *sampler_elem);
+
+
+/**
+ * Create a sampler element and initialise it.
+ *
+ * In this implementation this means choosing an auth_key for later use in
+ * a hmac at random.
+ *
+ * @return a newly created RPS_SamplerElement which currently holds no id.
+ */
+struct RPS_SamplerElement *
+RPS_sampler_elem_create (void);
+
+
+/**
+ * Destroy a sampler element.
+ *
+ * @param sampler_elem the element to destroy
+ */
+void
+RPS_sampler_elem_destroy (struct RPS_SamplerElement *sampler_elem);
+
+
+/**
+ * Update a sampler element with a PeerID
+ *
+ * @param sampler_elem The sampler element to update
+ * @param new_ID The PeerID to update with
+ */
+void
+RPS_sampler_elem_next (struct RPS_SamplerElement *sampler_elem,
+                       const struct GNUNET_PeerIdentity *new_ID);
+
+/**
+ * Set the min-wise independent function of the given sampler element.
+ *
+ * @param sampler_elem the sampler element
+ * @param auth_key the key to use
+ */
+void
+RPS_sampler_elem_set (struct RPS_SamplerElement *sampler_elem,
+                      struct GNUNET_CRYPTO_AuthKey auth_key);
+
+
+#endif /* RPS_SAMPLER_ELEM_H */
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_view.c b/src/contrib/service/rps/gnunet-service-rps_view.c
new file mode 100644
index 000000000..d58b995a3
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_view.c
@@ -0,0 +1,294 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_view.c
+ * @brief wrapper around the "local view"
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet-service-rps_view.h"
+#include <inttypes.h>
+
+struct View
+{
+  /**
+   * Array containing the peers
+   */
+  struct GNUNET_PeerIdentity *array;
+
+  /**
+   * (Maximum) length of the view
+   */
+  uint32_t length;
+
+  /**
+   * Multipeermap containing the peers
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *mpm;
+};
+
+
+/**
+ * Create an empty view.
+ *
+ * @param len the maximum length for the view
+ * @return The newly created view
+ */
+struct View *
+View_create (uint32_t len)
+{
+  struct View *view;
+
+  view = GNUNET_new (struct View);
+  view->length = len;
+  view->array = GNUNET_new_array (len, struct GNUNET_PeerIdentity);
+  view->mpm =
+    GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO);  /* might even be
+                                                           * set to _YES */
+  return view;
+}
+
+
+/**
+ * Change length of view
+ *
+ * If size is decreased, peers with higher indices are removed.
+ *
+ * @param view The view that is changed
+ * @param len the (maximum) length for the view
+ */
+void
+View_change_len (struct View *view,
+                 uint32_t len)
+{
+  uint32_t i;
+  uint32_t *index;
+
+  if (GNUNET_CONTAINER_multipeermap_size (view->mpm) < len)
+  {   /* Simply shrink */
+      /* We might simply clear and free the left over space */
+    GNUNET_array_grow (view->array, view->length, len);
+  }
+  else /* We have to remove elements */
+  {
+    /* TODO find a way to preserve indices */
+    for (i = 0; i < len; i++)
+    {
+      index = GNUNET_CONTAINER_multipeermap_get (view->mpm, &view->array[i]);
+      GNUNET_assert (NULL != index);
+      GNUNET_free (index);
+    }
+    GNUNET_array_grow (view->array, view->length, len);
+    GNUNET_CONTAINER_multipeermap_destroy (view->mpm);
+    view->mpm = GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO);
+    for (i = 0; i < len; i++)
+    {
+      index = GNUNET_new (uint32_t);
+      *index = i;
+      GNUNET_CONTAINER_multipeermap_put (view->mpm, &view->array[i], index,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    }
+  }
+  GNUNET_assert (view->length == len);
+}
+
+
+/**
+ * Get the view as an array
+ *
+ * @param view The view of which the array representation is of interest
+ * @return the view in array representation
+ */
+const struct GNUNET_PeerIdentity *
+View_get_as_array (const struct View *view)
+{
+  return view->array;
+}
+
+
+/**
+ * Get the size of the view
+ *
+ * @param view The view of which the size should be returned
+ * @return current number of actually contained peers
+ */
+unsigned int
+View_size (const struct View *view)
+{
+  return GNUNET_CONTAINER_multipeermap_size (view->mpm);
+}
+
+
+/**
+ * Insert peer into the view
+ *
+ * @param view The view to put the peer into
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ *         GNUNET_NO if peer was not inserted
+ */
+int
+View_put (struct View *view,
+          const struct GNUNET_PeerIdentity *peer)
+{
+  uint32_t *index;
+
+  if ((view->length <= View_size (view)) ||  /* If array is 'full' */
+      (GNUNET_YES == View_contains_peer (view, peer)))
+  {
+    return GNUNET_NO;
+  }
+  else
+  {
+    index = GNUNET_new (uint32_t);
+    *index = (uint32_t) View_size (view);
+    view->array[*index] = *peer;
+    GNUNET_CONTAINER_multipeermap_put (view->mpm, peer, index,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    return GNUNET_OK;
+  }
+}
+
+
+/**
+ * Check whether view contains a peer
+ *
+ * @param view The which is checked for a peer
+ * @param peer the peer to check for
+ *
+ * @return GNUNET_OK if view contains peer
+ *         GNUNET_NO otherwise
+ */
+int
+View_contains_peer (const struct View *view,
+                    const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_contains (view->mpm, peer);
+}
+
+
+/**
+ * Remove peer from view
+ *
+ * @param view The view of which to remove the peer
+ * @param peer the peer to remove
+ *
+ * @return GNUNET_OK if view contained peer and removed it successfully
+ *         GNUNET_NO if view does not contain peer
+ */
+int
+View_remove_peer (struct View *view,
+                  const struct GNUNET_PeerIdentity *peer)
+{
+  uint32_t *index;
+  uint32_t *swap_index;
+  uint32_t last_index;
+
+  if (GNUNET_NO == View_contains_peer (view, peer))
+  {
+    return GNUNET_NO;
+  }
+  index = GNUNET_CONTAINER_multipeermap_get (view->mpm, peer);
+  GNUNET_assert (NULL != index);
+  last_index = View_size (view) - 1;
+  if (*index < last_index)
+  {   /* Fill the 'gap' in the array with the last peer */
+    view->array[*index] = view->array[last_index];
+    GNUNET_assert (GNUNET_YES == View_contains_peer (view,
+                                                     &view->array[last_index]));
+    swap_index = GNUNET_CONTAINER_multipeermap_get (view->mpm,
+                                                    &view->array[last_index]);
+    GNUNET_assert (NULL != swap_index);
+    *swap_index = *index;
+    GNUNET_free (index);
+  }
+  GNUNET_CONTAINER_multipeermap_remove_all (view->mpm, peer);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get a peer by index
+ *
+ * @param view the view of which to get the peer
+ * @param index the index of the peer to get
+ *
+ * @return peer to the corresponding index.
+ *         NULL if this index is not known
+ */
+const struct GNUNET_PeerIdentity *
+View_get_peer_by_index (const struct View *view,
+                        uint32_t index)
+{
+  if (index < GNUNET_CONTAINER_multipeermap_size (view->mpm))
+  {
+    return &view->array[index];
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+
+/**
+ * Clear the view
+ *
+ * @param view The view to clear
+ */
+void
+View_clear (struct View *view)
+{
+  for (uint32_t i = 0; 0 < View_size (view); i++)
+  {   /* Need to free indices stored at peers */
+    uint32_t *index;
+
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_contains (view->mpm,
+                                                           &view->array[i]));
+    index = GNUNET_CONTAINER_multipeermap_get (view->mpm, &view->array[i]);
+    GNUNET_assert (NULL != index);
+    GNUNET_free (index);
+    GNUNET_CONTAINER_multipeermap_remove_all (view->mpm, &view->array[i]);
+  }
+  GNUNET_assert (0 == View_size (view));
+}
+
+
+/**
+ * Destroy view.
+ *
+ * @param view the view to destroy
+ */
+void
+View_destroy (struct View *view)
+{
+  View_clear (view);
+  GNUNET_free (view->array);
+  view->array = NULL;
+  GNUNET_CONTAINER_multipeermap_destroy (view->mpm);
+  GNUNET_free (view);
+}
+
+
+/* end of gnunet-service-rps_view.c */
diff --git a/src/contrib/service/rps/gnunet-service-rps_view.h b/src/contrib/service/rps/gnunet-service-rps_view.h
new file mode 100644
index 000000000..4d42272c1
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps_view.h
@@ -0,0 +1,145 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_view.h
+ * @brief wrapper around the "local view"
+ * @author Julius Bünger
+ */
+#include "gnunet_util_lib.h"
+#include <inttypes.h>
+
+struct View;
+
+/**
+ * Create an empty view.
+ *
+ * @param len the maximum length for the view
+ * @return The newly created view
+ */
+struct View *
+View_create (unsigned int len);
+
+
+/**
+ * Change length of view
+ *
+ * If size is decreased, peers with higher indices are removed.
+ *
+ * @param view The view that is changed
+ * @param len the (maximum) length for the view
+ */
+void
+View_change_len (struct View *view,
+                 unsigned int len);
+
+/**
+ * Get the view as an array
+ *
+ * @return the view in array representation
+ */
+const struct GNUNET_PeerIdentity *
+View_get_as_array (const struct View *view);
+
+
+/**
+ * Get the size of the view
+ *
+ * @param view The view of which the size should be returned
+ * @return current number of actually contained peers
+ */
+unsigned int
+View_size (const struct View *view);
+
+
+/**
+ * Insert peer into the view
+ *
+ * @param view The view to put the peer into
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ *         GNUNET_NO if peer was not inserted
+ */
+int
+View_put (struct View *view,
+          const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * Check whether view contains a peer
+ *
+ * @param view The which is checked for a peer
+ * @param peer the peer to check for
+ *
+ * @return GNUNET_OK if view contains peer
+ *         GNUNET_NO otherwise
+ */
+int
+View_contains_peer (const struct View *view,
+                    const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * Remove peer from view
+ *
+ * @param view The view of which to remove the peer
+ * @param peer the peer to remove
+ *
+ * @return GNUNET_OK if view contained peer and removed it successfully
+ *         GNUNET_NO if view does not contain peer
+ */
+int
+View_remove_peer (struct View *view,
+                  const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * Get a peer by index
+ *
+ * @param view the view of which to get the peer
+ * @param index the index of the peer to get
+ *
+ * @return peer to the corresponding index.
+ *         NULL if this index is not known
+ */
+const struct GNUNET_PeerIdentity *
+View_get_peer_by_index (const struct View *view,
+                        uint32_t index);
+
+
+/**
+ * Clear the view
+ *
+ * @param view The view to clear
+ */
+void
+View_clear (struct View *view);
+
+
+/**
+ * Destroy view.
+ *
+ * @param view the view to destroy
+ */
+void
+View_destroy (struct View *view);
+
+/* end of gnunet-service-rps_view.h */
diff --git a/src/contrib/service/rps/profiler_rps.conf b/src/contrib/service/rps/profiler_rps.conf
new file mode 100644
index 000000000..89e5e35f2
--- /dev/null
+++ b/src/contrib/service/rps/profiler_rps.conf
@@ -0,0 +1,139 @@
+[rps]
+#PREFIX = valgrind --leak-check=full --show-leak-kinds=all --log-file=/tmp/rps/valgrind!gnunet-service-rps!%p
+#PREFIX = valgrind --log-file=/tmp/rps/valgrind!gnunet-service-rps!%p
+#PREFIX = valgrind
+UNIXPATH = $GNUNET_TMP/gnunet-service-rps.sock
+HOME = $SERVICEHOME
+# PORT = 2106
+#@UNIXONLY@ PORT = 2087
+IMMEDIATE_START = YES
+START_ON_DEMAND = NO
+NOARMBIND = YES
+#OPTIONS=-l /tmp/rps_profiler_logs/rps-[]-%Y-%m-%d.log
+
+# This is the timeinterval between the rounds
+ROUNDINTERVAL = 2 s
+FILENAME_VALID_PEERS = $GNUNET_DATA_HOME/rps/valid_peers.txt
+
+# This is the 'estimate' in the beginning.
+# This determines the size of the peers we keep in memory
+# until we receive the first estimate from NSE.
+# Keep in mind, that (networksize)^(1/3) should be enough.
+# So, 50 is enough for a network of size 50^3 = 125000
+MINSIZE = 4
+
+DESIRED_PROBABILITY = 0.75
+
+DEFICIENCY_FACTOR = 0.4
+
+
+[testbed]
+HOSTNAME = localhost
+
+# MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS = 100
+
+#OVERLAY_TOPOLOGY = CLIQUE
+
+#OVERLAY_TOPOLOGY = SCALE_FREE
+#SCALE_FREE_TOPOLOGY_CAP = 100
+#SCALE_FREE_TOPOLOGY_M = 2
+
+OVERLAY_TOPOLOGY = RANDOM
+## We take half of the links a complete graph would have, so (n * n-1)/4
+## for n = 128, this would be
+OVERLAY_RANDOM_LINKS = 4064
+
+#OVERLAY_TOPOLOGY = SMALL_WORLD
+#OVERLAY_RANDOM_LINKS = 25
+
+SETUP_TIMEOUT = 1 h
+
+[nse]
+WORKBITS = 0
+
+[nat]
+# Use addresses from the local network interfaces (including loopback, but also others)
+USE_LOCALADDR = YES
+ENABLE_UPNP = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
+
+[transport]
+PLUGINS = unix
+
+[ats]
+# Network specific inbound/outbound quotas
+UNSPECIFIED_QUOTA_IN = unlimited
+UNSPECIFIED_QUOTA_OUT = unlimited
+# LOOPBACK
+LOOPBACK_QUOTA_IN = unlimited
+LOOPBACK_QUOTA_OUT = unlimited
+# LAN
+LAN_QUOTA_IN = unlimited
+LAN_QUOTA_OUT = unlimited
+#WAN
+WAN_QUOTA_OUT = unlimited
+WAN_QUOTA_IN = unlimited
+# WLAN
+WLAN_QUOTA_IN = unlimited
+WLAN_QUOTA_OUT = unlimited
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = unlimited
+BLUETOOTH_QUOTA_OUT = unlimited
+
+[dht]
+DISABLE_TRY_CONNECT = YES
+
+[cadet]
+OPTIONS=-l /tmp/rps_profiler_logs/cadet-[]-%Y-%m-%d.log
+
+#[arm]
+#GLOBAL_POSTFIX=-l /tmp/rps_profiler_logs/other-[]-%Y-%m-%d.log
+
+#[statistics]
+#IMMEDIATE_START = NO
+#START_ON_DEMAND = NO
+
+[peerinfo]
+NO_IO = YES
+
+[hostlist]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[zonemaster]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[namecache]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[namestore]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[topology]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[vpn]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[revocation]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[gns]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[fs]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[zonemaster-monitor]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
diff --git a/src/contrib/service/rps/rps-sampler_client.c b/src/contrib/service/rps/rps-sampler_client.c
new file mode 100644
index 000000000..f6e98ce29
--- /dev/null
+++ b/src/contrib/service/rps/rps-sampler_client.c
@@ -0,0 +1,439 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/gnunet-service-rps_sampler.c
+ * @brief sampler implementation
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "rps.h"
+
+#include "rps-sampler_common.h"
+#include "gnunet-service-rps_sampler.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <math.h>
+#include <inttypes.h>
+
+#include "rps-test_util.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-sampler", __VA_ARGS__)
+
+
+// multiple 'clients'?
+
+// TODO check for overflows
+
+// TODO align message structs
+
+// hist_size_init, hist_size_max
+
+/***********************************************************************
+* WARNING: This section needs to be reviewed regarding the use of
+* functions providing (pseudo)randomness!
+***********************************************************************/
+
+// TODO care about invalid input of the caller (size 0 or less...)
+
+/**
+ * @brief Callback called each time a new peer was put into the sampler
+ *
+ * @param cls A possibly given closure
+ */
+typedef void
+(*SamplerNotifyUpdateCB) (void *cls);
+
+/**
+ * @brief Context for a callback. Contains callback and closure.
+ *
+ * Meant to be an entry in an DLL.
+ */
+struct SamplerNotifyUpdateCTX
+{
+  /**
+   * @brief The Callback to call on updates
+   */
+  SamplerNotifyUpdateCB notify_cb;
+
+  /**
+   * @brief The according closure.
+   */
+  void *cls;
+
+  /**
+   * @brief Next element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *next;
+
+  /**
+   * @brief Previous element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *prev;
+};
+
+
+/**
+ * Type of function used to differentiate between modified and not modified
+ * Sampler.
+ */
+typedef void
+(*RPS_get_peers_type) (void *cls);
+
+
+/**
+ * Get one random peer out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ */
+static void
+sampler_mod_get_rand_peer (void *cls);
+
+
+/**
+ * Closure to _get_n_rand_peers_ready_cb()
+ */
+struct RPS_SamplerRequestHandle
+{
+  /**
+   * DLL
+   */
+  struct RPS_SamplerRequestHandle *next;
+  struct RPS_SamplerRequestHandle *prev;
+
+  /**
+   * Number of peers we are waiting for.
+   */
+  uint32_t num_peers;
+
+  /**
+   * Number of peers we currently have.
+   */
+  uint32_t cur_num_peers;
+
+  /**
+   * Pointer to the array holding the ids.
+   */
+  struct GNUNET_PeerIdentity *ids;
+
+  /**
+   * Head and tail for the DLL to store the tasks for single requests
+   */
+  struct GetPeerCls *gpc_head;
+  struct GetPeerCls *gpc_tail;
+
+  /**
+   * Sampler.
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * Callback to be called when all ids are available.
+   */
+  RPS_sampler_n_rand_peers_ready_cb callback;
+
+  /**
+   * Closure given to the callback
+   */
+  void *cls;
+};
+
+
+/**
+ * Closure to _get_rand_peer_info()
+ */
+struct RPS_SamplerRequestHandleSingleInfo
+{
+  /**
+   * DLL
+   */
+  struct RPS_SamplerRequestHandleSingleInfo *next;
+  struct RPS_SamplerRequestHandleSingleInfo *prev;
+
+  /**
+   * Pointer to the id
+   */
+  struct GNUNET_PeerIdentity *id;
+
+  /**
+   * Head and tail for the DLL to store the tasks for single requests
+   */
+  struct GetPeerCls *gpc_head;
+  struct GetPeerCls *gpc_tail;
+
+  /**
+   * Sampler.
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * Callback to be called when all ids are available.
+   */
+  RPS_sampler_sinlge_info_ready_cb callback;
+
+  /**
+   * Closure given to the callback
+   */
+  void *cls;
+};
+
+
+///**
+// * Global sampler variable.
+// */
+// struct RPS_Sampler *sampler;
+
+
+/**
+ * The minimal size for the extended sampler elements.
+ */
+static size_t min_size;
+
+/**
+ * The maximal size the extended sampler elements should grow to.
+ */
+static size_t max_size;
+
+/**
+ * The size the extended sampler elements currently have.
+ */
+// static size_t extra_size;
+
+/**
+ * Inedex to the sampler element that is the next to be returned
+ */
+static uint32_t client_get_index;
+
+
+/**
+ * Initialise a modified tuple of sampler elements.
+ *
+ * @param init_size the size the sampler is initialised with
+ * @param max_round_interval maximum time a round takes
+ * @return a handle to a sampler that consists of sampler elements.
+ */
+struct RPS_Sampler *
+RPS_sampler_mod_init (size_t init_size,
+                      struct GNUNET_TIME_Relative max_round_interval)
+{
+  struct RPS_Sampler *sampler;
+
+  /* Initialise context around extended sampler */
+  min_size = 10; // TODO make input to _samplers_init()
+  max_size = 1000; // TODO make input to _samplers_init()
+
+  sampler = GNUNET_new (struct RPS_Sampler);
+  sampler->max_round_interval = max_round_interval;
+  sampler->get_peers = sampler_mod_get_rand_peer;
+  // sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
+  // GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
+
+  client_get_index = 0;
+
+  // GNUNET_assert (init_size == sampler->sampler_size);
+
+  RPS_sampler_resize (sampler, init_size);
+
+  return sampler;
+}
+
+
+// /**
+//  * @brief Compute the probability that we already observed all peers from a
+//  * biased stream of peer ids.
+//  *
+//  * Deficiency factor:
+//  * As introduced by Brahms: Factor between the number of unique ids in a
+//  * truly random stream and number of unique ids in the gossip stream.
+//  *
+//  * @param num_peers_estim The estimated number of peers in the network
+//  * @param num_peers_observed The number of peers the given element has observed
+//  * @param deficiency_factor A factor that catches the 'bias' of a random stream
+//  * of peer ids
+//  *
+//  * @return The estimated probability
+//  */
+// static double
+// prob_observed_n_peers (uint32_t num_peers_estim,
+//                        uint32_t num_peers_observed,
+//                        double deficiency_factor)
+// {
+//   uint32_t num_peers = num_peers_estim * (1 / deficiency_factor);
+//   uint64_t sum = 0;
+// 
+//   for (uint32_t i = 0; i < num_peers; i++)
+//   {
+//     uint64_t a = pow (-1, num_peers - i);
+//     uint64_t b = binom (num_peers, i);
+//     uint64_t c = pow (i, num_peers_observed);
+//     sum += a * b * c;
+//   }
+// 
+//   return sum / (double) pow (num_peers, num_peers_observed);
+// }
+
+
+/**
+ * Get one random peer out of the sampled peers.
+ *
+ * This reinitialises the queried sampler element.
+ */
+static void
+sampler_mod_get_rand_peer (void *cls)
+{
+  struct GetPeerCls *gpc = cls;
+  struct RPS_SamplerElement *s_elem;
+  struct GNUNET_TIME_Relative last_request_diff;
+  struct RPS_Sampler *sampler;
+  double prob_observed_n;
+  uint32_t num_observed;
+
+  gpc->get_peer_task = NULL;
+  gpc->notify_ctx = NULL;
+  GNUNET_assert ((NULL != gpc->req_handle) ||
+                 (NULL != gpc->req_single_info_handle));
+  if (NULL != gpc->req_handle)
+    sampler = gpc->req_handle->sampler;
+  else
+    sampler = gpc->req_single_info_handle->sampler;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Single peer was requested\n");
+
+  /* Cycle the #client_get_index one step further */
+  client_get_index = (client_get_index + 1) % sampler->sampler_size;
+
+  s_elem = sampler->sampler_elements[client_get_index];
+  *gpc->id = s_elem->peer_id;
+  GNUNET_assert (NULL != s_elem);
+
+  if (EMPTY == s_elem->is_empty)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Sampler_mod element empty, rescheduling.\n");
+    GNUNET_assert (NULL == gpc->notify_ctx);
+    gpc->notify_ctx =
+      sampler_notify_on_update (sampler,
+                                &sampler_mod_get_rand_peer,
+                                gpc);
+    return;
+  }
+
+  /* Check whether we may use this sampler to give it back to the client */
+  if (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us !=
+      s_elem->last_client_request.abs_value_us)
+  {
+    // TODO remove this condition at least for the client sampler
+    last_request_diff =
+      GNUNET_TIME_absolute_get_difference (s_elem->last_client_request,
+                                           GNUNET_TIME_absolute_get ());
+    /* We're not going to give it back now if it was
+     * already requested by a client this round */
+    if (last_request_diff.rel_value_us <
+        sampler->max_round_interval.rel_value_us)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Last client request on this sampler was less than max round interval ago -- scheduling for later\n");
+      ///* How many time remains untile the next round has started? */
+      // inv_last_request_diff =
+      //  GNUNET_TIME_absolute_get_difference (last_request_diff,
+      //                                       sampler->max_round_interval);
+      // add a little delay
+      /* Schedule it one round later */
+      GNUNET_assert (NULL == gpc->notify_ctx);
+      gpc->notify_ctx =
+        sampler_notify_on_update (sampler,
+                                  &sampler_mod_get_rand_peer,
+                                  gpc);
+      return;
+    }
+  }
+  if (2 > s_elem->num_peers)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "This s_elem saw less than two peers -- scheduling for later\n");
+    GNUNET_assert (NULL == gpc->notify_ctx);
+    gpc->notify_ctx =
+      sampler_notify_on_update (sampler,
+                                &sampler_mod_get_rand_peer,
+                                gpc);
+    return;
+  }
+  /* compute probability */
+  /* FIXME: Currently disabled due to numerical limitations */
+  prob_observed_n = 0; // Inititialise to some value
+  // prob_observed_n = prob_observed_n_peers (sampler->num_peers_estim,
+  //                                         s_elem->num_peers,
+  //                                         sampler->deficiency_factor);
+  // LOG (GNUNET_ERROR_TYPE_DEBUG,
+  //    "Computed sample - prob %f, %" PRIu32 " peers, n: %" PRIu32 ", roh: %f\n",
+  //    prob_observed_n,
+  //    s_elem->num_peers,
+  //    sampler->num_peers_estim,
+  //    sampler->deficiency_factor);
+  ///* check if probability is above desired */
+  // if (prob_observed_n < sampler->desired_probability)
+  // {
+  //  LOG (GNUNET_ERROR_TYPE_DEBUG,
+  //      "Probability of having observed all peers (%f) too small ( < %f).\n",
+  //      prob_observed_n,
+  //      sampler->desired_probability);
+  //  GNUNET_assert (NULL == gpc->notify_ctx);
+  //  gpc->notify_ctx =
+  //    sampler_notify_on_update (sampler,
+  //                              &sampler_mod_get_rand_peer,
+  //                              gpc);
+  //  return;
+  // }
+  /* More reasons to wait could be added here */
+
+//  GNUNET_STATISTICS_set (stats,
+//                         "# client sampler element input",
+//                         s_elem->num_peers,
+//                         GNUNET_NO);
+//  GNUNET_STATISTICS_set (stats,
+//                         "# client sampler element change",
+//                         s_elem->num_change,
+//                         GNUNET_NO);
+
+  num_observed = s_elem->num_peers;
+  RPS_sampler_elem_reinit (s_elem);
+  s_elem->last_client_request = GNUNET_TIME_absolute_get ();
+
+  if (NULL != gpc->req_handle)
+  {
+    GNUNET_CONTAINER_DLL_remove (gpc->req_handle->gpc_head,
+                                 gpc->req_handle->gpc_tail,
+                                 gpc);
+  }
+  else
+  {
+    GNUNET_CONTAINER_DLL_remove (gpc->req_single_info_handle->gpc_head,
+                                 gpc->req_single_info_handle->gpc_tail,
+                                 gpc);
+  }
+  gpc->cont (gpc->cont_cls, gpc->id, prob_observed_n, num_observed);
+  GNUNET_free (gpc);
+}
+
+
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/rps-sampler_client.h b/src/contrib/service/rps/rps-sampler_client.h
new file mode 100644
index 000000000..7a674371d
--- /dev/null
+++ b/src/contrib/service/rps/rps-sampler_client.h
@@ -0,0 +1,156 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps-sampler_client.h
+ * @brief client sampler implementation
+ * @author Julius Bünger
+ */
+
+#ifndef RPS_SAMPLER_CLIENT_H
+#define RPS_SAMPLER_CLIENT_H
+#include <inttypes.h>
+#include "rps-sampler_common.h"
+
+
+/**
+ * A sampler sampling a stream of PeerIDs.
+ */
+struct RPS_Sampler;
+
+/**
+ * A handle to cancel a request.
+ */
+struct RPS_SamplerRequestHandle;
+
+/**
+ * Closure to _get_rand_peer_info()
+ */
+struct RPS_SamplerRequestHandleSingleInfo;
+
+
+/**
+ * Get the size of the sampler.
+ *
+ * @param sampler the sampler to return the size of.
+ * @return the size of the sampler
+ */
+unsigned int
+RPS_sampler_get_size (struct RPS_Sampler *sampler);
+
+
+/**
+ * Grow or shrink the size of the sampler.
+ *
+ * @param sampler the sampler to resize.
+ * @param new_size the new size of the sampler (not 0)
+ */
+void
+RPS_sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size);
+
+
+/**
+ * Initialise a modified tuple of sampler elements.
+ *
+ * @param init_size the size the sampler is initialised with
+ * @param max_round_interval maximum time a round takes
+ * @return a handle to a sampler that consists of sampler elements.
+ */
+struct RPS_Sampler *
+RPS_sampler_mod_init (size_t init_size,
+                      struct GNUNET_TIME_Relative max_round_interval);
+
+
+/**
+ * Update every sampler element of this sampler with given peer
+ *
+ * @param sampler the sampler to update.
+ * @param id the PeerID that is put in the sampler
+ */
+void
+RPS_sampler_update (struct RPS_Sampler *sampler,
+                    const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Reinitialise all previously initialised sampler elements with the given
+ * value.
+ *
+ * Used to get rid of a PeerID.
+ *
+ * @param sampler the sampler to reinitialise a sampler in.
+ * @param id the id of the samplers to update.
+ */
+void
+RPS_sampler_reinitialise_by_value (struct RPS_Sampler *sampler,
+                                   const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Get n random peers out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ * Random with or without consumption?
+ *
+ * @param sampler the sampler to get peers from.
+ * @param cb callback that will be called once the ids are ready.
+ * @param cls closure given to @a cb
+ * @param num_peers the number of peers requested
+ */
+struct RPS_SamplerRequestHandle *
+RPS_sampler_get_n_rand_peers (struct RPS_Sampler *sampler,
+                              uint32_t num_peers,
+                              RPS_sampler_n_rand_peers_ready_cb cb,
+                              void *cls);
+
+
+/**
+ * Cancel a request issued through #RPS_sampler_n_rand_peers_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle);
+
+
+/**
+ * Counts how many Samplers currently hold a given PeerID.
+ *
+ * @param sampler the sampler to count ids in.
+ * @param id the PeerID to count.
+ *
+ * @return the number of occurrences of id.
+ */
+uint32_t
+RPS_sampler_count_id (struct RPS_Sampler *sampler,
+                      const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Cleans the samplers.
+ *
+ * @param sampler the sampler to destroy.
+ */
+void
+RPS_sampler_destroy (struct RPS_Sampler *sampler);
+
+#endif /* RPS_SAMPLER_CLIENT_H */
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/rps-sampler_common.c b/src/contrib/service/rps/rps-sampler_common.c
new file mode 100644
index 000000000..e3fb79501
--- /dev/null
+++ b/src/contrib/service/rps/rps-sampler_common.c
@@ -0,0 +1,742 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps-sampler_common.c
+ * @brief Code common to client and service sampler
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+
+#include "rps-sampler_common.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <math.h>
+#include <inttypes.h>
+
+#include "rps-test_util.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-sampler_common", __VA_ARGS__)
+
+/**
+ * @brief Context for a callback. Contains callback and closure.
+ *
+ * Meant to be an entry in an DLL.
+ */
+struct SamplerNotifyUpdateCTX
+{
+  /**
+   * @brief The Callback to call on updates
+   */
+  SamplerNotifyUpdateCB notify_cb;
+
+  /**
+   * @brief The according closure.
+   */
+  void *cls;
+
+  /**
+   * @brief Next element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *next;
+
+  /**
+   * @brief Previous element in DLL.
+   */
+  struct SamplerNotifyUpdateCTX *prev;
+};
+
+
+/**
+ * Closure to _get_n_rand_peers_ready_cb()
+ */
+struct RPS_SamplerRequestHandle
+{
+  /**
+   * DLL
+   */
+  struct RPS_SamplerRequestHandle *next;
+  struct RPS_SamplerRequestHandle *prev;
+
+  /**
+   * Number of peers we are waiting for.
+   */
+  uint32_t num_peers;
+
+  /**
+   * Number of peers we currently have.
+   */
+  uint32_t cur_num_peers;
+
+  /**
+   * Pointer to the array holding the ids.
+   */
+  struct GNUNET_PeerIdentity *ids;
+
+  /**
+   * Head and tail for the DLL to store the tasks for single requests
+   */
+  struct GetPeerCls *gpc_head;
+  struct GetPeerCls *gpc_tail;
+
+  /**
+   * Sampler.
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * Callback to be called when all ids are available.
+   */
+  RPS_sampler_n_rand_peers_ready_cb callback;
+
+  /**
+   * Closure given to the callback
+   */
+  void *cls;
+};
+
+
+/**
+ * Closure to _get_rand_peer_info()
+ */
+struct RPS_SamplerRequestHandleSingleInfo
+{
+  /**
+   * DLL
+   */
+  struct RPS_SamplerRequestHandleSingleInfo *next;
+  struct RPS_SamplerRequestHandleSingleInfo *prev;
+
+  /**
+   * Pointer to the id
+   */
+  struct GNUNET_PeerIdentity *id;
+
+  /**
+   * Head and tail for the DLL to store the tasks for single requests
+   */
+  struct GetPeerCls *gpc_head;
+  struct GetPeerCls *gpc_tail;
+
+  /**
+   * Sampler.
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * Callback to be called when all ids are available.
+   */
+  RPS_sampler_sinlge_info_ready_cb callback;
+
+  /**
+   * Closure given to the callback
+   */
+  void *cls;
+};
+
+
+/**
+ * @brief Update the current estimate of the network size stored at the sampler
+ *
+ * Used for computing the condition when to return elements to the client
+ *
+ * Only used/useful with the client sampler
+ * (Maybe move to rps-sampler_client.{h|c} ?)
+ *
+ * @param sampler The sampler to update
+ * @param num_peers The estimated value
+ */
+void
+RPS_sampler_update_with_nw_size (struct RPS_Sampler *sampler,
+                                 uint32_t num_peers)
+{
+  sampler->num_peers_estim = num_peers;
+}
+
+
+/**
+ * @brief Set the probability that is needed at least with what a sampler
+ * element has to have observed all elements from the network.
+ *
+ * Only used/useful with the client sampler
+ * (Maybe move to rps-sampler_client.{h|c} ?)
+ *
+ * @param sampler
+ * @param desired_probability
+ */
+void
+RPS_sampler_set_desired_probability (struct RPS_Sampler *sampler,
+                                     double desired_probability)
+{
+  sampler->desired_probability = desired_probability;
+}
+
+
+void
+RPS_sampler_set_deficiency_factor (struct RPS_Sampler *sampler,
+                                   double deficiency_factor)
+{
+  sampler->deficiency_factor = deficiency_factor;
+}
+
+
+/**
+ * @brief Add a callback that will be called when the next peer is inserted
+ * into the sampler
+ *
+ * @param sampler The sampler on which update it will be called
+ * @param notify_cb The callback
+ * @param cls Closure given to the callback
+ *
+ * @return The context containing callback and closure
+ */
+struct SamplerNotifyUpdateCTX *
+sampler_notify_on_update (struct RPS_Sampler *sampler,
+                          SamplerNotifyUpdateCB notify_cb,
+                          void *cls)
+{
+  struct SamplerNotifyUpdateCTX *notify_ctx;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Inserting new context for notification\n");
+  notify_ctx = GNUNET_new (struct SamplerNotifyUpdateCTX);
+  notify_ctx->notify_cb = notify_cb;
+  notify_ctx->cls = cls;
+  GNUNET_CONTAINER_DLL_insert (sampler->notify_ctx_head,
+                               sampler->notify_ctx_tail,
+                               notify_ctx);
+  return notify_ctx;
+}
+
+
+/**
+ * Get the size of the sampler.
+ *
+ * @param sampler the sampler to return the size of.
+ * @return the size of the sampler
+ */
+unsigned int
+RPS_sampler_get_size (struct RPS_Sampler *sampler)
+{
+  return sampler->sampler_size;
+}
+
+
+/**
+ * @brief Notify about update of the sampler.
+ *
+ * Call the callbacks that are waiting for notification on updates to the
+ * sampler.
+ *
+ * @param sampler The sampler the updates are waiting for
+ */
+static void
+notify_update (struct RPS_Sampler *sampler)
+{
+  struct SamplerNotifyUpdateCTX *tmp_notify_head;
+  struct SamplerNotifyUpdateCTX *tmp_notify_tail;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Calling callbacks waiting for update notification.\n");
+  tmp_notify_head = sampler->notify_ctx_head;
+  tmp_notify_tail = sampler->notify_ctx_tail;
+  sampler->notify_ctx_head = NULL;
+  sampler->notify_ctx_tail = NULL;
+  for (struct SamplerNotifyUpdateCTX *notify_iter = tmp_notify_head;
+       NULL != tmp_notify_head;
+       notify_iter = tmp_notify_head)
+  {
+    GNUNET_assert (NULL != notify_iter->notify_cb);
+    GNUNET_CONTAINER_DLL_remove (tmp_notify_head,
+                                 tmp_notify_tail,
+                                 notify_iter);
+    notify_iter->notify_cb (notify_iter->cls);
+    GNUNET_free (notify_iter);
+  }
+}
+
+
+/**
+ * Update every sampler element of this sampler with given peer
+ *
+ * @param sampler the sampler to update.
+ * @param id the PeerID that is put in the sampler
+ */
+void
+RPS_sampler_update (struct RPS_Sampler *sampler,
+                    const struct GNUNET_PeerIdentity *id)
+{
+  for (uint32_t i = 0; i < sampler->sampler_size; i++)
+  {
+    RPS_sampler_elem_next (sampler->sampler_elements[i],
+                           id);
+  }
+  notify_update (sampler);
+}
+
+
+/**
+ * Reinitialise all previously initialised sampler elements with the given value.
+ *
+ * Used to get rid of a PeerID.
+ *
+ * FIXME: This should also consider currently pending requests
+ *        (Pending requests already collect peerids. As long as not all
+ *        requested IDs have been collected, they are kept.
+ *        Ideally, the @p id should be removed from all pending requests. This
+ *        seems quite complicated.)
+ *
+ * @param sampler the sampler to reinitialise a sampler element in.
+ * @param id the id of the sampler elements to update.
+ */
+void
+RPS_sampler_reinitialise_by_value (struct RPS_Sampler *sampler,
+                                   const struct GNUNET_PeerIdentity *id)
+{
+  uint32_t i;
+
+  for (i = 0; i < sampler->sampler_size; i++)
+  {
+    if (0 == GNUNET_memcmp (id,
+                            &(sampler->sampler_elements[i]->peer_id)))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Reinitialising sampler\n");
+      RPS_sampler_elem_reinit (sampler->sampler_elements[i]);
+    }
+  }
+}
+
+
+/**
+ * Counts how many Samplers currently hold a given PeerID.
+ *
+ * @param sampler the sampler to count ids in.
+ * @param id the PeerID to count.
+ *
+ * @return the number of occurrences of id.
+ */
+uint32_t
+RPS_sampler_count_id (struct RPS_Sampler *sampler,
+                      const struct GNUNET_PeerIdentity *id)
+{
+  uint32_t count;
+  uint32_t i;
+
+  count = 0;
+  for (i = 0; i < sampler->sampler_size; i++)
+  {
+    if ((0 == GNUNET_memcmp (&sampler->sampler_elements[i]->peer_id, id))
+        && (EMPTY != sampler->sampler_elements[i]->is_empty) )
+      count++;
+  }
+  return count;
+}
+
+
+/**
+ * Grow or shrink the size of the sampler.
+ *
+ * @param sampler the sampler to resize.
+ * @param new_size the new size of the sampler
+ */
+static void
+sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size)
+{
+  unsigned int old_size;
+  uint32_t i;
+
+  // TODO check min and max size
+
+  old_size = sampler->sampler_size;
+
+  if (old_size > new_size)
+  {   /* Shrinking */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Shrinking sampler %d -> %d\n",
+         old_size,
+         new_size);
+
+    for (i = new_size; i < old_size; i++)
+    {
+      RPS_sampler_elem_destroy (sampler->sampler_elements[i]);
+    }
+
+    GNUNET_array_grow (sampler->sampler_elements,
+                       sampler->sampler_size,
+                       new_size);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "sampler->sampler_elements now points to %p\n",
+         sampler->sampler_elements);
+  }
+  else if (old_size < new_size)
+  {   /* Growing */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Growing sampler %d -> %d\n",
+         old_size,
+         new_size);
+
+    GNUNET_array_grow (sampler->sampler_elements,
+                       sampler->sampler_size,
+                       new_size);
+
+    for (i = old_size; i < new_size; i++)
+    {     /* Add new sampler elements */
+      sampler->sampler_elements[i] = RPS_sampler_elem_create ();
+    }
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Size remains the same -- nothing to do\n");
+    return;
+  }
+
+  GNUNET_assert (sampler->sampler_size == new_size);
+}
+
+
+/**
+ * Grow or shrink the size of the sampler.
+ *
+ * @param sampler the sampler to resize.
+ * @param new_size the new size of the sampler
+ */
+void
+RPS_sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size)
+{
+  GNUNET_assert (0 < new_size);
+  sampler_resize (sampler, new_size);
+}
+
+
+/**
+ * Empty the sampler.
+ *
+ * @param sampler the sampler to empty.
+ */
+static void
+sampler_empty (struct RPS_Sampler *sampler)
+{
+  sampler_resize (sampler, 0);
+}
+
+
+/**
+ * Callback to _get_rand_peer() used by _get_n_rand_peers().
+ *
+ * Implements #RPS_sampler_rand_peer_ready_cont
+ *
+ * Checks whether all n peers are available. If they are,
+ * give those back.
+ * @param cls Closure
+ * @param id Peer ID
+ * @param probability The probability with which this sampler has seen all ids
+ * @param num_observed How many ids this sampler has observed
+ */
+static void
+check_n_peers_ready (void *cls,
+                     const struct GNUNET_PeerIdentity *id,
+                     double probability,
+                     uint32_t num_observed)
+{
+  struct RPS_SamplerRequestHandle *req_handle = cls;
+
+  (void) id;
+  RPS_sampler_n_rand_peers_ready_cb tmp_cb;
+  struct GNUNET_PeerIdentity *peers;
+  uint32_t num_peers;
+  void *cb_cls;
+  (void) probability;
+  (void) num_observed;
+
+  req_handle->cur_num_peers++;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got %" PRIX32 ". of %" PRIX32 " peers\n",
+       req_handle->cur_num_peers, req_handle->num_peers);
+
+  if (req_handle->num_peers == req_handle->cur_num_peers)
+  {   /* All peers are ready -- return those to the client */
+    GNUNET_assert (NULL != req_handle->callback);
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "returning %" PRIX32 " peers to the client\n",
+         req_handle->num_peers);
+
+    /* Copy pointers and peers temporarily as they
+    * might be deleted from within the callback */
+    tmp_cb = req_handle->callback;
+    num_peers = req_handle->num_peers;
+    peers = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
+    GNUNET_memcpy (peers,
+                   req_handle->ids,
+                   num_peers * sizeof(struct GNUNET_PeerIdentity));
+    cb_cls = req_handle->cls;
+    RPS_sampler_request_cancel (req_handle);
+    req_handle = NULL;
+    tmp_cb (peers, num_peers, cb_cls);
+    GNUNET_free (peers);
+  }
+}
+
+
+/**
+ * Callback to _get_rand_peer() used by _get_rand_peer_info().
+ *
+ * Implements #RPS_sampler_rand_peer_ready_cont
+ *
+ * @param cls Closure
+ * @param id Peer ID
+ * @param probability The probability with which this sampler has seen all ids
+ * @param num_observed How many ids this sampler has observed
+ */
+static void
+check_peer_info_ready (void *cls,
+                       const struct GNUNET_PeerIdentity *id,
+                       double probability,
+                       uint32_t num_observed)
+{
+  struct RPS_SamplerRequestHandleSingleInfo *req_handle = cls;
+
+  (void) id;
+  RPS_sampler_sinlge_info_ready_cb tmp_cb;
+  struct GNUNET_PeerIdentity *peer;
+  void *cb_cls;
+  (void) probability;
+  (void) num_observed;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got single peer with additional info\n");
+
+  GNUNET_assert (NULL != req_handle->callback);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "returning single peer with info to the client\n");
+
+  /* Copy pointers and peers temporarily as they
+  * might be deleted from within the callback */
+  tmp_cb = req_handle->callback;
+  peer = GNUNET_new (struct GNUNET_PeerIdentity);
+  GNUNET_memcpy (peer,
+                 req_handle->id,
+                 sizeof(struct GNUNET_PeerIdentity));
+  cb_cls = req_handle->cls;
+  RPS_sampler_request_single_info_cancel (req_handle);
+  req_handle = NULL;
+  tmp_cb (peer, cb_cls, probability, num_observed);
+  GNUNET_free (peer);
+}
+
+
+struct RPS_SamplerRequestHandle *
+RPS_sampler_get_n_rand_peers (struct RPS_Sampler *sampler,
+                              uint32_t num_peers,
+                              RPS_sampler_n_rand_peers_ready_cb cb,
+                              void *cls)
+{
+  uint32_t i;
+  struct RPS_SamplerRequestHandle *req_handle;
+  struct GetPeerCls *gpc;
+
+  GNUNET_assert (0 != sampler->sampler_size);
+  if (0 == num_peers)
+    return NULL;
+
+  // TODO check if we have too much (distinct) sampled peers
+  req_handle = GNUNET_new (struct RPS_SamplerRequestHandle);
+  req_handle->num_peers = num_peers;
+  req_handle->cur_num_peers = 0;
+  req_handle->ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
+  req_handle->sampler = sampler;
+  req_handle->callback = cb;
+  req_handle->cls = cls;
+  GNUNET_CONTAINER_DLL_insert (sampler->req_handle_head,
+                               sampler->req_handle_tail,
+                               req_handle);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Scheduling requests for %" PRIu32 " peers\n", num_peers);
+
+  for (i = 0; i < num_peers; i++)
+  {
+    gpc = GNUNET_new (struct GetPeerCls);
+    gpc->req_handle = req_handle;
+    gpc->req_single_info_handle = NULL;
+    gpc->cont = check_n_peers_ready;
+    gpc->cont_cls = req_handle;
+    gpc->id = &req_handle->ids[i];
+
+    GNUNET_CONTAINER_DLL_insert (req_handle->gpc_head,
+                                 req_handle->gpc_tail,
+                                 gpc);
+    // maybe add a little delay
+    gpc->get_peer_task = GNUNET_SCHEDULER_add_now (sampler->get_peers,
+                                                   gpc);
+  }
+  return req_handle;
+}
+
+
+/**
+ * Get one random peer with additional information.
+ *
+ * @param sampler the sampler to get peers from.
+ * @param cb callback that will be called once the ids are ready.
+ * @param cls closure given to @a cb
+ */
+struct RPS_SamplerRequestHandleSingleInfo *
+RPS_sampler_get_rand_peer_info (struct RPS_Sampler *sampler,
+                                RPS_sampler_sinlge_info_ready_cb cb,
+                                void *cls)
+{
+  struct RPS_SamplerRequestHandleSingleInfo *req_handle;
+  struct GetPeerCls *gpc;
+
+  GNUNET_assert (0 != sampler->sampler_size);
+
+  // TODO check if we have too much (distinct) sampled peers
+  req_handle = GNUNET_new (struct RPS_SamplerRequestHandleSingleInfo);
+  req_handle->id = GNUNET_malloc (sizeof(struct GNUNET_PeerIdentity));
+  req_handle->sampler = sampler;
+  req_handle->callback = cb;
+  req_handle->cls = cls;
+  GNUNET_CONTAINER_DLL_insert (sampler->req_handle_single_head,
+                               sampler->req_handle_single_tail,
+                               req_handle);
+
+  gpc = GNUNET_new (struct GetPeerCls);
+  gpc->req_handle = NULL;
+  gpc->req_single_info_handle = req_handle;
+  gpc->cont = check_peer_info_ready;
+  gpc->cont_cls = req_handle;
+  gpc->id = req_handle->id;
+
+  GNUNET_CONTAINER_DLL_insert (req_handle->gpc_head,
+                               req_handle->gpc_tail,
+                               gpc);
+  // maybe add a little delay
+  gpc->get_peer_task = GNUNET_SCHEDULER_add_now (sampler->get_peers,
+                                                 gpc);
+  return req_handle;
+}
+
+
+/**
+ * Cancel a request issued through #RPS_sampler_n_rand_peers_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle)
+{
+  struct GetPeerCls *i;
+
+  while (NULL != (i = req_handle->gpc_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (req_handle->gpc_head,
+                                 req_handle->gpc_tail,
+                                 i);
+    if (NULL != i->get_peer_task)
+    {
+      GNUNET_SCHEDULER_cancel (i->get_peer_task);
+    }
+    if (NULL != i->notify_ctx)
+    {
+      GNUNET_CONTAINER_DLL_remove (req_handle->sampler->notify_ctx_head,
+                                   req_handle->sampler->notify_ctx_tail,
+                                   i->notify_ctx);
+      GNUNET_free (i->notify_ctx);
+      i->notify_ctx = NULL;
+    }
+    GNUNET_free (i);
+  }
+  GNUNET_free (req_handle->ids);
+  req_handle->ids = NULL;
+  GNUNET_CONTAINER_DLL_remove (req_handle->sampler->req_handle_head,
+                               req_handle->sampler->req_handle_tail,
+                               req_handle);
+  GNUNET_free (req_handle);
+}
+
+
+/**
+ * Cancel a request issued through #RPS_sampler_sinlge_info_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_single_info_cancel (
+  struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle)
+{
+  struct GetPeerCls *i;
+
+  while (NULL != (i = req_single_info_handle->gpc_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (req_single_info_handle->gpc_head,
+                                 req_single_info_handle->gpc_tail,
+                                 i);
+    if (NULL != i->get_peer_task)
+    {
+      GNUNET_SCHEDULER_cancel (i->get_peer_task);
+    }
+    if (NULL != i->notify_ctx)
+    {
+      GNUNET_CONTAINER_DLL_remove (
+        req_single_info_handle->sampler->notify_ctx_head,
+        req_single_info_handle->sampler->
+        notify_ctx_tail,
+        i->notify_ctx);
+      GNUNET_free (i->notify_ctx);
+      i->notify_ctx = NULL;
+    }
+    GNUNET_free (i);
+  }
+  GNUNET_free (req_single_info_handle->id);
+  req_single_info_handle->id = NULL;
+  GNUNET_CONTAINER_DLL_remove (
+    req_single_info_handle->sampler->req_handle_single_head,
+    req_single_info_handle->sampler->
+    req_handle_single_tail,
+    req_single_info_handle);
+  GNUNET_free (req_single_info_handle);
+}
+
+
+/**
+ * Cleans the sampler.
+ */
+void
+RPS_sampler_destroy (struct RPS_Sampler *sampler)
+{
+  if (NULL != sampler->req_handle_head)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "There are still pending requests. Going to remove them.\n");
+    while (NULL != sampler->req_handle_head)
+    {
+      RPS_sampler_request_cancel (sampler->req_handle_head);
+    }
+  }
+  sampler_empty (sampler);
+  GNUNET_free (sampler);
+}
+
+
+/* end of rps-sampler_common.c */
diff --git a/src/contrib/service/rps/rps-sampler_common.h b/src/contrib/service/rps/rps-sampler_common.h
new file mode 100644
index 000000000..94727028a
--- /dev/null
+++ b/src/contrib/service/rps/rps-sampler_common.h
@@ -0,0 +1,389 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps-sampler_common.h
+ * @brief Code common to client and service sampler
+ * @author Julius Bünger
+ */
+
+#ifndef RPS_SAMPLER_COMMON_H
+#define RPS_SAMPLER_COMMON_H
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <math.h>
+#include <inttypes.h>
+
+#include "rps-test_util.h"
+
+
+/**
+ * Callback that is called from _get_rand_peer() when the PeerID is ready.
+ *
+ * @param cls the closure given alongside this function.
+ * @param id the PeerID that was returned
+ * @param probability The probability with which this sampler has seen all ids
+ * @param num_observed How many ids this sampler has observed
+ */
+typedef void
+(*RPS_sampler_rand_peer_ready_cont) (void *cls,
+                                     const struct GNUNET_PeerIdentity *id,
+                                     double probability,
+                                     uint32_t num_observed);
+
+
+/**
+ * Type of function used to differentiate between modified and not modified
+ * Sampler.
+ */
+typedef void
+(*RPS_get_peers_type) (void *cls);
+
+
+/**
+ * Callback that is called from _get_n_rand_peers() when the PeerIDs are ready.
+ *
+ * @param cls the closure given alongside this function.
+ * @param ids the PeerIDs that were returned
+ *        to be freed
+ */
+typedef void
+(*RPS_sampler_n_rand_peers_ready_cb) (const struct GNUNET_PeerIdentity *ids,
+                                      uint32_t num_peers,
+                                      void *cls);
+
+
+/**
+ * Callback that is called from _get_n_rand_peers() when the PeerIDs are ready.
+ *
+ * @param cls the closure given alongside this function.
+ * @param probability Probability with which all IDs have been observed
+ * @param num_observed Number of observed IDs
+ * @param ids the PeerIDs that were returned
+ *        to be freed
+ */
+typedef void
+(*RPS_sampler_sinlge_info_ready_cb) (const struct GNUNET_PeerIdentity *ids,
+                                     void *cls,
+                                     double probability,
+                                     uint32_t num_observed);
+
+
+/**
+ * @brief Callback called each time a new peer was put into the sampler
+ *
+ * @param cls A possibly given closure
+ */
+typedef void
+(*SamplerNotifyUpdateCB) (void *cls);
+
+
+/**
+ * Closure for #sampler_mod_get_rand_peer() and #sampler_get_rand_peer
+ */
+struct GetPeerCls
+{
+  /**
+   * DLL
+   */
+  struct GetPeerCls *next;
+  struct GetPeerCls *prev;
+
+  /**
+   * The #RPS_SamplerRequestHandle this single request belongs to.
+   */
+  struct RPS_SamplerRequestHandle *req_handle;
+
+  /**
+   * The #RPS_SamplerRequestHandleSingleInfo this single request belongs to.
+   */
+  struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle;
+
+  /**
+   * The task for this function.
+   */
+  struct GNUNET_SCHEDULER_Task *get_peer_task;
+
+  /**
+   * @brief Context to the given callback.
+   */
+  struct SamplerNotifyUpdateCTX *notify_ctx;
+
+  /**
+   * The callback
+   */
+  RPS_sampler_rand_peer_ready_cont cont;
+
+  /**
+   * The closure to the callback @e cont
+   */
+  void *cont_cls;
+
+  /**
+   * The address of the id to be stored at
+   */
+  struct GNUNET_PeerIdentity *id;
+};
+
+
+/**
+ * Sampler with its own array of SamplerElements
+ */
+struct RPS_Sampler
+{
+  /**
+   * Number of sampler elements we hold.
+   */
+  unsigned int sampler_size;
+  // size_t size;
+
+  /**
+   * All sampler elements in one array.
+   */
+  struct RPS_SamplerElement **sampler_elements;
+
+  /**
+   * Maximum time a round takes
+   *
+   * Used in the context of RPS
+   */
+  struct GNUNET_TIME_Relative max_round_interval;
+
+  /**
+   * @brief The estimated total number of peers in the network
+   */
+  uint32_t num_peers_estim;
+
+  /**
+   * @brief The desired probability with which we want to have observed all
+   * peers.
+   */
+  double desired_probability;
+
+  /**
+   * @brief A factor that catches the 'bias' of a random stream of peer ids.
+   *
+   * As introduced by Brahms: Factor between the number of unique ids in a
+   * truly random stream and number of unique ids in the gossip stream.
+   */
+  double deficiency_factor;
+
+  /**
+   * Stores the function to return peers. Which one it is depends on whether
+   * the Sampler is the modified one or not.
+   */
+  RPS_get_peers_type get_peers;
+
+  /**
+   * Head and tail for the DLL to store the #RPS_SamplerRequestHandle
+   */
+  struct RPS_SamplerRequestHandle *req_handle_head;
+  struct RPS_SamplerRequestHandle *req_handle_tail;
+
+  /**
+   * Head and tail for the DLL to store the #RPS_SamplerRequestHandleSingleInfo
+   */
+  struct RPS_SamplerRequestHandleSingleInfo *req_handle_single_head;
+  struct RPS_SamplerRequestHandleSingleInfo *req_handle_single_tail;
+
+  struct SamplerNotifyUpdateCTX *notify_ctx_head;
+  struct SamplerNotifyUpdateCTX *notify_ctx_tail;
+};
+
+
+/**
+ * @brief Update the current estimate of the network size stored at the sampler
+ *
+ * Used for computing the condition when to return elements to the client
+ *
+ * @param sampler The sampler to update
+ * @param num_peers The estimated value
+ */
+void
+RPS_sampler_update_with_nw_size (struct RPS_Sampler *sampler,
+                                 uint32_t num_peers);
+
+
+/**
+ * @brief Set the probability that is needed at least with what a sampler
+ * element has to have observed all elements from the network.
+ *
+ * Only used/useful with the client sampler
+ * (Maybe move to rps-sampler_client.{h|c} ?)
+ *
+ * @param sampler
+ * @param desired_probability
+ */
+void
+RPS_sampler_set_desired_probability (struct RPS_Sampler *sampler,
+                                     double desired_probability);
+
+
+/**
+ * @brief Set the deficiency factor.
+ *
+ * Only used/useful with the client sampler
+ * (Maybe move to rps-sampler_client.{h|c} ?)
+ *
+ * @param sampler
+ * @param desired_probability
+ */
+void
+RPS_sampler_set_deficiency_factor (struct RPS_Sampler *sampler,
+                                   double deficiency_factor);
+
+
+/**
+ * @brief Add a callback that will be called when the next peer is inserted
+ * into the sampler
+ *
+ * @param sampler The sampler on which update it will be called
+ * @param notify_cb The callback
+ * @param cls Closure given to the callback
+ *
+ * @return The context containing callback and closure
+ */
+struct SamplerNotifyUpdateCTX *
+sampler_notify_on_update (struct RPS_Sampler *sampler,
+                          SamplerNotifyUpdateCB notify_cb,
+                          void *cls);
+
+
+/**
+ * Update every sampler element of this sampler with given peer
+ *
+ * @param sampler the sampler to update.
+ * @param id the PeerID that is put in the sampler
+ */
+void
+RPS_sampler_update (struct RPS_Sampler *sampler,
+                    const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Reinitialise all previously initialised sampler elements with the given value.
+ *
+ * Used to get rid of a PeerID.
+ *
+ * @param sampler the sampler to reinitialise a sampler element in.
+ * @param id the id of the sampler elements to update.
+ */
+void
+RPS_sampler_reinitialise_by_value (struct RPS_Sampler *sampler,
+                                   const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Get the size of the sampler.
+ *
+ * @param sampler the sampler to return the size of.
+ * @return the size of the sampler
+ */
+unsigned int
+RPS_sampler_get_size (struct RPS_Sampler *sampler);
+
+
+/**
+ * Grow or shrink the size of the sampler.
+ *
+ * @param sampler the sampler to resize.
+ * @param new_size the new size of the sampler
+ */
+void
+RPS_sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size);
+
+
+/**
+ * Get n random peers out of the sampled peers.
+ *
+ * We might want to reinitialise this sampler after giving the
+ * corrsponding peer to the client.
+ * Random with or without consumption?
+ *
+ * @param sampler the sampler to get peers from.
+ * @param cb callback that will be called once the ids are ready.
+ * @param cls closure given to @a cb
+ * @param num_peers the number of peers requested
+ */
+struct RPS_SamplerRequestHandle *
+RPS_sampler_get_n_rand_peers (struct RPS_Sampler *sampler,
+                              uint32_t num_peers,
+                              RPS_sampler_n_rand_peers_ready_cb cb,
+                              void *cls);
+
+
+/**
+ * Get one random peer with additional information.
+ *
+ * @param sampler the sampler to get peers from.
+ * @param cb callback that will be called once the ids are ready.
+ * @param cls closure given to @a cb
+ */
+struct RPS_SamplerRequestHandleSingleInfo *
+RPS_sampler_get_rand_peer_info (struct RPS_Sampler *sampler,
+                                RPS_sampler_sinlge_info_ready_cb cb,
+                                void *cls);
+
+
+/**
+ * Counts how many Samplers currently hold a given PeerID.
+ *
+ * @param sampler the sampler to count ids in.
+ * @param id the PeerID to count.
+ *
+ * @return the number of occurrences of id.
+ */
+uint32_t
+RPS_sampler_count_id (struct RPS_Sampler *sampler,
+                      const struct GNUNET_PeerIdentity *id);
+
+
+/**
+ * Cancel a request issued through #RPS_sampler_n_rand_peers_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle);
+
+
+/**
+ * Cancel a request issued through #RPS_sampler_n_rand_peers_ready_cb.
+ *
+ * @param req_handle the handle to the request
+ */
+void
+RPS_sampler_request_single_info_cancel (
+  struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle);
+
+
+/**
+ * Cleans the sampler.
+ */
+void
+RPS_sampler_destroy (struct RPS_Sampler *sampler);
+
+#endif /* RPS_SAMPLER_COMMON_H */
+/* end of rps-sampler_common.h */
diff --git a/src/contrib/service/rps/rps-test_util.c b/src/contrib/service/rps/rps-test_util.c
new file mode 100644
index 000000000..8fd82f7b3
--- /dev/null
+++ b/src/contrib/service/rps/rps-test_util.c
@@ -0,0 +1,550 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps-test_util.c
+ * @brief Some utils facilitating the view into the internals for the sampler
+ *        needed for evaluation
+ *
+ * @author Julius Bünger
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "rps-test_util.h"
+
+#include <inttypes.h>
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-test_util", __VA_ARGS__)
+
+#define B2B_PAT "%c%c%c%c%c%c%c%c"
+#define B2B(byte)  \
+  (byte & 0x80 ? '1' : '0'), \
+  (byte & 0x40 ? '1' : '0'), \
+  (byte & 0x20 ? '1' : '0'), \
+  (byte & 0x10 ? '1' : '0'), \
+  (byte & 0x08 ? '1' : '0'), \
+  (byte & 0x04 ? '1' : '0'), \
+  (byte & 0x02 ? '1' : '0'), \
+  (byte & 0x01 ? '1' : '0')
+
+#ifdef TO_FILE
+
+
+/**
+ * @brief buffer for storing the unaligned bits for the next write
+ */
+static char buf_unaligned;
+
+/**
+ * @brief number of bits in unaligned buffer
+ */
+static unsigned num_bits_buf_unaligned;
+
+static struct GNUNET_CONTAINER_MultiHashMap *open_files;
+
+
+/**
+ * @brief Get file handle
+ *
+ * If necessary, create file handle and store it with the other file handles.
+ *
+ * @param name Name of the file
+ *
+ * @return File handle
+ */
+struct GNUNET_DISK_FileHandle *
+get_file_handle (const char *name)
+{
+  struct GNUNET_HashCode hash;
+  struct GNUNET_DISK_FileHandle *fh;
+
+  if (NULL == open_files)
+  {
+    open_files = GNUNET_CONTAINER_multihashmap_create (16,
+                                                       GNUNET_NO);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Created map of open files.\n");
+  }
+  GNUNET_CRYPTO_hash (name,
+                      strlen (name),
+                      &hash);
+  if (NULL != (fh = GNUNET_CONTAINER_multihashmap_get (open_files,
+                                                       &hash)))
+    return fh;
+  fh = GNUNET_DISK_file_open (name,
+                              GNUNET_DISK_OPEN_WRITE
+                              | GNUNET_DISK_OPEN_CREATE
+                              | GNUNET_DISK_OPEN_APPEND,
+                              GNUNET_DISK_PERM_USER_READ
+                              | GNUNET_DISK_PERM_USER_WRITE
+                              | GNUNET_DISK_PERM_GROUP_READ);
+  if (NULL == fh)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Opening file `%s' failed.\n",
+         name);
+    GNUNET_assert (0);
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_put (open_files,
+                                                    &hash,
+                                                    fh,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  return fh;
+}
+
+
+/**
+ * @brief Closes the file of the current entry
+ *
+ * Implements #GNUNET_CONTAINER_HashMapIterator
+ *
+ * @param cls unused
+ * @param key unused
+ * @param value the file handle
+ *
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+int
+close_files_iter (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  (void) cls;
+  (void) key;
+  struct GNUNET_DISK_FileHandle *fh = value;
+
+  if (NULL != fh)
+  {
+    GNUNET_DISK_file_close (fh);
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Close all files that were opened with #get_file_handle
+ *
+ * @return Success of iterating over files
+ */
+int
+close_all_files ()
+{
+  int ret;
+
+  if (NULL != open_files)
+  {
+    ret = GNUNET_CONTAINER_multihashmap_iterate (open_files,
+                                                 close_files_iter,
+                                                 NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (open_files);
+    open_files = NULL;
+    return ret;
+  }
+  return GNUNET_YES;
+}
+
+
+void
+to_file_raw (const char *file_name, const char *buf, size_t size_buf)
+{
+  struct GNUNET_DISK_FileHandle *f;
+  size_t size_written;
+
+  if (NULL == (f = GNUNET_DISK_file_open (file_name,
+                                          GNUNET_DISK_OPEN_APPEND
+                                          | GNUNET_DISK_OPEN_WRITE
+                                          | GNUNET_DISK_OPEN_CREATE,
+                                          GNUNET_DISK_PERM_USER_READ
+                                          | GNUNET_DISK_PERM_USER_WRITE
+                                          | GNUNET_DISK_PERM_GROUP_READ
+                                          | GNUNET_DISK_PERM_OTHER_READ)))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not able to open file %s\n",
+         file_name);
+    return;
+  }
+
+  size_written = GNUNET_DISK_file_write (f, buf, size_buf);
+  if (size_buf != size_written)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Unable to write to file! (Size: %llu, size_written: %llu)\n",
+         (unsigned long long) size_buf,
+         (unsigned long long) size_written);
+
+    if (GNUNET_YES != GNUNET_DISK_file_close (f))
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Unable to close file\n");
+
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "Wrote %llu bytes raw.\n",
+       (unsigned long long) size_written);
+  if (GNUNET_YES != GNUNET_DISK_file_close (f))
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Unable to close file\n");
+}
+
+
+void
+to_file_raw_unaligned (const char *file_name,
+                       const char *buf,
+                       size_t size_buf,
+                       unsigned bits_needed)
+{
+  // TODO endianness!
+  GNUNET_assert (size_buf >= (bits_needed / 8));
+  // if (0 == num_bits_buf_unaligned)
+  // {
+  //  if (0 == (bits_needed % 8))
+  //  {
+  //    to_file_raw (file_name, buf, size_buf);
+  //    return;
+  //  }
+  //  to_file_raw (file_name, buf, size_buf - 1);
+  //  buf_unaligned = buf[size_buf - 1];
+  //  num_bits_buf_unaligned = bits_needed % 8;
+  //  return;
+  // }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Was asked to write %u bits\n", bits_needed);
+
+  char buf_write[size_buf + 1];
+  const unsigned bytes_iter = (0 != bits_needed % 8 ?
+                               (bits_needed / 8) + 1 :
+                               bits_needed / 8);
+  // TODO what if no iteration happens?
+  unsigned size_buf_write = 0;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "num_bits_buf_unaligned: %u\n",
+       num_bits_buf_unaligned);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "ua args: size_buf: %llu, bits_needed: %u -> iter: %u\n",
+       (unsigned long long) size_buf,
+       bits_needed,
+       bytes_iter);
+  buf_write[0] = buf_unaligned;
+  /* Iterate over input bytes */
+  for (unsigned i = 0; i < bytes_iter; i++)
+  {
+    /* Number of bits needed in this iteration - 8 for all except last iter */
+    unsigned num_bits_needed_iter;
+    /* Mask for bits to actually use */
+    unsigned mask_bits_needed_iter;
+    char byte_input;
+    /* Number of bits needed to align unaligned byte */
+    unsigned num_bits_to_align;
+    /* Number of bits that are to be moved */
+    unsigned num_bits_to_move;
+    /* Mask for bytes to be moved */
+    char mask_input_to_move;
+    /* Masked bits to be moved */
+    char bits_to_move;
+    /* The amount of bits needed to fit the bits to shift to the nearest spot */
+    unsigned distance_shift_bits;
+    /* Shifted bits on the move */
+    char bits_moving;
+    /* (unaligned) byte being filled with bits */
+    char byte_to_fill;
+    /* mask for needed bits of the input byte that have not been moved */
+    char mask_input_leftover;
+    /* needed bits of the input byte that have not been moved */
+    char byte_input_leftover;
+    unsigned num_bits_leftover;
+    // unsigned num_bits_discard;
+    char byte_unaligned_new;
+
+    if ((bits_needed - (i * 8)) <= 8)
+    {
+      /* last iteration */
+      num_bits_needed_iter = bits_needed - (i * 8);
+    }
+    else
+    {
+      num_bits_needed_iter = 8;
+    }
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "number of bits needed in this iteration: %u\n",
+         num_bits_needed_iter);
+    mask_bits_needed_iter = ((char) 1 << num_bits_needed_iter) - 1;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "mask needed bits (current iter): "B2B_PAT "\n",
+         B2B (mask_bits_needed_iter));
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Unaligned byte: "B2B_PAT " (%u bits)\n",
+         B2B (buf_unaligned),
+         num_bits_buf_unaligned);
+    byte_input = buf[i];
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "next whole input byte: "B2B_PAT "\n",
+         B2B (byte_input));
+    byte_input &= mask_bits_needed_iter;
+    num_bits_to_align = 8 - num_bits_buf_unaligned;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "input byte, needed bits: "B2B_PAT "\n",
+         B2B (byte_input));
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "number of bits needed to align unaligned bit: %u\n",
+         num_bits_to_align);
+    num_bits_to_move = GNUNET_MIN (num_bits_to_align, num_bits_needed_iter);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "number of bits of new byte to move: %u\n",
+         num_bits_to_move);
+    mask_input_to_move = ((char) 1 << num_bits_to_move) - 1;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "mask of bits of new byte to take for moving: "B2B_PAT "\n",
+         B2B (mask_input_to_move));
+    bits_to_move = byte_input & mask_input_to_move;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "masked bits of new byte to take for moving: "B2B_PAT "\n",
+         B2B (bits_to_move));
+    distance_shift_bits = num_bits_buf_unaligned;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "distance needed to shift bits to their correct spot: %u\n",
+         distance_shift_bits);
+    bits_moving = bits_to_move << distance_shift_bits;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "shifted, masked bits of new byte being moved: "B2B_PAT "\n",
+         B2B (bits_moving));
+    byte_to_fill = buf_unaligned | bits_moving;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "byte being filled: "B2B_PAT "\n",
+         B2B (byte_to_fill));
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "pending bytes: %u\n",
+         num_bits_buf_unaligned + num_bits_needed_iter);
+    if (num_bits_buf_unaligned + num_bits_needed_iter >= 8)
+    {
+      /* buf_unaligned was aligned by filling
+       * -> can be written to storage */
+      buf_write[i] = byte_to_fill;
+      size_buf_write++;
+
+      /* store the leftover, unaligned bits in buffer */
+      mask_input_leftover = mask_bits_needed_iter & (~mask_input_to_move);
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "mask of leftover bits of new byte: "B2B_PAT "\n",
+           B2B (mask_input_leftover));
+      byte_input_leftover = byte_input & mask_input_leftover;
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "masked, leftover bits of new byte: "B2B_PAT "\n",
+           B2B (byte_input_leftover));
+      num_bits_leftover = num_bits_needed_iter - num_bits_to_move;
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "number of unaligned bits left: %u\n",
+           num_bits_leftover);
+      // num_bits_discard = 8 - num_bits_needed_iter;
+      byte_unaligned_new = byte_input_leftover >> num_bits_to_move;
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "new unaligned byte: "B2B_PAT "\n",
+           B2B (byte_unaligned_new));
+      buf_unaligned = byte_unaligned_new;
+      num_bits_buf_unaligned = num_bits_leftover % 8;
+    }
+    else
+    {
+      /* unaligned buffer still unaligned but 'fuller' */
+      buf_unaligned = byte_to_fill;
+      num_bits_buf_unaligned = (num_bits_buf_unaligned + bits_needed) % 8;
+    }
+  }
+  to_file_raw (file_name, buf_write, size_buf_write);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
+}
+
+
+char *
+auth_key_to_string (struct GNUNET_CRYPTO_AuthKey auth_key)
+{
+  int size;
+  size_t name_buf_size;
+  char *end;
+  char *buf;
+  char *name_buf;
+  size_t keylen = (sizeof(struct GNUNET_CRYPTO_AuthKey)) * 8;
+
+  name_buf_size = 512 * sizeof(char);
+  name_buf = GNUNET_malloc (name_buf_size);
+
+  if (keylen % 5 > 0)
+    keylen += 5 - keylen % 5;
+  keylen /= 5;
+  buf = GNUNET_malloc (keylen + 1);
+
+  end = GNUNET_STRINGS_data_to_string (&(auth_key.key),
+                                       sizeof(struct GNUNET_CRYPTO_AuthKey),
+                                       buf,
+                                       keylen);
+
+  if (NULL == end)
+  {
+    GNUNET_free (buf);
+    GNUNET_break (0);
+  }
+  else
+  {
+    *end = '\0';
+  }
+
+  size = GNUNET_snprintf (name_buf, name_buf_size, "sampler_el-%s", buf);
+  if (0 > size)
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to create name_buf\n");
+
+  GNUNET_free (buf);
+
+  return name_buf;
+}
+
+
+#endif /* TO_FILE */
+
+
+struct GNUNET_CRYPTO_AuthKey
+string_to_auth_key (const char *str)
+{
+  struct GNUNET_CRYPTO_AuthKey auth_key;
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_string_to_data (str,
+                                     strlen (str),
+                                     &auth_key.key,
+                                     sizeof(struct GNUNET_CRYPTO_AuthKey)))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to convert string to data\n");
+  }
+
+  return auth_key;
+}
+
+
+/**
+ * @brief Try to ensure that `/tmp/rps` exists.
+ *
+ * @return #GNUNET_YES on success
+ *         #GNUNET_SYSERR on failure
+ */
+static int
+ensure_folder_exist (void)
+{
+  if (GNUNET_OK !=
+      GNUNET_DISK_directory_create ("/tmp/rps"))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Could not create directory `/tmp/rps'\n");
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_YES;
+}
+
+
+char *
+store_prefix_file_name (const unsigned int index,
+                        const char *prefix)
+{
+  int len_file_name;
+  int out_size;
+  char *file_name;
+  char index_str[64];
+
+  if (GNUNET_SYSERR == ensure_folder_exist ())
+    return NULL;
+  out_size = GNUNET_snprintf (index_str,
+                              64,
+                              "%u",
+                              index);
+  if ((64 < out_size) ||
+      (0 > out_size) )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to write string to buffer (size: %i, out_size: %i)\n",
+                64,
+                out_size);
+  }
+  len_file_name = (strlen (prefix)
+                   + strlen (index_str)
+                   + 11)
+                  * sizeof(char);
+  file_name = GNUNET_malloc (len_file_name);
+  out_size = GNUNET_snprintf (file_name,
+                              len_file_name,
+                              "/tmp/rps/%s-%s",
+                              prefix,
+                              index_str);
+  if ((len_file_name < out_size) ||
+      (0 > out_size) )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to write string to buffer (size: %i, out_size: %i)\n",
+                len_file_name,
+                out_size);
+  }
+  return file_name;
+}
+
+
+/**
+ * @brief Factorial
+ *
+ * @param x Number of which to compute the factorial
+ *
+ * @return Factorial of @a x
+ */
+uint32_t
+fac (uint32_t x)
+{
+  if (1 >= x)
+  {
+    return x;
+  }
+  return x * fac (x - 1);
+}
+
+
+/**
+ * @brief Binomial coefficient (n choose k)
+ *
+ * @param n
+ * @param k
+ *
+ * @return Binomial coefficient of @a n and @a k
+ */
+uint32_t
+binom (uint32_t n, uint32_t k)
+{
+  // GNUNET_assert (n >= k);
+  if (k > n)
+    return 0;
+  /* if (0 > n) return 0;  - always false */
+  /* if (0 > k) return 0;  - always false */
+  if (0 == k)
+    return 1;
+  return fac (n)
+         /
+         fac (k) * fac (n - k);
+}
+
+
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/rps-test_util.h b/src/contrib/service/rps/rps-test_util.h
new file mode 100644
index 000000000..9ff13bdcf
--- /dev/null
+++ b/src/contrib/service/rps/rps-test_util.h
@@ -0,0 +1,144 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps-test_util.h
+ * @brief Some utils facilitating the view into the internals for the sampler
+ *        needed for evaluation
+ * @author Julius Bünger
+ */
+
+#ifndef RPS_TEST_UTIL_H
+#define RPS_TEST_UTIL_H
+
+#define TO_FILE 0
+
+
+char *
+auth_key_to_string (struct GNUNET_CRYPTO_AuthKey auth_key);
+
+struct GNUNET_CRYPTO_AuthKey
+string_to_auth_key (const char *str);
+
+
+/**
+ * @brief Get file handle
+ *
+ * If necessary, create file handle and store it with the other file handles.
+ *
+ * @param name Name of the file
+ *
+ * @return File handle
+ */
+struct GNUNET_DISK_FileHandle *
+get_file_handle (const char *name);
+
+/**
+ * @brief Close all files that were opened with #get_file_handle
+ *
+ * @return Success of iterating over files
+ */
+int
+close_all_files ();
+
+/**
+ * This function is used to facilitate writing important information to disk
+ */
+#ifdef TO_FILE
+#define to_file(file_name, ...) do { \
+    char tmp_buf[512] = ""; \
+    int size; \
+    if (NULL == file_name) break; \
+    size = GNUNET_snprintf (tmp_buf, sizeof(tmp_buf), __VA_ARGS__); \
+    if (0 > size) \
+    { \
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \
+                  "Failed to create tmp_buf\n"); \
+      break; \
+    } \
+    (void) strncat (tmp_buf, "\n", 511); \
+    GNUNET_DISK_file_write (get_file_handle (file_name), \
+                            tmp_buf, \
+                            strnlen (tmp_buf, 512)); \
+} while (0);
+
+
+#define to_file_w_len(file_name, len, ...) do { char tmp_buf [len]; \
+                                                int size; \
+                                                memset (tmp_buf, 0, len); \
+                                                size = GNUNET_snprintf (tmp_buf, \
+                                                                        sizeof( \
+                                                                          tmp_buf), \
+                                                                        __VA_ARGS__); \
+                                                if (0 > size) \
+                                                { \
+                                                  GNUNET_log ( \
+                                                    GNUNET_ERROR_TYPE_WARNING, \
+                                                    "Failed to create tmp_buf\n"); \
+                                                  break; \
+                                                } \
+                                                (void) strncat (tmp_buf, "\n", 2); \
+                                                GNUNET_DISK_file_write ( \
+                                                  get_file_handle (file_name), \
+                                                  tmp_buf, \
+                                                  strnlen ( \
+                                                    tmp_buf, len)); \
+} while (0);
+#else /* TO_FILE */
+#  define to_file(file_name, ...)
+#  define to_file_w_len(file_name, len, ...)
+#endif /* TO_FILE */
+
+char *
+store_prefix_file_name (const unsigned int index,
+                        const char *prefix);
+
+void
+to_file_raw (const char *file_name, const char *buf, size_t size_buf);
+
+void
+to_file_raw_unaligned (const char *file_name,
+                       const char *buf,
+                       size_t size_buf,
+                       unsigned bits_needed);
+
+
+/**
+ * @brief Factorial
+ *
+ * @param x Number of which to compute the factorial
+ *
+ * @return Factorial of @a x
+ */
+uint32_t fac (uint32_t x);
+
+
+/**
+ * @brief Binomial coefficient (n choose k)
+ *
+ * @param n
+ * @param k
+ *
+ * @return Binomial coefficient of @a n and @a k
+ */
+uint32_t binom (uint32_t n, uint32_t k);
+
+#endif /* RPS_TEST_UTIL_H */
+/* end of gnunet-service-rps.c */
diff --git a/src/contrib/service/rps/rps.conf.in b/src/contrib/service/rps/rps.conf.in
new file mode 100644
index 000000000..8c7098747
--- /dev/null
+++ b/src/contrib/service/rps/rps.conf.in
@@ -0,0 +1,38 @@
+[rps]
+START_ON_DEMAND = @START_ON_DEMAND@
+IMMEDIATE_START = YES
+BINARY = gnunet-service-rps
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-rps.sock
+HOME = $SERVICEHOME
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+HOSTNAME = localhost
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+# PORT = 2119
+@UNIXONLY@ PORT = 2119
+
+# This is the timeinterval between the rounds
+ROUNDINTERVAL = 30 s
+
+# This is the file in which valid peers are stored
+FILENAME_VALID_PEERS = $GNUNET_DATA_HOME/rps/valid_peers.txt
+# Disable storage of valid peers
+#FILENAME_VALID_PEERS = DISABLE
+
+# This is the 'estimate' in the beginning.
+# This determines the size of the peers we keep in memory
+# until we receive the first estimate from NSE.
+# Keep in mind, that (networksize)^(1/3) should be enough.
+# So, 50 is enough for a network of size 50^3 = 125000
+MINSIZE = 10
+
+# The probability with which we want a sampler element to have observed all
+# peer ids in the network at least
+DESIRED_PROBABILITY = 0.9
+
+# A factor that catches the 'bias' of a random stream of peer ids.
+#
+# As introduced by Brahms: Factor between the number of unique ids in a
+# truly random stream and number of unique ids in the gossip stream.
+DEFICIENCY_FACTOR = 0.4
diff --git a/src/contrib/service/rps/rps.h b/src/contrib/service/rps/rps.h
new file mode 100644
index 000000000..202f881c9
--- /dev/null
+++ b/src/contrib/service/rps/rps.h
@@ -0,0 +1,336 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012-2013 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file rps/rps.h
+ * @brief example IPC messages between RPS API and GNS service
+ * @author Julius Bünger
+ */
+
+#include "gnunet_rps_service.h"
+
+/**
+ * Mesh port used by RPS.
+ */
+#define GNUNET_RPS_CADET_PORT 31337
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/***********************************************************************
+* P2P Messages
+***********************************************************************/
+
+/**
+ * P2P Message to send PeerIDs to other peer.
+ */
+struct GNUNET_RPS_P2P_PullReplyMessage
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of PeerIDs sent
+   */
+  uint32_t num_peers GNUNET_PACKED;
+
+  /* Followed by num_peers * GNUNET_PeerIdentity */
+};
+
+
+/***********************************************************************
+* Client-Service Messages
+***********************************************************************/
+
+/**
+ * Message from client to service with seed of peers.
+ */
+struct GNUNET_RPS_CS_SeedMessage
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of peers
+   */
+  uint32_t num_peers GNUNET_PACKED;
+
+  /* Followed by num_peers * GNUNET_PeerIdentity */
+};
+
+#if ENABLE_MALICIOUS
+/**
+ * Message from client to service to turn service malicious.
+ */
+struct GNUNET_RPS_CS_ActMaliciousMessage
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * If the type is 2 this is the attacked peer,
+   * empty otherwise.
+   */
+  struct GNUNET_PeerIdentity attacked_peer;
+
+  /**
+   * Type of malicious behaviour.
+   *
+   * 0 No malicious behaviour at all
+   * 1 Try to maximise representation
+   * 2 Try to partition the network
+   */
+  uint32_t type GNUNET_PACKED;
+
+  /**
+   * Number of peers
+   */
+  uint32_t num_peers GNUNET_PACKED;
+
+  /* Followed by num_peers * GNUNET_PeerIdentity when the type of malicious
+     behaviour is 1 */
+};
+#endif /* ENABLE_MALICIOUS */
+
+
+/**
+ * Message from client to service telling it to start a new sub
+ */
+struct GNUNET_RPS_CS_SubStartMessage
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * For alignment.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Mean interval between two rounds
+   */
+  struct GNUNET_TIME_RelativeNBO round_interval;
+
+  /**
+   * Length of the shared value represented as string.
+   */
+  struct GNUNET_HashCode hash GNUNET_PACKED;
+};
+
+
+/**
+ * Message from client to service telling it to stop a new sub
+ */
+struct GNUNET_RPS_CS_SubStopMessage
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Length of the shared value represented as string.
+   */
+  struct GNUNET_HashCode hash GNUNET_PACKED;
+};
+
+
+/* Debug messages */
+
+/**
+ * Message from client to service indicating that
+ * clients wants to get updates of the view
+ */
+struct GNUNET_RPS_CS_DEBUG_ViewRequest
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of updates
+   * 0 for sending updates until cancellation
+   */
+  uint32_t num_updates GNUNET_PACKED;
+};
+
+/**
+ * Message from service to client containing current update of view
+ */
+struct GNUNET_RPS_CS_DEBUG_ViewReply
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Identifyer of the message.
+   */
+  uint32_t id GNUNET_PACKED;
+
+  /**
+   * Number of peers in the view
+   */
+  uint64_t num_peers GNUNET_PACKED;
+};
+/* Followed by num_peers * GNUNET_PeerIdentity */
+
+/**
+ * Message from client to service indicating that
+ * clients wants to get stream of biased peers
+ */
+struct GNUNET_RPS_CS_DEBUG_StreamRequest
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+/**
+ * Message from service to client containing peer from biased stream
+ */
+struct GNUNET_RPS_CS_DEBUG_StreamReply
+{
+  /**
+   * Header including size and type in NBO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of peers
+   */
+  uint64_t num_peers GNUNET_PACKED;
+
+  // TODO maybe source of peer (pull/push list, peerinfo, ...)
+
+  /* Followed by num_peers * GNUNET_PeerIdentity */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/***********************************************************************
+* Defines from old gnunet-service-rps_peers.h
+***********************************************************************/
+
+/**
+ * Different flags indicating the status of another peer.
+ */
+enum Peers_PeerFlags
+{
+  /**
+   * If we are waiting for a reply from that peer (sent a pull request).
+   */
+  Peers_PULL_REPLY_PENDING   = 0x01,
+
+  /* IN_OTHER_GOSSIP_LIST = 0x02, unneeded? */
+  /* IN_OWN_SAMPLER_LIST  = 0x04, unneeded? */
+  /* IN_OWN_GOSSIP_LIST   = 0x08, unneeded? */
+
+  /**
+   * We set this bit when we know the peer is online.
+   */
+  Peers_ONLINE               = 0x20,
+
+  /**
+   * We set this bit when we are going to destroy the channel to this peer.
+   * When cleanup_channel is called, we know that we wanted to destroy it.
+   * Otherwise the channel to the other peer was destroyed.
+   */
+  Peers_TO_DESTROY           = 0x40,
+};
+
+/**
+ * Keep track of the status of a channel.
+ *
+ * This is needed in order to know what to do with a channel when it's
+ * destroyed.
+ */
+enum Peers_ChannelFlags
+{
+  /**
+   * We destroyed the channel because the other peer established a second one.
+   */
+  Peers_CHANNEL_ESTABLISHED_TWICE = 0x1,
+
+  /**
+   * The channel was removed because it was not needed any more. This should be
+   * the sending channel.
+   */
+  Peers_CHANNEL_CLEAN = 0x2,
+
+  /**
+   * We destroyed the channel because the other peer established a second one.
+   */
+  Peers_CHANNEL_DESTROING = 0x4,
+};
+
+
+/**
+ * @brief The role of a channel. Sending or receiving.
+ */
+enum Peers_ChannelRole
+{
+  /**
+   * Channel is used for sending
+   */
+  Peers_CHANNEL_ROLE_SENDING   = 0x01,
+
+  /**
+   * Channel is used for receiving
+   */
+  Peers_CHANNEL_ROLE_RECEIVING = 0x02,
+};
+
+/**
+ * @brief Functions of this type can be used to be stored at a peer for later execution.
+ *
+ * @param cls closure
+ * @param peer peer to execute function on
+ */
+typedef void (*PeerOp) (void *cls, const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * @brief Iterator over valid peers.
+ *
+ * @param cls closure
+ * @param peer current public peer id
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+typedef int
+(*PeersIterator) (void *cls,
+                  const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * Handle to the statistics service.
+ */
+extern struct GNUNET_STATISTICS_Handle *stats;
diff --git a/src/contrib/service/rps/rps_api.c b/src/contrib/service/rps/rps_api.c
new file mode 100644
index 000000000..c4166745a
--- /dev/null
+++ b/src/contrib/service/rps/rps_api.c
@@ -0,0 +1,1320 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/rps_api.c
+ * @brief API for rps
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "rps.h"
+#include "gnunet_rps_service.h"
+#include "rps-sampler_client.h"
+
+#include "gnunet_nse_service.h"
+
+#include <inttypes.h>
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "rps-api", __VA_ARGS__)
+
+/**
+ * Handle for a request to get peers from biased stream of ids
+ */
+struct GNUNET_RPS_StreamRequestHandle
+{
+  /**
+   * The client issuing the request.
+   */
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  /**
+   * The callback to be called when we receive an answer.
+   */
+  GNUNET_RPS_NotifyReadyCB ready_cb;
+
+  /**
+   * The closure for the callback.
+   */
+  void *ready_cb_cls;
+
+  /**
+   * @brief Scheduler task for scheduled callback
+   */
+  struct GNUNET_SCHEDULER_Task *callback_task;
+
+  /**
+   * @brief Next element of the DLL
+   */
+  struct GNUNET_RPS_StreamRequestHandle *next;
+
+  /**
+   * @brief Previous element of the DLL
+   */
+  struct GNUNET_RPS_StreamRequestHandle *prev;
+};
+
+
+/**
+ * Handler to handle requests from a client.
+ */
+struct GNUNET_RPS_Handle
+{
+  /**
+   * The handle to the client configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * The message queue to the client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * @brief Callback called on each update of the view
+   */
+  GNUNET_RPS_NotifyReadyCB view_update_cb;
+
+  /**
+   * @brief Closure to each requested update of the view
+   */
+  void *view_update_cls;
+
+  /**
+   * @brief Closure to each requested peer from the biased stream
+   */
+  void *stream_input_cls;
+
+  /**
+   * @brief Head of the DLL of stream requests
+   */
+  struct GNUNET_RPS_StreamRequestHandle *stream_requests_head;
+
+  /**
+   * @brief Tail of the DLL of stream requests
+   */
+  struct GNUNET_RPS_StreamRequestHandle *stream_requests_tail;
+
+  /**
+   * @brief Handle to nse service
+   */
+  struct GNUNET_NSE_Handle *nse;
+
+  /**
+   * @brief Pointer to the head element in DLL of request handles
+   */
+  struct GNUNET_RPS_Request_Handle *rh_head;
+
+  /**
+   * @brief Pointer to the tail element in DLL of request handles
+   */
+  struct GNUNET_RPS_Request_Handle *rh_tail;
+
+  /**
+   * @brief Pointer to the head element in DLL of single request handles
+   */
+  struct GNUNET_RPS_Request_Handle_Single_Info *rhs_head;
+
+  /**
+   * @brief Pointer to the tail element in DLL of single request handles
+   */
+  struct GNUNET_RPS_Request_Handle_Single_Info *rhs_tail;
+
+  /**
+   * @brief The desired probability with which we want to have observed all
+   * peers.
+   */
+  float desired_probability;
+
+  /**
+   * @brief A factor that catches the 'bias' of a random stream of peer ids.
+   *
+   * As introduced by Brahms: Factor between the number of unique ids in a
+   * truly random stream and number of unique ids in the gossip stream.
+   */
+  float deficiency_factor;
+};
+
+
+/**
+ * Handler for a single request from a client.
+ */
+struct GNUNET_RPS_Request_Handle
+{
+  /**
+   * The client issuing the request.
+   */
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  /**
+   * The number of requested peers.
+   */
+  uint32_t num_requests;
+
+  /**
+   * @brief The Sampler for the client request
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * @brief Request handle of the request to the sampler - needed to cancel the request
+   */
+  struct RPS_SamplerRequestHandle *sampler_rh;
+
+  /**
+   * @brief Request handle of the request of the biased stream of peers -
+   * needed to cancel the request
+   */
+  struct GNUNET_RPS_StreamRequestHandle *srh;
+
+  /**
+   * The callback to be called when we receive an answer.
+   */
+  GNUNET_RPS_NotifyReadyCB ready_cb;
+
+  /**
+   * The closure for the callback.
+   */
+  void *ready_cb_cls;
+
+  /**
+   * @brief Pointer to next element in DLL
+   */
+  struct GNUNET_RPS_Request_Handle *next;
+
+  /**
+   * @brief Pointer to previous element in DLL
+   */
+  struct GNUNET_RPS_Request_Handle *prev;
+};
+
+
+/**
+ * Handler for a single request from a client.
+ */
+struct GNUNET_RPS_Request_Handle_Single_Info
+{
+  /**
+   * The client issuing the request.
+   */
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  /**
+   * @brief The Sampler for the client request
+   */
+  struct RPS_Sampler *sampler;
+
+  /**
+   * @brief Request handle of the request to the sampler - needed to cancel the request
+   */
+  struct RPS_SamplerRequestHandleSingleInfo *sampler_rh;
+
+  /**
+   * @brief Request handle of the request of the biased stream of peers -
+   * needed to cancel the request
+   */
+  struct GNUNET_RPS_StreamRequestHandle *srh;
+
+  /**
+   * The callback to be called when we receive an answer.
+   */
+  GNUNET_RPS_NotifyReadySingleInfoCB ready_cb;
+
+  /**
+   * The closure for the callback.
+   */
+  void *ready_cb_cls;
+
+  /**
+   * @brief Pointer to next element in DLL
+   */
+  struct GNUNET_RPS_Request_Handle_Single_Info *next;
+
+  /**
+   * @brief Pointer to previous element in DLL
+   */
+  struct GNUNET_RPS_Request_Handle_Single_Info *prev;
+};
+
+
+/**
+ * Struct used to pack the callback, its closure (provided by the caller)
+ * and the connection handler to the service to pass it to a callback function.
+ */
+struct cb_cls_pack
+{
+  /**
+   * Callback provided by the client
+   */
+  GNUNET_RPS_NotifyReadyCB cb;
+
+  /**
+   * Closure provided by the client
+   */
+  void *cls;
+
+  /**
+   * Handle to the service connection
+   */
+  struct GNUNET_CLIENT_Connection *service_conn;
+};
+
+
+/**
+ * @brief Peers received from the biased stream to be passed to all
+ * srh_handlers
+ */
+static struct GNUNET_PeerIdentity *srh_callback_peers;
+
+/**
+ * @brief Number of peers in the biased stream that are to be passed to all
+ * srh_handlers
+ */
+static uint64_t srh_callback_num_peers;
+
+
+/**
+ * @brief Create a new handle for a stream request
+ *
+ * @param rps_handle The rps handle
+ * @param num_peers The number of desired peers
+ * @param ready_cb The callback to be called, once all peers are ready
+ * @param cls The colsure to provide to the callback
+ *
+ * @return The handle to the stream request
+ */
+static struct GNUNET_RPS_StreamRequestHandle *
+new_stream_request (struct GNUNET_RPS_Handle *rps_handle,
+                    GNUNET_RPS_NotifyReadyCB ready_cb,
+                    void *cls)
+{
+  struct GNUNET_RPS_StreamRequestHandle *srh;
+
+  srh = GNUNET_new (struct GNUNET_RPS_StreamRequestHandle);
+  srh->rps_handle = rps_handle;
+  srh->ready_cb = ready_cb;
+  srh->ready_cb_cls = cls;
+  GNUNET_CONTAINER_DLL_insert (rps_handle->stream_requests_head,
+                               rps_handle->stream_requests_tail,
+                               srh);
+
+  return srh;
+}
+
+
+/**
+ * @brief Remove the given stream request from the list of requests and memory
+ *
+ * @param srh The request to be removed
+ */
+static void
+remove_stream_request (struct GNUNET_RPS_StreamRequestHandle *srh)
+{
+  struct GNUNET_RPS_Handle *rps_handle = srh->rps_handle;
+
+  GNUNET_assert (NULL != srh);
+  if (NULL != srh->callback_task)
+  {
+    GNUNET_SCHEDULER_cancel (srh->callback_task);
+    srh->callback_task = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (rps_handle->stream_requests_head,
+                               rps_handle->stream_requests_tail,
+                               srh);
+  GNUNET_free (srh);
+}
+
+
+/**
+ * @brief Called once the sampler has collected all requested peers.
+ *
+ * Calls the callback provided by the client with the corresponding cls.
+ *
+ * @param peers The array of @a num_peers that has been returned.
+ * @param num_peers The number of peers that have been returned
+ * @param cls The #GNUNET_RPS_Request_Handle
+ */
+static void
+peers_ready_cb (const struct GNUNET_PeerIdentity *peers,
+                uint32_t num_peers,
+                void *cls)
+{
+  struct GNUNET_RPS_Request_Handle *rh = cls;
+
+  rh->sampler_rh = NULL;
+  rh->ready_cb (rh->ready_cb_cls,
+                num_peers,
+                peers);
+  GNUNET_RPS_request_cancel (rh);
+}
+
+
+/**
+ * @brief Called once the sampler has collected the requested peer.
+ *
+ * Calls the callback provided by the client with the corresponding cls.
+ *
+ * @param peers The array of @a num_peers that has been returned.
+ * @param num_peers The number of peers that have been returned
+ * @param cls The #GNUNET_RPS_Request_Handle
+ * @param probability Probability with which all IDs have been observed
+ * @param num_observed Number of observed IDs
+ */
+static void
+peer_info_ready_cb (const struct GNUNET_PeerIdentity *peers,
+                    void *cls,
+                    double probability,
+                    uint32_t num_observed)
+{
+  struct GNUNET_RPS_Request_Handle_Single_Info *rh = cls;
+
+  rh->sampler_rh = NULL;
+  rh->ready_cb (rh->ready_cb_cls,
+                peers,
+                probability,
+                num_observed);
+  GNUNET_RPS_request_single_info_cancel (rh);
+}
+
+
+/**
+ * @brief Callback to collect the peers from the biased stream and put those
+ * into the sampler.
+ *
+ * @param cls The #GNUNET_RPS_Request_Handle
+ * @param num_peers The number of peer that have been returned
+ * @param peers The array of @a num_peers that have been returned
+ */
+static void
+collect_peers_cb (void *cls,
+                  uint64_t num_peers,
+                  const struct GNUNET_PeerIdentity *peers)
+{
+  struct GNUNET_RPS_Request_Handle *rh = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Service sent %" PRIu64 " peers from stream\n",
+       num_peers);
+  for (uint64_t i = 0; i < num_peers; i++)
+  {
+    RPS_sampler_update (rh->sampler, &peers[i]);
+  }
+}
+
+
+/**
+ * @brief Callback to collect the peers from the biased stream and put those
+ * into the sampler.
+ *
+ * This version is for the modified #GNUNET_RPS_Request_Handle_Single_Info
+ *
+ * @param cls The #GNUNET_RPS_Request_Handle
+ * @param num_peers The number of peer that have been returned
+ * @param peers The array of @a num_peers that have been returned
+ */
+static void
+collect_peers_info_cb (void *cls,
+                       uint64_t num_peers,
+                       const struct GNUNET_PeerIdentity *peers)
+{
+  struct GNUNET_RPS_Request_Handle_Single_Info *rhs = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Service sent %" PRIu64 " peers from stream\n",
+       num_peers);
+  for (uint64_t i = 0; i < num_peers; i++)
+  {
+    RPS_sampler_update (rhs->sampler, &peers[i]);
+  }
+}
+
+
+/* Get internals for debugging/profiling purposes */
+
+/**
+ * Request updates of view
+ *
+ * @param rps_handle handle to the rps service
+ * @param num_req_peers number of peers we want to receive
+ *        (0 for infinite updates)
+ * @param cls a closure that will be given to the callback
+ * @param ready_cb the callback called when the peers are available
+ */
+void
+GNUNET_RPS_view_request (struct GNUNET_RPS_Handle *rps_handle,
+                         uint32_t num_updates,
+                         GNUNET_RPS_NotifyReadyCB view_update_cb,
+                         void *cls)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client requests %" PRIu32 " view updates\n",
+       num_updates);
+  rps_handle->view_update_cb = view_update_cb;
+  rps_handle->view_update_cls = cls;
+
+  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST);
+  msg->num_updates = htonl (num_updates);
+  GNUNET_MQ_send (rps_handle->mq, ev);
+}
+
+
+void
+GNUNET_RPS_view_request_cancel (struct GNUNET_RPS_Handle *rps_handle)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  GNUNET_assert (NULL != rps_handle->view_update_cb);
+
+  rps_handle->view_update_cb = NULL;
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL);
+  GNUNET_MQ_send (rps_handle->mq, ev);
+}
+
+
+/**
+ * Request biased stream of peers that are being put into the sampler
+ *
+ * @param rps_handle handle to the rps service
+ * @param cls a closure that will be given to the callback
+ * @param ready_cb the callback called when the peers are available
+ */
+struct GNUNET_RPS_StreamRequestHandle *
+GNUNET_RPS_stream_request (struct GNUNET_RPS_Handle *rps_handle,
+                           GNUNET_RPS_NotifyReadyCB stream_input_cb,
+                           void *cls)
+{
+  struct GNUNET_RPS_StreamRequestHandle *srh;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_DEBUG_StreamRequest *msg;
+
+  srh = new_stream_request (rps_handle,
+                            stream_input_cb,
+                            cls);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requests biased stream updates\n");
+
+  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST);
+  GNUNET_MQ_send (rps_handle->mq, ev);
+  return srh;
+}
+
+
+/**
+ * This function is called, when the service updates the view.
+ * It verifies that @a msg is well-formed.
+ *
+ * @param cls the closure
+ * @param msg the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_view_update (void *cls,
+                   const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
+{
+  uint16_t msize = ntohs (msg->header.size);
+  uint32_t num_peers = ntohl (msg->num_peers);
+
+  (void) cls;
+
+  msize -= sizeof(struct GNUNET_RPS_CS_DEBUG_ViewReply);
+  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
+      (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * This function is called, when the service updated its view.
+ * It calls the callback the caller provided
+ * and disconnects afterwards.
+ *
+ * @param msg the message
+ */
+static void
+handle_view_update (void *cls,
+                    const struct GNUNET_RPS_CS_DEBUG_ViewReply *msg)
+{
+  struct GNUNET_RPS_Handle *h = cls;
+  struct GNUNET_PeerIdentity *peers;
+
+  /* Give the peers back */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "New view of %" PRIu32 " peers:\n",
+       ntohl (msg->num_peers));
+
+  peers = (struct GNUNET_PeerIdentity *) &msg[1];
+  GNUNET_assert (NULL != h);
+  GNUNET_assert (NULL != h->view_update_cb);
+  h->view_update_cb (h->view_update_cls, ntohl (msg->num_peers), peers);
+}
+
+
+/**
+ * @brief Send message to service that this client does not want to receive
+ * further updates from the biased peer stream
+ *
+ * @param rps_handle The handle representing the service to the client
+ */
+static void
+cancel_stream (struct GNUNET_RPS_Handle *rps_handle)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL);
+  GNUNET_MQ_send (rps_handle->mq, ev);
+}
+
+
+/**
+ * @brief Cancel a specific request for updates from the biased peer stream
+ *
+ * @param srh The request handle to cancel
+ */
+void
+GNUNET_RPS_stream_cancel (struct GNUNET_RPS_StreamRequestHandle *srh)
+{
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  rps_handle = srh->rps_handle;
+  remove_stream_request (srh);
+  if (NULL == rps_handle->stream_requests_head)
+    cancel_stream (rps_handle);
+}
+
+
+/**
+ * This function is called, when the service sends another peer from the biased
+ * stream.
+ * It calls the callback the caller provided
+ * and disconnects afterwards.
+ *
+ * TODO merge with check_view_update
+ *
+ * @param msg the message
+ */
+static int
+check_stream_input (void *cls,
+                    const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
+{
+  uint16_t msize = ntohs (msg->header.size);
+  uint32_t num_peers = ntohl (msg->num_peers);
+
+  (void) cls;
+
+  msize -= sizeof(struct GNUNET_RPS_CS_DEBUG_StreamReply);
+  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
+      (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Called by the scheduler to call the callbacks of the srh handlers
+ *
+ * @param cls Stream request handle
+ */
+static void
+srh_callback_scheduled (void *cls)
+{
+  struct GNUNET_RPS_StreamRequestHandle *srh = cls;
+
+  srh->callback_task = NULL;
+  srh->ready_cb (srh->ready_cb_cls,
+                 srh_callback_num_peers,
+                 srh_callback_peers);
+}
+
+
+/**
+ * This function is called, when the service sends another peer from the biased
+ * stream.
+ * It calls the callback the caller provided
+ * and disconnects afterwards.
+ *
+ * @param msg the message
+ */
+static void
+handle_stream_input (void *cls,
+                     const struct GNUNET_RPS_CS_DEBUG_StreamReply *msg)
+{
+  struct GNUNET_RPS_Handle *h = cls;
+  // const struct GNUNET_PeerIdentity *peers;
+  uint64_t num_peers;
+  struct GNUNET_RPS_StreamRequestHandle *srh_iter;
+  struct GNUNET_RPS_StreamRequestHandle *srh_next;
+
+  // peers = (struct GNUNET_PeerIdentity *) &msg[1];
+  num_peers = ntohl (msg->num_peers);
+  srh_callback_num_peers = num_peers;
+  GNUNET_free (srh_callback_peers);
+  srh_callback_peers = GNUNET_new_array (num_peers,
+                                         struct GNUNET_PeerIdentity);
+  GNUNET_memcpy (srh_callback_peers,
+                 &msg[1],
+                 num_peers * sizeof(struct GNUNET_PeerIdentity));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received %" PRIu64 " peer(s) from stream input.\n",
+       num_peers);
+  for (srh_iter = h->stream_requests_head;
+       NULL != srh_iter;
+       srh_iter = srh_next)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Calling srh \n");
+    /* Store next pointer - srh might be removed/freed in callback */
+    srh_next = srh_iter->next;
+    if (NULL != srh_iter->callback_task)
+      GNUNET_SCHEDULER_cancel (srh_iter->callback_task);
+    srh_iter->callback_task =
+      GNUNET_SCHEDULER_add_now (&srh_callback_scheduled,
+                                srh_iter);
+  }
+
+  if (NULL == h->stream_requests_head)
+  {
+    cancel_stream (h);
+  }
+}
+
+
+/**
+ * Reconnect to the service
+ */
+static void
+reconnect (struct GNUNET_RPS_Handle *h);
+
+
+/**
+ * Error handler for mq.
+ *
+ * This function is called when mq encounters an error.
+ * Until now mq doesn't provide useful error messages.
+ *
+ * @param cls the closure
+ * @param error error code without specyfied meaning
+ */
+static void
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_RPS_Handle *h = cls;
+
+  // TODO LOG
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "Problem with message queue. error: %i\n\
+       1: READ,\n\
+       2: WRITE,\n\
+       4: TIMEOUT\n",
+       // TODO: write GNUNET_MQ_strerror (error)
+       error);
+  reconnect (h);
+  /* Resend all pending request as the service destroyed its knowledge
+   * about them */
+}
+
+
+/**
+ * @brief Create the hash value from the share value that defines the sub
+ * (-group)
+ *
+ * @param share_val Share value
+ * @param[out] hash Pointer to the location in which the hash will be stored.
+ */
+static void
+hash_from_share_val (const char *share_val,
+                     struct GNUNET_HashCode *hash)
+{
+  GNUNET_CRYPTO_kdf (hash,
+                     sizeof(struct GNUNET_HashCode),
+                     "rps",
+                     strlen ("rps"),
+                     share_val,
+                     strlen (share_val),
+                     NULL, 0);
+}
+
+
+/**
+ * @brief Callback for network size estimate - called with new estimates about
+ * the network size, updates all samplers with the new estimate
+ *
+ * Implements #GNUNET_NSE_Callback
+ *
+ * @param cls the rps handle
+ * @param timestamp unused
+ * @param logestimate the estimate
+ * @param std_dev the standard distribution
+ */
+static void
+nse_cb (void *cls,
+        struct GNUNET_TIME_Absolute timestamp,
+        double logestimate,
+        double std_dev)
+{
+  struct GNUNET_RPS_Handle *h = cls;
+
+  (void) timestamp;
+  (void) std_dev;
+
+  for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
+       NULL != rh_iter && NULL != rh_iter->next;
+       rh_iter = rh_iter->next)
+  {
+    RPS_sampler_update_with_nw_size (rh_iter->sampler,
+                                     GNUNET_NSE_log_estimate_to_n (
+                                       logestimate));
+  }
+  for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
+       NULL != rhs_iter && NULL != rhs_iter->next;
+       rhs_iter = rhs_iter->next)
+  {
+    RPS_sampler_update_with_nw_size (rhs_iter->sampler,
+                                     GNUNET_NSE_log_estimate_to_n (
+                                       logestimate));
+  }
+}
+
+
+/**
+ * Reconnect to the service
+ */
+static void
+reconnect (struct GNUNET_RPS_Handle *h)
+{
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_var_size (view_update,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY,
+                           struct GNUNET_RPS_CS_DEBUG_ViewReply,
+                           h),
+    GNUNET_MQ_hd_var_size (stream_input,
+                           GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY,
+                           struct GNUNET_RPS_CS_DEBUG_StreamReply,
+                           h),
+    GNUNET_MQ_handler_end ()
+  };
+
+  if (NULL != h->mq)
+    GNUNET_MQ_destroy (h->mq);
+  h->mq = GNUNET_CLIENT_connect (h->cfg,
+                                 "rps",
+                                 mq_handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL != h->nse)
+    GNUNET_NSE_disconnect (h->nse);
+  h->nse = GNUNET_NSE_connect (h->cfg, &nse_cb, h);
+}
+
+
+/**
+ * Connect to the rps service
+ *
+ * @param cfg configuration to use
+ * @return a handle to the service, NULL on error
+ */
+struct GNUNET_RPS_Handle *
+GNUNET_RPS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_RPS_Handle *h;
+
+  h = GNUNET_new (struct GNUNET_RPS_Handle);
+  h->cfg = cfg;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_float (cfg,
+                                            "RPS",
+                                            "DESIRED_PROBABILITY",
+                                            &h->desired_probability))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "RPS", "DESIRED_PROBABILITY");
+    GNUNET_free (h);
+    return NULL;
+  }
+  if ((0 > h->desired_probability) ||
+      (1 < h->desired_probability) )
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "The desired probability must be in the interval [0;1]\n");
+    GNUNET_free (h);
+    return NULL;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_float (cfg,
+                                            "RPS",
+                                            "DEFICIENCY_FACTOR",
+                                            &h->deficiency_factor))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "RPS", "DEFICIENCY_FACTOR");
+    GNUNET_free (h);
+    return NULL;
+  }
+  if ((0 > h->desired_probability) ||
+      (1 < h->desired_probability) )
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "The deficiency factor must be in the interval [0;1]\n");
+    GNUNET_free (h);
+    return NULL;
+  }
+  reconnect (h);
+  if (NULL == h->mq)
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
+  return h;
+}
+
+
+/**
+ * @brief Start a sub with the given shared value
+ *
+ * @param h Handle to rps
+ * @param shared_value The shared value that defines the members of the sub (-gorup)
+ */
+void
+GNUNET_RPS_sub_start (struct GNUNET_RPS_Handle *h,
+                      const char *shared_value)
+{
+  struct GNUNET_RPS_CS_SubStartMessage *msg;
+  struct GNUNET_MQ_Envelope *ev;
+
+  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START);
+  hash_from_share_val (shared_value, &msg->hash);
+  msg->round_interval = GNUNET_TIME_relative_hton ( // TODO read from config!
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30));
+  GNUNET_assert (0 != msg->round_interval.rel_value_us__);
+
+  GNUNET_MQ_send (h->mq, ev);
+}
+
+
+/**
+ * @brief Stop a sub with the given shared value
+ *
+ * @param h Handle to rps
+ * @param shared_value The shared value that defines the members of the sub (-gorup)
+ */
+void
+GNUNET_RPS_sub_stop (struct GNUNET_RPS_Handle *h,
+                     const char *shared_value)
+{
+  struct GNUNET_RPS_CS_SubStopMessage *msg;
+  struct GNUNET_MQ_Envelope *ev;
+
+  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP);
+  hash_from_share_val (shared_value, &msg->hash);
+
+  GNUNET_MQ_send (h->mq, ev);
+}
+
+
+/**
+ * Request n random peers.
+ *
+ * @param rps_handle handle to the rps service
+ * @param num_req_peers number of peers we want to receive
+ * @param ready_cb the callback called when the peers are available
+ * @param cls closure given to the callback
+ * @return a handle to cancel this request
+ */
+struct GNUNET_RPS_Request_Handle *
+GNUNET_RPS_request_peers (struct GNUNET_RPS_Handle *rps_handle,
+                          uint32_t num_req_peers,
+                          GNUNET_RPS_NotifyReadyCB ready_cb,
+                          void *cls)
+{
+  struct GNUNET_RPS_Request_Handle *rh;
+
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Client requested %" PRIu32 " peers\n",
+       num_req_peers);
+  rh = GNUNET_new (struct GNUNET_RPS_Request_Handle);
+  rh->rps_handle = rps_handle;
+  rh->num_requests = num_req_peers;
+  rh->sampler = RPS_sampler_mod_init (num_req_peers,
+                                      GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
+  RPS_sampler_set_desired_probability (rh->sampler,
+                                       rps_handle->desired_probability);
+  RPS_sampler_set_deficiency_factor (rh->sampler,
+                                     rps_handle->deficiency_factor);
+  rh->sampler_rh = RPS_sampler_get_n_rand_peers (rh->sampler,
+                                                 num_req_peers,
+                                                 peers_ready_cb,
+                                                 rh);
+  rh->srh = GNUNET_RPS_stream_request (rps_handle,
+                                       collect_peers_cb,
+                                       rh); /* cls */
+  rh->ready_cb = ready_cb;
+  rh->ready_cb_cls = cls;
+  GNUNET_CONTAINER_DLL_insert (rps_handle->rh_head,
+                               rps_handle->rh_tail,
+                               rh);
+
+  return rh;
+}
+
+
+/**
+ * Request one random peer, getting additional information.
+ *
+ * @param rps_handle handle to the rps service
+ * @param ready_cb the callback called when the peers are available
+ * @param cls closure given to the callback
+ * @return a handle to cancel this request
+ */
+struct GNUNET_RPS_Request_Handle_Single_Info *
+GNUNET_RPS_request_peer_info (struct GNUNET_RPS_Handle *rps_handle,
+                              GNUNET_RPS_NotifyReadySingleInfoCB ready_cb,
+                              void *cls)
+{
+  struct GNUNET_RPS_Request_Handle_Single_Info *rhs;
+  uint32_t num_req_peers = 1;
+
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Client requested peer with additional info\n");
+  rhs = GNUNET_new (struct GNUNET_RPS_Request_Handle_Single_Info);
+  rhs->rps_handle = rps_handle;
+  rhs->sampler = RPS_sampler_mod_init (num_req_peers,
+                                       GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
+  RPS_sampler_set_desired_probability (rhs->sampler,
+                                       rps_handle->desired_probability);
+  RPS_sampler_set_deficiency_factor (rhs->sampler,
+                                     rps_handle->deficiency_factor);
+  rhs->sampler_rh = RPS_sampler_get_rand_peer_info (rhs->sampler,
+                                                    peer_info_ready_cb,
+                                                    rhs);
+  rhs->srh = GNUNET_RPS_stream_request (rps_handle,
+                                        collect_peers_info_cb,
+                                        rhs); /* cls */
+  rhs->ready_cb = ready_cb;
+  rhs->ready_cb_cls = cls;
+  GNUNET_CONTAINER_DLL_insert (rps_handle->rhs_head,
+                               rps_handle->rhs_tail,
+                               rhs);
+
+  return rhs;
+}
+
+
+/**
+ * Seed rps service with peerIDs.
+ *
+ * @param h handle to the rps service
+ * @param n number of peers to seed
+ * @param ids the ids of the peers seeded
+ */
+void
+GNUNET_RPS_seed_ids (struct GNUNET_RPS_Handle *h,
+                     uint32_t n,
+                     const struct GNUNET_PeerIdentity *ids)
+{
+  size_t size_needed;
+  uint32_t num_peers_max;
+  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_SeedMessage *msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client wants to seed %" PRIu32 " peers:\n",
+       n);
+  for (unsigned int i = 0; i < n; i++)
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "%u. peer: %s\n",
+         i,
+         GNUNET_i2s (&ids[i]));
+
+  /* The actual size the message occupies */
+  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
+                + n * sizeof(struct GNUNET_PeerIdentity);
+  /* The number of peers that fits in one message together with
+   * the respective header */
+  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE
+                   - sizeof(struct GNUNET_RPS_CS_SeedMessage))
+                  / sizeof(struct GNUNET_PeerIdentity);
+  tmp_peer_pointer = ids;
+
+  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
+  {
+    ev = GNUNET_MQ_msg_extra (msg,
+                              num_peers_max * sizeof(struct
+                                                     GNUNET_PeerIdentity),
+                              GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
+    msg->num_peers = htonl (num_peers_max);
+    GNUNET_memcpy (&msg[1],
+                   tmp_peer_pointer,
+                   num_peers_max * sizeof(struct GNUNET_PeerIdentity));
+    GNUNET_MQ_send (h->mq,
+                    ev);
+    n -= num_peers_max;
+    size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
+                  + n * sizeof(struct GNUNET_PeerIdentity);
+    /* Set pointer to beginning of next block of num_peers_max peers */
+    tmp_peer_pointer = &ids[num_peers_max];
+  }
+
+  ev = GNUNET_MQ_msg_extra (msg,
+                            n * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
+  msg->num_peers = htonl (n);
+  GNUNET_memcpy (&msg[1],
+                 tmp_peer_pointer,
+                 n * sizeof(struct GNUNET_PeerIdentity));
+  GNUNET_MQ_send (h->mq,
+                  ev);
+}
+
+
+#if ENABLE_MALICIOUS
+/**
+ * Turn RPS service to act malicious.
+ *
+ * @param h handle to the rps service
+ * @param type which type of malicious peer to turn to.
+ *             0 Don't act malicious at all
+ *             1 Try to maximise representation
+ *             2 Try to partition the network
+ *               (isolate one peer from the rest)
+ * @param n number of @a ids
+ * @param ids the ids of the malicious peers
+ *            if @type is 2 the last id is the id of the
+ *            peer to be isolated from the rest
+ */
+void
+GNUNET_RPS_act_malicious (struct GNUNET_RPS_Handle *h,
+                          uint32_t type,
+                          uint32_t num_peers,
+                          const struct GNUNET_PeerIdentity *peer_ids,
+                          const struct GNUNET_PeerIdentity *target_peer)
+{
+  size_t size_needed;
+  uint32_t num_peers_max;
+  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_RPS_CS_ActMaliciousMessage *msg;
+
+  unsigned int i;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client turns malicious (type %" PRIu32 ") with %" PRIu32
+       " other peers:\n",
+       type,
+       num_peers);
+  for (i = 0; i < num_peers; i++)
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "%u. peer: %s\n",
+         i,
+         GNUNET_i2s (&peer_ids[i]));
+
+  /* The actual size the message would occupy */
+  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
+                + num_peers * sizeof(struct GNUNET_PeerIdentity);
+  /* The number of peers that fit in one message together with
+   * the respective header */
+  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE
+                   - sizeof(struct GNUNET_RPS_CS_SeedMessage))
+                  / sizeof(struct GNUNET_PeerIdentity);
+  tmp_peer_pointer = peer_ids;
+
+  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Too many peers to send at once, sending %" PRIu32
+         " (all we can so far)\n",
+         num_peers_max);
+    ev = GNUNET_MQ_msg_extra (msg,
+                              num_peers_max * sizeof(struct
+                                                     GNUNET_PeerIdentity),
+                              GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
+    msg->type = htonl (type);
+    msg->num_peers = htonl (num_peers_max);
+    if ((2 == type) ||
+        (3 == type))
+      msg->attacked_peer = peer_ids[num_peers];
+    GNUNET_memcpy (&msg[1],
+                   tmp_peer_pointer,
+                   num_peers_max * sizeof(struct GNUNET_PeerIdentity));
+
+    GNUNET_MQ_send (h->mq, ev);
+
+    num_peers -= num_peers_max;
+    size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
+                  + num_peers * sizeof(struct GNUNET_PeerIdentity);
+    /* Set pointer to beginning of next block of num_peers_max peers */
+    tmp_peer_pointer = &peer_ids[num_peers_max];
+  }
+
+  ev = GNUNET_MQ_msg_extra (msg,
+                            num_peers * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
+  msg->type = htonl (type);
+  msg->num_peers = htonl (num_peers);
+  if ((2 == type) ||
+      (3 == type))
+    msg->attacked_peer = *target_peer;
+  GNUNET_memcpy (&msg[1],
+                 tmp_peer_pointer,
+                 num_peers * sizeof(struct GNUNET_PeerIdentity));
+
+  GNUNET_MQ_send (h->mq, ev);
+}
+
+
+#endif /* ENABLE_MALICIOUS */
+
+
+/**
+ * Cancel an issued request.
+ *
+ * @param rh request handle of request to cancel
+ */
+void
+GNUNET_RPS_request_cancel (struct GNUNET_RPS_Request_Handle *rh)
+{
+  struct GNUNET_RPS_Handle *h;
+
+  h = rh->rps_handle;
+  GNUNET_assert (NULL != rh);
+  GNUNET_assert (NULL != rh->srh);
+  GNUNET_assert (h == rh->srh->rps_handle);
+  GNUNET_RPS_stream_cancel (rh->srh);
+  rh->srh = NULL;
+  if (NULL == h->stream_requests_head)
+    cancel_stream (h);
+  if (NULL != rh->sampler_rh)
+  {
+    RPS_sampler_request_cancel (rh->sampler_rh);
+  }
+  RPS_sampler_destroy (rh->sampler);
+  rh->sampler = NULL;
+  GNUNET_CONTAINER_DLL_remove (h->rh_head,
+                               h->rh_tail,
+                               rh);
+  GNUNET_free (rh);
+}
+
+
+/**
+ * Cancel an issued single info request.
+ *
+ * @param rhs request handle of request to cancel
+ */
+void
+GNUNET_RPS_request_single_info_cancel (
+  struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
+{
+  struct GNUNET_RPS_Handle *h;
+
+  h = rhs->rps_handle;
+  GNUNET_assert (NULL != rhs);
+  GNUNET_assert (NULL != rhs->srh);
+  GNUNET_assert (h == rhs->srh->rps_handle);
+  GNUNET_RPS_stream_cancel (rhs->srh);
+  rhs->srh = NULL;
+  if (NULL == h->stream_requests_head)
+    cancel_stream (h);
+  if (NULL != rhs->sampler_rh)
+  {
+    RPS_sampler_request_single_info_cancel (rhs->sampler_rh);
+  }
+  RPS_sampler_destroy (rhs->sampler);
+  rhs->sampler = NULL;
+  GNUNET_CONTAINER_DLL_remove (h->rhs_head,
+                               h->rhs_tail,
+                               rhs);
+  GNUNET_free (rhs);
+}
+
+
+/**
+ * Disconnect from the rps service
+ *
+ * @param h the handle to the rps service
+ */
+void
+GNUNET_RPS_disconnect (struct GNUNET_RPS_Handle *h)
+{
+  if (NULL != h->stream_requests_head)
+  {
+    struct GNUNET_RPS_StreamRequestHandle *srh_next;
+
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Still waiting for replies\n");
+    for (struct GNUNET_RPS_StreamRequestHandle *srh_iter =
+           h->stream_requests_head;
+         NULL != srh_iter;
+         srh_iter = srh_next)
+    {
+      srh_next = srh_iter->next;
+      GNUNET_RPS_stream_cancel (srh_iter);
+    }
+  }
+  if (NULL != h->rh_head)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not all requests were cancelled!\n");
+    for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
+         h->rh_head != NULL;
+         rh_iter = h->rh_head)
+    {
+      GNUNET_RPS_request_cancel (rh_iter);
+    }
+  }
+  if (NULL != h->rhs_head)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Not all requests were cancelled!\n");
+    for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
+         h->rhs_head != NULL;
+         rhs_iter = h->rhs_head)
+    {
+      GNUNET_RPS_request_single_info_cancel (rhs_iter);
+    }
+  }
+  if (NULL != srh_callback_peers)
+  {
+    GNUNET_free (srh_callback_peers);
+    srh_callback_peers = NULL;
+  }
+  if (NULL != h->view_update_cb)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Still waiting for view updates\n");
+    GNUNET_RPS_view_request_cancel (h);
+  }
+  if (NULL != h->nse)
+    GNUNET_NSE_disconnect (h->nse);
+  GNUNET_MQ_destroy (h->mq);
+  GNUNET_free (h);
+}
+
+
+/* end of rps_api.c */
diff --git a/src/contrib/service/rps/test_rps.c b/src/contrib/service/rps/test_rps.c
new file mode 100644
index 000000000..ab132ec8a
--- /dev/null
+++ b/src/contrib/service/rps/test_rps.c
@@ -0,0 +1,3183 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file rps/test_rps.c
+ * @brief Testcase for the random peer sampling service.  Starts
+ *        a peergroup with a given number of peers, then waits to
+ *        receive size pushes/pulls from each peer.  Expects to wait
+ *        for one message from each peer.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testbed_service.h"
+
+#include "gnunet_rps_service.h"
+#include "rps-test_util.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#include <inttypes.h>
+
+
+/**
+ * How many peers do we start?
+ */
+static uint32_t num_peers;
+
+/**
+ * How long do we run the test?
+ * In seconds.
+ */
+static uint32_t timeout_s;
+
+/**
+ * How long do we run the test?
+ */
+// #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+static struct GNUNET_TIME_Relative timeout;
+
+
+/**
+ * Portion of malicious peers
+ */
+static double portion = .1;
+
+/**
+ * Type of malicious peer to test
+ */
+static unsigned int mal_type = 0;
+
+/**
+ * Handles to all of the running peers
+ */
+static struct GNUNET_TESTBED_Peer **testbed_peers;
+
+/**
+ * @brief Indicates whether peer should go off- or online
+ */
+enum PEER_ONLINE_DELTA
+{
+  /**
+   * @brief Indicates peer going online
+   */
+  PEER_GO_ONLINE = 1,
+  /**
+   * @brief Indicates peer going offline
+   */
+  PEER_GO_OFFLINE = -1,
+};
+
+/**
+ * Operation map entry
+ */
+struct OpListEntry
+{
+  /**
+   * DLL next ptr
+   */
+  struct OpListEntry *next;
+
+  /**
+   * DLL prev ptr
+   */
+  struct OpListEntry *prev;
+
+  /**
+   * The testbed operation
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+  /**
+   * Depending on whether we start or stop RPS service at the peer, set this to
+   * #PEER_GO_ONLINE (1) or #PEER_GO_OFFLINE (-1)
+   */
+  enum PEER_ONLINE_DELTA delta;
+
+  /**
+   * Index of the regarding peer
+   */
+  unsigned int index;
+};
+
+/**
+ * OpList DLL head
+ */
+static struct OpListEntry *oplist_head;
+
+/**
+ * OpList DLL tail
+ */
+static struct OpListEntry *oplist_tail;
+
+
+/**
+ * A pending reply: A request was sent and the reply is pending.
+ */
+struct PendingReply
+{
+  /**
+   * DLL next,prev ptr
+   */
+  struct PendingReply *next;
+  struct PendingReply *prev;
+
+  /**
+   * Handle to the request we are waiting for
+   */
+  struct GNUNET_RPS_Request_Handle *req_handle;
+
+  /**
+   * The peer that requested
+   */
+  struct RPSPeer *rps_peer;
+};
+
+
+/**
+ * A pending request: A request was not made yet but is scheduled for later.
+ */
+struct PendingRequest
+{
+  /**
+   * DLL next,prev ptr
+   */
+  struct PendingRequest *next;
+  struct PendingRequest *prev;
+
+  /**
+   * Handle to the request we are waiting for
+   */
+  struct GNUNET_SCHEDULER_Task *request_task;
+
+  /**
+   * The peer that requested
+   */
+  struct RPSPeer *rps_peer;
+};
+
+
+/**
+ * Information we track for each peer.
+ */
+struct RPSPeer
+{
+  /**
+   * Index of the peer.
+   */
+  uint32_t index;
+
+  /**
+   * Handle for RPS connect operation.
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+  /**
+   * Handle to RPS service.
+   */
+  struct GNUNET_RPS_Handle *rps_handle;
+
+  /**
+   * Handle to stream requests
+   */
+  struct GNUNET_RPS_StreamRequestHandle *rps_srh;
+
+  /**
+   * ID of the peer.
+   */
+  struct GNUNET_PeerIdentity *peer_id;
+
+  /**
+   * A request handle to check for an request
+   */
+  // struct GNUNET_RPS_Request_Handle *req_handle;
+
+  /**
+   * Peer on- or offline?
+   */
+  int online;
+
+  /**
+   * Number of Peer IDs to request during the whole test
+   */
+  unsigned int num_ids_to_request;
+
+  /**
+   * Pending requests DLL
+   */
+  struct PendingRequest *pending_req_head;
+  struct PendingRequest *pending_req_tail;
+
+  /**
+   * Number of pending requests
+   */
+  unsigned int num_pending_reqs;
+
+  /**
+   * Pending replies DLL
+   */
+  struct PendingReply *pending_rep_head;
+  struct PendingReply *pending_rep_tail;
+
+  /**
+   * Number of pending replies
+   */
+  unsigned int num_pending_reps;
+
+  /**
+   * Number of received PeerIDs
+   */
+  unsigned int num_recv_ids;
+
+  /**
+   * Pending operation on that peer
+   */
+  const struct OpListEntry *entry_op_manage;
+
+  /**
+   * Testbed operation to connect to statistics service
+   */
+  struct GNUNET_TESTBED_Operation *stat_op;
+
+  /**
+   * Handle to the statistics service
+   */
+  struct GNUNET_STATISTICS_Handle *stats_h;
+
+  /**
+   * @brief flags to indicate which statistics values have been already
+   * collected from the statistics service.
+   * Used to check whether we are able to shutdown.
+   */
+  uint32_t stat_collected_flags;
+
+  /**
+   * @brief File name of the file the stats are finally written to
+   */
+  const char *file_name_stats;
+
+  /**
+   * @brief File name of the file the stats are finally written to
+   */
+  const char *file_name_probs;
+
+  /**
+   * @brief The current view
+   */
+  struct GNUNET_PeerIdentity *cur_view;
+
+  /**
+   * @brief Number of peers in the #cur_view.
+   */
+  uint32_t cur_view_count;
+
+  /**
+   * @brief Number of occurrences in other peer's view
+   */
+  uint32_t count_in_views;
+
+  /**
+   * @brief statistics values
+   */
+  uint64_t num_rounds;
+  uint64_t num_blocks;
+  uint64_t num_blocks_many_push;
+  uint64_t num_blocks_no_push;
+  uint64_t num_blocks_no_pull;
+  uint64_t num_blocks_many_push_no_pull;
+  uint64_t num_blocks_no_push_no_pull;
+  uint64_t num_issued_push;
+  uint64_t num_issued_pull_req;
+  uint64_t num_issued_pull_rep;
+  uint64_t num_sent_push;
+  uint64_t num_sent_pull_req;
+  uint64_t num_sent_pull_rep;
+  uint64_t num_recv_push;
+  uint64_t num_recv_pull_req;
+  uint64_t num_recv_pull_rep;
+};
+
+enum STAT_TYPE
+{
+  STAT_TYPE_ROUNDS                    =    0x1, /*   1 */
+  STAT_TYPE_BLOCKS                    =    0x2, /*   2 */
+  STAT_TYPE_BLOCKS_MANY_PUSH          =    0x4, /*   3 */
+  STAT_TYPE_BLOCKS_NO_PUSH            =    0x8, /*   4 */
+  STAT_TYPE_BLOCKS_NO_PULL            =   0x10, /*   5 */
+  STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL  =   0x20, /*   6 */
+  STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL    =   0x40, /*   7 */
+  STAT_TYPE_ISSUED_PUSH_SEND          =   0x80, /*   8 */
+  STAT_TYPE_ISSUED_PULL_REQ           =  0x100, /*   9 */
+  STAT_TYPE_ISSUED_PULL_REP           =  0x200, /*  10 */
+  STAT_TYPE_SENT_PUSH_SEND            =  0x400, /*  11 */
+  STAT_TYPE_SENT_PULL_REQ             =  0x800, /*  12 */
+  STAT_TYPE_SENT_PULL_REP             = 0x1000, /*  13 */
+  STAT_TYPE_RECV_PUSH_SEND            = 0x2000, /*  14 */
+  STAT_TYPE_RECV_PULL_REQ             = 0x4000, /*  15 */
+  STAT_TYPE_RECV_PULL_REP             = 0x8000, /*  16 */
+  STAT_TYPE_MAX          = 0x80000000, /*  32 */
+};
+
+struct STATcls
+{
+  struct RPSPeer *rps_peer;
+  enum STAT_TYPE stat_type;
+};
+
+
+/**
+ * Information for all the peers.
+ */
+static struct RPSPeer *rps_peers;
+
+/**
+ * Peermap to get the index of a given peer ID quick.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+
+/**
+ * IDs of the peers.
+ */
+static struct GNUNET_PeerIdentity *rps_peer_ids;
+
+/**
+ * ID of the targeted peer.
+ */
+static struct GNUNET_PeerIdentity *target_peer;
+
+/**
+ * ID of the peer that requests for the evaluation.
+ */
+static struct RPSPeer *eval_peer;
+
+/**
+ * Number of online peers.
+ */
+static unsigned int num_peers_online;
+
+/**
+ * @brief The added sizes of the peer's views
+ */
+static unsigned int view_sizes;
+
+/**
+ * Return value from 'main'.
+ */
+static int ok;
+
+/**
+ * Identifier for the churn task that runs periodically
+ */
+static struct GNUNET_SCHEDULER_Task *post_test_task;
+
+/**
+ * Identifier for the churn task that runs periodically
+ */
+static struct GNUNET_SCHEDULER_Task *shutdown_task;
+
+/**
+ * Identifier for the churn task that runs periodically
+ */
+static struct GNUNET_SCHEDULER_Task *churn_task;
+
+/**
+ * Called to initialise the given RPSPeer
+ */
+typedef void (*InitPeer) (struct RPSPeer *rps_peer);
+
+/**
+ * @brief Called directly after connecting to the service
+ *
+ * @param rps_peer Specific peer the function is called on
+ * @param h the handle to the rps service
+ */
+typedef void (*PreTest) (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h);
+
+/**
+ * @brief Executes functions to test the api/service for a given peer
+ *
+ * Called from within #rps_connect_complete_cb ()
+ * Implemented by #churn_test_cb, #profiler_cb, #mal_cb, #single_req_cb,
+ * #delay_req_cb, #seed_big_cb, #single_peer_seed_cb, #seed_cb, #req_cancel_cb
+ *
+ * @param rps_peer the peer the task runs on
+ */
+typedef void (*MainTest) (struct RPSPeer *rps_peer);
+
+/**
+ * Callback called once the requested random peers are available
+ */
+typedef void (*ReplyHandle) (void *cls,
+                             uint64_t n,
+                             const struct GNUNET_PeerIdentity *recv_peers);
+
+/**
+ * Called directly before disconnecting from the service
+ */
+typedef void (*PostTest) (struct RPSPeer *peer);
+
+/**
+ * Function called after disconnect to evaluate test success
+ */
+typedef int (*EvaluationCallback) (void);
+
+/**
+ * @brief Do we have Churn?
+ */
+enum OPTION_CHURN
+{
+  /**
+   * @brief If we have churn this is set
+   */
+  HAVE_CHURN,
+  /**
+   * @brief If we have no churn this is set
+   */
+  HAVE_NO_CHURN,
+};
+
+/**
+ * @brief Is it ok to quit the test before the timeout?
+ */
+enum OPTION_QUICK_QUIT
+{
+  /**
+   * @brief It is ok for the test to quit before the timeout triggers
+   */
+  HAVE_QUICK_QUIT,
+
+  /**
+   * @brief It is NOT ok for the test to quit before the timeout triggers
+   */
+  HAVE_NO_QUICK_QUIT,
+};
+
+/**
+ * @brief Do we collect statistics at the end?
+ */
+enum OPTION_COLLECT_STATISTICS
+{
+  /**
+   * @brief We collect statistics at the end
+   */
+  COLLECT_STATISTICS,
+
+  /**
+   * @brief We do not collect statistics at the end
+   */
+  NO_COLLECT_STATISTICS,
+};
+
+/**
+ * @brief Do we collect views during run?
+ */
+enum OPTION_COLLECT_VIEW
+{
+  /**
+   * @brief We collect view during run
+   */
+  COLLECT_VIEW,
+
+  /**
+   * @brief We do not collect the view during run
+   */
+  NO_COLLECT_VIEW,
+};
+
+/**
+ * Structure to define a single test
+ */
+struct SingleTestRun
+{
+  /**
+   * Name of the test
+   */
+  char *name;
+
+  /**
+   * Called with a single peer in order to initialise that peer
+   */
+  InitPeer init_peer;
+
+  /**
+   * Called directly after connecting to the service
+   */
+  PreTest pre_test;
+
+  /**
+   * Main function for each peer
+   */
+  MainTest main_test;
+
+  /**
+   * Callback called once the requested peers are available
+   */
+  ReplyHandle reply_handle;
+
+  /**
+   * Called directly before disconnecting from the service
+   */
+  PostTest post_test;
+
+  /**
+   * Function to evaluate the test results
+   */
+  EvaluationCallback eval_cb;
+
+  /**
+   * Request interval
+   */
+  uint32_t request_interval;
+
+  /**
+   * Number of Requests to make.
+   */
+  uint32_t num_requests;
+
+  /**
+   * Run with (-out) churn
+   */
+  enum OPTION_CHURN have_churn;
+
+  /**
+   * Quit test before timeout?
+   */
+  enum OPTION_QUICK_QUIT have_quick_quit;
+
+  /**
+   * Collect statistics at the end?
+   */
+  enum OPTION_COLLECT_STATISTICS have_collect_statistics;
+
+  /**
+   * Collect view during run?
+   */
+  enum OPTION_COLLECT_VIEW have_collect_view;
+
+  /**
+   * @brief Mark which values from the statistics service to collect at the end
+   * of the run
+   */
+  uint32_t stat_collect_flags;
+} cur_test_run;
+
+/**
+ * Did we finish the test?
+ */
+static int post_test;
+
+/**
+ * Are we shutting down?
+ */
+static int in_shutdown;
+
+/**
+ * Append arguments to file
+ */
+static void
+tofile_ (const char *file_name, const char *line)
+{
+  struct GNUNET_DISK_FileHandle *f;
+  /* char output_buffer[512]; */
+  size_t size;
+  /* int size; */
+  size_t size2;
+
+  if (NULL == (f = GNUNET_DISK_file_open (file_name,
+                                          GNUNET_DISK_OPEN_APPEND
+                                          | GNUNET_DISK_OPEN_WRITE
+                                          | GNUNET_DISK_OPEN_CREATE,
+                                          GNUNET_DISK_PERM_USER_READ
+                                          | GNUNET_DISK_PERM_USER_WRITE
+                                          | GNUNET_DISK_PERM_GROUP_READ
+                                          | GNUNET_DISK_PERM_OTHER_READ)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Not able to open file %s\n",
+                file_name);
+    return;
+  }
+  /* size = GNUNET_snprintf (output_buffer,
+                          sizeof (output_buffer),
+                          "%llu %s\n",
+                          GNUNET_TIME_absolute_get ().abs_value_us,
+                          line);
+     if (0 > size)
+     {
+     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to write string to buffer (size: %i)\n",
+                size);
+     return;
+     } */size = strlen (line) * sizeof(char);
+
+  size2 = GNUNET_DISK_file_write (f, line, size);
+  if (size != size2)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unable to write to file! (Size: %lu, size2: %lu)\n",
+                size,
+                size2);
+    if (GNUNET_YES != GNUNET_DISK_file_close (f))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Unable to close file\n");
+    }
+    return;
+  }
+
+  if (GNUNET_YES != GNUNET_DISK_file_close (f))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unable to close file\n");
+  }
+}
+
+
+/**
+ * This function is used to facilitate writing important information to disk
+ */
+#define tofile(file_name, ...) do { \
+    char tmp_buf[512]; \
+    int size; \
+    size = GNUNET_snprintf (tmp_buf, sizeof(tmp_buf), __VA_ARGS__); \
+    if (0 > size) \
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \
+                "Failed to create tmp_buf\n"); \
+    else \
+    tofile_ (file_name, tmp_buf); \
+} while (0);
+
+
+/**
+ * Write the ids and their according index in the given array to a file
+ * Unused
+ */
+/* static void
+   ids_to_file (char *file_name,
+             struct GNUNET_PeerIdentity *peer_ids,
+             unsigned int num_peer_ids)
+   {
+   unsigned int i;
+
+   for (i=0 ; i < num_peer_ids ; i++)
+   {
+    to_file (file_name,
+             "%u\t%s",
+             i,
+             GNUNET_i2s_full (&peer_ids[i]));
+   }
+   } */
+
+/**
+ * Task run on timeout to collect statistics and potentially shut down.
+ */
+static void
+post_test_op (void *cls);
+
+
+/**
+ * Test the success of a single test
+ */
+static int
+evaluate (void)
+{
+  unsigned int i;
+  int tmp_ok;
+
+  tmp_ok = 1;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u. peer [%s] received %u of %u expected peer_ids: %i\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                rps_peers[i].num_recv_ids,
+                rps_peers[i].num_ids_to_request,
+                (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids));
+    tmp_ok &= (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids);
+  }
+  return tmp_ok ? 0 : 1;
+}
+
+
+/**
+ * Creates an oplist entry and adds it to the oplist DLL
+ */
+static struct OpListEntry *
+make_oplist_entry ()
+{
+  struct OpListEntry *entry;
+
+  entry = GNUNET_new (struct OpListEntry);
+  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
+  return entry;
+}
+
+
+/**
+ * @brief Checks if given peer already received its statistics value from the
+ * statistics service.
+ *
+ * @param rps_peer the peer to check for
+ *
+ * @return #GNUNET_YES if so
+ *         #GNUNET_NO otherwise
+ */
+static int
+check_statistics_collect_completed_single_peer (
+  const struct RPSPeer *rps_peer)
+{
+  if (cur_test_run.stat_collect_flags !=
+      (cur_test_run.stat_collect_flags
+       & rps_peer->stat_collected_flags))
+  {
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * @brief Checks if all peers already received their statistics value from the
+ * statistics service.
+ *
+ * @return #GNUNET_YES if so
+ *         #GNUNET_NO otherwise
+ */
+static int
+check_statistics_collect_completed ()
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    if (GNUNET_NO == check_statistics_collect_completed_single_peer (
+          &rps_peers[i]))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "At least Peer %" PRIu32
+                  " did not yet receive all statistics values\n",
+                  i);
+      return GNUNET_NO;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All peers received their statistics values\n");
+  return GNUNET_YES;
+}
+
+
+/**
+ * Task run on timeout to shut everything down.
+ */
+static void
+shutdown_op (void *cls)
+{
+  unsigned int i;
+
+  (void) cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Shutdown task scheduled, going down.\n");
+  in_shutdown = GNUNET_YES;
+  if (NULL != post_test_task)
+  {
+    GNUNET_SCHEDULER_cancel (post_test_task);
+    post_test_op (NULL);
+  }
+  if (NULL != churn_task)
+  {
+    GNUNET_SCHEDULER_cancel (churn_task);
+    churn_task = NULL;
+  }
+  for (i = 0; i < num_peers; i++)
+  {
+    if (NULL != rps_peers[i].rps_handle)
+    {
+      GNUNET_RPS_disconnect (rps_peers[i].rps_handle);
+    }
+    if (NULL != rps_peers[i].op)
+    {
+      GNUNET_TESTBED_operation_done (rps_peers[i].op);
+    }
+  }
+}
+
+
+/**
+ * Task run on timeout to collect statistics and potentially shut down.
+ */
+static void
+post_test_op (void *cls)
+{
+  unsigned int i;
+
+  (void) cls;
+
+  post_test_task = NULL;
+  post_test = GNUNET_YES;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Post test task scheduled, going down.\n");
+  if (NULL != churn_task)
+  {
+    GNUNET_SCHEDULER_cancel (churn_task);
+    churn_task = NULL;
+  }
+  for (i = 0; i < num_peers; i++)
+  {
+    if (NULL != cur_test_run.post_test)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing post_test for peer %u\n",
+                  i);
+      cur_test_run.post_test (&rps_peers[i]);
+    }
+    if (NULL != rps_peers[i].op)
+    {
+      GNUNET_TESTBED_operation_done (rps_peers[i].op);
+      rps_peers[i].op = NULL;
+    }
+  }
+  /* If we do not collect statistics, shut down directly */
+  if ((NO_COLLECT_STATISTICS == cur_test_run.have_collect_statistics) ||
+      (GNUNET_YES == check_statistics_collect_completed ()) )
+  {
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Seed peers.
+ */
+static void
+seed_peers (void *cls)
+{
+  struct RPSPeer *peer = cls;
+  unsigned int amount;
+  unsigned int i;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  GNUNET_assert (NULL != peer->rps_handle);
+
+  // TODO if malicious don't seed mal peers
+  amount = round (.5 * num_peers);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding peers:\n");
+  for (i = 0; i < amount; i++)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
+                i,
+                GNUNET_i2s (&rps_peer_ids[i]));
+
+  GNUNET_RPS_seed_ids (peer->rps_handle, amount, rps_peer_ids);
+}
+
+
+/**
+ * Seed peers.
+ */
+static void
+seed_peers_big (void *cls)
+{
+  struct RPSPeer *peer = cls;
+  unsigned int seed_msg_size;
+  uint32_t num_peers_max;
+  unsigned int amount;
+  unsigned int i;
+
+  seed_msg_size = 8; /* sizeof (struct GNUNET_RPS_CS_SeedMessage) */
+  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE - seed_msg_size)
+                  / sizeof(struct GNUNET_PeerIdentity);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peers that fit in one seed msg; %u\n",
+              num_peers_max);
+  amount = num_peers_max + (0.5 * num_peers_max);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Seeding many (%u) peers:\n",
+              amount);
+  struct GNUNET_PeerIdentity ids_to_seed[amount];
+  for (i = 0; i < amount; i++)
+  {
+    ids_to_seed[i] = *peer->peer_id;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
+                i,
+                GNUNET_i2s (&ids_to_seed[i]));
+  }
+
+  GNUNET_RPS_seed_ids (peer->rps_handle, amount, ids_to_seed);
+}
+
+
+/**
+ * Get the id of peer i.
+ */
+void
+info_cb (void *cb_cls,
+         struct GNUNET_TESTBED_Operation *op,
+         const struct GNUNET_TESTBED_PeerInformation *pinfo,
+         const char *emsg)
+{
+  struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
+
+  (void) op;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  if ((NULL == pinfo) || (NULL != emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got Error: %s\n", emsg);
+    GNUNET_TESTBED_operation_done (entry->op);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u is %s\n",
+              entry->index,
+              GNUNET_i2s (pinfo->result.id));
+
+  rps_peer_ids[entry->index] = *(pinfo->result.id);
+  rps_peers[entry->index].peer_id = &rps_peer_ids[entry->index];
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (peer_map,
+                                                    &rps_peer_ids[entry->index],
+                                                    &rps_peers[entry->index],
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  tofile ("/tmp/rps/peer_ids",
+          "%u\t%s\n",
+          entry->index,
+          GNUNET_i2s_full (&rps_peer_ids[entry->index]));
+
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  GNUNET_TESTBED_operation_done (entry->op);
+  GNUNET_free (entry);
+}
+
+
+/**
+ * Callback to be called when RPS service connect operation is completed
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @param op the operation that has been finished
+ * @param ca_result the RPS service handle returned from rps_connect_adapter
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+rps_connect_complete_cb (void *cls,
+                         struct GNUNET_TESTBED_Operation *op,
+                         void *ca_result,
+                         const char *emsg)
+{
+  struct RPSPeer *rps_peer = cls;
+  struct GNUNET_RPS_Handle *rps = ca_result;
+
+  GNUNET_assert (NULL != ca_result);
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  rps_peer->rps_handle = rps;
+  rps_peer->online = GNUNET_YES;
+  num_peers_online++;
+
+  GNUNET_assert (op == rps_peer->op);
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to RPS service: %s\n",
+                emsg);
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started client successfully\n");
+
+  cur_test_run.main_test (rps_peer);
+}
+
+
+/**
+ * Adapter function called to establish a connection to
+ * the RPS service.
+ *
+ * @param cls closure
+ * @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 *
+rps_connect_adapter (void *cls,
+                     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_RPS_Handle *h;
+
+  h = GNUNET_RPS_connect (cfg);
+  GNUNET_assert (NULL != h);
+
+  if (NULL != cur_test_run.pre_test)
+    cur_test_run.pre_test (cls, h);
+  GNUNET_assert (NULL != h);
+
+  return h;
+}
+
+
+/**
+ * Called to open a connection to the peer's statistics
+ *
+ * @param cls peer 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 *
+stat_connect_adapter (void *cls,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct RPSPeer *peer = cls;
+
+  peer->stats_h = GNUNET_STATISTICS_create ("rps-profiler", cfg);
+  return peer->stats_h;
+}
+
+
+/**
+ * Called to disconnect from peer's statistics service
+ *
+ * @param cls peer context
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+stat_disconnect_adapter (void *cls, void *op_result)
+{
+  struct RPSPeer *peer = cls;
+
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "core", "# peers connected",
+  //               stat_iterator, peer));
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "nse", "# peers connected",
+  //               stat_iterator, peer));
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
+  peer->stats_h = NULL;
+}
+
+
+/**
+ * Called after successfully opening a connection to a peer's statistics
+ * service; we register statistics monitoring for CORE and NSE here.
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @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
+stat_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result, const char *emsg)
+{
+  // struct GNUNET_STATISTICS_Handle *sh = ca_result;
+  // struct RPSPeer *peer = (struct RPSPeer *) cls;
+  (void) cls;
+  (void) op;
+  (void) ca_result;
+
+  if (NULL != emsg)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "core", "# peers connected",
+  //               stat_iterator, peer));
+  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "nse", "# peers connected",
+  //               stat_iterator, peer));
+}
+
+
+/**
+ * Adapter function called to destroy connection to
+ * RPS service.
+ *
+ * @param cls closure
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+rps_disconnect_adapter (void *cls,
+                        void *op_result)
+{
+  struct RPSPeer *peer = cls;
+  struct GNUNET_RPS_Handle *h = op_result;
+
+  if (NULL != peer->rps_srh)
+  {
+    GNUNET_RPS_stream_cancel (peer->rps_srh);
+    peer->rps_srh = NULL;
+  }
+  GNUNET_assert (NULL != peer);
+  GNUNET_RPS_disconnect (h);
+  peer->rps_handle = NULL;
+}
+
+
+/***********************************************************************
+* Definition of tests
+***********************************************************************/
+
+// TODO check whether tests can be stopped earlier
+static int
+default_eval_cb (void)
+{
+  return evaluate ();
+}
+
+
+static int
+no_eval (void)
+{
+  return 0;
+}
+
+
+/**
+ * Initialise given RPSPeer
+ */
+static void
+default_init_peer (struct RPSPeer *rps_peer)
+{
+  rps_peer->num_ids_to_request = 1;
+}
+
+
+/**
+ * Callback to call on receipt of a reply
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+default_reply_handle (void *cls,
+                      uint64_t n,
+                      const struct GNUNET_PeerIdentity *recv_peers)
+{
+  struct RPSPeer *rps_peer;
+  struct PendingReply *pending_rep = (struct PendingReply *) cls;
+  unsigned int i;
+
+  rps_peer = pending_rep->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
+                               rps_peer->pending_rep_tail,
+                               pending_rep);
+  rps_peer->num_pending_reps--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "[%s] got %" PRIu64 " peers:\n",
+              GNUNET_i2s (rps_peer->peer_id),
+              n);
+
+  for (i = 0; i < n; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u: %s\n",
+                i,
+                GNUNET_i2s (&recv_peers[i]));
+
+    rps_peer->num_recv_ids++;
+  }
+
+  if ((0 == evaluate ()) && (HAVE_QUICK_QUIT == cur_test_run.have_quick_quit))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test succeeded before timeout\n");
+    GNUNET_assert (NULL != post_test_task);
+    GNUNET_SCHEDULER_cancel (post_test_task);
+    post_test_task = GNUNET_SCHEDULER_add_now (&post_test_op, NULL);
+    GNUNET_assert (NULL != post_test_task);
+  }
+}
+
+
+/**
+ * Request random peers.
+ */
+static void
+request_peers (void *cls)
+{
+  struct PendingRequest *pending_req = cls;
+  struct RPSPeer *rps_peer;
+  struct PendingReply *pending_rep;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+    return;
+  rps_peer = pending_req->rps_peer;
+  GNUNET_assert (1 <= rps_peer->num_pending_reqs);
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
+                               rps_peer->pending_req_tail,
+                               pending_req);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Requesting one peer\n");
+  pending_rep = GNUNET_new (struct PendingReply);
+  pending_rep->rps_peer = rps_peer;
+  pending_rep->req_handle = GNUNET_RPS_request_peers (rps_peer->rps_handle,
+                                                      1,
+                                                      cur_test_run.reply_handle,
+                                                      pending_rep);
+  GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_rep_head,
+                                    rps_peer->pending_rep_tail,
+                                    pending_rep);
+  rps_peer->num_pending_reps++;
+  rps_peer->num_pending_reqs--;
+}
+
+
+static void
+cancel_pending_req (struct PendingRequest *pending_req)
+{
+  struct RPSPeer *rps_peer;
+
+  rps_peer = pending_req->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
+                               rps_peer->pending_req_tail,
+                               pending_req);
+  rps_peer->num_pending_reqs--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling pending request\n");
+  GNUNET_SCHEDULER_cancel (pending_req->request_task);
+  GNUNET_free (pending_req);
+}
+
+
+static void
+cancel_request (struct PendingReply *pending_rep)
+{
+  struct RPSPeer *rps_peer;
+
+  rps_peer = pending_rep->rps_peer;
+  GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
+                               rps_peer->pending_rep_tail,
+                               pending_rep);
+  rps_peer->num_pending_reps--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling request\n");
+  GNUNET_RPS_request_cancel (pending_rep->req_handle);
+  GNUNET_free (pending_rep);
+}
+
+
+/**
+ * Cancel a request.
+ */
+static void
+cancel_request_cb (void *cls)
+{
+  struct RPSPeer *rps_peer = cls;
+  struct PendingReply *pending_rep;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+    return;
+  pending_rep = rps_peer->pending_rep_head;
+  GNUNET_assert (1 <= rps_peer->num_pending_reps);
+  cancel_request (pending_rep);
+}
+
+
+/**
+ * Schedule requests for peer @a rps_peer that have neither been scheduled, nor
+ * issued, nor replied
+ */
+void
+schedule_missing_requests (struct RPSPeer *rps_peer)
+{
+  unsigned int i;
+  struct PendingRequest *pending_req;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling %u - %u missing requests\n",
+              rps_peer->num_ids_to_request,
+              rps_peer->num_pending_reqs + rps_peer->num_pending_reps);
+  GNUNET_assert (rps_peer->num_pending_reqs + rps_peer->num_pending_reps <=
+                 rps_peer->num_ids_to_request);
+  for (i = rps_peer->num_pending_reqs + rps_peer->num_pending_reps;
+       i < rps_peer->num_ids_to_request; i++)
+  {
+    pending_req = GNUNET_new (struct PendingRequest);
+    pending_req->rps_peer = rps_peer;
+    pending_req->request_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     cur_test_run.request_interval * i),
+      request_peers,
+      pending_req);
+    GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_req_head,
+                                      rps_peer->pending_req_tail,
+                                      pending_req);
+    rps_peer->num_pending_reqs++;
+  }
+}
+
+
+void
+cancel_pending_req_rep (struct RPSPeer *rps_peer)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelling all (pending) requests.\n");
+  while (NULL != rps_peer->pending_req_head)
+    cancel_pending_req (rps_peer->pending_req_head);
+  GNUNET_assert (0 == rps_peer->num_pending_reqs);
+  while (NULL != rps_peer->pending_rep_head)
+    cancel_request (rps_peer->pending_rep_head);
+  GNUNET_assert (0 == rps_peer->num_pending_reps);
+}
+
+
+/***********************************
+* MALICIOUS
+***********************************/
+
+/**
+ * Initialise only non-mal RPSPeers
+ */
+static void
+mal_init_peer (struct RPSPeer *rps_peer)
+{
+  if (rps_peer->index >= round (portion * num_peers))
+    rps_peer->num_ids_to_request = 1;
+}
+
+
+/**
+ * @brief Set peers to (non-)malicious before execution
+ *
+ * Of signature #PreTest
+ *
+ * @param rps_peer the peer to set (non-) malicious
+ * @param h the handle to the service
+ */
+static void
+mal_pre (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
+{
+  #if ENABLE_MALICIOUS
+  uint32_t num_mal_peers;
+
+  GNUNET_assert ((1 >= portion) &&
+                 (0 < portion));
+  num_mal_peers = round (portion * num_peers);
+
+  if (rps_peer->index < num_mal_peers)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u. peer [%s] of %" PRIu32
+                " malicious peers turning malicious\n",
+                rps_peer->index,
+                GNUNET_i2s (rps_peer->peer_id),
+                num_mal_peers);
+
+    GNUNET_RPS_act_malicious (h, mal_type, num_mal_peers,
+                              rps_peer_ids, target_peer);
+  }
+  #endif /* ENABLE_MALICIOUS */
+}
+
+
+static void
+mal_cb (struct RPSPeer *rps_peer)
+{
+  uint32_t num_mal_peers;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  #if ENABLE_MALICIOUS
+  GNUNET_assert ((1 >= portion) &&
+                 (0 < portion));
+  num_mal_peers = round (portion * num_peers);
+
+  if (rps_peer->index >= num_mal_peers)
+  {   /* It's useless to ask a malicious peer about a random sample -
+         it's not sampling */
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+                                    GNUNET_TIME_UNIT_SECONDS, 2),
+                                  seed_peers, rps_peer);
+    schedule_missing_requests (rps_peer);
+  }
+  #endif /* ENABLE_MALICIOUS */
+}
+
+
+/***********************************
+* SINGLE_REQUEST
+***********************************/
+static void
+single_req_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  schedule_missing_requests (rps_peer);
+}
+
+
+/***********************************
+* DELAYED_REQUESTS
+***********************************/
+static void
+delay_req_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  schedule_missing_requests (rps_peer);
+}
+
+
+/***********************************
+* SEED
+***********************************/
+static void
+seed_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
+    seed_peers, rps_peer);
+}
+
+
+/***********************************
+* SEED_BIG
+***********************************/
+static void
+seed_big_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  // TODO test seeding > GNUNET_MAX_MESSAGE_SIZE peers
+  GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
+    seed_peers_big, rps_peer);
+}
+
+
+/***********************************
+* SINGLE_PEER_SEED
+***********************************/
+static void
+single_peer_seed_cb (struct RPSPeer *rps_peer)
+{
+  (void) rps_peer;
+  // TODO
+}
+
+
+/***********************************
+* SEED_REQUEST
+***********************************/
+static void
+seed_req_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
+    seed_peers, rps_peer);
+  schedule_missing_requests (rps_peer);
+}
+
+
+// TODO start big mal
+
+/***********************************
+* REQUEST_CANCEL
+***********************************/
+static void
+req_cancel_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  schedule_missing_requests (rps_peer);
+  GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                   (cur_test_run.request_interval + 1)),
+    cancel_request_cb, rps_peer);
+}
+
+
+/***********************************
+* CHURN
+***********************************/
+
+static void
+churn (void *cls);
+
+/**
+ * @brief Starts churn
+ *
+ * Has signature of #MainTest
+ *
+ * This is not implemented too nicely as this is called for each peer, but we
+ * only need to call it once. (Yes we check that we only schedule the task
+ * once.)
+ *
+ * @param rps_peer The peer it's called for
+ */
+static void
+churn_test_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  /* Start churn */
+  if ((HAVE_CHURN == cur_test_run.have_churn) && (NULL == churn_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting churn task\n");
+    churn_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+      churn,
+      NULL);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not starting churn task\n");
+  }
+
+  schedule_missing_requests (rps_peer);
+}
+
+
+/***********************************
+* SUB
+***********************************/
+
+static void
+got_stream_peer_cb (void *cls,
+                    uint64_t num_peers,
+                    const struct GNUNET_PeerIdentity *peers)
+{
+  const struct RPSPeer *rps_peer = cls;
+
+  for (uint64_t i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer %" PRIu32 " received [%s] from stream.\n",
+                rps_peer->index,
+                GNUNET_i2s (&peers[i]));
+    if ((0 != rps_peer->index) &&
+        (0 == memcmp (&peers[i],
+                      &rps_peers[0].peer_id,
+                      sizeof(struct GNUNET_PeerIdentity))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Received a peer id outside sub\n");
+      ok = 1;
+    }
+    else if ((0 == rps_peer->index) &&
+             (0 != memcmp (&peers[i],
+                           &rps_peers[0].peer_id,
+                           sizeof(struct GNUNET_PeerIdentity))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Received a peer id outside sub (lonely)\n");
+      ok = 1;
+    }
+  }
+}
+
+
+static void
+sub_post (struct RPSPeer *rps_peer)
+{
+  if (0 != rps_peer->index)
+    GNUNET_RPS_sub_stop (rps_peer->rps_handle, "test");
+  else
+    GNUNET_RPS_sub_stop (rps_peer->rps_handle, "lonely");
+}
+
+
+static void
+sub_pre (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
+{
+  (void) rps_peer;
+
+  if (0 != rps_peer->index)
+    GNUNET_RPS_sub_start (h, "test");
+  else
+    GNUNET_RPS_sub_start (h, "lonely");    /* have a group of one */
+  rps_peer->rps_srh = GNUNET_RPS_stream_request (h,
+                                                 &got_stream_peer_cb,
+                                                 rps_peer);
+}
+
+
+/***********************************
+* PROFILER
+***********************************/
+
+/**
+ * Callback to be called when RPS service is started or stopped at peers
+ *
+ * @param cls NULL
+ * @param op the operation handle
+ * @param emsg NULL on success; otherwise an error description
+ */
+static void
+churn_cb (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          const char *emsg)
+{
+  (void) op;
+  // FIXME
+  struct OpListEntry *entry = cls;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  GNUNET_TESTBED_operation_done (entry->op);
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to start/stop RPS at a peer\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_assert (0 != entry->delta);
+
+  num_peers_online += entry->delta;
+
+  if (PEER_GO_OFFLINE == entry->delta)
+  {   /* Peer hopefully just went offline */
+    if (GNUNET_YES != rps_peers[entry->index].online)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "peer %s was expected to go offline but is still marked as online\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      GNUNET_break (0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "peer %s probably went offline as expected\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+    }
+    rps_peers[entry->index].online = GNUNET_NO;
+  }
+
+  else if (PEER_GO_ONLINE < entry->delta)
+  {   /* Peer hopefully just went online */
+    if (GNUNET_NO != rps_peers[entry->index].online)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "peer %s was expected to go online but is still marked as offline\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      GNUNET_break (0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "peer %s probably went online as expected\n",
+                  GNUNET_i2s (rps_peers[entry->index].peer_id));
+      if (NULL != cur_test_run.pre_test)
+      {
+        cur_test_run.pre_test (&rps_peers[entry->index],
+                               rps_peers[entry->index].rps_handle);
+        schedule_missing_requests (&rps_peers[entry->index]);
+      }
+    }
+    rps_peers[entry->index].online = GNUNET_YES;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Invalid value for delta: %i\n", entry->delta);
+    GNUNET_break (0);
+  }
+
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  rps_peers[entry->index].entry_op_manage = NULL;
+  GNUNET_free (entry);
+  // if (num_peers_in_round[current_round] == peers_running)
+  //  run_round ();
+}
+
+
+/**
+ * @brief Set the rps-service up or down for a specific peer
+ *
+ * @param i index of action
+ * @param j index of peer
+ * @param delta (#PEER_ONLINE_DELTA) down (-1) or up (1)
+ * @param prob_go_on_off the probability of the action
+ */
+static void
+manage_service_wrapper (unsigned int i, unsigned int j,
+                        enum PEER_ONLINE_DELTA delta,
+                        double prob_go_on_off)
+{
+  struct OpListEntry *entry = NULL;
+  uint32_t prob;
+
+  /* make sure that management operation is not already scheduled */
+  if (NULL != rps_peers[j].entry_op_manage)
+  {
+    return;
+  }
+
+  prob = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                   UINT32_MAX);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%u. selected peer (%u: %s) is %s.\n",
+              i,
+              j,
+              GNUNET_i2s (rps_peers[j].peer_id),
+              (PEER_GO_ONLINE == delta) ? "online" : "offline");
+  if (prob < prob_go_on_off * UINT32_MAX)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%s goes %s\n",
+                GNUNET_i2s (rps_peers[j].peer_id),
+                (PEER_GO_OFFLINE == delta) ? "offline" : "online");
+
+    if (PEER_GO_OFFLINE == delta)
+      cancel_pending_req_rep (&rps_peers[j]);
+    entry = make_oplist_entry ();
+    entry->delta = delta;
+    entry->index = j;
+    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
+                                                    testbed_peers[j],
+                                                    "rps",
+                                                    &churn_cb,
+                                                    entry,
+                                                    (PEER_GO_OFFLINE == delta) ?
+                                                    0 : 1);
+    rps_peers[j].entry_op_manage = entry;
+  }
+}
+
+
+static void
+churn (void *cls)
+{
+  (void) cls;
+  unsigned int i;
+  unsigned int j;
+  double portion_online;
+  unsigned int *permut;
+  double prob_go_offline;
+  double portion_go_online;
+  double portion_go_offline;
+
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Churn function executing\n");
+
+  churn_task = NULL; /* Should be invalid by now */
+
+  /* Compute the probability for an online peer to go offline
+   * this round */
+  portion_online = num_peers_online * 1.0 / num_peers;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion online: %f\n",
+              portion_online);
+  portion_go_online = ((1 - portion_online) * .5 * .66);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion that should go online: %f\n",
+              portion_go_online);
+  portion_go_offline = (portion_online + portion_go_online) - .75;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Portion that probably goes offline: %f\n",
+              portion_go_offline);
+  prob_go_offline = portion_go_offline / (portion_online * .5);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Probability of a selected online peer to go offline: %f\n",
+              prob_go_offline);
+
+  permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         (unsigned int) num_peers);
+
+  /* Go over 50% randomly chosen peers */
+  for (i = 0; i < .5 * num_peers; i++)
+  {
+    j = permut[i];
+
+    /* If online, shut down with certain probability */
+    if (GNUNET_YES == rps_peers[j].online)
+    {
+      manage_service_wrapper (i, j, -1, prob_go_offline);
+    }
+
+    /* If offline, restart with certain probability */
+    else if (GNUNET_NO == rps_peers[j].online)
+    {
+      manage_service_wrapper (i, j, 1, 0.66);
+    }
+  }
+
+  GNUNET_free (permut);
+
+  churn_task = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
+    churn,
+    NULL);
+}
+
+
+/**
+ * Initialise given RPSPeer
+ */
+static void
+profiler_init_peer (struct RPSPeer *rps_peer)
+{
+  if (num_peers - 1 == rps_peer->index)
+    rps_peer->num_ids_to_request = cur_test_run.num_requests;
+}
+
+
+/**
+ * Callback to call on receipt of a reply
+ *
+ * @param cls closure
+ * @param n number of peers
+ * @param recv_peers the received peers
+ */
+static void
+profiler_reply_handle (void *cls,
+                       uint64_t n,
+                       const struct GNUNET_PeerIdentity *recv_peers)
+{
+  struct RPSPeer *rps_peer;
+  struct RPSPeer *rcv_rps_peer;
+  char *file_name;
+  char *file_name_dh;
+  unsigned int i;
+  struct PendingReply *pending_rep = (struct PendingReply *) cls;
+
+  rps_peer = pending_rep->rps_peer;
+  file_name = "/tmp/rps/received_ids";
+  file_name_dh = "/tmp/rps/diehard_input";
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "[%s] got %" PRIu64 " peers:\n",
+              GNUNET_i2s (rps_peer->peer_id),
+              n);
+  for (i = 0; i < n; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u: %s\n",
+                i,
+                GNUNET_i2s (&recv_peers[i]));
+    tofile (file_name,
+            "%s\n",
+            GNUNET_i2s_full (&recv_peers[i]));
+    rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, &recv_peers[i]);
+    GNUNET_assert (NULL != rcv_rps_peer);
+    tofile (file_name_dh,
+            "%" PRIu32 "\n",
+            (uint32_t) rcv_rps_peer->index);
+  }
+  default_reply_handle (cls, n, recv_peers);
+}
+
+
+static void
+profiler_cb (struct RPSPeer *rps_peer)
+{
+  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
+  {
+    return;
+  }
+
+  /* Start churn */
+  if ((HAVE_CHURN == cur_test_run.have_churn) && (NULL == churn_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting churn task\n");
+    churn_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+      churn,
+      NULL);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Not starting churn task\n");
+  }
+
+  /* Only request peer ids at one peer.
+   * (It's the before-last because last one is target of the focused attack.)
+   */
+  if (eval_peer == rps_peer)
+    schedule_missing_requests (rps_peer);
+}
+
+
+/**
+ * Function called from #profiler_eval with a filename.
+ *
+ * @param cls closure
+ * @param filename complete filename (absolute path)
+ * @return #GNUNET_OK to continue to iterate,
+ *  #GNUNET_NO to stop iteration with no error,
+ *  #GNUNET_SYSERR to abort iteration with error!
+ */
+int
+file_name_cb (void *cls, const char *filename)
+{
+  (void) cls;
+
+  if (NULL != strstr (filename, "sampler_el"))
+  {
+    struct RPS_SamplerElement *s_elem;
+    struct GNUNET_CRYPTO_AuthKey auth_key;
+    const char *key_char;
+    uint32_t i;
+
+    key_char = filename + 20;   /* Length of "/tmp/rps/sampler_el-" */
+    tofile (filename, "--------------------------\n");
+
+    auth_key = string_to_auth_key (key_char);
+    s_elem = RPS_sampler_elem_create ();
+    RPS_sampler_elem_set (s_elem, auth_key);
+
+    for (i = 0; i < num_peers; i++)
+    {
+      RPS_sampler_elem_next (s_elem, &rps_peer_ids[i]);
+    }
+    RPS_sampler_elem_destroy (s_elem);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * This is run after the test finished.
+ *
+ * Compute all perfect samples.
+ */
+int
+profiler_eval (void)
+{
+  /* Compute perfect sample for each sampler element */
+  if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n");
+  }
+
+  return evaluate ();
+}
+
+
+/**
+ * @brief is b in view of a?
+ *
+ * @param a
+ * @param b
+ *
+ * @return
+ */
+static int
+is_in_view (uint32_t a, uint32_t b)
+{
+  uint32_t i;
+
+  for (i = 0; i < rps_peers[a].cur_view_count; i++)
+  {
+    if (0 == memcmp (rps_peers[b].peer_id,
+                     &rps_peers[a].cur_view[i],
+                     sizeof(struct GNUNET_PeerIdentity)))
+    {
+      return GNUNET_YES;
+    }
+  }
+  return GNUNET_NO;
+}
+
+
+static uint32_t
+get_idx_of_pid (const struct GNUNET_PeerIdentity *pid)
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    if (0 == memcmp (pid,
+                     rps_peers[i].peer_id,
+                     sizeof(struct GNUNET_PeerIdentity)))
+    {
+      return i;
+    }
+  }
+  // return 0; /* Should not happen - make compiler happy */
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "No known _PeerIdentity %s!\n",
+              GNUNET_i2s_full (pid));
+  GNUNET_assert (0);
+}
+
+
+/**
+ * @brief Counts number of peers in view of a that have b in their view
+ *
+ * @param a
+ * @param uint32_tb
+ *
+ * @return
+ */
+static uint32_t
+count_containing_views (uint32_t a, uint32_t b)
+{
+  uint32_t i;
+  uint32_t peer_idx;
+  uint32_t count = 0;
+
+  for (i = 0; i < rps_peers[a].cur_view_count; i++)
+  {
+    peer_idx = get_idx_of_pid (&rps_peers[a].cur_view[i]);
+    if (GNUNET_YES == is_in_view (peer_idx, b))
+    {
+      count++;
+    }
+  }
+  return count;
+}
+
+
+/**
+ * @brief Computes the probability for each other peer to be selected by the
+ * sampling process based on the views of all peers
+ *
+ * @param peer_idx index of the peer that is about to sample
+ */
+static void
+compute_probabilities (uint32_t peer_idx)
+{
+  // double probs[num_peers] = { 0 };
+  double probs[num_peers];
+  size_t probs_as_str_size = (num_peers * 10 + 1) * sizeof(char);
+  char *probs_as_str = GNUNET_malloc (probs_as_str_size);
+  char *probs_as_str_cpy;
+  uint32_t i;
+  double prob_push;
+  double prob_pull;
+  uint32_t view_size;
+  uint32_t cont_views;
+  uint32_t number_of_being_in_pull_events;
+  int tmp;
+  uint32_t count_non_zero_prob = 0;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Computing probabilities for peer %" PRIu32 "\n", peer_idx);
+  /* Firstly without knowledge of old views */
+  for (i = 0; i < num_peers; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\tfor peer %" PRIu32 ":\n", i);
+    view_size = rps_peers[i].cur_view_count;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tview_size: %" PRIu32 "\n", view_size);
+    /* For peer i the probability of being sampled is
+     * evenly distributed among all possibly observed peers. */
+    /* We could have observed a peer in three cases:
+     *   1. peer sent a push
+     *   2. peer was contained in a pull reply
+     *   3. peer was in history (sampler) - ignored for now */
+    /* 1. Probability of having received a push from peer i */
+    if ((GNUNET_YES == is_in_view (i, peer_idx)) &&
+        (1 <= (0.45 * view_size)))
+    {
+      prob_push = 1.0 * binom (0.45 * view_size, 1)
+                  /
+                  binom (view_size, 0.45 * view_size);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\t%" PRIu32 " is in %" PRIu32 "'s view, prob: %f\n",
+                  peer_idx,
+                  i,
+                  prob_push);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\tposs choices from view: %" PRIu32 ", containing i: %"
+                  PRIu32 "\n",
+                  binom (view_size, 0.45 * view_size),
+                  binom (0.45 * view_size, 1));
+    }
+    else
+    {
+      prob_push = 0;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t\t%" PRIu32 " is not in %" PRIu32 "'s view, prob: 0\n",
+                  peer_idx,
+                  i);
+    }
+    /* 2. Probability of peer i being contained in pulls */
+    view_size = rps_peers[peer_idx].cur_view_count;
+    cont_views = count_containing_views (peer_idx, i);
+    number_of_being_in_pull_events =
+      (binom (view_size, 0.45 * view_size)
+       - binom (view_size - cont_views, 0.45 * view_size));
+    if (0 != number_of_being_in_pull_events)
+    {
+      prob_pull = number_of_being_in_pull_events
+                  /
+                  (1.0 * binom (view_size, 0.45 * view_size));
+    }
+    else
+    {
+      prob_pull = 0;
+    }
+    probs[i] = prob_push + prob_pull - (prob_push * prob_pull);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\t%" PRIu32 " has %" PRIu32 " of %" PRIu32
+                " peers in its view who know %" PRIu32 " prob: %f\n",
+                peer_idx,
+                cont_views,
+                view_size,
+                i,
+                prob_pull);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations: %" PRIu32 "\n",
+                binom (view_size, 0.45 * view_size));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations without %" PRIu32
+                ": %" PRIu32 "\n",
+                i,
+                binom (view_size - cont_views, 0.45 * view_size));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t\tnumber of possible pull combinations with %" PRIu32
+                ": %" PRIu32 "\n",
+                i,
+                number_of_being_in_pull_events);
+
+    if (0 != probs[i])
+      count_non_zero_prob++;
+  }
+  /* normalize */
+  if (0 != count_non_zero_prob)
+  {
+    for (i = 0; i < num_peers; i++)
+    {
+      probs[i] = probs[i] * (1.0 / count_non_zero_prob);
+    }
+  }
+  else
+  {
+    for (i = 0; i < num_peers; i++)
+    {
+      probs[i] = 0;
+    }
+  }
+  /* str repr */
+  for (i = 0; i < num_peers; i++)
+  {
+    probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
+    tmp = GNUNET_snprintf (probs_as_str,
+                           probs_as_str_size,
+                           "%s %7.6f", probs_as_str_cpy, probs[i]);
+    GNUNET_free (probs_as_str_cpy);
+    GNUNET_assert (0 <= tmp);
+  }
+
+  to_file_w_len (rps_peers[peer_idx].file_name_probs,
+                 probs_as_str_size,
+                 probs_as_str);
+  GNUNET_free (probs_as_str);
+}
+
+
+/**
+ * @brief This counts the number of peers in which views a given peer occurs.
+ *
+ * It also stores this value in the rps peer.
+ *
+ * @param peer_idx the index of the peer to count the representation
+ *
+ * @return the number of occurrences
+ */
+static uint32_t
+count_peer_in_views_2 (uint32_t peer_idx)
+{
+  uint32_t i, j;
+  uint32_t count = 0;
+
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    for (j = 0; j < rps_peers[i].cur_view_count; j++)   /* entry in view */
+    {
+      if (0 == memcmp (rps_peers[peer_idx].peer_id,
+                       &rps_peers[i].cur_view[j],
+                       sizeof(struct GNUNET_PeerIdentity)))
+      {
+        count++;
+        break;
+      }
+    }
+  }
+  rps_peers[peer_idx].count_in_views = count;
+  return count;
+}
+
+
+static uint32_t
+cumulated_view_sizes ()
+{
+  uint32_t i;
+
+  view_sizes = 0;
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    view_sizes += rps_peers[i].cur_view_count;
+  }
+  return view_sizes;
+}
+
+
+static void
+count_peer_in_views (uint32_t *count_peers)
+{
+  uint32_t i, j;
+
+  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
+  {
+    for (j = 0; j < rps_peers[i].cur_view_count; j++)   /* entry in view */
+    {
+      if (0 == memcmp (rps_peers[i].peer_id,
+                       &rps_peers[i].cur_view[j],
+                       sizeof(struct GNUNET_PeerIdentity)))
+      {
+        count_peers[i]++;
+      }
+    }
+  }
+}
+
+
+void
+compute_diversity ()
+{
+  uint32_t i;
+  /* ith entry represents the number of occurrences in other peer's views */
+  uint32_t *count_peers = GNUNET_new_array (num_peers, uint32_t);
+  uint32_t views_total_size;
+  double expected;
+  /* deviation from expected number of peers */
+  double *deviation = GNUNET_new_array (num_peers, double);
+
+  views_total_size = 0;
+  expected = 0;
+
+  /* For each peer count its representation in other peer's views*/
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    views_total_size += rps_peers[i].cur_view_count;
+    count_peer_in_views (count_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Counted representation of %" PRIu32 "th peer [%s]: %" PRIu32
+                "\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                count_peers[i]);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "size of all views combined: %" PRIu32 "\n",
+              views_total_size);
+  expected = ((double) 1 / num_peers) * views_total_size;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Expected number of occurrences of each peer in all views: %f\n",
+              expected);
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    deviation[i] = expected - count_peers[i];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Deviation from expectation: %f\n", deviation[i]);
+  }
+  GNUNET_free (count_peers);
+  GNUNET_free (deviation);
+}
+
+
+void
+print_view_sizes ()
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++) /* Peer to count */
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "View size of %" PRIu32 ". [%s] is %" PRIu32 "\n",
+                i,
+                GNUNET_i2s (rps_peers[i].peer_id),
+                rps_peers[i].cur_view_count);
+  }
+}
+
+
+void
+all_views_updated_cb ()
+{
+  compute_diversity ();
+  print_view_sizes ();
+}
+
+
+void
+view_update_cb (void *cls,
+                uint64_t view_size,
+                const struct GNUNET_PeerIdentity *peers)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "View was updated (%" PRIu64 ")\n", view_size);
+  struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
+  to_file ("/tmp/rps/view_sizes.txt",
+           "%" PRIu32 " %" PRIu64 "",
+           rps_peer->index,
+           view_size);
+  for (uint64_t i = 0; i < view_size; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\t%s\n", GNUNET_i2s (&peers[i]));
+  }
+  GNUNET_array_grow (rps_peer->cur_view,
+                     rps_peer->cur_view_count,
+                     view_size);
+  // *rps_peer->cur_view = *peers;
+  GNUNET_memcpy (rps_peer->cur_view,
+                 peers,
+                 view_size * sizeof(struct GNUNET_PeerIdentity));
+  to_file ("/tmp/rps/count_in_views.txt",
+           "%" PRIu32 " %" PRIu32 "",
+           rps_peer->index,
+           count_peer_in_views_2 (rps_peer->index));
+  cumulated_view_sizes ();
+  if (0 != view_size)
+  {
+    to_file ("/tmp/rps/repr.txt",
+             "%" PRIu32  /* index */
+             " %" PRIu32  /* occurrence in views */
+             " %" PRIu32  /* view sizes */
+             " %f"  /* fraction of repr in views */
+             " %f"  /* average view size */
+             " %f"  /* prob of occurrence in view slot */
+             " %f" "",  /* exp frac of repr in views */
+             rps_peer->index,
+             count_peer_in_views_2 (rps_peer->index),
+             view_sizes,
+             count_peer_in_views_2 (rps_peer->index) / (view_size * 1.0), /* fraction of representation in views */
+             view_sizes / (view_size * 1.0),  /* average view size */
+             1.0 / view_size,  /* prob of occurrence in view slot */
+             (1.0 / view_size) * (view_sizes / view_size)  /* expected fraction of repr in views */
+             );
+  }
+  compute_probabilities (rps_peer->index);
+  all_views_updated_cb ();
+}
+
+
+static void
+pre_profiler (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
+{
+  rps_peer->file_name_probs =
+    store_prefix_file_name (rps_peer->index, "probs");
+  GNUNET_RPS_view_request (h, 0, view_update_cb, rps_peer);
+}
+
+
+void
+write_final_stats (void)
+{
+  uint32_t i;
+
+  for (i = 0; i < num_peers; i++)
+  {
+    to_file ("/tmp/rps/final_stats.dat",
+             "%" PRIu32 " "  /* index */
+             "%s %"  /* id */
+             PRIu64 " %"  /* rounds */
+             PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
+             " %"                                                                     /* blocking */
+             PRIu64 " %" PRIu64 " %" PRIu64 " %"  /* issued */
+             PRIu64 " %" PRIu64 " %" PRIu64 " %"  /* sent */
+             PRIu64 " %" PRIu64 " %" PRIu64 /* recv */,
+             i,
+             GNUNET_i2s (rps_peers[i].peer_id),
+             rps_peers[i].num_rounds,
+             rps_peers[i].num_blocks,
+             rps_peers[i].num_blocks_many_push,
+             rps_peers[i].num_blocks_no_push,
+             rps_peers[i].num_blocks_no_pull,
+             rps_peers[i].num_blocks_many_push_no_pull,
+             rps_peers[i].num_blocks_no_push_no_pull,
+             rps_peers[i].num_issued_push,
+             rps_peers[i].num_issued_pull_req,
+             rps_peers[i].num_issued_pull_rep,
+             rps_peers[i].num_sent_push,
+             rps_peers[i].num_sent_pull_req,
+             rps_peers[i].num_sent_pull_rep,
+             rps_peers[i].num_recv_push,
+             rps_peers[i].num_recv_pull_req,
+             rps_peers[i].num_recv_pull_rep);
+  }
+}
+
+
+/**
+ * Continuation called by #GNUNET_STATISTICS_get() functions.
+ *
+ * Remembers that this specific statistics value was received for this peer.
+ * Checks whether all peers received their statistics yet.
+ * Issues the shutdown.
+ *
+ * @param cls closure
+ * @param success #GNUNET_OK if statistics were
+ *        successfully obtained, #GNUNET_SYSERR if not.
+ */
+void
+post_test_shutdown_ready_cb (void *cls,
+                             int success)
+{
+  struct STATcls *stat_cls = (struct STATcls *) cls;
+  struct RPSPeer *rps_peer = stat_cls->rps_peer;
+
+  if (GNUNET_OK == success)
+  {
+    /* set flag that we we got the value */
+    rps_peer->stat_collected_flags |= stat_cls->stat_type;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Peer %u did not receive statistics value\n",
+                rps_peer->index);
+    GNUNET_free (stat_cls);
+    GNUNET_break (0);
+  }
+
+  if ((NULL != rps_peer->stat_op) &&
+      (GNUNET_YES == check_statistics_collect_completed_single_peer (
+         rps_peer)) )
+  {
+    GNUNET_TESTBED_operation_done (rps_peer->stat_op);
+  }
+
+  write_final_stats ();
+  if (GNUNET_YES == check_statistics_collect_completed ())
+  {
+    // write_final_stats ();
+    GNUNET_free (stat_cls);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Shutting down\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  else
+  {
+    GNUNET_free (stat_cls);
+  }
+}
+
+
+/**
+ * @brief Converts string representation to the corresponding #STAT_TYPE enum.
+ *
+ * @param stat_str string representation of statistics specifier
+ *
+ * @return corresponding enum
+ */
+enum STAT_TYPE
+stat_str_2_type (const char *stat_str)
+{
+  if (0 == strncmp ("# rounds blocked - no pull replies", stat_str, strlen (
+                      "# rounds blocked - no pull replies")))
+  {
+    return STAT_TYPE_BLOCKS_NO_PULL;
+  }
+  else if (0 == strncmp ("# rounds blocked - too many pushes, no pull replies",
+                         stat_str, strlen (
+                           "# rounds blocked - too many pushes, no pull replies")))
+  {
+    return STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL;
+  }
+  else if (0 == strncmp ("# rounds blocked - too many pushes", stat_str,
+                         strlen ("# rounds blocked - too many pushes")))
+  {
+    return STAT_TYPE_BLOCKS_MANY_PUSH;
+  }
+  else if (0 == strncmp ("# rounds blocked - no pushes, no pull replies",
+                         stat_str, strlen (
+                           "# rounds blocked - no pushes, no pull replies")))
+  {
+    return STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL;
+  }
+  else if (0 == strncmp ("# rounds blocked - no pushes", stat_str, strlen (
+                           "# rounds blocked - no pushes")))
+  {
+    return STAT_TYPE_BLOCKS_NO_PUSH;
+  }
+  else if (0 == strncmp ("# rounds blocked", stat_str, strlen (
+                           "# rounds blocked")))
+  {
+    return STAT_TYPE_BLOCKS;
+  }
+  else if (0 == strncmp ("# rounds", stat_str, strlen ("# rounds")))
+  {
+    return STAT_TYPE_ROUNDS;
+  }
+  else if (0 == strncmp ("# push send issued", stat_str, strlen (
+                           "# push send issued")))
+  {
+    return STAT_TYPE_ISSUED_PUSH_SEND;
+  }
+  else if (0 == strncmp ("# pull request send issued", stat_str, strlen (
+                           "# pull request send issued")))
+  {
+    return STAT_TYPE_ISSUED_PULL_REQ;
+  }
+  else if (0 == strncmp ("# pull reply send issued", stat_str, strlen (
+                           "# pull reply send issued")))
+  {
+    return STAT_TYPE_ISSUED_PULL_REP;
+  }
+  else if (0 == strncmp ("# pushes sent", stat_str, strlen ("# pushes sent")))
+  {
+    return STAT_TYPE_SENT_PUSH_SEND;
+  }
+  else if (0 == strncmp ("# pull requests sent", stat_str, strlen (
+                           "# pull requests sent")))
+  {
+    return STAT_TYPE_SENT_PULL_REQ;
+  }
+  else if (0 == strncmp ("# pull replies sent", stat_str, strlen (
+                           "# pull replies sent")))
+  {
+    return STAT_TYPE_SENT_PULL_REP;
+  }
+  else if (0 == strncmp ("# push message received", stat_str, strlen (
+                           "# push message received")))
+  {
+    return STAT_TYPE_RECV_PUSH_SEND;
+  }
+  else if (0 == strncmp ("# pull request message received", stat_str, strlen (
+                           "# pull request message received")))
+  {
+    return STAT_TYPE_RECV_PULL_REQ;
+  }
+  else if (0 == strncmp ("# pull reply messages received", stat_str, strlen (
+                           "# pull reply messages received")))
+  {
+    return STAT_TYPE_RECV_PULL_REP;
+  }
+  return STAT_TYPE_MAX;
+}
+
+
+/**
+ * @brief Converts #STAT_TYPE enum to the equivalent string representation that
+ * is stored with the statistics service.
+ *
+ * @param stat_type #STAT_TYPE enum
+ *
+ * @return string representation that matches statistics value
+ */
+char*
+stat_type_2_str (enum STAT_TYPE stat_type)
+{
+  switch (stat_type)
+  {
+  case STAT_TYPE_ROUNDS:
+    return "# rounds";
+
+  case STAT_TYPE_BLOCKS:
+    return "# rounds blocked";
+
+  case STAT_TYPE_BLOCKS_MANY_PUSH:
+    return "# rounds blocked - too many pushes";
+
+  case STAT_TYPE_BLOCKS_NO_PUSH:
+    return "# rounds blocked - no pushes";
+
+  case STAT_TYPE_BLOCKS_NO_PULL:
+    return "# rounds blocked - no pull replies";
+
+  case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
+    return "# rounds blocked - too many pushes, no pull replies";
+
+  case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
+    return "# rounds blocked - no pushes, no pull replies";
+
+  case STAT_TYPE_ISSUED_PUSH_SEND:
+    return "# push send issued";
+
+  case STAT_TYPE_ISSUED_PULL_REQ:
+    return "# pull request send issued";
+
+  case STAT_TYPE_ISSUED_PULL_REP:
+    return "# pull reply send issued";
+
+  case STAT_TYPE_SENT_PUSH_SEND:
+    return "# pushes sent";
+
+  case STAT_TYPE_SENT_PULL_REQ:
+    return "# pull requests sent";
+
+  case STAT_TYPE_SENT_PULL_REP:
+    return "# pull replies sent";
+
+  case STAT_TYPE_RECV_PUSH_SEND:
+    return "# push message received";
+
+  case STAT_TYPE_RECV_PULL_REQ:
+    return "# pull request message received";
+
+  case STAT_TYPE_RECV_PULL_REP:
+    return "# pull reply messages received";
+
+  case STAT_TYPE_MAX:
+  default:
+    return "ERROR";
+    ;
+  }
+}
+
+
+/**
+ * Callback function to process statistic values.
+ *
+ * @param cls closure
+ * @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
+ */
+int
+stat_iterator (void *cls,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
+{
+  (void) subsystem;
+  (void) is_persistent;
+  const struct STATcls *stat_cls = (const struct STATcls *) cls;
+  struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got stat value: %s - %" PRIu64 "\n",
+              // stat_type_2_str (stat_cls->stat_type),
+              name,
+              value);
+  to_file (rps_peer->file_name_stats,
+           "%s: %" PRIu64 "\n",
+           name,
+           value);
+  switch (stat_str_2_type (name))
+  {
+  case STAT_TYPE_ROUNDS:
+    rps_peer->num_rounds = value;
+    break;
+
+  case STAT_TYPE_BLOCKS:
+    rps_peer->num_blocks = value;
+    break;
+
+  case STAT_TYPE_BLOCKS_MANY_PUSH:
+    rps_peer->num_blocks_many_push = value;
+    break;
+
+  case STAT_TYPE_BLOCKS_NO_PUSH:
+    rps_peer->num_blocks_no_push = value;
+    break;
+
+  case STAT_TYPE_BLOCKS_NO_PULL:
+    rps_peer->num_blocks_no_pull = value;
+    break;
+
+  case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
+    rps_peer->num_blocks_many_push_no_pull = value;
+    break;
+
+  case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
+    rps_peer->num_blocks_no_push_no_pull = value;
+    break;
+
+  case STAT_TYPE_ISSUED_PUSH_SEND:
+    rps_peer->num_issued_push = value;
+    break;
+
+  case STAT_TYPE_ISSUED_PULL_REQ:
+    rps_peer->num_issued_pull_req = value;
+    break;
+
+  case STAT_TYPE_ISSUED_PULL_REP:
+    rps_peer->num_issued_pull_rep = value;
+    break;
+
+  case STAT_TYPE_SENT_PUSH_SEND:
+    rps_peer->num_sent_push = value;
+    break;
+
+  case STAT_TYPE_SENT_PULL_REQ:
+    rps_peer->num_sent_pull_req = value;
+    break;
+
+  case STAT_TYPE_SENT_PULL_REP:
+    rps_peer->num_sent_pull_rep = value;
+    break;
+
+  case STAT_TYPE_RECV_PUSH_SEND:
+    rps_peer->num_recv_push = value;
+    break;
+
+  case STAT_TYPE_RECV_PULL_REQ:
+    rps_peer->num_recv_pull_req = value;
+    break;
+
+  case STAT_TYPE_RECV_PULL_REP:
+    rps_peer->num_recv_pull_rep = value;
+    break;
+
+  case STAT_TYPE_MAX:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unknown statistics string: %s\n",
+                name);
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+void
+post_profiler (struct RPSPeer *rps_peer)
+{
+  if (COLLECT_STATISTICS != cur_test_run.have_collect_statistics)
+  {
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Going to request statistic values with mask 0x%" PRIx32 "\n",
+              cur_test_run.stat_collect_flags);
+
+  struct STATcls *stat_cls;
+  uint32_t stat_type;
+  for (stat_type = STAT_TYPE_ROUNDS;
+       stat_type < STAT_TYPE_MAX;
+       stat_type = stat_type << 1)
+  {
+    if (stat_type & cur_test_run.stat_collect_flags)
+    {
+      stat_cls = GNUNET_malloc (sizeof(struct STATcls));
+      stat_cls->rps_peer = rps_peer;
+      stat_cls->stat_type = stat_type;
+      rps_peer->file_name_stats =
+        store_prefix_file_name (rps_peer->peer_id, "stats");
+      GNUNET_STATISTICS_get (rps_peer->stats_h,
+                             "rps",
+                             stat_type_2_str (stat_type),
+                             post_test_shutdown_ready_cb,
+                             stat_iterator,
+                             (struct STATcls *) stat_cls);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Requested statistics for %s (peer %" PRIu32 ")\n",
+                  stat_type_2_str (stat_type),
+                  rps_peer->index);
+    }
+  }
+}
+
+
+/***********************************************************************
+* /Definition of tests
+***********************************************************************/
+
+
+/**
+ * Actual "main" function for the testcase.
+ *
+ * @param cls closure
+ * @param h the run handle
+ * @param n_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 connection attempts that
+ *          failed
+ */
+static void
+run (void *cls,
+     struct GNUNET_TESTBED_RunHandle *h,
+     unsigned int n_peers,
+     struct GNUNET_TESTBED_Peer **peers,
+     unsigned int links_succeeded,
+     unsigned int links_failed)
+{
+  (void) cls;
+  (void) h;
+  (void) links_failed;
+  unsigned int i;
+  struct OpListEntry *entry;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
+
+  /* Check whether we timed out */
+  if ((n_peers != num_peers) ||
+      (NULL == peers) ||
+      (0 == links_succeeded) )
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Going down due to args (eg. timeout)\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n",
+                num_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n",
+                links_succeeded);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+
+  /* Initialize peers */
+  testbed_peers = peers;
+  num_peers_online = 0;
+  for (i = 0; i < num_peers; i++)
+  {
+    entry = make_oplist_entry ();
+    entry->index = i;
+    rps_peers[i].index = i;
+    if (NULL != cur_test_run.init_peer)
+      cur_test_run.init_peer (&rps_peers[i]);
+    if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
+    {
+      rps_peers->cur_view_count = 0;
+      rps_peers->cur_view = NULL;
+    }
+    entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
+                                                     GNUNET_TESTBED_PIT_IDENTITY,
+                                                     &info_cb,
+                                                     entry);
+  }
+
+  /* Bring peers up */
+  GNUNET_assert (num_peers == n_peers);
+  for (i = 0; i < n_peers; i++)
+  {
+    rps_peers[i].index = i;
+    rps_peers[i].op =
+      GNUNET_TESTBED_service_connect (&rps_peers[i],
+                                      peers[i],
+                                      "rps",
+                                      &rps_connect_complete_cb,
+                                      &rps_peers[i],
+                                      &rps_connect_adapter,
+                                      &rps_disconnect_adapter,
+                                      &rps_peers[i]);
+    /* Connect all peers to statistics service */
+    if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
+    {
+      rps_peers[i].stat_op =
+        GNUNET_TESTBED_service_connect (NULL,
+                                        peers[i],
+                                        "statistics",
+                                        stat_complete_cb,
+                                        &rps_peers[i],
+                                        &stat_connect_adapter,
+                                        &stat_disconnect_adapter,
+                                        &rps_peers[i]);
+    }
+  }
+
+  if (NULL != churn_task)
+    GNUNET_SCHEDULER_cancel (churn_task);
+  post_test_task = GNUNET_SCHEDULER_add_delayed (timeout, &post_test_op, NULL);
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                           (timeout_s * 1.2) + 0.1 * num_peers);
+  shutdown_task = GNUNET_SCHEDULER_add_delayed (timeout, &shutdown_op, NULL);
+}
+
+
+/**
+ * Entry point for the testcase, sets up the testbed.
+ *
+ * @param argc unused
+ * @param argv unused
+ * @return 0 on success
+ */
+int
+main (int argc, char *argv[])
+{
+  int ret_value;
+
+  (void) argc;
+
+  /* Defaults for tests */
+  num_peers = 5;
+  cur_test_run.name = "test-rps-default";
+  cur_test_run.init_peer = default_init_peer;
+  cur_test_run.pre_test = NULL;
+  cur_test_run.reply_handle = default_reply_handle;
+  cur_test_run.eval_cb = default_eval_cb;
+  cur_test_run.post_test = NULL;
+  cur_test_run.have_churn = HAVE_CHURN;
+  cur_test_run.have_collect_statistics = NO_COLLECT_STATISTICS;
+  cur_test_run.stat_collect_flags = 0;
+  cur_test_run.have_collect_view = NO_COLLECT_VIEW;
+  churn_task = NULL;
+  timeout_s = 30;
+
+  if (strstr (argv[0], "malicious") != NULL)
+  {
+    cur_test_run.pre_test = mal_pre;
+    cur_test_run.main_test = mal_cb;
+    cur_test_run.init_peer = mal_init_peer;
+    timeout_s = 40;
+
+    if (strstr (argv[0], "_1") != NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 1\n");
+      cur_test_run.name = "test-rps-malicious_1";
+      mal_type = 1;
+    }
+    else if (strstr (argv[0], "_2") != NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 2\n");
+      cur_test_run.name = "test-rps-malicious_2";
+      mal_type = 2;
+    }
+    else if (strstr (argv[0], "_3") != NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 3\n");
+      cur_test_run.name = "test-rps-malicious_3";
+      mal_type = 3;
+    }
+  }
+
+  else if (strstr (argv[0], "_single_req") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
+    cur_test_run.name = "test-rps-single-req";
+    cur_test_run.main_test = single_req_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+  }
+
+  else if (strstr (argv[0], "_delayed_reqs") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
+    cur_test_run.name = "test-rps-delayed-reqs";
+    cur_test_run.main_test = delay_req_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+  }
+
+  else if (strstr (argv[0], "_seed_big") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Test seeding (num_peers > GNUNET_MAX_MESSAGE_SIZE)\n");
+    num_peers = 1;
+    cur_test_run.name = "test-rps-seed-big";
+    cur_test_run.main_test = seed_big_cb;
+    cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+    timeout_s = 10;
+  }
+
+  else if (strstr (argv[0], "_single_peer_seed") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Test seeding and requesting on a single peer\n");
+    cur_test_run.name = "test-rps-single-peer-seed";
+    cur_test_run.main_test = single_peer_seed_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+  }
+
+  else if (strstr (argv[0], "_seed_request") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Test seeding and requesting on multiple peers\n");
+    cur_test_run.name = "test-rps-seed-request";
+    cur_test_run.main_test = seed_req_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+  }
+
+  else if (strstr (argv[0], "_seed") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding\n");
+    cur_test_run.name = "test-rps-seed";
+    cur_test_run.main_test = seed_cb;
+    cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+  }
+
+  else if (strstr (argv[0], "_req_cancel") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test cancelling a request\n");
+    cur_test_run.name = "test-rps-req-cancel";
+    num_peers = 1;
+    cur_test_run.main_test = req_cancel_cb;
+    cur_test_run.eval_cb = no_eval;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+    timeout_s = 10;
+  }
+
+  else if (strstr (argv[0], "_churn") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test churn\n");
+    cur_test_run.name = "test-rps-churn";
+    num_peers = 5;
+    cur_test_run.init_peer = default_init_peer;
+    cur_test_run.main_test = churn_test_cb;
+    cur_test_run.reply_handle = default_reply_handle;
+    cur_test_run.eval_cb = default_eval_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+    cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
+    timeout_s = 40;
+  }
+
+  else if (strstr (argv[0], "_sub") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test subs\n");
+    cur_test_run.name = "test-rps-sub";
+    num_peers = 5;
+    // cur_test_run.init_peer = &default_init_peer;
+    cur_test_run.pre_test = &sub_pre;
+    cur_test_run.main_test = &single_req_cb;
+    // cur_test_run.reply_handle = default_reply_handle;
+    cur_test_run.post_test = &sub_post;
+    // cur_test_run.eval_cb = default_eval_cb;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+    cur_test_run.have_quick_quit = HAVE_QUICK_QUIT;
+  }
+
+  else if (strstr (argv[0], "profiler") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
+    cur_test_run.name = "test-rps-profiler";
+    num_peers = 16;
+    mal_type = 3;
+    cur_test_run.init_peer = profiler_init_peer;
+    // cur_test_run.pre_test = mal_pre;
+    cur_test_run.pre_test = pre_profiler;
+    cur_test_run.main_test = profiler_cb;
+    cur_test_run.reply_handle = profiler_reply_handle;
+    cur_test_run.eval_cb = profiler_eval;
+    cur_test_run.post_test = post_profiler;
+    cur_test_run.request_interval = 2;
+    cur_test_run.num_requests = 5;
+    // cur_test_run.have_churn = HAVE_CHURN;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
+    cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
+    cur_test_run.have_collect_statistics = COLLECT_STATISTICS;
+    cur_test_run.stat_collect_flags = STAT_TYPE_ROUNDS
+                                      | STAT_TYPE_BLOCKS
+                                      | STAT_TYPE_BLOCKS_MANY_PUSH
+                                      | STAT_TYPE_BLOCKS_NO_PUSH
+                                      | STAT_TYPE_BLOCKS_NO_PULL
+                                      | STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL
+                                      | STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL
+                                      | STAT_TYPE_ISSUED_PUSH_SEND
+                                      | STAT_TYPE_ISSUED_PULL_REQ
+                                      | STAT_TYPE_ISSUED_PULL_REP
+                                      | STAT_TYPE_SENT_PUSH_SEND
+                                      | STAT_TYPE_SENT_PULL_REQ
+                                      | STAT_TYPE_SENT_PULL_REP
+                                      | STAT_TYPE_RECV_PUSH_SEND
+                                      | STAT_TYPE_RECV_PULL_REQ
+                                      | STAT_TYPE_RECV_PULL_REP;
+    cur_test_run.have_collect_view = COLLECT_VIEW;
+    timeout_s = 150;
+
+    /* 'Clean' directory */
+    (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
+    GNUNET_DISK_directory_create ("/tmp/rps/");
+  }
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, timeout_s);
+
+  rps_peers = GNUNET_new_array (num_peers, struct RPSPeer);
+  peer_map = GNUNET_CONTAINER_multipeermap_create (num_peers, GNUNET_NO);
+  rps_peer_ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
+  if ((2 == mal_type) ||
+      (3 == mal_type))
+    target_peer = &rps_peer_ids[num_peers - 2];
+  if (profiler_eval == cur_test_run.eval_cb)
+    eval_peer = &rps_peers[num_peers - 1];    /* FIXME: eval_peer could be a
+                                                 malicious peer if not careful
+                                                 with the malicious portion */
+
+  ok = 1;
+  ret_value = GNUNET_TESTBED_test_run (cur_test_run.name,
+                                       "test_rps.conf",
+                                       num_peers,
+                                       0, NULL, NULL,
+                                       &run, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "_test_run returned.\n");
+  if (GNUNET_OK != ret_value)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Test did not run successfully!\n");
+  }
+
+  ret_value = cur_test_run.eval_cb ();
+
+  if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
+  {
+    GNUNET_array_grow (rps_peers->cur_view,
+                       rps_peers->cur_view_count,
+                       0);
+  }
+  GNUNET_free (rps_peers);
+  GNUNET_free (rps_peer_ids);
+  GNUNET_CONTAINER_multipeermap_destroy (peer_map);
+  return ret_value;
+}
+
+
+/* end of test_rps.c */
diff --git a/src/contrib/service/rps/test_rps.conf b/src/contrib/service/rps/test_rps.conf
new file mode 100644
index 000000000..2b1101786
--- /dev/null
+++ b/src/contrib/service/rps/test_rps.conf
@@ -0,0 +1,135 @@
+[rps]
+#PREFIX = valgrind --leak-check=full --show-leak-kinds=all --log-file=/tmp/rps/valgrind!gnunet-service-rps!%p
+#PREFIX = valgrind --log-file=/tmp/rps/valgrind!gnunet-service-rps!%p
+#PREFIX = valgrind
+UNIXPATH = $GNUNET_TMP/gnunet-service-rps.sock
+HOME = $SERVICEHOME
+# PORT = 2106
+#@UNIXONLY@ PORT = 2087
+IMMEDIATE_START = YES
+START_ON_DEMAND = NO
+NOARMBIND = YES
+#OPTIONS=-l /tmp/rps_profiler_logs/rps-[]-%Y-%m-%d.log
+
+# This is the timeinterval between the rounds
+ROUNDINTERVAL = 100 ms
+FILENAME_VALID_PEERS = $GNUNET_DATA_HOME/rps/valid_peers.txt
+
+# This is the 'estimate' in the beginning.
+# This determines the size of the peers we keep in memory
+# until we receive the first estimate from NSE.
+# Keep in mind, that (networksize)^(1/3) should be enough.
+# So, 50 is enough for a network of size 50^3 = 125000
+MINSIZE = 4
+
+DESIRED_PROBABILITY = 0.75
+
+DEFICIENCY_FACTOR = 0.4
+
+
+
+[testbed]
+HOSTNAME = localhost
+
+# MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS = 100
+
+#OVERLAY_TOPOLOGY = CLIQUE
+
+OVERLAY_TOPOLOGY = SCALE_FREE
+SCALE_FREE_TOPOLOGY_CAP = 100
+SCALE_FREE_TOPOLOGY_M = 2
+
+#OVERLAY_TOPOLOGY = RANDOM
+#OVERLAY_RANDOM_LINKS = 25
+
+#OVERLAY_TOPOLOGY = SMALL_WORLD
+#OVERLAY_RANDOM_LINKS = 25
+
+SETUP_TIMEOUT = 2 m
+
+[nse]
+WORKBITS = 0
+
+[nat]
+# Use addresses from the local network interfaces (including loopback, but also others)
+USE_LOCALADDR = YES
+ENABLE_UPNP = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
+
+[transport]
+PLUGINS = unix
+
+[ats]
+# Network specific inbound/outbound quotas
+UNSPECIFIED_QUOTA_IN = unlimited
+UNSPECIFIED_QUOTA_OUT = unlimited
+# LOOPBACK
+LOOPBACK_QUOTA_IN = unlimited
+LOOPBACK_QUOTA_OUT = unlimited
+# LAN
+LAN_QUOTA_IN = unlimited
+LAN_QUOTA_OUT = unlimited
+#WAN
+WAN_QUOTA_OUT = unlimited
+WAN_QUOTA_IN = unlimited
+# WLAN
+WLAN_QUOTA_IN = unlimited
+WLAN_QUOTA_OUT = unlimited
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = unlimited
+BLUETOOTH_QUOTA_OUT = unlimited
+
+[dht]
+DISABLE_TRY_CONNECT = YES
+
+[cadet]
+#OPTIONS=-l /tmp/rps_profiler_logs/cadet-[]-%Y-%m-%d.log
+#PREFIX = valgrind --log-file=/tmp/rps/valgrind_gnunet-service-cadet_%p
+
+#[arm]
+#GLOBAL_POSTFIX=-l /tmp/rps_profiler_logs/other-[]-%Y-%m-%d.log
+
+#[statistics]
+#IMMEDIATE_START = NO
+#START_ON_DEMAND = NO
+
+[peerinfo]
+NO_IO = YES
+
+[hostlist]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[zonemaster]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[namecache]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[namestore]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[topology]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[vpn]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[revocation]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[gns]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
+
+[fs]
+IMMEDIATE_START = NO
+START_ON_DEMAND = NO
diff --git a/src/contrib/service/rps/test_rps_api.c b/src/contrib/service/rps/test_rps_api.c
new file mode 100644
index 000000000..06dad2887
--- /dev/null
+++ b/src/contrib/service/rps/test_rps_api.c
@@ -0,0 +1,87 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/test_rps_api.c
+ * @brief testcase for rps_api.c
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_rps_service.h"
+
+
+static int ok = 1;
+
+
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  ok = 0;
+}
+
+
+static int
+check ()
+{
+  char *const argv[] = { "test-rps-api", NULL };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  struct GNUNET_OS_Process *proc;
+  char *path = GNUNET_OS_get_libexec_binary_path ("gnunet-service-rps");
+
+  if (NULL == path)
+  {
+    fprintf (stderr, "Service executable not found `%s'\n",
+             "gnunet-service-rps");
+    return;
+  }
+
+  proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL,
+                                  NULL, NULL, path, "gnunet-service-rps", NULL);
+
+  GNUNET_free (path);
+  GNUNET_assert (NULL != proc);
+  GNUNET_PROGRAM_run (1, argv, "test-rps-api", "nohelp",
+                      options, &run, &ok);
+  if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    ok = 1;
+  }
+  GNUNET_OS_process_wait (proc);
+  GNUNET_OS_process_destroy (proc);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  GNUNET_log_setup ("test_statistics_api",
+                    "WARNING",
+                    NULL);
+  return check ();
+}
+
+
+/* end of test_rps_api.c */
diff --git a/src/contrib/service/rps/test_service_rps_custommap.c b/src/contrib/service/rps/test_service_rps_custommap.c
new file mode 100644
index 000000000..82d75b7e0
--- /dev/null
+++ b/src/contrib/service/rps/test_service_rps_custommap.c
@@ -0,0 +1,128 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/test_service_rps_custommap.c
+ * @brief testcase for gnunet-service-rps_peers.c
+ */
+#include "platform.h"
+#include <platform.h>
+#include "gnunet-service-rps_custommap.h"
+
+#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+                  if (NULL != c_m) CustomPeerMap_destroy (c_m); return 1; }
+#define CHECK(c) { if (! (c)) ABORT (); }
+
+
+static int
+check ()
+{
+  struct CustomPeerMap *c_m;
+  struct GNUNET_PeerIdentity k1;
+  struct GNUNET_PeerIdentity k2;
+  unsigned int j;
+
+  CHECK (NULL != (c_m = CustomPeerMap_create (4)));
+  memset (&k1, 0, sizeof(k1));
+  memset (&k2, 1, sizeof(k2));
+  CHECK (GNUNET_NO == CustomPeerMap_contains_peer (c_m, &k1));
+  CHECK (GNUNET_NO == CustomPeerMap_contains_peer (c_m, &k2));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer (c_m, &k1));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer (c_m, &k2));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer_by_index (c_m, 0));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer_by_index (c_m, 0));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer_by_index (c_m, 1));
+  CHECK (GNUNET_NO == CustomPeerMap_remove_peer_by_index (c_m, 1));
+  CHECK (NULL == CustomPeerMap_get_peer_by_index (c_m, 0));
+  CHECK (NULL == CustomPeerMap_get_peer_by_index (c_m, 0));
+  CHECK (NULL == CustomPeerMap_get_peer_by_index (c_m, 1));
+  CHECK (NULL == CustomPeerMap_get_peer_by_index (c_m, 1));
+  CustomPeerMap_clear (c_m);  /* See if assertions trigger */
+  CHECK (0 == CustomPeerMap_size (c_m));
+
+  CHECK (GNUNET_OK == CustomPeerMap_put (c_m, &k1));
+  CHECK (1 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_NO == CustomPeerMap_put (c_m, &k1));
+  CHECK (1 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_YES == CustomPeerMap_contains_peer (c_m, &k1));
+  CHECK (GNUNET_OK == CustomPeerMap_remove_peer (c_m, &k1));
+  CHECK (0 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_NO == CustomPeerMap_contains_peer (c_m, &k1));
+  CHECK (GNUNET_NO == CustomPeerMap_contains_peer (c_m, &k2));
+
+  CHECK (GNUNET_OK == CustomPeerMap_put (c_m, &k1));
+  CHECK (1 == CustomPeerMap_size (c_m));
+  for (j = 0; j < 16; j++)
+  {
+    CHECK (GNUNET_NO == CustomPeerMap_put (c_m, &k1));
+  }
+  CHECK (1 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_OK == CustomPeerMap_put (c_m, &k2));
+  CHECK (2 == CustomPeerMap_size (c_m));
+  for (j = 0; j < 16; j++)
+  {
+    CHECK (GNUNET_NO == CustomPeerMap_put (c_m, &k2));
+  }
+  CHECK (2 == CustomPeerMap_size (c_m));
+
+  /* iterate */
+  for (j = 0; j < CustomPeerMap_size (c_m); j++)
+  {
+    CHECK (NULL != CustomPeerMap_get_peer_by_index (c_m, j));
+  }
+  CHECK ((0 == memcmp (CustomPeerMap_get_peer_by_index (c_m, 0),
+                       &k1, sizeof(k1))));
+  CHECK ((0 == memcmp (CustomPeerMap_get_peer_by_index (c_m, 1),
+                       &k2, sizeof(k2))));
+  CHECK (GNUNET_OK == CustomPeerMap_remove_peer (c_m, &k1));
+  CHECK (1 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_NO == CustomPeerMap_contains_peer (c_m, &k1));
+  CHECK (GNUNET_YES == CustomPeerMap_contains_peer (c_m, &k2));
+  CHECK (NULL != CustomPeerMap_get_peer_by_index (c_m, 0));
+
+  CustomPeerMap_clear (c_m);
+  CHECK (0 == CustomPeerMap_size (c_m));
+
+  CHECK (GNUNET_OK == CustomPeerMap_put (c_m, &k1));
+  CHECK (1 == CustomPeerMap_size (c_m));
+  CHECK (GNUNET_OK == CustomPeerMap_put (c_m, &k2));
+  CHECK (2 == CustomPeerMap_size (c_m));
+  CustomPeerMap_clear (c_m);
+  CHECK (0 == CustomPeerMap_size (c_m));
+
+  CustomPeerMap_destroy (c_m);
+
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+
+  GNUNET_log_setup ("test_service_rps_peers",
+                    "WARNING",
+                    NULL);
+  return check ();
+}
+
+
+/* end of test_service_rps_custommap.c */
diff --git a/src/contrib/service/rps/test_service_rps_sampler_elem.c b/src/contrib/service/rps/test_service_rps_sampler_elem.c
new file mode 100644
index 000000000..afa17611c
--- /dev/null
+++ b/src/contrib/service/rps/test_service_rps_sampler_elem.c
@@ -0,0 +1,214 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/test_service_rps_sampler_elem.c
+ * @brief testcase for gnunet-service-rps_sampler_elem.c
+ */
+#include "platform.h"
+#include <platform.h>
+#include "gnunet_util_lib.h"
+#include "gnunet-service-rps_sampler_elem.h"
+
+#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+                  return 1; }
+#define CHECK(c) { if (! (c)) ABORT (); }
+
+
+static int
+check ()
+{
+  struct GNUNET_PeerIdentity pid0;
+  struct GNUNET_PeerIdentity pid1;
+  struct RPS_SamplerElement *s_elem;
+  struct GNUNET_CRYPTO_AuthKey auth_key;
+  struct GNUNET_CRYPTO_AuthKey auth_key2;
+  struct GNUNET_HashCode hash_code;
+  struct GNUNET_HashCode hash_code2;
+
+  memset (&pid0, 1, sizeof(pid0));
+  memset (&pid1, 0, sizeof(pid1));
+
+  /* Check if creation and destruction of an
+   * (empty) sampler element works */
+  s_elem = RPS_sampler_elem_create ();
+  CHECK (NULL != s_elem);
+  CHECK (EMPTY == s_elem->is_empty);
+  CHECK (NULL != &s_elem->auth_key);
+  auth_key = s_elem->auth_key;
+  RPS_sampler_elem_destroy (s_elem);
+
+
+  /* Check creation of another sampler element
+   * yields another (random) key */
+  s_elem = RPS_sampler_elem_create ();
+  CHECK (NULL != s_elem);
+  CHECK (EMPTY == s_elem->is_empty);
+  CHECK (NULL != &s_elem->auth_key);
+  CHECK (auth_key.key != s_elem->auth_key.key);
+  CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key,
+                      GNUNET_CRYPTO_HASH_LENGTH));
+  auth_key = s_elem->auth_key;
+
+  /* Check that reinitialisation
+   * yields another (random) key */
+  RPS_sampler_elem_reinit (s_elem);
+  CHECK (NULL != s_elem);
+  CHECK (EMPTY == s_elem->is_empty);
+  CHECK (NULL != &s_elem->auth_key);
+  CHECK (auth_key.key != s_elem->auth_key.key);
+  CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key,
+                      GNUNET_CRYPTO_HASH_LENGTH));
+  RPS_sampler_elem_destroy (s_elem);
+
+
+  /* Check that input of single peer id
+   * sets valid values */
+  s_elem = RPS_sampler_elem_create ();
+  CHECK (EMPTY == s_elem->is_empty);
+  CHECK (NULL != &s_elem->auth_key);
+  CHECK (auth_key.key != s_elem->auth_key.key);
+  /* This fails only with minimal chance */
+  CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key,
+                      GNUNET_CRYPTO_HASH_LENGTH));
+  auth_key = s_elem->auth_key;
+
+  /* Check also that the hash of the peer id changed
+   * Also fails with minimal probability */
+  hash_code = s_elem->peer_id_hash;
+  RPS_sampler_elem_next (s_elem, &pid0);
+  CHECK (0 == memcmp (&pid0,
+                      &s_elem->peer_id,
+                      sizeof(struct GNUNET_PeerIdentity)));
+  CHECK (0 != memcmp (&hash_code,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  hash_code = s_elem->peer_id_hash;
+
+  /* We can only check that the peer id is one of both inputs */
+  RPS_sampler_elem_next (s_elem, &pid1);
+  CHECK ((0 == memcmp (&pid0,
+                       &s_elem->peer_id,
+                       sizeof(struct GNUNET_PeerIdentity))) ||
+         (0 == memcmp (&pid1,
+                       &s_elem->peer_id,
+                       sizeof(struct GNUNET_PeerIdentity))));
+
+  /* Check that hash stayed the same when peer id did not change */
+  if (0 == memcmp (&pid0,
+                   &s_elem->peer_id,
+                   sizeof(struct GNUNET_PeerIdentity)))
+  {
+    CHECK (0 == memcmp (&hash_code,
+                        &s_elem->peer_id_hash,
+                        sizeof(struct GNUNET_HashCode)));
+  }
+  else /* Check that hash changed */
+  {
+    CHECK (0 != memcmp (&hash_code,
+                        &s_elem->peer_id_hash,
+                        sizeof(struct GNUNET_HashCode)));
+  }
+
+  /* Check multiple inputs of same id
+  * hash should not change anymore */
+  hash_code2 = s_elem->peer_id_hash;
+  RPS_sampler_elem_next (s_elem, &pid0);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid1);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid0);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid0);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid0);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid1);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid1);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+  RPS_sampler_elem_next (s_elem, &pid1);
+  CHECK (0 == memcmp (&hash_code2,
+                      &s_elem->peer_id_hash,
+                      sizeof(struct GNUNET_HashCode)));
+
+  /* Check whether pid stayed the same all the time */
+  if (0 == memcmp (&hash_code,
+                   &hash_code2,
+                   sizeof(struct GNUNET_HashCode)))
+  {
+    CHECK (0 == memcmp (&pid0,
+                        &s_elem->peer_id,
+                        sizeof(struct GNUNET_PeerIdentity)));
+  }
+  else
+  {
+    CHECK (0 == memcmp (&pid1,
+                        &s_elem->peer_id,
+                        sizeof(struct GNUNET_PeerIdentity)));
+  }
+  RPS_sampler_elem_destroy (s_elem);
+
+  /* Check _set() */
+  s_elem = RPS_sampler_elem_create ();
+  CHECK (NULL != s_elem);
+  CHECK (EMPTY == s_elem->is_empty);
+  CHECK (NULL != &s_elem->auth_key);
+  auth_key = s_elem->auth_key;
+  memset (&auth_key2, 0, sizeof(auth_key2));
+  RPS_sampler_elem_set (s_elem, auth_key2);
+  CHECK (0 == memcmp (auth_key2.key,
+                      s_elem->auth_key.key,
+                      GNUNET_CRYPTO_HASH_LENGTH));
+  RPS_sampler_elem_destroy (s_elem);
+
+
+  /* TODO: deterministic tests (use _set() to set auth_key) */
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+
+  GNUNET_log_setup ("test_service_rps_peers",
+                    "WARNING",
+                    NULL);
+  return check ();
+}
+
+
+/* end of test_service_rps_peers.c */
diff --git a/src/contrib/service/rps/test_service_rps_view.c b/src/contrib/service/rps/test_service_rps_view.c
new file mode 100644
index 000000000..bb1413168
--- /dev/null
+++ b/src/contrib/service/rps/test_service_rps_view.c
@@ -0,0 +1,146 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C)
+
+     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 rps/test_service_rps_view.c
+ * @brief testcase for gnunet-service-rps_view.c
+ */
+#include "platform.h"
+#include <platform.h>
+#include "gnunet-service-rps_view.h"
+
+#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+                  View_destroy (view); return 1; }
+#define CHECK(c) { if (! (c)) ABORT (); }
+
+
+static int
+check ()
+{
+  struct View *view;
+  struct GNUNET_PeerIdentity k1;
+  struct GNUNET_PeerIdentity k2;
+  const struct GNUNET_PeerIdentity *array;
+  unsigned int j;
+
+  view = View_create (3);
+  memset (&k1, 0, sizeof(k1));
+  memset (&k2, 1, sizeof(k2));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k2));
+  CHECK (GNUNET_NO == View_remove_peer (view, &k1));
+  CHECK (GNUNET_NO == View_remove_peer (view, &k2));
+  CHECK (NULL == View_get_peer_by_index (view, 0));
+  CHECK (NULL == View_get_peer_by_index (view, 1));
+  View_clear (view);  /* See if assertions trigger */
+  CHECK (0 == View_size (view));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_NO == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_OK == View_remove_peer (view, &k1));
+  CHECK (0 == View_size (view));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k2));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  for (j = 0; j < 16; j++)
+  {
+    CHECK (GNUNET_NO == View_put (view, &k1));
+  }
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
+  for (j = 0; j < 16; j++)
+  {
+    CHECK (GNUNET_NO == View_put (view, &k2));
+  }
+  CHECK (2 == View_size (view));
+
+  /* iterate */
+  for (j = 0; j < View_size (view); j++)
+  {
+    CHECK (NULL != View_get_peer_by_index (view, j));
+  }
+  CHECK ((0 == memcmp (View_get_peer_by_index (view, 0),
+                       &k1, sizeof(k1))));
+  CHECK ((0 == memcmp (View_get_peer_by_index (view, 1),
+                       &k2, sizeof(k2))));
+  CHECK (GNUNET_OK == View_remove_peer (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  CHECK (NULL != View_get_peer_by_index (view, 0));
+  CHECK (NULL == View_get_peer_by_index (view, 1));
+
+  View_clear (view);
+  CHECK (0 == View_size (view));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
+  CHECK (0 == memcmp (&array[0], &k1, sizeof(k1)));
+  CHECK (0 == memcmp (&array[1], &k2, sizeof(k2)));
+  View_clear (view);
+  CHECK (0 == View_size (view));
+
+  /*View_change_len () */
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
+  View_change_len (view, 4);
+  CHECK (2 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
+  CHECK (0 == memcmp (&array[0], &k1, sizeof(k1)));
+  CHECK (0 == memcmp (&array[1], &k2, sizeof(k2)));
+  View_change_len (view, 1);
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
+  CHECK (0 == memcmp (&array[0], &k1, sizeof(k1)));
+  View_clear (view);
+  CHECK (0 == View_size (view));
+
+  View_destroy (view);
+
+  return 0;
+}
+
+
+int
+main ()
+{
+  GNUNET_log_setup ("test_service_rps_peers",
+                    "WARNING",
+                    NULL);
+  return check ();
+}
+
+
+/* end of test_service_rps_view.c */